@babylonjs/core 9.2.0 → 9.2.2

package/Meshes/GaussianSplatting/gaussianSplattingMeshBase.js

@@ -157,7 +157,34 @@ var PLYValue;
     PLYValue[PLYValue["SH_42"] = 82] = "SH_42";
     PLYValue[PLYValue["SH_43"] = 83] = "SH_43";
     PLYValue[PLYValue["SH_44"] = 84] = "SH_44";
-    PLYValue[PLYValue["UNDEFINED"] = 85] = "UNDEFINED";
+    PLYValue[PLYValue["SH_45"] = 85] = "SH_45";
+    PLYValue[PLYValue["SH_46"] = 86] = "SH_46";
+    PLYValue[PLYValue["SH_47"] = 87] = "SH_47";
+    PLYValue[PLYValue["SH_48"] = 88] = "SH_48";
+    PLYValue[PLYValue["SH_49"] = 89] = "SH_49";
+    PLYValue[PLYValue["SH_50"] = 90] = "SH_50";
+    PLYValue[PLYValue["SH_51"] = 91] = "SH_51";
+    PLYValue[PLYValue["SH_52"] = 92] = "SH_52";
+    PLYValue[PLYValue["SH_53"] = 93] = "SH_53";
+    PLYValue[PLYValue["SH_54"] = 94] = "SH_54";
+    PLYValue[PLYValue["SH_55"] = 95] = "SH_55";
+    PLYValue[PLYValue["SH_56"] = 96] = "SH_56";
+    PLYValue[PLYValue["SH_57"] = 97] = "SH_57";
+    PLYValue[PLYValue["SH_58"] = 98] = "SH_58";
+    PLYValue[PLYValue["SH_59"] = 99] = "SH_59";
+    PLYValue[PLYValue["SH_60"] = 100] = "SH_60";
+    PLYValue[PLYValue["SH_61"] = 101] = "SH_61";
+    PLYValue[PLYValue["SH_62"] = 102] = "SH_62";
+    PLYValue[PLYValue["SH_63"] = 103] = "SH_63";
+    PLYValue[PLYValue["SH_64"] = 104] = "SH_64";
+    PLYValue[PLYValue["SH_65"] = 105] = "SH_65";
+    PLYValue[PLYValue["SH_66"] = 106] = "SH_66";
+    PLYValue[PLYValue["SH_67"] = 107] = "SH_67";
+    PLYValue[PLYValue["SH_68"] = 108] = "SH_68";
+    PLYValue[PLYValue["SH_69"] = 109] = "SH_69";
+    PLYValue[PLYValue["SH_70"] = 110] = "SH_70";
+    PLYValue[PLYValue["SH_71"] = 111] = "SH_71";
+    PLYValue[PLYValue["UNDEFINED"] = 112] = "UNDEFINED";
 })(PLYValue || (PLYValue = {}));
 /**
  * Base class for Gaussian Splatting meshes. Contains all single-cloud rendering logic.
@@ -197,7 +224,7 @@ export class GaussianSplattingMeshBase extends Mesh {
         return this._shDegree;
     }
     set shDegree(value) {
-        const maxDegree = this._shTextures?.length ?? 0;
+        const maxDegree = this._maxShDegree;
         const clamped = Math.max(0, Math.min(Math.round(value), maxDegree));
         if (this._shDegree === clamped) {
             return;
@@ -209,7 +236,7 @@ export class GaussianSplattingMeshBase extends Mesh {
      * Maximum SH degree available from the loaded data.
      */
     get maxShDegree() {
-        return this._shTextures?.length ?? 0;
+        return this._maxShDegree;
     }
     /**
      * Number of splats in the mesh
@@ -341,6 +368,7 @@ export class GaussianSplattingMeshBase extends Mesh {
         this._textureSize = new Vector2(0, 0);
         this._keepInRam = false;
         this._alwaysRetainSplatsData = false;
+        this._flipY = false;
         this._delayedTextureUpdate = null;
         this._useRGBACovariants = false;
         this._material = null;
@@ -351,6 +379,7 @@ export class GaussianSplattingMeshBase extends Mesh {
         this._cachedBoundingMax = null;
         /** @internal */
         this._shDegree = 0;
