@babylonjs/core 9.2.0 → 9.2.2

package/Meshes/GaussianSplatting/gaussianSplattingMesh.js

@@ -3,8 +3,56 @@ import { GetGaussianSplattingMaxPartCount } from "../../Materials/GaussianSplatt
 import { GaussianSplattingMeshBase } from "./gaussianSplattingMeshBase.js";
 import { RawTexture } from "../../Materials/Textures/rawTexture.js";
 
+import { DecodeBase64ToBinary, EncodeArrayBufferToBase64 } from "../../Misc/stringTools.js";
+import { Mesh } from "../mesh.js";
 import "../thinInstanceMesh.js";
 import { GaussianSplattingPartProxyMesh } from "./gaussianSplattingPartProxyMesh.js";
+const _GaussianSplattingBytesPerSplat = 32;
+const _GaussianSplattingBytesPerShTexel = 16;
+/**
+ * Run-Length Encoding (RLE) compression for serialization
+ * Compressed Uint32Array can be parsed using {@link ParsePartIndices}
+ * Some notes for devs: We do not expect Uint8Array larger than 4GB,
+ * so it should be safe to use Uint32Array.
+ * @param partIndices A view of partIndices from GaussianSplattingMesh
+ * @returns A compressed Uint32Array of [count, value, ...]
+ */
+function CompressPartIndices(partIndices) {
+    const runs = [];
+    const length = partIndices.length;
+    let i = 0;
+    while (i < length) {
+        const value = partIndices[i];
+        let count = 1;
+        while (i + count < length && partIndices[i + count] === value) {
+            count++;
+        }
+        runs.push(count, value);
+        i += count;
+    }
+    return new Uint32Array(runs);
+}
+/**
+ * Parse partIndices compressed by {@link CompressPartIndices} to runtime array
+ * @param compressed The compressed partIndices of [count, value, ...]
+ * @returns runtime Uint8Array for GaussianSplattingMesh
+ */
+function ParsePartIndices(compressed) {
+    let totalCount = 0;
+    const length = compressed.length;
+    for (let i = 0; i < length; i += 2) {
+        totalCount += compressed[i];
+    }
+    const partIndices = new Uint8Array(totalCount);
+    let offset = 0;
+    for (let i = 0; i < length; i += 2) {
+        const count = compressed[i];
+        const value = compressed[i + 1];
+        partIndices.fill(value, offset, offset + count);
+        offset += count;
+    }
+    return partIndices;
+}
 /**
  * Class used to render a Gaussian Splatting mesh. Supports both single-cloud and compound
  * (multi-part) rendering. In compound mode, multiple Gaussian Splatting source meshes are
@@ -290,10 +338,88 @@ export class GaussianSplattingMesh extends GaussianSplattingMeshBase {
             this._worker.postMessage({ partIndices: partIndices ?? null });
         }
     }
+    _appendPartSourceToArrays(source, dstOffset, covA, covB, colorArray, sh, minimum, maximum) {
+        this._appendSourceToArrays(source, dstOffset, covA, covB, colorArray, sh, minimum, maximum);
+    }
+    _createRetainedPartSource(proxy) {
+        if (!this._splatsData || (this._shDegree > 0 && !this._shData)) {
+            return null;
+        }
+        const splatByteOffset = proxy._splatsDataOffset * _GaussianSplattingBytesPerSplat;
+        const splatByteLength = proxy._vertexCount * _GaussianSplattingBytesPerSplat;
+        const shByteOffset = proxy._shDataOffset * _GaussianSplattingBytesPerShTexel;
+        const shByteLength = proxy._vertexCount * _GaussianSplattingBytesPerShTexel;
+        return {
+            name: proxy.name,
+            _vertexCount: proxy._vertexCount,
+            _splatsData: this._splatsData.slice(splatByteOffset, splatByteOffset + splatByteLength),
+            _shData: this._shData?.map((texture) => texture.slice(shByteOffset, shByteOffset + shByteLength)) ?? null,
+            _shDegree: this._shData?.length ?? 0,
+            isCompound: false,
+            getWorldMatrix: () => proxy.getWorldMatrix(),
+            getBoundingInfo: () => proxy.getBoundingInfo(),
+            dispose: () => { },
+        };
+    }
+    _retainMergedPartData(existingVertexCount, totalCount, others, shDegree) {
+        if (!this._keepInRam && !this._alwaysRetainSplatsData) {
+            this._splatsData = null;
+            this._shData = null;
+            return;
+        }
+        const getSourceBuffer = (data) => {
+            return data instanceof ArrayBuffer ? data : data.buffer;
+        };
+        const mergedSplatsData = new Uint8Array(totalCount * _GaussianSplattingBytesPerSplat);
+        let splatByteOffset = 0;
+        if (this._splatsData && existingVertexCount > 0) {
+            mergedSplatsData.set(new Uint8Array(getSourceBuffer(this._splatsData), 0, existingVertexCount * _GaussianSplattingBytesPerSplat), splatByteOffset);
+            splatByteOffset += existingVertexCount * _GaussianSplattingBytesPerSplat;
+        }
+        for (const other of others) {
+            if (!other._splatsData) {
+                continue;
+            }
+            const splatByteLength = other._vertexCount * _GaussianSplattingBytesPerSplat;
+            mergedSplatsData.set(new Uint8Array(getSourceBuffer(other._splatsData), 0, splatByteLength), splatByteOffset);
+            splatByteOffset += splatByteLength;
+        }
+        this._splatsData = mergedSplatsData.buffer;
+        if (shDegree <= 0) {
+            this._shData = null;
+            return;
+        }
+        const mergedShData = [];
+        for (let textureIndex = 0; textureIndex < shDegree; textureIndex++) {
+            mergedShData.push(new Uint8Array(totalCount * _GaussianSplattingBytesPerShTexel));
+        }
+        let shByteOffset = 0;
+        if (this._shData && existingVertexCount > 0) {
+            const existingShByteLength = existingVertexCount * _GaussianSplattingBytesPerShTexel;
+            for (let textureIndex = 0; textureIndex < mergedShData.length; textureIndex++) {
+                if (textureIndex < this._shData.length) {
+                    mergedShData[textureIndex].set(this._shData[textureIndex].subarray(0, existingShByteLength), shByteOffset);
+                }
+            }
+            shByteOffset += existingShByteLength;
+        }
+        for (const other of others) {
+            const otherShByteLength = other._vertexCount * _GaussianSplattingBytesPerShTexel;
+            if (other._shData) {
+                for (let textureIndex = 0; textureIndex < mergedShData.length; textureIndex++) {
+                    if (textureIndex < other._shData.length) {
+                        mergedShData[textureIndex].set(other._shData[textureIndex].subarray(0, otherShByteLength), shByteOffset);
+                    }
+                }
+            }
+            shByteOffset += otherShByteLength;
+        }
+        this._shData = mergedShData;
+    }
     /**
-     * Core implementation for adding one or more external GaussianSplattingMesh objects as new
-     * parts. Writes directly into texture-sized CPU arrays and uploads in one pass — no merged
-     * CPU splat buffer is ever constructed.
+     * Core implementation for adding one or more source parts as new
+     * parts. Writes directly into texture-sized CPU arrays, updates the retained merged source
+     * buffers, and uploads in one pass.
      *
      * @param others - Source meshes to append (must each be non-compound and fully loaded)
      * @param disposeOthers - Dispose source meshes after appending
@@ -355,6 +481,7 @@ export class GaussianSplattingMesh extends GaussianSplattingMeshBase {
         this._partIndices = new Uint8Array(textureLength);
         this._partIndices.set(partIndicesA.subarray(0, splatCountA));
         const assignedPartIndices = [];
+        const assignedSplatsDataOffsets = [];
         let dstOffset = splatCountA;
         const maxPartCount = GetGaussianSplattingMaxPartCount(this._scene.getEngine());
         for (const other of others) {
@@ -363,6 +490,7 @@ export class GaussianSplattingMesh extends GaussianSplattingMeshBase {
             }
             const newPartIndex = nextPartIndex++;
             assignedPartIndices.push(newPartIndex);
+            assignedSplatsDataOffsets.push(dstOffset);
             this._partIndices.fill(newPartIndex, dstOffset, dstOffset + other._vertexCount);
             dstOffset += other._vertexCount;
         }
@@ -394,7 +522,7 @@ export class GaussianSplattingMesh extends GaussianSplattingMeshBase {
                     // Rebuild the compound's legacy "own" data at part 0 (scenario A only).
                     // Skipped in the preferred empty-composer path (scenario B).
                     if (!this._partProxies[0] && this._splatsData) {
-                        const proxyVertexCount = this._partProxies.reduce((sum, proxy) => sum + (proxy ? proxy.proxiedMesh._vertexCount : 0), 0);
+                        const proxyVertexCount = this._partProxies.reduce((sum, proxy) => sum + (proxy ? proxy._vertexCount : 0), 0);
                         const part0Count = splatCountA - proxyVertexCount;
                         if (part0Count > 0) {
                             const uBufA = new Uint8Array(this._splatsData);
@@ -417,11 +545,15 @@ export class GaussianSplattingMesh extends GaussianSplattingMeshBase {
                     // scenario B, part 0 is itself a proxied part with no implicit "own" data.
                     for (let partIndex = 0; partIndex < this._partProxies.length; partIndex++) {
                         const proxy = this._partProxies[partIndex];
-                        if (!proxy || !proxy.proxiedMesh) {
+                        if (!proxy) {
                             continue;
                         }
-                        this._appendSourceToArrays(proxy.proxiedMesh, rebuildOffset, covA, covB, colorArray, sh, minimum, maximum);
-                        rebuildOffset += proxy.proxiedMesh._vertexCount;
+                        const source = this._createRetainedPartSource(proxy);
+                        if (!source) {
+                            throw new Error(`Cannot rebuild compound part "${proxy.name}": the retained compound source data is not available.`);
+                        }
+                        this._appendPartSourceToArrays(source, rebuildOffset, covA, covB, colorArray, sh, minimum, maximum);
+                        rebuildOffset += source._vertexCount;
                     }
                 }
                 else {
@@ -474,7 +606,7 @@ export class GaussianSplattingMesh extends GaussianSplattingMeshBase {
                     // Handles both layouts (see full-rebuild comment above):
                     //   A) LEGACY: _partProxies[0] absent → seed lookup[0] with this._splatsData
                     //   B) PREFERRED: _partProxies[0] present → all entries filled from proxies
-                    const proxyTotal = this._partProxies.reduce((s, p) => s + (p ? p.proxiedMesh._vertexCount : 0), 0);
+                    const proxyTotal = this._partProxies.reduce((s, p) => s + (p ? p._vertexCount : 0), 0);
                     const part0Count = splatCountA - proxyTotal; // > 0 only in legacy scenario A
                     const srcUBufs = new Array(this._partProxies.length).fill(null);
                     const srcFBufs = new Array(this._partProxies.length).fill(null);
@@ -489,14 +621,17 @@ export class GaussianSplattingMesh extends GaussianSplattingMeshBase {
                     let cumOffset = part0Count;
                     for (let pi = 0; pi < this._partProxies.length; pi++) {
                         const proxy = this._partProxies[pi];
-                        if (!proxy?.proxiedMesh) {
+                        if (!proxy) {
                             continue;
                         }
-                        const srcData = proxy.proxiedMesh._splatsData ?? null;
-                        srcUBufs[pi] = srcData ? new Uint8Array(srcData) : null;
-                        srcFBufs[pi] = srcData ? new Float32Array(srcData) : null;
+                        const source = this._createRetainedPartSource(proxy);
+                        if (!source || !source._splatsData) {
+                            throw new Error(`Cannot rebuild compound part "${proxy.name}": the retained compound source data is not available.`);
+                        }
+                        srcUBufs[pi] = new Uint8Array(source._splatsData);
+                        srcFBufs[pi] = new Float32Array(source._splatsData);
                         partStarts[pi] = cumOffset;
-                        cumOffset += proxy.proxiedMesh._vertexCount;
+                        cumOffset += source._vertexCount;
                     }
                     for (let splatIdx = firstNewTexel; splatIdx < splatCountA; splatIdx++) {
                         const partIdx = this._partIndices ? this._partIndices[splatIdx] : 0;
@@ -512,7 +647,7 @@ export class GaussianSplattingMesh extends GaussianSplattingMeshBase {
         // Append each new source
         dstOffset = splatCountA;
         for (const other of others) {
-            this._appendSourceToArrays(other, dstOffset, covA, covB, colorArray, sh, minimum, maximum);
+            this._appendPartSourceToArrays(other, dstOffset, covA, covB, colorArray, sh, minimum, maximum);
             dstOffset += other._vertexCount;
         }
         // Pad empty splats to texture boundary
@@ -524,50 +659,82 @@ export class GaussianSplattingMesh extends GaussianSplattingMeshBase {
         if (totalCount !== this._vertexCount) {
             this._updateSplatIndexBuffer(totalCount);
         }
+        this._retainMergedPartData(splatCountA, totalCount, others, shDegreeNew);
         this._vertexCount = totalCount;
         this._shDegree = shDegreeNew;
-        // --- Upload to GPU ---
-        if (incremental) {
-            // Update the part-indices texture (handles both create and update-in-place).
-            // _ensurePartIndicesTexture is a no-op when the texture already exists, so on the
-            // second+ addPart the partIndices would be stale without this call.
-            this._onUpdateTextures(textureSize);
-            this._updateSubTextures(this._splatPositions, covA, covB, colorArray, firstNewLine, textureSize.y - firstNewLine, sh);
-        }
-        else {
-            this._updateTextures(covA, covB, colorArray, sh);
-        }
-        this.getBoundingInfo().reConstruct(minimum, maximum, this.getWorldMatrix());
-        this.setEnabled(true);
-        this._cachedBoundingMin = minimum.clone();
-        this._cachedBoundingMax = maximum.clone();
-        this._notifyWorkerNewData();
-        // --- Create proxy meshes ---
-        const proxyMeshes = [];
-        for (let i = 0; i < others.length; i++) {
-            const other = others[i];
-            const newPartIndex = assignedPartIndices[i];
-            const partWorldMatrix = other.getWorldMatrix();
-            this.setWorldMatrixForPart(newPartIndex, partWorldMatrix);
-            const proxyMesh = new GaussianSplattingPartProxyMesh(other.name, this.getScene(), this, other, newPartIndex);
-            if (disposeOthers) {
-                other.dispose();
+        // Gate the sort worker for the duration of this operation. _updateTextures (below) may create the worker and fire an
+        // immediate sort via _postToWorker. At that point partMatrices has not yet been updated for the incoming parts, so the
+        // worker would compute depthCoeffs for fewer parts than partIndices references — crashing with
+        // "Cannot read properties of undefined (reading '0')".
+        // When called from removePart, _rebuilding is already true and _canPostToWorker is already false, so the gate is a
+        // no-op — removePart handles the final post+sort.
+        const needsWorkerGate = !this._rebuilding;
+        if (needsWorkerGate) {
+            this._canPostToWorker = false;
+            this._rebuilding = true;
+        }
+        try {
+            // --- Upload to GPU ---
+            if (incremental) {
+                // Update the part-indices texture (handles both create and update-in-place).
+                // _ensurePartIndicesTexture is a no-op when the texture already exists, so on the
+                // second+ addPart the partIndices would be stale without this call.
+                this._onUpdateTextures(textureSize);
+                this._updateSubTextures(this._splatPositions, covA, covB, colorArray, firstNewLine, textureSize.y - firstNewLine, sh);
             }
-            const quaternion = new Quaternion();
-            partWorldMatrix.decompose(proxyMesh.scaling, quaternion, proxyMesh.position);
-            proxyMesh.rotationQuaternion = quaternion;
-            proxyMesh.computeWorldMatrix(true);
-            this._partProxies[newPartIndex] = proxyMesh;
-            proxyMeshes.push(proxyMesh);
+            else {
+                this._updateTextures(covA, covB, colorArray, sh);
+            }
+            this.getBoundingInfo().reConstruct(minimum, maximum, this.getWorldMatrix());
+            this.setEnabled(true);
+            this._cachedBoundingMin = minimum.clone();
+            this._cachedBoundingMax = maximum.clone();
+            this._notifyWorkerNewData();
+            // --- Create proxy meshes ---
+            const proxyMeshes = [];
+            for (let i = 0; i < others.length; i++) {
+                const other = others[i];
+                const newPartIndex = assignedPartIndices[i];
+                const partWorldMatrix = other.getWorldMatrix();
+                this.setWorldMatrixForPart(newPartIndex, partWorldMatrix);
+                const proxyMesh = new GaussianSplattingPartProxyMesh(other.name, this.getScene(), this, newPartIndex, other.getBoundingInfo(), other._vertexCount, assignedSplatsDataOffsets[i], assignedSplatsDataOffsets[i]);
+                if (disposeOthers) {
+                    other.dispose();
+                }
+                const quaternion = new Quaternion();
+                partWorldMatrix.decompose(proxyMesh.scaling, quaternion, proxyMesh.position);
+                proxyMesh.rotationQuaternion = quaternion;
+                proxyMesh.computeWorldMatrix(true);
+                this._partProxies[newPartIndex] = proxyMesh;
+                proxyMeshes.push(proxyMesh);
+            }
+            // Restore the rebuild gate and post the now-complete partMatrices in one message, then trigger a single sort pass.
+            // This ensures the worker sees a consistent partMatrices array that matches the partIndices for every splat.
+            if (needsWorkerGate) {
+                this._rebuilding = false;
+                if (this._worker) {
+                    this._worker.postMessage({ partMatrices: this._partMatrices.map((matrix) => new Float32Array(matrix.m)) });
+                }
+                this._canPostToWorker = true;
+                this._postToWorker(true);
+            }
+            return { proxyMeshes, assignedPartIndices };
+        }
+        catch (e) {
+            // Ensure the gates are always restored so sorting is not permanently frozen.
+            if (needsWorkerGate) {
+                this._rebuilding = false;
+                this._canPostToWorker = true;
+            }
+            throw e;
         }
-        return { proxyMeshes, assignedPartIndices };
     }
     // ---------------------------------------------------------------------------
     // Public compound API
     // ---------------------------------------------------------------------------
     /**
      * Add another mesh to this mesh, as a new part. This makes the current mesh a compound, if not already.
-     * The source mesh's splat data is read directly — no merged CPU buffer is constructed.
+     * The source mesh's splat data is read directly and copied into the compound's retained source buffers.
      * @param other - The other mesh to add. Must be fully loaded before calling this method.
      * @param disposeOther - Whether to dispose the other mesh after adding it to the current mesh.
      * @returns a placeholder mesh that can be used to manipulate the part transform
@@ -579,9 +746,9 @@ export class GaussianSplattingMesh extends GaussianSplattingMeshBase {
     }
     /**
      * Remove a part from this compound mesh.
-     * The remaining parts are rebuilt directly from their stored source mesh references —
-     * no merged CPU splat buffer is read back. The current mesh is reset to a plain (single-part)
-     * state and then each remaining source is re-added via addParts.
+     * The remaining parts are rebuilt directly from the compound mesh's retained source buffers.
+     * The current mesh is reset to a plain (single-part) state and then each remaining source is
+     * re-added via addParts.
      * @param index - The index of the part to remove
      * @deprecated Use {@link GaussianSplattingCompoundMesh.removePart} instead.
      */
