GaussianSplattingMesh: serialization support

packages/dev/core/src/Loading/Plugins/babylonFileLoader.ts

@@ -464,6 +464,21 @@ const LoadAssetContainer = (scene: Scene, data: string | object, rootUrl: string
                         instance._parentContainer = container;
                     }
                 }
+                // Load partProxies from GaussianSplattingMesh into AssetContainer
+                if (mesh.getClassName() === "GaussianSplattingMesh") {
+                    const partProxies = (mesh as any)._partProxies as AbstractMesh[] | Map<number, AbstractMesh> | undefined;
+                    const proxies = Array.isArray(partProxies) ? partProxies : partProxies ? Array.from(partProxies.values()) : [];
+                    for (const partProxy of proxies) {
+                        if (!partProxy) {
+                            continue;
+                        }
+                        container.meshes.push(partProxy);
+                        partProxy._parentContainer = container;
+                        if (partProxy._waitingParsedUniqueId != null) {
+                            TempIndexContainer[partProxy._waitingParsedUniqueId] = partProxy;
+                        }
+                    }
+                }
                 log += index === 0 ? "\n\tMeshes:" : "";
                 log += "\n\t\t" + mesh.toString(fullDetails);
             }
@@ -1000,6 +1015,17 @@ RegisterSceneLoaderPlugin({
                         meshes.push(mesh);
                         parsedIdToNodeMap.set(mesh._waitingParsedUniqueId!, mesh);
                         mesh._waitingParsedUniqueId = null;
+                        if (mesh.getClassName() === "GaussianSplattingMesh") {
+                            const partProxies = (mesh as any)._partProxies as AbstractMesh[] | Map<number, AbstractMesh> | undefined;
+                            const proxies = Array.isArray(partProxies) ? partProxies : partProxies ? Array.from(partProxies.values()) : [];
+                            for (const partProxy of proxies) {
+                                if (!partProxy || partProxy._waitingParsedUniqueId == null) {
+                                    continue;
+                                }
+                                parsedIdToNodeMap.set(partProxy._waitingParsedUniqueId, partProxy);
+                                partProxy._waitingParsedUniqueId = null;
+                            }
+                        }
                         log += "\n\tMesh " + mesh.toString(fullDetails);
                     }
                 }

packages/dev/core/src/Materials/GaussianSplatting/gaussianSplattingMaterial.ts

@@ -597,6 +597,7 @@ export class GaussianSplattingMaterial extends PushMaterial {
                 needAlphaBlending: alphaBlendedDepth,
             }
         );
+        shaderMaterial.doNotSerialize = true;
         shaderMaterial.backFaceCulling = false;
         shaderMaterial.onBindObservable.add((mesh: AbstractMesh) => {
             const gsMaterial = mesh.material as GaussianSplattingMaterial;
@@ -622,6 +623,7 @@ export class GaussianSplattingMaterial extends PushMaterial {
                 shaderLanguage: shaderLanguage,
             }
         );
+        shaderMaterial.doNotSerialize = true;
         shaderMaterial.backFaceCulling = false;
 
         const shadowDepthWrapper = new ShadowDepthWrapper(shaderMaterial, scene, {

packages/dev/core/src/Meshes/GaussianSplatting/gaussianSplattingCompoundMesh.ts

@@ -2,6 +2,7 @@ import { type Nullable } from "core/types";
 import { type Scene } from "core/scene";
 import { GaussianSplattingMesh } from "./gaussianSplattingMesh";
 import { type GaussianSplattingPartProxyMesh } from "./gaussianSplattingPartProxyMesh";
+import { Mesh } from "../mesh";
 
 /**
  * Class used to compose multiple Gaussian Splatting meshes into a single draw call,
@@ -26,7 +27,7 @@ export class GaussianSplattingCompoundMesh extends GaussianSplattingMesh {
 
     /**
      * Add another mesh to this compound mesh as a new part.
-     * 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.
      * @returns a placeholder mesh that can be used to manipulate the part transform
@@ -37,7 +38,7 @@ export class GaussianSplattingCompoundMesh extends GaussianSplattingMesh {
 
     /**
      * Add multiple meshes to this compound mesh as new parts in a single operation.
-     * Splat data is written directly into texture arrays without constructing a merged CPU buffer.
+     * Splat data is written into texture arrays while the compound refreshes its retained merged source buffers.
      * @param others - The meshes to add. Each must be fully loaded and must not be a compound.
      * @param disposeOthers - Whether to dispose the other meshes after adding them.
      * @returns an array of placeholder meshes that can be used to manipulate the part transforms
@@ -52,11 +53,38 @@ export class GaussianSplattingCompoundMesh extends GaussianSplattingMesh {
 
     /**
      * 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 remaining parts are rebuilt directly from the compound mesh's retained source buffers.
      * @param index - The index of the part to remove
      */
     public override removePart(index: number): void {
         super.removePart(index);
     }
+
+    /**
+     * 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
+     */
+    public override serialize(serializationObject: any = {}, encoding: string = "base64"): any {
+        serializationObject = super.serialize(serializationObject, encoding);
+        // Note here, the getClassName() is not overridden,
+        // as a lot of code currently depend on `getClassName() === "GaussianSplattingMesh"` check,
+        // to not break those code, serialization uses `_isCompound` to mark the type
+        serializationObject._isCompound = true;
+        return serializationObject;
+    }
+
+    /**
+     * Parses a serialized GaussianSplattingCompoundMesh
+     * @param parsedMesh the serialized mesh
+     * @param scene the scene to create the GaussianSplattingCompoundMesh in
+     * @returns the created GaussianSplattingCompoundMesh
+     */
+    public static override Parse(parsedMesh: any, scene: Scene): GaussianSplattingCompoundMesh {
+        return GaussianSplattingMesh._ParseInternal(parsedMesh, scene, GaussianSplattingCompoundMesh);
+    }
 }
+
+Mesh._GaussianSplattingCompoundMeshParser = GaussianSplattingCompoundMesh.Parse;