+        this._maxShDegree = 0;
         this._cameraViewInfos = new Map();
         /**
          * Cosine value of the angle threshold to update view dependent splat sorting. Default is 0.0001.
@@ -373,6 +402,7 @@ export class GaussianSplattingMeshBase extends Mesh {
         const gaussianSplattingMaterial = new GaussianSplattingMaterial(this.name + "_material", this._scene);
         // Cast is safe: GaussianSplattingMeshBase is @internal; all concrete instances are GaussianSplattingMesh.
         gaussianSplattingMaterial.setSourceMesh(this);
+        gaussianSplattingMaterial.doNotSerialize = true;
         this._material = gaussianSplattingMaterial;
         // delete meshes created for cameras on camera removal
         this._scene.onCameraRemovedObservable.add((camera) => {
@@ -464,6 +494,7 @@ export class GaussianSplattingMeshBase extends Mesh {
             else {
                 // mesh doesn't exist yet for this camera
                 const cameraMesh = new Mesh(this.name + "_cameraMesh_" + cameraId, this._scene);
+                cameraMesh.doNotSerialize = true;
                 // not visible with inspector or the scene graph
                 cameraMesh.reservedDataStore = { hidden: true };
                 cameraMesh.setEnabled(false);
@@ -772,8 +803,62 @@ export class GaussianSplattingMeshBase extends Mesh {
                 return 83 /* PLYValue.SH_43 */;
             case "f_rest_44":
                 return 84 /* PLYValue.SH_44 */;
