@myned-ai/gsplat-flame-avatar-renderer 1.0.1 → 1.0.4

package/src/worker/SortWorker.js

@@ -0,0 +1,284 @@
+/**
+ * SortWorker
+ * 
+ * Derived from @mkkellogg/gaussian-splats-3d (MIT License)
+ * https://github.com/mkkellogg/GaussianSplats3D
+ * 
+ * Handles GPU-based sorting using WebAssembly
+ */
+
+import { isIOS, getIOSSemever } from '../utils/Util.js';
+import { Constants } from '../enums/EngineConstants.js';
+
+// Base64 encoded WASM modules for sorting
+const SorterWasm = "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";
+
+const SorterWasmNoSIMD = "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";
+
+const SorterWasmNonShared = "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";
+
+const SorterWasmNoSIMDNonShared = "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";
+
+/**
+ * Sort worker function that runs in a Web Worker
+ * Handles the actual sorting logic using WebAssembly
+ */
+function sortWorker(self) {
+
+    let wasmInstance;
+    let wasmMemory;
+    let useSharedMemory;
+    let integerBasedSort;
+    let dynamicMode;
+    let splatCount;
+    let indexesToSortOffset;
+    let sortedIndexesOffset;
+    let sceneIndexesOffset;
+    let transformsOffset;
+    let precomputedDistancesOffset;
+    let mappedDistancesOffset;
+    let frequenciesOffset;
+    let centersOffset;
+    let modelViewProjOffset;
+    let countsZero;
+    let sortedIndexesOut;
+    let distanceMapRange;
+    let uploadedSplatCount;
+    let Constants;
+
+    function sort(splatSortCount, splatRenderCount, modelViewProj,
+                  usePrecomputedDistances, copyIndexesToSort, copyPrecomputedDistances, copyTransforms) {
+        const sortStartTime = performance.now();
+
+        if (!useSharedMemory) {
+            const indexesToSort = new Uint32Array(wasmMemory, indexesToSortOffset, copyIndexesToSort.byteLength / Constants.BytesPerInt);
+            indexesToSort.set(copyIndexesToSort);
+            const transforms = new Float32Array(wasmMemory, transformsOffset, copyTransforms.byteLength / Constants.BytesPerFloat);
+            transforms.set(copyTransforms);
+            if (usePrecomputedDistances) {
+                let precomputedDistances;
+                if (integerBasedSort) {
+                    precomputedDistances = new Int32Array(wasmMemory, precomputedDistancesOffset,
+                                                          copyPrecomputedDistances.byteLength / Constants.BytesPerInt);
+                } else {
+                    precomputedDistances = new Float32Array(wasmMemory, precomputedDistancesOffset,
+                                                            copyPrecomputedDistances.byteLength / Constants.BytesPerFloat);
+                }
+                precomputedDistances.set(copyPrecomputedDistances);
+            }
+        }
+
+        if (!countsZero) countsZero = new Uint32Array(distanceMapRange);
+        new Float32Array(wasmMemory, modelViewProjOffset, 16).set(modelViewProj);
+        new Uint32Array(wasmMemory, frequenciesOffset, distanceMapRange).set(countsZero);
+        wasmInstance.exports.sortIndexes(indexesToSortOffset, centersOffset, precomputedDistancesOffset,
+                                         mappedDistancesOffset, frequenciesOffset, modelViewProjOffset,
+                                         sortedIndexesOffset, sceneIndexesOffset, transformsOffset, distanceMapRange,
+                                         splatSortCount, splatRenderCount, splatCount, usePrecomputedDistances, integerBasedSort,
+                                         dynamicMode);
+
+        const sortMessage = {
+            'sortDone': true,
+            'splatSortCount': splatSortCount,
+            'splatRenderCount': splatRenderCount,
+            'sortTime': 0
+        };
+        if (!useSharedMemory) {
+            const sortedIndexes = new Uint32Array(wasmMemory, sortedIndexesOffset, splatRenderCount);
+            if (!sortedIndexesOut || sortedIndexesOut.length < splatRenderCount) {
+                sortedIndexesOut = new Uint32Array(splatRenderCount);
+            }
+            sortedIndexesOut.set(sortedIndexes);
+            sortMessage.sortedIndexes = sortedIndexesOut;
+        }
+        const sortEndTime = performance.now();
+
+        sortMessage.sortTime = sortEndTime - sortStartTime;
+
+        self.postMessage(sortMessage);
+    }
+
+    self.onmessage = (e) => {
+        if (e.data.centers) {
+            let centers = e.data.centers;
+            let sceneIndexes = e.data.sceneIndexes;
+            if (integerBasedSort) {
+                new Int32Array(wasmMemory, centersOffset + e.data.range.from * Constants.BytesPerInt * 4,
+                               e.data.range.count * 4).set(new Int32Array(centers));
+            } else {
+                new Float32Array(wasmMemory, centersOffset + e.data.range.from * Constants.BytesPerFloat * 4,
+                                 e.data.range.count * 4).set(new Float32Array(centers));
+            }
+            if (dynamicMode) {
+                new Uint32Array(wasmMemory, sceneIndexesOffset + e.data.range.from * 4,
+                                e.data.range.count).set(new Uint32Array(sceneIndexes));
+            }
+            uploadedSplatCount = e.data.range.from + e.data.range.count;
+        } else if (e.data.sort) {
+            const renderCount = Math.min(e.data.sort.splatRenderCount || 0, uploadedSplatCount);
+            const sortCount = Math.min(e.data.sort.splatSortCount || 0, uploadedSplatCount);
+            const usePrecomputedDistances = e.data.sort.usePrecomputedDistances;
+
+            let copyIndexesToSort;
+            let copyPrecomputedDistances;
+            let copyTransforms;
+            if (!useSharedMemory) {
+                copyIndexesToSort = e.data.sort.indexesToSort;
+                copyTransforms = e.data.sort.transforms;
+                if (usePrecomputedDistances) copyPrecomputedDistances = e.data.sort.precomputedDistances;
+            }
+            sort(sortCount, renderCount, e.data.sort.modelViewProj, usePrecomputedDistances,
+                 copyIndexesToSort, copyPrecomputedDistances, copyTransforms);
+        } else if (e.data.init) {
+            // Yep, this is super hacky and gross :(
+            Constants = e.data.init.Constants;
+
+            splatCount = e.data.init.splatCount;
+            useSharedMemory = e.data.init.useSharedMemory;
+            integerBasedSort = e.data.init.integerBasedSort;
+            dynamicMode = e.data.init.dynamicMode;
+            distanceMapRange = e.data.init.distanceMapRange;
+            uploadedSplatCount = 0;
+
+            const CENTERS_BYTES_PER_ENTRY = integerBasedSort ? (Constants.BytesPerInt * 4) : (Constants.BytesPerFloat * 4);
+
+            const sorterWasmBytes = new Uint8Array(e.data.init.sorterWasmBytes);
+
+            const matrixSize = 16 * Constants.BytesPerFloat;
+            const memoryRequiredForIndexesToSort = splatCount * Constants.BytesPerInt;
+            const memoryRequiredForCenters = splatCount * CENTERS_BYTES_PER_ENTRY;
+            const memoryRequiredForModelViewProjectionMatrix = matrixSize;
+            const memoryRequiredForPrecomputedDistances = integerBasedSort ?
+                                                          (splatCount * Constants.BytesPerInt) : (splatCount * Constants.BytesPerFloat);
+            const memoryRequiredForMappedDistances = splatCount * Constants.BytesPerInt;
+            const memoryRequiredForSortedIndexes = splatCount * Constants.BytesPerInt;
+            const memoryRequiredForIntermediateSortBuffers = integerBasedSort ? (distanceMapRange * Constants.BytesPerInt * 2) :
+                                                                                (distanceMapRange * Constants.BytesPerFloat * 2);
+            const memoryRequiredforTransformIndexes = dynamicMode ? (splatCount * Constants.BytesPerInt) : 0;
+            const memoryRequiredforTransforms = dynamicMode ? (Constants.MaxScenes * matrixSize) : 0;
+            const extraMemory = Constants.MemoryPageSize * 32;
+
+            const totalRequiredMemory = memoryRequiredForIndexesToSort +
+                                        memoryRequiredForCenters +
+                                        memoryRequiredForModelViewProjectionMatrix +
+                                        memoryRequiredForPrecomputedDistances +
+                                        memoryRequiredForMappedDistances +
+                                        memoryRequiredForIntermediateSortBuffers +
+                                        memoryRequiredForSortedIndexes +
+                                        memoryRequiredforTransformIndexes +
+                                        memoryRequiredforTransforms +
+                                        extraMemory;
+            const totalPagesRequired = Math.floor(totalRequiredMemory / Constants.MemoryPageSize ) + 1;
+            const sorterWasmImport = {
+                module: {},
+                env: {
+                    memory: new WebAssembly.Memory({
+                        initial: totalPagesRequired,
+                        maximum: totalPagesRequired,
+                        shared: true,
+                    }),
+                }
+            };
+            WebAssembly.compile(sorterWasmBytes)
+            .then((wasmModule) => {
+                return WebAssembly.instantiate(wasmModule, sorterWasmImport);
+            })
+            .then((instance) => {
+                wasmInstance = instance;
+                indexesToSortOffset = 0;
+                centersOffset = indexesToSortOffset + memoryRequiredForIndexesToSort;
+                modelViewProjOffset = centersOffset + memoryRequiredForCenters;
+                precomputedDistancesOffset = modelViewProjOffset + memoryRequiredForModelViewProjectionMatrix;
+                mappedDistancesOffset = precomputedDistancesOffset + memoryRequiredForPrecomputedDistances;
+                frequenciesOffset = mappedDistancesOffset + memoryRequiredForMappedDistances;
+                sortedIndexesOffset = frequenciesOffset + memoryRequiredForIntermediateSortBuffers;
+                sceneIndexesOffset = sortedIndexesOffset + memoryRequiredForSortedIndexes;
+                transformsOffset = sceneIndexesOffset + memoryRequiredforTransformIndexes;
+                wasmMemory = sorterWasmImport.env.memory.buffer;
+                if (useSharedMemory) {
+                    self.postMessage({
+                        'sortSetupPhase1Complete': true,
+                        'indexesToSortBuffer': wasmMemory,
+                        'indexesToSortOffset': indexesToSortOffset,
+                        'sortedIndexesBuffer': wasmMemory,
+                        'sortedIndexesOffset': sortedIndexesOffset,
+                        'precomputedDistancesBuffer': wasmMemory,
+                        'precomputedDistancesOffset': precomputedDistancesOffset,
+                        'transformsBuffer': wasmMemory,
+                        'transformsOffset': transformsOffset
+                    });
+                } else {
+                    self.postMessage({
+                        'sortSetupPhase1Complete': true
+                    });
+                }
+            });
+        }
+    };
+}
+
+/**
+ * Creates a sort worker for GPU-based sorting
+ * @param {number} splatCount - Number of splats to sort
+ * @param {boolean} useSharedMemory - Whether to use shared memory
+ * @param {boolean} enableSIMDInSort - Whether to enable SIMD instructions
+ * @param {boolean} integerBasedSort - Whether to use integer-based sorting
+ * @param {boolean} dynamicMode - Whether dynamic mode is enabled
+ * @param {number} splatSortDistanceMapPrecision - Precision for distance map
+ * @returns {Worker} The created sort worker
+ */
+export function createSortWorker(splatCount, useSharedMemory, enableSIMDInSort, integerBasedSort, dynamicMode,
+                                 splatSortDistanceMapPrecision = Constants.DefaultSplatSortDistanceMapPrecision) {
+    const worker = new Worker(
+        URL.createObjectURL(
+            new Blob(['(', sortWorker.toString(), ')(self)'], {
+                type: 'application/javascript',
+            }),
+        ),
+    );
+
+    let sourceWasm = SorterWasm;
+
+    // iOS makes choosing the right WebAssembly configuration tricky :(
+    const iOSSemVer = isIOS() ? getIOSSemever() : null;
+    if (!enableSIMDInSort && !useSharedMemory) {
+        sourceWasm = SorterWasmNoSIMD;
+        // Testing on various devices has shown that even when shared memory is disabled, the WASM module with shared
+        // memory can still be used most of the time -- the exception seems to be iOS devices below 16.4
+        if (iOSSemVer && iOSSemVer.major <= 16 && iOSSemVer.minor < 4) {
+            sourceWasm = SorterWasmNoSIMDNonShared;
+        }
+    } else if (!enableSIMDInSort) {
+        sourceWasm = SorterWasmNoSIMD;
+    } else if (!useSharedMemory) {
+        // Same issue with shared memory as above on iOS devices
+        if (iOSSemVer && iOSSemVer.major <= 16 && iOSSemVer.minor < 4) {
+            sourceWasm = SorterWasmNonShared;
+        }
+    }
+
+    const sorterWasmBinaryString = atob(sourceWasm);
+    const sorterWasmBytes = new Uint8Array(sorterWasmBinaryString.length);
+    for (let i = 0; i < sorterWasmBinaryString.length; i++) {
+        sorterWasmBytes[i] = sorterWasmBinaryString.charCodeAt(i);
+    }
+
+    worker.postMessage({
+        'init': {
+            'sorterWasmBytes': sorterWasmBytes.buffer,
+            'splatCount': splatCount,
+            'useSharedMemory': useSharedMemory,
+            'integerBasedSort': integerBasedSort,
+            'dynamicMode': dynamicMode,
+            'distanceMapRange': 1 << splatSortDistanceMapPrecision,
+            // Super hacky
+            'Constants': {
+                'BytesPerFloat': Constants.BytesPerFloat,
+                'BytesPerInt': Constants.BytesPerInt,
+                'MemoryPageSize': Constants.MemoryPageSize,
+                'MaxScenes': Constants.MaxScenes
+            }
+        }
+    });
+    return worker;
+}

package/src/worker/index.js

@@ -0,0 +1,8 @@
+/**
+ * gsplat-flame-avatar - Worker Module
+ * WebAssembly-based sorting for depth ordering.
+ * 
+ * Derived from @mkkellogg/gaussian-splats-3d (MIT License)
+ */
+
+export { createSortWorker } from './SortWorker.js';