@babylonjs/core 9.2.1 → 9.3.0

package/Meshes/GaussianSplatting/gaussianSplattingMesh.d.ts

@@ -5,6 +5,18 @@ import { type Effect } from "../../Materials/effect.js";
 import { GaussianSplattingMeshBase } from "./gaussianSplattingMeshBase.js";
 import "../thinInstanceMesh.js";
 import { GaussianSplattingPartProxyMesh } from "./gaussianSplattingPartProxyMesh.js";
+import { type BoundingInfo } from "../../Culling/boundingInfo.js";
+interface IGaussianSplattingPartSource {
+    name: string;
+    _vertexCount: number;
+    _splatsData: Nullable<ArrayBuffer>;
+    _shData: Nullable<Uint8Array[]>;
+    _shDegree: number;
+    isCompound: boolean;
+    getWorldMatrix(): Matrix;
+    getBoundingInfo(): BoundingInfo;
+    dispose(): void;
+}
 /**
  * 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
@@ -140,22 +152,25 @@ export declare class GaussianSplattingMesh extends GaussianSplattingMeshBase {
      * @param partIndices - Part index data; if undefined the method is a no-op
      */
     protected _ensurePartIndicesTexture(textureSize: Vector2, partIndices: Uint8Array | undefined): void;
+    private _appendPartSourceToArrays;
+    private _createRetainedPartSource;
+    private _retainMergedPartData;
     /**
-     * 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
      * @returns Proxy meshes and their assigned part indices
      */
-    protected _addPartsInternal(others: GaussianSplattingMesh[], disposeOthers: boolean): {
+    protected _addPartsInternal(others: IGaussianSplattingPartSource[], disposeOthers: boolean): {
         proxyMeshes: GaussianSplattingPartProxyMesh[];
         assignedPartIndices: number[];
     };
     /**
      * 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
@@ -164,11 +179,36 @@ export declare class GaussianSplattingMesh extends GaussianSplattingMeshBase {
     addPart(other: GaussianSplattingMesh, disposeOther?: boolean): GaussianSplattingPartProxyMesh;
     /**
      * 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.
      */
     removePart(index: number): void;
+    /**
+     * 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?: any, encoding?: string): any;
+    /**
+     * 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<T extends GaussianSplattingMesh>(parsedMesh: any, scene: Scene, ctor: new (name: string, url: Nullable<string>, scene: Nullable<Scene>, keepInRam: boolean) => T): T;
+    /**
+     * 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: any, scene: Scene): GaussianSplattingMesh;
 }
+export {};

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,6 +659,7 @@ export class GaussianSplattingMesh extends GaussianSplattingMeshBase {
         if (totalCount !== this._vertexCount) {
             this._updateSplatIndexBuffer(totalCount);
         }
+        this._retainMergedPartData(splatCountA, totalCount, others, shDegreeNew);
         this._vertexCount = totalCount;
         this._shDegree = shDegreeNew;
         // Gate the sort worker for the duration of this operation. _updateTextures (below) may create the worker and fire an
@@ -561,7 +697,7 @@ export class GaussianSplattingMesh extends GaussianSplattingMeshBase {
                 const newPartIndex = assignedPartIndices[i];
                 const partWorldMatrix = other.getWorldMatrix();
                 this.setWorldMatrixForPart(newPartIndex, partWorldMatrix);
-                const proxyMesh = new GaussianSplattingPartProxyMesh(other.name, this.getScene(), this, other, newPartIndex);
+                const proxyMesh = new GaussianSplattingPartProxyMesh(other.name, this.getScene(), this, newPartIndex, other.getBoundingInfo(), other._vertexCount, assignedSplatsDataOffsets[i], assignedSplatsDataOffsets[i]);
                 if (disposeOthers) {
                     other.dispose();
                 }
@@ -598,7 +734,7 @@ export class GaussianSplattingMesh extends GaussianSplattingMeshBase {
     // ---------------------------------------------------------------------------
     /**
      * 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
@@ -610,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.
      */
@@ -624,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 ---
@@ -672,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) {
@@ -689,7 +836,7 @@ export class GaussianSplattingMesh extends GaussianSplattingMeshBase {
         this._rebuilding = true;
         this._canPostToWorker = false;
         try {
-            const sources = survivors.map((s) => s.proxyMesh.proxiedMesh);
+            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++) {
@@ -703,8 +850,9 @@ export class GaussianSplattingMesh extends GaussianSplattingMeshBase {
                 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
+                // 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();
@@ -725,5 +873,107 @@ export class GaussianSplattingMesh extends GaussianSplattingMeshBase {
             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