-        }
-        return 85 /* PLYValue.UNDEFINED */;
+            case "f_rest_45":
+                return 85 /* PLYValue.SH_45 */;
+            case "f_rest_46":
+                return 86 /* PLYValue.SH_46 */;
+            case "f_rest_47":
+                return 87 /* PLYValue.SH_47 */;
+            case "f_rest_48":
+                return 88 /* PLYValue.SH_48 */;
+            case "f_rest_49":
+                return 89 /* PLYValue.SH_49 */;
+            case "f_rest_50":
+                return 90 /* PLYValue.SH_50 */;
+            case "f_rest_51":
+                return 91 /* PLYValue.SH_51 */;
+            case "f_rest_52":
+                return 92 /* PLYValue.SH_52 */;
+            case "f_rest_53":
+                return 93 /* PLYValue.SH_53 */;
+            case "f_rest_54":
+                return 94 /* PLYValue.SH_54 */;
+            case "f_rest_55":
+                return 95 /* PLYValue.SH_55 */;
+            case "f_rest_56":
+                return 96 /* PLYValue.SH_56 */;
+            case "f_rest_57":
+                return 97 /* PLYValue.SH_57 */;
+            case "f_rest_58":
+                return 98 /* PLYValue.SH_58 */;
+            case "f_rest_59":
+                return 99 /* PLYValue.SH_59 */;
+            case "f_rest_60":
+                return 100 /* PLYValue.SH_60 */;
+            case "f_rest_61":
+                return 101 /* PLYValue.SH_61 */;
+            case "f_rest_62":
+                return 102 /* PLYValue.SH_62 */;
+            case "f_rest_63":
+                return 103 /* PLYValue.SH_63 */;
+            case "f_rest_64":
+                return 104 /* PLYValue.SH_64 */;
+            case "f_rest_65":
+                return 105 /* PLYValue.SH_65 */;
+            case "f_rest_66":
+                return 106 /* PLYValue.SH_66 */;
+            case "f_rest_67":
+                return 107 /* PLYValue.SH_67 */;
+            case "f_rest_68":
+                return 108 /* PLYValue.SH_68 */;
+            case "f_rest_69":
+                return 109 /* PLYValue.SH_69 */;
+            case "f_rest_70":
+                return 110 /* PLYValue.SH_70 */;
+            case "f_rest_71":
+                return 111 /* PLYValue.SH_71 */;
+        }
+        return 112 /* PLYValue.UNDEFINED */;
     }
     /**
      * Parse a PLY file header and returns metas infos on splats and chunks
@@ -823,12 +908,15 @@ export class GaussianSplattingMeshBase extends Mesh {
             if (prop.startsWith("property ")) {
                 const [, typeName, name] = prop.split(" ");
                 const value = GaussianSplattingMeshBase._ValueNameToEnum(name);
-                if (value != 85 /* PLYValue.UNDEFINED */) {
-                    // SH degree 1,2 or 3 for 9, 24 or 45 values
-                    if (value >= 84 /* PLYValue.SH_44 */) {
-                        shDegree = 3;
+                if (value != 112 /* PLYValue.UNDEFINED */) {
+                    // SH degree 1,2,3 or 4 for 9, 24, 45 or 72 values
+                    if (value >= 111 /* PLYValue.SH_71 */) {
+                        shDegree = 4;
+                    }
+                    else if (value >= 84 /* PLYValue.SH_44 */) {
+                        shDegree = Math.max(shDegree, 3);
                     }
-                    else if (value >= 64 /* PLYValue.SH_24 */) {
+                    else if (value >= 63 /* PLYValue.SH_23 */) {
                         shDegree = Math.max(shDegree, 2);
                     }
                     else if (value >= 48 /* PLYValue.SH_8 */) {
@@ -1112,7 +1200,7 @@ export class GaussianSplattingMeshBase extends Mesh {
                     r3 = value;
                     break;
             }
-            if (sh && property.value >= 40 /* PLYValue.SH_0 */ && property.value <= 84 /* PLYValue.SH_44 */) {
+            if (sh && property.value >= 40 /* PLYValue.SH_0 */ && property.value <= 111 /* PLYValue.SH_71 */) {
                 const shIndex = property.value - 40 /* PLYValue.SH_0 */;
                 if (property.type == 4 /* PLYType.UCHAR */ && header.chunkCount) {
                     // compressed ply. dataView points to beginning of vertex
@@ -1128,7 +1216,7 @@ export class GaussianSplattingMeshBase extends Mesh {
             }
         }
         if (sh) {
-            const shDim = header.shDegree == 1 ? 3 : header.shDegree == 2 ? 8 : 15;
+            const shDim = header.shDegree == 1 ? 3 : header.shDegree == 2 ? 8 : header.shDegree == 3 ? 15 : 24;
             for (let j = 0; j < shDim; j++) {
                 sh[j * 3 + 0] = plySH[j];
                 sh[j * 3 + 1] = plySH[j + shDim];
@@ -1193,7 +1281,7 @@ export class GaussianSplattingMeshBase extends Mesh {
                 }
             }
         }
-        return { buffer: header.buffer, sh: sh };
+        return { buffer: header.buffer, sh: sh, shDegree: header.shDegree };
     }
     /**
      * Converts a .ply data array buffer to splat
@@ -1275,8 +1363,8 @@ export class GaussianSplattingMeshBase extends Mesh {
         this._cachedBoundingMin = null;
         this._cachedBoundingMax = null;
         // Note: _splatsData and _shData are intentionally kept alive after dispose.
-        // They serve as the source reference for the compound API (addPart/removePart)
-        // when this mesh is held by a GaussianSplattingPartProxyMesh.compoundSplatMesh.
+        // They can still be used as runtime source buffers by a compound mesh that retained
+        // this mesh's data before disposal.
         this._worker?.terminate();
         this._worker = null;
         // delete meshes created for each camera
@@ -1524,10 +1612,11 @@ export class GaussianSplattingMeshBase extends Mesh {
         }
         this._sortIsDirty = true;
     }
-    *_updateData(data, isAsync, sh, partIndices, { flipY = false, previousVertexCount = 0 } = {}) {
+    *_updateData(data, isAsync, sh, partIndices, { flipY = false, previousVertexCount = 0 } = {}, shDegree) {
         if (!this._covariancesATexture) {
             this._readyToDisplay = false;
         }
+        this._flipY = flipY;
         const uBuffer = new Uint8Array(data);
         const fBuffer = new Float32Array(uBuffer.buffer);
         // Optionally store the raw splat buffer as an ArrayBuffer. This is the source reference
@@ -1547,8 +1636,8 @@ export class GaussianSplattingMeshBase extends Mesh {
             this._updateSplatIndexBuffer(vertexCount);
         }
         this._vertexCount = vertexCount;
-        // degree == 1 for 1 texture (3 terms), 2 for 2 textures (8 terms) and 3 for 3 textures (15 terms)
-        this._shDegree = sh ? sh.length : 0;
+        this._maxShDegree = sh ? (shDegree ?? 0) : 0;
+        this._shDegree = this._maxShDegree;
         const textureSize = this._getTextureSize(vertexCount);
         const textureLength = textureSize.x * textureSize.y;
         const lineCountUpdate = GaussianSplattingMeshBase.ProgressiveUpdateAmount ?? textureSize.y;
@@ -1653,10 +1742,11 @@ export class GaussianSplattingMeshBase extends Mesh {
      * @param data array buffer containing center, color, orientation and scale of splats
      * @param sh optional array of uint8 array for SH data
      * @param partIndices optional array of uint8 for rig node indices
+     * @param shDegree optional SH degree of the data
      * @returns a promise
      */
-    async updateDataAsync(data, sh, partIndices) {
-        return await runCoroutineAsync(this._updateData(data, true, sh, partIndices), createYieldingScheduler());
+    async updateDataAsync(data, sh, partIndices, shDegree) {
+        return await runCoroutineAsync(this._updateData(data, true, sh, partIndices, undefined, shDegree), createYieldingScheduler());
     }
     /**
      * @experimental
@@ -1665,9 +1755,10 @@ export class GaussianSplattingMeshBase extends Mesh {
      * @param sh optional array of uint8 array for SH data
      * @param options optional informations on how to treat data (needs to be 3rd for backward compatibility)
      * @param partIndices optional array of uint8 for rig node indices
+     * @param shDegree optional SH degree of the data
      */
-    updateData(data, sh, options = { flipY: true }, partIndices) {
-        runCoroutineSync(this._updateData(data, false, sh, partIndices, options));
+    updateData(data, sh, options = { flipY: true }, partIndices, shDegree) {
+        runCoroutineSync(this._updateData(data, false, sh, partIndices, options, shDegree));
     }
     /**
      * Refreshes the bounding info, taking into account all the thin instances defined
@@ -1741,6 +1832,10 @@ export class GaussianSplattingMeshBase extends Mesh {
         const positions = Float32Array.from(this._splatPositions);
         this._worker.postMessage({ positions }, [positions.buffer]);
         this._onWorkerCreated(this._worker);
+        this._worker.onerror = () => {
+            // If the worker throws an unhandled error, unlock the posting gate so the next frame can retry the sort.
+            this._canPostToWorker = true;
+        };
         this._worker.onmessage = (e) => {
             // Recompute vertexCountPadded in case _vertexCount has changed since the last update
             const vertexCountPadded = (this._vertexCount + 15) & ~0xf;
@@ -1964,12 +2059,13 @@ GaussianSplattingMeshBase._CreateWorker = function (self) {
             const globalWorldMatrix = e.data.worldMatrix;
             const cameraForward = e.data.cameraForward;
             const cameraPosition = e.data.cameraPosition;
-            const vertexCountPadded = (positions.length / 4 + 15) & ~0xf;
+            depthMix = e.data.depthMix;
             if (!positions || !cameraForward) {
-                // Sanity check, it shouldn't happen!
-                throw new Error("positions or camera info is not defined!");
+                // Sort request arrived before positions were initialized — return the buffer unchanged so the main thread can unlock _canPostToWorker.
+                self.postMessage({ depthMix, cameraId }, [depthMix.buffer]);
+                return;
             }
-            depthMix = e.data.depthMix;
+            const vertexCountPadded = (positions.length / 4 + 15) & ~0xf;
             indices = new Uint32Array(depthMix.buffer);
             floatMix = new Float32Array(depthMix.buffer);
             // Sort
@@ -1986,30 +2082,39 @@ GaussianSplattingMeshBase._CreateWorker = function (self) {
                     cameraForward[0] * m[12] + cameraForward[1] * m[13] + cameraForward[2] * m[14] - camDot,
                 ];
             };
-            if (partMatrices && partIndices) {
-                // Precompute depth coefficients for each rig node
-                const depthCoeffs = partMatrices.map((m) => computeDepthCoeffs(m));
-                // NB: For performance reasons, we assume that part indices are valid
-                const length = partIndices.length;
-                for (let j = 0; j < vertexCountPadded; j++) {
-                    // NB: We need this 'min' because vertex array is padded, not partIndices
-                    const partIndex = partIndices[Math.min(j, length - 1)];
-                    const coeff = depthCoeffs[partIndex];
-                    floatMix[2 * j + 1] = coeff[0] * positions[4 * j + 0] + coeff[1] * positions[4 * j + 1] + coeff[2] * positions[4 * j + 2] + coeff[3];
-                    // instead of using minus to sort back to front, we use bitwise not operator to invert the order of indices
-                    // might not be faster but a minus sign implies a reference value that may not be enough and will decrease floatting precision
-                    indices[2 * j + 1] = ~indices[2 * j + 1];
+            try {
+                if (partMatrices && partIndices) {
+                    // Precompute depth coefficients for each rig node
+                    const depthCoeffs = partMatrices.map((m) => computeDepthCoeffs(m));
+                    // NB: For performance reasons, we assume that part indices are valid
+                    const length = partIndices.length;
+                    for (let j = 0; j < vertexCountPadded; j++) {
+                        // NB: We need this 'min' because vertex array is padded, not partIndices
+                        const partIndex = partIndices[Math.min(j, length - 1)];
+                        const coeff = depthCoeffs[partIndex];
+                        floatMix[2 * j + 1] = coeff[0] * positions[4 * j + 0] + coeff[1] * positions[4 * j + 1] + coeff[2] * positions[4 * j + 2] + coeff[3];
+                        // instead of using minus to sort back to front, we use bitwise not operator to invert the order of indices
+                        // might not be faster but a minus sign implies a reference value that may not be enough and will decrease floatting precision
+                        indices[2 * j + 1] = ~indices[2 * j + 1];
+                    }
                 }
-            }
-            else {
-                // Compute depth coefficients from global world matrix
-                const [a, b, c, d] = computeDepthCoeffs(globalWorldMatrix);
-                for (let j = 0; j < vertexCountPadded; j++) {
-                    floatMix[2 * j + 1] = a * positions[4 * j + 0] + b * positions[4 * j + 1] + c * positions[4 * j + 2] + d;
-                    indices[2 * j + 1] = ~indices[2 * j + 1];
+                else {
+                    // Compute depth coefficients from global world matrix
+                    const [a, b, c, d] = computeDepthCoeffs(globalWorldMatrix);
+                    for (let j = 0; j < vertexCountPadded; j++) {
+                        floatMix[2 * j + 1] = a * positions[4 * j + 0] + b * positions[4 * j + 1] + c * positions[4 * j + 2] + d;
+                        indices[2 * j + 1] = ~indices[2 * j + 1];
+                    }
                 }
+                depthMix.sort();
+            }
+            catch (sortError) {
+                // Transient data inconsistency (e.g. partIndices/partMatrices mismatch during addPart/removePart rebuild).
+                // Return the buffer unsorted so the main thread can unlock _canPostToWorker and retry next frame.
+                // Logger is unavailable inside the worker — console is the only option.
+                // eslint-disable-next-line no-console
+                console.error("Gaussian splat sort worker encountered an error (will retry next frame):", sortError);
             }
-            depthMix.sort();
             self.postMessage({ depthMix, cameraId }, [depthMix.buffer]);
         }
     };