@onerjs/core 8.54.2 → 8.54.4

package/Meshes/GaussianSplatting/gaussianSplattingMeshBase.pure.js

@@ -1044,7 +1044,11 @@ export class GaussianSplattingMeshBase extends Mesh {
             }
             return a.frameIdLastUpdate - b.frameIdLastUpdate;
         });
-        const hasSortFunction = this._worker || Native?.sortSplats || this._disableDepthSort;
+        // The native sort writes into _splatPositions/_splatIndex: both must be allocated (they still are
+        // null before any splat data has been committed) or the native binding throws on the conversion.
+        const hasNativeSort = !!Native?.sortSplats && !!this._splatPositions && !!this._splatIndex;
+        // When depth sort is disabled, no sort function must run: fall through to the no-sort path below.
+        const hasSortFunction = !this._disableDepthSort && (this._worker || hasNativeSort);
         if ((forced || outdated) && hasSortFunction && (this._scene.activeCameras?.length || this._scene.activeCamera) && this._canPostToWorker) {
             const worldMatrix = this.computeWorldMatrix(true);
             // view infos sorted by least recent updated frame id
@@ -1098,14 +1102,16 @@ export class GaussianSplattingMeshBase extends Mesh {
             });
         }
         else if (this._disableDepthSort) {
-            activeViewInfos.forEach((cameraViewInfos) => {
-                if (!cameraViewInfos.splatIndexBufferSet) {
-                    cameraViewInfos.mesh.thinInstanceSetBuffer("splatIndex", this._splatIndex, 16, false);
-                    cameraViewInfos.splatIndexBufferSet = true;
-                }
-            });
+            if (this._splatIndex) {
+                activeViewInfos.forEach((cameraViewInfos) => {
+                    if (!cameraViewInfos.splatIndexBufferSet) {
+                        cameraViewInfos.mesh.thinInstanceSetBuffer("splatIndex", this._splatIndex, 16, false);
+                        cameraViewInfos.splatIndexBufferSet = true;
+                    }
+                });
+                this._readyToDisplay = true;
+            }
             this._canPostToWorker = true;
-            this._readyToDisplay = true;
         }
     }
     /**
@@ -2161,6 +2167,18 @@ export class GaussianSplattingMeshBase extends Mesh {
             this._postToWorker(true);
         }
         else {
+            // Full rebuild: the texture size changed (or this is a size-changing reload), so the existing
+            // GPU textures cannot be reused. Dispose them before recreating to avoid leaking the old ones.
+            this._covariancesATexture?.dispose();
+            this._covariancesBTexture?.dispose();
+            this._centersTexture?.dispose();
+            this._colorsTexture?.dispose();
+            if (this._shTextures) {
+                for (const shTexture of this._shTextures) {
+                    shTexture.dispose();
+                }
+                this._shTextures = null;
+            }
             this._textureSize = textureSize;
             this._covariancesATexture = createTextureFromDataF16(covA, textureSize.x, textureSize.y, 5);
             this._covariancesBTexture = createTextureFromDataF16(covB, textureSize.x, textureSize.y, this._useRGBACovariants ? 5 : 7);
@@ -2458,8 +2476,10 @@ export class GaussianSplattingMeshBase extends Mesh {
                     splatIndex[index++] = sourceIndex;
                 }
             }
+            // Pad with `vertexCount` itself, not 0: splat 0 is real data, not a reserved empty slot, and
+            // range filtering can leave it fully visible — see gaussianSplattingSortWorker.ts.
             for (; index < paddedVertexCount; index++) {
-                splatIndex[index] = 0;
+                splatIndex[index] = vertexCount;
             }
         }
         else {
@@ -2550,10 +2570,12 @@ export class GaussianSplattingMeshBase extends Mesh {
         if (!this._vertexCount) {
             return;
         }
+        // The identity index buffer must exist even when no sort worker is needed: every render path
+        // (including the Native one) reads it, and a null buffer breaks the Native bindings.
+        this._updateSplatIndexBuffer(this._vertexCount);
         if (this._disableDepthSort) {
             return;
         }
-        this._updateSplatIndexBuffer(this._vertexCount);
         // no worker in native
         if (IsNative) {
             return;
@@ -2568,7 +2590,8 @@ export class GaussianSplattingMeshBase extends Mesh {
             type: "application/javascript",
         })));
         const positions = Float32Array.from(this._splatPositions);
-        this._worker.postMessage({ command: GaussianSplattingSortWorkerCommand.POSITIONS, positions }, [positions.buffer]);
+        const vertexCount = this._vertexCount;
+        this._worker.postMessage({ command: GaussianSplattingSortWorkerCommand.POSITIONS, positions, vertexCount }, [positions.buffer]);
         // The main thread owns the active interval set: send it explicitly (covering all indices when
         // no LOD filter is active) rather than letting the worker assume the full source set.
         this._postIntervalsToWorker();
@@ -2652,9 +2675,25 @@ export class GaussianSplattingMeshBase extends Mesh {
             while (width * height < length) {
                 height *= 2;
             }
+            // See the WebGL2/WebGPU branch below for why this guarantees an extra row when `length`
+            // exactly fills every row. A power-of-2 height has to double to add any slack at all.
+            // Usually this is a no-op since it is rare that the asset exactly contains a power-of-2
+            // number of splats.
+            if (length > 0 && width * height === length) {
+                height *= 2;
+            }
         }
         else {
             height = Math.ceil(length / width);
+            // When `length` exactly fills every row, force one extra (fully zeroed) row so the atlas
+            // always has at least one genuinely-empty splat slot past the real data, at index `length`.
+            // The sort worker (gaussianSplattingSortWorker.ts) relies on that slot always existing to
+            // safely pad the 16-aligned draw order — without it, the only "spare" index would be the
+            // last real splat, which range-filtering (setSplatIndexRanges/opacity/size culling) can
+            // leave fully visible and opaque, reproducing the same "stuck in front" bug on that splat.
+            if (length > 0 && height * width === length) {
+                height += 1;
+            }
         }
         if (height > width) {
             Logger.Error("GaussianSplatting texture size: (" + width + ", " + height + "), maxTextureSize: " + width);