feat: add double precision matrix support

package.json

@@ -1,6 +1,6 @@
 {
     "name": "@orillusion/core",
-    "version": "0.8.3",
+    "version": "0.8.4-dev.1",
     "author": "Orillusion",
     "description": "Orillusion WebGPU Engine",
     "type": "module",

packages/wasm-matrix/WasmMatrix.ts

@@ -1,38 +1,32 @@
-import { Matrix4 } from '../../src';
-import matrixjs from './matrix?raw'
+import { Engine3D, Matrix4 } from '../../src';
+import matrix from './matrix';
+
+export type FloatArray = Float32Array | Float64Array;
+
+export function CreateFloatArray(buffer: ArrayBufferLike, byteOffset?: number, length?: number) {
+    if (Engine3D.setting.doublePrecision) 
+        return new Float64Array(buffer, byteOffset, length);
+    return new Float32Array(buffer, byteOffset, length);
+}
 
 export class WasmMatrix {
 
-    public static matrixBuffer: Float32Array;
-    public static matrixSRTBuffer: Float32Array;
-    public static matrixContinuedSRTBuffer: Float32Array;
+    public static matrixBuffer: FloatArray;
+    public static matrixSRTBuffer: FloatArray;
+    public static matrixContinuedSRTBuffer: FloatArray;
     public static matrixStateBuffer: Int32Array;
     static matrixBufferPtr: number;
     static matrixSRTBufferPtr: number;
     static matrixContinuedSRTBufferPtr: number;
     static matrixStateBufferPtr: number;
-    static wasm: any;
+    static wasm: typeof matrix;
     static stateStruct: number = 4;
+    static useDoublePrecision: boolean = false;
 
-    public static async init(count: number) {
-        await new Promise((resolve)=>{
-            const script = document.createElement('script');
-            script.async = true;
-            script.type = "text/javascript";
-            script.src = URL.createObjectURL(new Blob([matrixjs]));
-            document.head.appendChild(script)
-            script.onload = () => {
-                let check = ()=>{
-                    this.wasm = window['wasmMatrix'];
-                    if (this.wasm && this.wasm['calledRun'])
-                        resolve(true)
-                    else
-                        setTimeout(check, 20)
-                }
-                check()
-            }
-        })
-        // this.wasm = window['wasmMatrix'];
+    public static async init(count: number, useDoublePrecision: boolean = false) {
+        this.wasm = await matrix();
+        this.useDoublePrecision = useDoublePrecision;
+        this.wasm._initialize(count, useDoublePrecision, 0);
         this.allocMatrix(count);
     }
 
@@ -41,16 +35,25 @@ export class WasmMatrix {
             console.error(`The maximum allocation size is exceeded! current:${count}, limit:${Matrix4.maxCount}`);
         }
 
-        this.wasm._allocation(count);
+        this.wasm._allocMatrix(count);
 
         this.matrixBufferPtr = this.wasm._getMatrixBufferPtr();
         this.matrixSRTBufferPtr = this.wasm._getSRTPtr();
         this.matrixStateBufferPtr = this.wasm._getInfoPtr();
         this.matrixContinuedSRTBufferPtr = this.wasm._getContinuedSRTPtr();
 
-        this.matrixBuffer = new Float32Array(this.wasm.HEAPF32.buffer, this.matrixBufferPtr, 16 * count);
-        this.matrixSRTBuffer = new Float32Array(this.wasm.HEAPF32.buffer, this.matrixSRTBufferPtr, (3 * 3) * count);
-        this.matrixContinuedSRTBuffer = new Float32Array(this.wasm.HEAPF32.buffer, this.matrixContinuedSRTBufferPtr, (3 * 3) * count);
+        if (this.useDoublePrecision) {
+            this.matrixBuffer = CreateFloatArray(this.wasm.HEAPF64.buffer, this.matrixBufferPtr, 16 * count);
+            this.matrixSRTBuffer = CreateFloatArray(this.wasm.HEAPF64.buffer, this.matrixSRTBufferPtr, (3 * 3) * count);
+            this.matrixContinuedSRTBuffer = CreateFloatArray(this.wasm.HEAPF64.buffer, this.matrixContinuedSRTBufferPtr, (3 * 3) * count);
+            Matrix4.blockBytes = Matrix4.block * 8;
+        } else {
+            this.matrixBuffer = CreateFloatArray(this.wasm.HEAPF32.buffer, this.matrixBufferPtr, 16 * count);
+            this.matrixSRTBuffer = CreateFloatArray(this.wasm.HEAPF32.buffer, this.matrixSRTBufferPtr, (3 * 3) * count);
+            this.matrixContinuedSRTBuffer = CreateFloatArray(this.wasm.HEAPF32.buffer, this.matrixContinuedSRTBufferPtr, (3 * 3) * count);
+            Matrix4.blockBytes = Matrix4.block * 4;
+        }
+
         this.matrixStateBuffer = new Int32Array(this.wasm.HEAP32.buffer, this.matrixStateBufferPtr, (WasmMatrix.stateStruct) * count);
 
         Matrix4.allocMatrix(count);

packages/wasm-matrix/_WasmMatrix4.d.ts → packages/wasm-matrix/matrix.d.ts

@@ -13,15 +13,16 @@ declare module Module {
     const HEAPF32: Float32Array;
     const HEAPF64: Float64Array;
 
-    function _initialize(count: number);
+    function _initialize(count: number, useDoublePrecision: boolean, threadCount: number);
 
+    function _allocMatrix(count: number);
+
     function _updateAllMatrixTransform(start: number, end: number);
 
-    function _updateAllMatrixContinueTransform(start: number, end: number);
+    function _updateAllMatrixContinueTransform(start: number, end: number, dt: number);
 
     function _printMatrix(index: number);
 
-
     function _getSRTPtr(): number;
 
     function _getInfoPtr(): number;

packages/wasm-matrix/package.json

@@ -1,13 +1,13 @@
 {
     "name": "@orillusion/wasm-matrix",
-    "version": "0.7.0",
+    "version": "0.8.3",
     "author": "Orillusion",
-    "description": "Orillusion WebGPU Engine",
+    "description": "Update matrix by WASM",
     "main": "matrix.js",
-    "types": "_WasmMatrix4.d.ts",
+    "types": "matrix.d.ts",
     "files": [
         "matrix.js",
-        "_WasmMatrix4.d.ts"
+        "matrix.d.ts"
     ],
     "license": "MIT",
     "repository": {

samples/base/Sample_MatrixAllocation.ts

@@ -5,6 +5,8 @@ import { GUIUtil } from '@samples/utils/GUIUtil';
 
 class Sample_MatrixAllocation {
     async run() {
+        Engine3D.setting.doublePrecision = true;
+
         Matrix4.allocCount = 10;
         Matrix4.allocOnceCount = 5;
 

src/Engine3D.ts

@@ -6,9 +6,7 @@ import { InputSystem } from './io/InputSystem';
 import { View3D } from './core/View3D';
 import { version } from '../package.json';
 
-import { GPUTextureFormat } from './gfx/graphics/webGpu/WebGPUConst';
 import { webGPUContext } from './gfx/graphics/webGpu/Context3D';
-import { RTResourceConfig } from './gfx/renderJob/config/RTResourceConfig';
 import { RTResourceMap } from './gfx/renderJob/frame/RTResourceMap';
 
 import { ForwardRenderJob } from './gfx/renderJob/jobs/ForwardRenderJob';
@@ -20,7 +18,6 @@ import { ShaderLib } from './assets/shader/ShaderLib';
 import { ShaderUtil } from './gfx/graphics/webGpu/shader/util/ShaderUtil';
 import { ComponentCollect } from './gfx/renderJob/collect/ComponentCollect';
 import { ShadowLightsCollect } from './gfx/renderJob/collect/ShadowLightsCollect';
-import { GUIConfig } from './components/gui/GUIConfig';
 import { WasmMatrix } from '@orillusion/wasm-matrix/WasmMatrix';
 import { Matrix4 } from './math/Matrix4';
 import { FXAAPost } from './gfx/renderJob/post/FXAAPost';
@@ -109,6 +106,8 @@ export class Engine3D {
      * engine setting
      */
     public static setting: EngineSetting = {
+        doublePrecision: false,
+
         occlusionQuery: {
             enable: true,
             debug: false,
@@ -325,7 +324,7 @@ export class Engine3D {
 
         this.setting = { ...this.setting, ...descriptor.engineSetting }
 
-        await WasmMatrix.init(Matrix4.allocCount);
+        await WasmMatrix.init(Matrix4.allocCount, this.setting.doublePrecision);
 
         await webGPUContext.init(descriptor.canvasConfig);
 

src/components/anim/AnimatorComponent.ts

@@ -1,3 +1,4 @@
+import { FloatArray } from "@orillusion/wasm-matrix/WasmMatrix";
 import { Engine3D, Matrix4, MeshRenderer, Object3D, PrefabAvatarData, Quaternion, RenderNode, RendererMask, RendererMaskUtil, SkinnedMeshRenderer2, StorageGPUBuffer, Time, Vector3, Vector4, View3D } from "../..";
 import { PropertyAnimationClip } from "../../math/AnimationCurveClip";
 import { RegisterComponent } from "../../util/SerializeDecoration";
@@ -8,7 +9,7 @@ export class AnimatorComponent extends ComponentBase {
     public timeScale: number = 1.0;
     public jointMatrixIndexTableBuffer: StorageGPUBuffer;
     public playBlendShapeLoop: boolean = false;
-    protected inverseBindMatrices: Float32Array[];
+    protected inverseBindMatrices: FloatArray[];
     protected _avatar: PrefabAvatarData;
     protected _rendererList: SkinnedMeshRenderer2[];
     protected propertyCache: Map<RenderNode, { [name: string]: any }>

src/components/renderer/SkinnedMeshRenderer2.ts

@@ -36,7 +36,7 @@ export class SkinnedMeshRenderer2 extends MeshRenderer {
         this.skinJointsName = value.skinNames;
         let matrixList: Float32Array[] = [];
         for (let i = 0; i < value.bindPose.length; i++) {
-            matrixList.push(value.bindPose[i].rawData.slice(0, 16));
+            matrixList.push(new Float32Array(value.bindPose[i].rawData.slice(0, 16)));
         }
         this.skinInverseBindMatrices = matrixList;
         super.geometry = value;

src/core/pool/memory/MemoryInfo.ts

@@ -1,3 +1,4 @@
+import { FloatArray } from '@orillusion/wasm-matrix/WasmMatrix';
 import { Color } from '../../../math/Color';
 import { Quaternion } from '../../../math/Quaternion';
 import { Vector2 } from '../../../math/Vector2';
@@ -174,6 +175,19 @@ export class MemoryInfo {
         tmp.set(data);
     }
 
+    public setFloatArray(index: number, value: FloatArray) {
+        let data: Float32Array;
+        if (value instanceof Float32Array) {
+            data = value;
+        } else {
+            // GPU nonsupport f64
+            data = new Float32Array(value)
+        }
+
+        let tmp = new Float32Array(this.dataBytes.buffer, this.dataBytes.byteOffset + index * Float32Array.BYTES_PER_ELEMENT, data.length);
+        tmp.set(data);
+    }
+
     public setArrayBuffer(index: number, arrayBuffer: ArrayBuffer) {
         if (arrayBuffer instanceof Uint8Array) {
             this.setUint8Array(index, arrayBuffer);

src/gfx/graphics/webGpu/core/bindGroups/GlobalUniformGroup.ts

@@ -56,7 +56,7 @@ export class GlobalUniformGroup {
 
     createBindGroup() {
         this.uniformByteLength = this.uniformGPUBuffer.memory.shareDataBuffer.byteLength;
-        this.matrixesByteLength = Matrix4.blockBytes * Matrix4.maxCount;
+        this.matrixesByteLength = (Matrix4.block * 4) * Matrix4.maxCount;
 
         this.globalBindGroup = webGPUContext.device.createBindGroup({
             label: `global_bindGroupLayout`,

src/gfx/graphics/webGpu/core/buffer/GPUBufferBase.ts

@@ -11,6 +11,7 @@ import { Struct } from "../../../../../util/struct/Struct";
 import { webGPUContext } from "../../Context3D";
 import { MemoryDO } from "../../../../../core/pool/memory/MemoryDO";
 import { MemoryInfo } from "../../../../../core/pool/memory/MemoryInfo";
+import { FloatArray } from "@orillusion/wasm-matrix/WasmMatrix";
 
 /**
  * @internal
@@ -279,7 +280,8 @@ export class GPUBufferBase {
             node = this.memory.allocation_node(16 * 4);
             this.memoryNodes.set(name, node);
         }
-        node.setFloat32Array(0, mat.rawData);
+
+        node.setFloatArray(0, mat.rawData);
     }
 
     public setMatrixArray(name: string, mats: Matrix4[]) {
@@ -290,7 +292,7 @@ export class GPUBufferBase {
         }
         for (let i = 0; i < mats.length; i++) {
             const mat = mats[i];
-            node.setFloat32Array(i * 16, mat.rawData);
+            node.setFloatArray(i * 16, mat.rawData);
         }
     }
 
@@ -365,6 +367,10 @@ export class GPUBufferBase {
                 node.writeFloat32Array(value);
                 break;
 
+            case `Float64Array`:
+                node.writeFloat32Array(new Float32Array(value));
+                break;
+
             case `Vector2`:
                 node.writeVector2(value);
                 break;
@@ -410,7 +416,13 @@ export class GPUBufferBase {
         // this.applyMapAsync();
     }
 
-    public mapAsyncWrite(mapAsyncArray: Float32Array, len: number) {
+    public mapAsyncWrite(floatArray: FloatArray, len: number) {
+        let mapAsyncArray: Float32Array;
+        if (floatArray instanceof Float64Array) {
+            mapAsyncArray = new Float32Array(floatArray);
+        } else {
+            mapAsyncArray = floatArray as Float32Array;
+        }
         // Upload data using mapAsync and a queue of staging buffers.
         let bytesLen = len;
         let device = webGPUContext.device;

src/gfx/graphics/webGpu/core/buffer/MatrixGPUBuffer.ts

@@ -1,3 +1,4 @@
+import { FloatArray } from '@orillusion/wasm-matrix/WasmMatrix';
 import { webGPUContext } from '../../Context3D';
 import { ArrayBufferData } from './ArrayBufferData';
 import { GPUBufferBase } from './GPUBufferBase';
@@ -20,7 +21,13 @@ export class MatrixGPUBuffer extends GPUBufferBase {
         this.createBuffer(GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST | usage, size, data, "MatrixGPUBuffer");
     }
 
-    public writeBufferByHeap(mapAsyncArray: Float32Array, len: number) {
+    public writeBufferByHeap(floatArray: FloatArray, len: number) {
+        let mapAsyncArray: Float32Array;
+        if (floatArray instanceof Float64Array) {
+            mapAsyncArray = new Float32Array(floatArray);
+        } else {
+            mapAsyncArray = floatArray as Float32Array;
+        }
         // Upload data using mapAsync and a queue of staging buffers.
         let bytesLen = len;
         let device = webGPUContext.device;

src/math/MathUtil.ts

@@ -258,7 +258,7 @@ export class MathUtil {
      */
     public static transformVector(matrix: Matrix4, vector: Vector3, result: Vector3 = null): Vector3 {
         result ||= new Vector3();
-        let raw: Float32Array = matrix.rawData;
+        let raw = matrix.rawData;
         let a: number = raw[0];
         let e: number = raw[1];
         let i: number = raw[2];