@@ -593,15 +760,23 @@ export class GaussianSplattingMesh extends GaussianSplattingMeshBase {
         const survivors = [];
         for (let proxyIndex = 0; proxyIndex < this._partProxies.length; proxyIndex++) {
             const proxy = this._partProxies[proxyIndex];
-            if (proxy && proxyIndex !== index) {
-                survivors.push({ proxyMesh: proxy, oldIndex: proxyIndex, worldMatrix: proxy.getWorldMatrix().clone(), visibility: this._partVisibility[proxyIndex] ?? 1.0 });
+            if (!proxy || proxyIndex === index) {
+                continue;
+            }
+            const source = this._createRetainedPartSource(proxy);
+            if (!source) {
+                throw new Error(`Cannot remove part: the retained compound source data is not available for part "${proxy.name}".`);
             }
+            survivors.push({ proxyMesh: proxy, source, oldIndex: proxyIndex, worldMatrix: proxy.getWorldMatrix().clone(), visibility: this._partVisibility[proxyIndex] ?? 1.0 });
         }
         survivors.sort((a, b) => a.oldIndex - b.oldIndex);
         // Validate every survivor still has its source data. If even one is missing we cannot rebuild.
-        for (const { proxyMesh } of survivors) {
-            if (!proxyMesh.proxiedMesh._splatsData) {
-                throw new Error(`Cannot remove part: the source mesh for part "${proxyMesh.name}" no longer has its splat data available.`);
+        for (const { proxyMesh, source } of survivors) {
+            if (!source._splatsData) {
+                throw new Error(`Cannot remove part: the source data for part "${proxyMesh.name}" is not available.`);
+            }
+            if (source._shDegree > 0 && !source._shData) {
+                throw new Error(`Cannot remove part: the SH data for part "${proxyMesh.name}" is not available.`);
             }
         }
         // --- Reset this mesh to an empty state ---
@@ -641,6 +816,9 @@ export class GaussianSplattingMesh extends GaussianSplattingMeshBase {
         this._partVisibility = [];
         this._cachedBoundingMin = null;
         this._cachedBoundingMax = null;
+        this._splatsData = null;
+        this._shData = null;
+        this._shDegree = 0;
         // Remove the proxy for the removed part and dispose it
         const proxyToRemove = this._partProxies[index];
         if (proxyToRemove) {
@@ -657,34 +835,145 @@ export class GaussianSplattingMesh extends GaussianSplattingMeshBase {
         // Gate the sort worker: suppress any sort request until the full rebuild is committed.
         this._rebuilding = true;
         this._canPostToWorker = false;
-        const sources = survivors.map((s) => s.proxyMesh.proxiedMesh);
-        const { proxyMeshes: newProxies } = this._addPartsInternal(sources, false);
-        // Restore world matrices and re-map proxies
-        for (let i = 0; i < survivors.length; i++) {
-            const oldProxy = survivors[i].proxyMesh;
-            const newProxy = newProxies[i];
-            const newPartIndex = newProxy.partIndex;
-            // Restore the world matrix and visibility the user had set on the old proxy
-            this.setWorldMatrixForPart(newPartIndex, survivors[i].worldMatrix);
-            this.setPartVisibility(newPartIndex, survivors[i].visibility);
-            const quaternion = new Quaternion();
-            survivors[i].worldMatrix.decompose(newProxy.scaling, quaternion, newProxy.position);
-            newProxy.rotationQuaternion = quaternion;
-            newProxy.computeWorldMatrix(true);
-            // Update the old proxy's index so any existing user references still work
-            oldProxy.updatePartIndex(newPartIndex);
-            this._partProxies[newPartIndex] = oldProxy;
-            // newProxy is redundant — it was created inside _addPartsInternal; dispose it
-            newProxy.dispose();
-        }
-        // Rebuild is complete: all partMatrices are now set correctly.
-        // Post the final complete set and fire one sort.
-        this._rebuilding = false;
-        // Break TypeScript's flow narrowing — _addPartsInternal may have reinstantiated _worker.
-        const workerAfterRebuild = this._worker;
-        workerAfterRebuild?.postMessage({ partMatrices: this._partMatrices.map((matrix) => new Float32Array(matrix.m)) });
-        this._canPostToWorker = true;
-        this._postToWorker(true);
+        try {
+            const sources = survivors.map((s) => s.source);
+            const { proxyMeshes: newProxies } = this._addPartsInternal(sources, false);
+            // Restore world matrices and re-map proxies
+            for (let i = 0; i < survivors.length; i++) {
+                const oldProxy = survivors[i].proxyMesh;
+                const newProxy = newProxies[i];
+                const newPartIndex = newProxy.partIndex;
+                // Restore the world matrix and visibility the user had set on the old proxy
+                this.setWorldMatrixForPart(newPartIndex, survivors[i].worldMatrix);
+                this.setPartVisibility(newPartIndex, survivors[i].visibility);
+                const quaternion = new Quaternion();
+                survivors[i].worldMatrix.decompose(newProxy.scaling, quaternion, newProxy.position);
+                newProxy.rotationQuaternion = quaternion;
+                newProxy.computeWorldMatrix(true);
+                // Update the old proxy's index and metadata so existing user references still work.
+                oldProxy.updatePartIndex(newPartIndex);
+                oldProxy.updatePartMetadata(newProxy._vertexCount, newProxy._splatsDataOffset, newProxy._shDataOffset);
+                this._partProxies[newPartIndex] = oldProxy;
+                // newProxy is redundant — it was created inside _addPartsInternal; dispose it
+                newProxy.dispose();
+            }
+            // Rebuild is complete: all partMatrices are now set correctly.
+            // Post the final complete set and fire one sort.
+            this._rebuilding = false;
+            // Break TypeScript's flow narrowing — _addPartsInternal may have reinstantiated _worker.
+            const workerAfterRebuild = this._worker;
+            workerAfterRebuild?.postMessage({ partMatrices: this._partMatrices.map((matrix) => new Float32Array(matrix.m)) });
+            this._canPostToWorker = true;
+            this._postToWorker(true);
+        }
+        catch (e) {
+            // Ensure the gates are always restored so sorting is not permanently frozen.
+            this._rebuilding = false;
+            this._canPostToWorker = true;
+            throw e;
+        }
+    }
+    /**
+     * Serialize current GaussianSplattingMesh
+     * @param serializationObject defines the object which will receive the serialization data
+     * @param encoding the encoding of binary data, defaults to base64 for json serialize,
+     * kept for future internal use like cloning where base64 encoding wastes cycles and memory
+     * @returns the serialized object
+     */
+    serialize(serializationObject = {}, encoding = "base64") {
+        serializationObject = super.serialize(serializationObject);
+        serializationObject.subMeshes = [];
+        serializationObject.geometryUniqueId = undefined;
+        serializationObject.geometryId = undefined;
+        serializationObject.materialUniqueId = undefined;
+        serializationObject.materialId = undefined;
+        serializationObject.instances = [];
+        serializationObject.actions = undefined;
+        serializationObject.type = this.getClassName();
+        serializationObject.keepInRam = this._keepInRam;
+        serializationObject.disableDepthSort = this._disableDepthSort;
+        serializationObject.viewUpdateThreshold = this.viewUpdateThreshold;
+        serializationObject._flipY = this._flipY;
+        if (this._splatsData) {
+            serializationObject.splatsData = encoding === "base64" ? EncodeArrayBufferToBase64(this._splatsData) : this._splatsData;
+        }
+        if (this._shData) {
+            serializationObject.shData = encoding === "base64" ? this._shData.map(EncodeArrayBufferToBase64) : this._shData;
+        }
+        if (this._partIndices) {
+            const compressedIndices = CompressPartIndices(this._partIndices.subarray(0, this._vertexCount));
+            serializationObject.partIndices = encoding === "base64" ? EncodeArrayBufferToBase64(compressedIndices) : compressedIndices;
+        }
+        if (this._partProxies.length) {
+            serializationObject.partProxies = this._partProxies.filter((proxy) => !!proxy).map((proxy) => proxy.serialize());
+        }
+        return serializationObject;
+    }
+    /**
+     * Internal helper to parses a serialized GaussianSplattingMesh or GaussianSplattingCompoundMesh
+     * @param parsedMesh the serialized mesh
+     * @param scene the scene to create the GaussianSplattingMesh or GaussianSplattingCompoundMesh in
+     * @param ctor the constructor of the mesh to create
+     * @returns the created GaussianSplattingMesh
+     * @internal
+     */
+    static _ParseInternal(parsedMesh, scene, ctor) {
+        const mesh = new ctor(parsedMesh.name, null, scene, parsedMesh.keepInRam);
+        mesh.disableDepthSort = parsedMesh.disableDepthSort ?? false;
+        mesh.viewUpdateThreshold = parsedMesh.viewUpdateThreshold ?? GaussianSplattingMeshBase._DefaultViewUpdateThreshold;
+        let splatsData = parsedMesh.splatsData;
+        if (typeof splatsData === "string") {
+            splatsData = DecodeBase64ToBinary(splatsData);
+        }
+        const shData = parsedMesh.shData;
+        let parsedShData;
+        if (Array.isArray(shData) && shData.length) {
+            const newData = [];
+            for (let i = 0, length = shData.length; i < length; i++) {
+                const data = shData[i];
+                if (typeof data === "string") {
+                    newData[i] = new Uint8Array(DecodeBase64ToBinary(data));
+                }
+                else {
+                    newData[i] = data;
+                }
+            }
+            parsedShData = newData;
+        }
+        let partIndices = parsedMesh.partIndices;
+        let parsedPartIndices;
+        if (typeof partIndices === "string") {
+            partIndices = new Uint32Array(DecodeBase64ToBinary(partIndices));
+        }
+        if (partIndices) {
+            parsedPartIndices = ParsePartIndices(partIndices);
+        }
+        if (splatsData) {
+            const flipY = parsedMesh._flipY ?? false;
+            mesh.updateData(splatsData, parsedShData, { flipY }, parsedPartIndices);
+        }
+        if (parsedMesh.partProxies) {
+            for (const serializedPart of parsedMesh.partProxies) {
+                const part = Object.assign({}, serializedPart);
+                part.compoundSplatMesh = mesh;
+                const proxyMesh = Mesh.Parse(part, scene, "");
+                const newPartIndex = proxyMesh.partIndex;
+                mesh._partProxies[newPartIndex] = proxyMesh;
+                mesh.setWorldMatrixForPart(newPartIndex, proxyMesh.getWorldMatrix());
+                mesh.setPartVisibility(newPartIndex, proxyMesh.visibility);
+            }
+        }
+        return mesh;
+    }
+    /**
+     * Parses a serialized GaussianSplattingMesh
+     * @param parsedMesh the serialized mesh
+     * @param scene the scene to create the GaussianSplattingMesh in
+     * @returns the created GaussianSplattingMesh
+     */
+    static Parse(parsedMesh, scene) {
+        return GaussianSplattingMesh._ParseInternal(parsedMesh, scene, GaussianSplattingMesh);
     }
 }
+Mesh._GaussianSplattingMeshParser = GaussianSplattingMesh.Parse;
 //# sourceMappingURL=gaussianSplattingMesh.js.map