@babylonjs/core 9.9.1 → 9.9.2

package/Meshes/GaussianSplatting/gaussianSplattingMeshBase.pure.js

@@ -352,7 +352,7 @@ export class GaussianSplattingMeshBase extends Mesh {
         this._needsRotationScaleTextures = value;
         if (value && this._covariancesATexture) {
             if (this._splatsData) {
-                this.updateData(this._splatsData, this._shData ?? undefined, { flipY: false });
+                this.updateData(this._splatsData, this._shData ?? undefined, { flipY: false }, undefined, this._shDegree);
             }
             else {
                 Logger.Error("GaussianSplattingMeshBase: needsRotationScaleTextures was enabled after the mesh was already loaded, but the splat data is not kept in RAM. " +
@@ -366,6 +366,96 @@ export class GaussianSplattingMeshBase extends Mesh {
     get shTextures() {
         return this._shTextures;
     }
+    /**
+     * True when this mesh holds raw SOG webp textures (dequantized in-shader) rather than the
+     * pre-decoded covariance/center/color textures produced by the standard splat loader.
+     */
+    get useSog() {
+        return this._useSog;
+    }
+    /**
+     * SOG dequantization parameters paired with the raw textures.
+     * Set by the splat loader when `useSogTextures: true`. Null otherwise.
+     */
+    get sogParams() {
+        return this._sogParams;
+    }
+    /**
+     * Install a set of raw SOG webp textures and bind the mesh to the in-shader dequantization path.
+     * @param pack SOG texture pack produced by ParseSogMetaAsTextures.
+     * @internal
+     */
+    setSogTextureData(pack) {
+        this._useSog = true;
+        this._sogParams?.codebookTexture?.dispose();
+        this._sogParams = pack;
+        this._vertexCount = pack.splatCount;
+        this._shDegree = pack.shDegree ?? 0;
+        this._maxShDegree = this._shDegree;
+        // Stride-4 (xyz + 1) — required by the depth-sort worker and the centers texture path.
+        this._splatPositions = pack.positions;
+        // Reuse existing texture slots for SOG textures (the shader, under USE_SOG, samples them as RGBA8).
+        this._covariancesATexture?.dispose();
+        this._covariancesBTexture?.dispose();
+        this._centersTexture?.dispose();
+        this._colorsTexture?.dispose();
+        this._rotationsATexture?.dispose();
+        if (this._shTextures) {
+            for (const t of this._shTextures) {
+                t.dispose();
+            }
+        }
+        this._centersTexture = pack.meansTextureL;
+        this._covariancesATexture = pack.meansTextureU;
+        this._covariancesBTexture = pack.scalesTexture;
+        this._rotationsATexture = pack.quatsTexture;
+        this._colorsTexture = pack.sh0Texture;
+        const shTextures = [];
+        if (pack.shCentroidsTexture) {
+            shTextures.push(pack.shCentroidsTexture);
+        }
+        if (pack.shLabelsTexture) {
+            shTextures.push(pack.shLabelsTexture);
+        }
+        this._shTextures = shTextures.length ? shTextures : null;
+        // Force pipeline rebuild so the USE_SOG define and extra samplers are picked up.
+        this._material?.resetDrawCache();
+        const size = pack.meansTextureL.getSize();
+        this._textureSize.x = size.width;
+        this._textureSize.y = size.height;
+        this._updateSplatIndexBuffer(this._vertexCount);
+        this._instantiateWorker();
+        // Compute bounds from the CPU-decoded positions (stride-4) so the mesh is not frustum-culled.
+        const positions = pack.positions;
+        const minimum = new Vector3(Number.POSITIVE_INFINITY, Number.POSITIVE_INFINITY, Number.POSITIVE_INFINITY);
+        const maximum = new Vector3(Number.NEGATIVE_INFINITY, Number.NEGATIVE_INFINITY, Number.NEGATIVE_INFINITY);
+        for (let i = 0; i < this._vertexCount; i++) {
+            const x = positions[i * 4 + 0];
+            const y = positions[i * 4 + 1];
+            const z = positions[i * 4 + 2];
+            if (x < minimum.x) {
+                minimum.x = x;
+            }
+            if (y < minimum.y) {
+                minimum.y = y;
+            }
+            if (z < minimum.z) {
+                minimum.z = z;
+            }
+            if (x > maximum.x) {
+                maximum.x = x;
+            }
+            if (y > maximum.y) {
+                maximum.y = y;
+            }
+            if (z > maximum.z) {
+                maximum.z = z;
+            }
+        }
+        this.getBoundingInfo().reConstruct(minimum, maximum, this.getWorldMatrix());
+        this.setEnabled(true);
+        this._sortIsDirty = true;
+    }
     /**
      * Gets the kernel size
      * Documentation and mathematical explanations here:
@@ -458,6 +548,8 @@ export class GaussianSplattingMeshBase extends Mesh {
         this._flipY = false;
         this._delayedTextureUpdate = null;
         this._useRGBACovariants = false;
+        this._useSog = false;
+        this._sogParams = null;
         this._material = null;
         this._tmpCovariances = [0, 0, 0, 0, 0, 0];
         this._splatSizeMin = Infinity;
@@ -567,10 +659,11 @@ export class GaussianSplattingMeshBase extends Mesh {
                     anyDirty = true;
                     continue;
                 }
-                // Also detect drift: if the world or camera state has changed since the last post,
-                // mark dirty so the next render does not silently queue a new sort that completes
-                // after isReady has reported true.
-                if (this._isSortStateDirty(cameraViewInfo, worldMatrix, camera)) {
+                // If world matrix drifted (user applied transforms after load), re-sort before first render.
+                // Camera drift is intentionally excluded here: checking camera movement would cause isReady()
+                // to return false indefinitely while the camera is moving. The render loop handles camera
+                // re-sorting continuously via _postToWorker() in render().
+                if (this._isSortStateDirty(cameraViewInfo, worldMatrix, camera, true)) {
                     anyDirty = true;
                 }
             }
@@ -643,7 +736,7 @@ export class GaussianSplattingMeshBase extends Mesh {
         localDirection.normalize();
         return localDirection;
     }
-    _isSortStateDirty(cameraViewInfo, worldMatrix, camera) {
+    _isSortStateDirty(cameraViewInfo, worldMatrix, camera, worldMatrixOnly = false) {
         const world = worldMatrix.m;
         const previousWorld = cameraViewInfo.sortWorldMatrix.m;
         for (let i = 0; i < previousWorld.length; i++) {
@@ -651,6 +744,9 @@ export class GaussianSplattingMeshBase extends Mesh {
                 return true;
             }
         }
+        if (worldMatrixOnly) {
+            return false;
+        }
         const cameraViewMatrix = camera.getViewMatrix();
         if (!Scalar.WithinEpsilon(cameraViewInfo.sortCameraForward.x, cameraViewMatrix.m[2], this.viewUpdateThreshold) ||
             !Scalar.WithinEpsilon(cameraViewInfo.sortCameraForward.y, cameraViewMatrix.m[6], this.viewUpdateThreshold) ||
@@ -1478,10 +1574,7 @@ export class GaussianSplattingMeshBase extends Mesh {
                 const width = engine.getCaps().maxTextureSize;
                 const height = Math.ceil(splatCount / width);
                 // create array for the number of textures needed.
-                for (let textureIndex = 0; textureIndex < textureCount; textureIndex++) {
-                    const texture = new Uint8Array(height * width * 4 * 4); // 4 components per texture, 4 sh per component
-                    sh.push(texture);
-                }
+                sh = AllocateShBuffers(textureCount, height * width * 4 * 4);
                 for (let i = 0; i < splatCount; i++) {
                     for (let shIndexWrite = 0; shIndexWrite < header.shCoefficientCount; shIndexWrite++) {
                         const shValue = ubuf[shIndexRead++];
@@ -1571,6 +1664,7 @@ export class GaussianSplattingMeshBase extends Mesh {
         this._rotationsATexture?.dispose();
         this._rotationsBTexture?.dispose();
         this._rotationScaleTexture?.dispose();
+        this._sogParams?.codebookTexture?.dispose();
         this._rotationsATexture = null;
         this._rotationsBTexture = null;
         this._rotationScaleTexture = null;
@@ -2201,9 +2295,14 @@ export class GaussianSplattingMeshBase extends Mesh {
             const vertexCountPadded = (this._vertexCount + 15) & ~0xf;
             // If the vertex count changed, we discard this result and trigger a new sort
             if (e.data.depthMix.length != vertexCountPadded) {
-                this._canPostToWorker = true;
-                this._postToWorker(true);
-                this._sortIsDirty = false;
+                // Only re-enable posting and trigger a re-sort if the buffer is available.
+                // If byteLength === 0 the buffer is already in-flight for a newer sort;
+                // that sort's onmessage will handle things when it returns.
+                if (this._depthMix.buffer.byteLength > 0) {
+                    this._canPostToWorker = true;
+                    this._postToWorker(true);
+                    this._sortIsDirty = false;
+                }
                 return;
             }
             this._depthMix = e.data.depthMix;
@@ -2478,4 +2577,22 @@ GaussianSplattingMeshBase._CreateWorker = function (self) {
         }
     };
 };
+/**
+ * Allocates SH texture buffers pre-filled with 128 (the neutral encoding of ~0.0 in the
+ * shader's decompose() function). Padding bytes beyond the actual coefficients in the last
+ * texture are read as higher-order SH bands when the mesh is added to a compound with a
+ * higher degree; zero would decode to -1.0 instead, producing wrong colors.
+ * @param textureCount number of SH textures to allocate
+ * @param bytesEach byte size of each texture buffer
+ * @returns array of initialized Uint8Array buffers
+ */
+export function AllocateShBuffers(textureCount, bytesEach) {
+    const result = [];
+    for (let i = 0; i < textureCount; i++) {
+        const arr = new Uint8Array(bytesEach);
+        arr.fill(128);
+        result.push(arr);
+    }
+    return result;
+}
 //# sourceMappingURL=gaussianSplattingMeshBase.pure.js.map