@babylonjs/core 9.12.0 → 9.13.0

package/Meshes/GaussianSplatting/gaussianSplattingMeshBase.pure.d.ts

@@ -40,6 +40,19 @@ interface IUpdateOptions {
     /** @internal When set, skips reprocessing splats [0, previousVertexCount) and copies from cached arrays instead. */
     previousVertexCount?: number;
 }
+/**
+ * Defines a contiguous source-splat range to render from a GaussianSplattingMesh.
+ */
+export interface IGaussianSplattingSplatRange {
+    /**
+     * First source splat index to render.
+     */
+    offset: number;
+    /**
+     * Number of source splats to render.
+     */
+    count: number;
+}
 interface ITextureDataUpdateCapableEngine {
     updateTextureData(texture: InternalTexture, imageData: ArrayBufferView, xOffset: number, yOffset: number, width: number, height: number, faceIndex?: number, lod?: number, generateMipMaps?: boolean): void;
     updateRawTexture(texture: Nullable<InternalTexture>, data: Nullable<ArrayBufferView>, format: number, invertY: boolean, compression?: Nullable<string>, type?: number, useSRGBBuffer?: boolean): void;
@@ -246,6 +259,17 @@ export interface PLYHeader {
  * @internal Use GaussianSplattingMesh instead; this class is an internal implementation detail.
  */
 export declare class GaussianSplattingMeshBase extends Mesh {
+    /**
+     * When true (default), the depth-sort worker uses the fast O(n) counting (radix) sort. Set to false to
+     * fall back to the legacy comparison sort (useful for A/B comparison or as a safety fallback). The change
+     * takes effect on the next sort.
+     */
+    static UseCountingSort: boolean;
+    /**
+     * When true, the depth-sort worker logs each sort's duration (ms) and active splat count to the console.
+     * Off by default; intended for performance investigation only.
+     */
+    static LogSortPerformance: boolean;
     /** @internal */
     _vertexCount: number;
     protected _worker: Nullable<Worker>;
@@ -254,6 +278,7 @@ export declare class GaussianSplattingMeshBase extends Mesh {
     protected _canPostToWorker: boolean;
     private _readyToDisplay;
     private _sortRequestId;
+    private _activeRangeVersion;
     private _hasRenderedOnce;
     protected _covariancesATexture: Nullable<BaseTexture>;
     protected _covariancesBTexture: Nullable<BaseTexture>;
@@ -286,6 +311,9 @@ export declare class GaussianSplattingMeshBase extends Mesh {
     private _splatSizeMin;
     private _splatSizeMax;
     private _sortIsDirty;
+    private _activeSplatRanges;
+    private _activeSplatRangeKey;
+    private _activeSplatRenderCount;
     protected _cachedBoundingMin: Nullable<Vector3>;
     protected _cachedBoundingMax: Nullable<Vector3>;
     private static _RowOutputLength;
@@ -317,6 +345,7 @@ export declare class GaussianSplattingMeshBase extends Mesh {
      * @internal
      */
     protected static _GetSplatDataFloats(data: ArrayBuffer | ArrayBufferView): Float32Array;
+    private static _BuildSplatRangeData;
     /**
      * Cosine value of the angle threshold to update view dependent splat sorting. Default is 0.0001.
      */
@@ -346,6 +375,38 @@ export declare class GaussianSplattingMeshBase extends Mesh {
      * Number of splats in the mesh
      */
     get splatCount(): number | undefined;
+    /**
+     * Number of source splats currently selected for rendering.
+     * When no range filter is active, this is the mesh's full source splat count.
+     */
+    get renderedSplatCount(): number;
+    /**
+     * Restricts rendering to the provided source splat ranges.
+     * Passing `null` clears the range filter and renders the full source splat set.
+     * @param ranges contiguous source ranges to render, or null to render all splats
+     */
+    setSplatIndexRanges(ranges: Nullable<readonly IGaussianSplattingSplatRange[]>): void;
+    private _setSplatIndexRanges;
+    private _ensureDepthMixSize;
+    /**
+     * Sends the active source-splat intervals to the sort worker. When no range filter is active,
+     * a single interval covering all source splats is sent so the worker never assumes the full set.
+     */
+    private _postIntervalsToWorker;
+    /**
+     * Initializes this mesh to render from an externally-provided, GPU-decoded work buffer, bypassing the
+     * CPU `updateData` path. The four textures must hold the standard decoded GS layout addressed by linear
+     * splat index over a square texture: centers (x,y,z,1), covariance A (Sigma00,01,02,11) and B
+     * (Sigma12,22,*,*) as full covariance (so `center.w` is 1), and RGBA color. `splatPositions` are the
+     * stride-4 CPU centers consumed by the depth-sort worker.
+     * @param centers centers texture
+     * @param covariancesA covariance A texture
+     * @param covariancesB covariance B texture
+     * @param colors color texture
+     * @param splatPositions stride-4 CPU centers for depth sorting (length vertexCount*4)
+     * @param vertexCount number of splats addressable in the work buffer
+     */
+    protected _setExternalWorkBuffer(centers: BaseTexture, covariancesA: BaseTexture, covariancesB: BaseTexture, colors: BaseTexture, splatPositions: Float32Array, vertexCount: number): void;
     /**
      * returns the splats data array buffer that contains in order : postions (3 floats), size (3 floats), color (4 bytes), orientation quaternion (4 bytes)
      * Only available if the mesh was created with keepInRam: true
@@ -434,6 +495,12 @@ export declare class GaussianSplattingMeshBase extends Mesh {
      * Get the compensation state
      */
     get compensation(): boolean;
+    /**
+     * Minimum projected splat size, in pixels, below which a splat is discarded (0 = disabled).
+     * Applied in real time; no rebuild required.
+     */
+    get minPixelSize(): number;
+    set minPixelSize(value: number);
     private _loadingPromise;
     /**
      * set rendering material
@@ -559,7 +626,6 @@ export declare class GaussianSplattingMeshBase extends Mesh {
      * @returns a new Gaussian Splatting Mesh
      */
     clone(name?: string): GaussianSplattingMeshBase;
-    private static _CreateWorker;
     protected _makeEmptySplat(index: number, covA: Uint16Array, covB: Uint16Array, colorArray: Uint8Array): void;
     /**
      * Processes a single splat from the source buffer (at srcIndex) and writes the result into
@@ -618,6 +684,16 @@ export declare class GaussianSplattingMeshBase extends Mesh {
      * Subclasses (e.g. compound) may override to additionally post part-index data.
      */
     protected _notifyWorkerNewData(): void;
+    /**
+     * Patches only a contiguous range of source-splat centers in the sort worker, instead of re-copying and
+     * transferring the entire position buffer (which is hundreds of MB for large streamed datasets and caused
+     * a multi-frame freeze on every LOD decode). The worker must already hold a full-size position buffer (from
+     * the initial {@link GaussianSplattingSortWorkerCommand.POSITIONS} message at worker creation). Marks the
+     * sort dirty so the new splats are sorted in; the caller is responsible for any interval/range refresh.
+     * @param splatOffset first splat index of the updated range
+     * @param splatCount number of splats in the updated range
+     */
+    protected _postWorkerPositionsRange(splatOffset: number, splatCount: number): void;
     private _updateData;
     /**
      * Update asynchronously the buffer

package/Meshes/GaussianSplatting/gaussianSplattingMeshBase.pure.js

@@ -13,6 +13,7 @@ import { Scalar } from "../../Maths/math.scalar.js";
 import { runCoroutineSync, runCoroutineAsync, createYieldingScheduler } from "../../Misc/coroutine.js";
 import { EngineStore } from "../../Engines/engineStore.js";
 import { ImportMeshAsync } from "../../Loading/sceneLoader.js";
+import { GaussianSplattingSortWorker, GaussianSplattingSortWorkerCommand } from "./gaussianSplattingSortWorker.js";
 const IsNative = typeof _native !== "undefined";
 const Native = IsNative ? _native : null;
 // @internal
@@ -273,6 +274,27 @@ export class GaussianSplattingMeshBase extends Mesh {
         }
         return new Float32Array(bytes.buffer, bytes.byteOffset, bytes.byteLength / floatSize);
     }
+    static _BuildSplatRangeData(ranges, vertexCount) {
+        if (ranges === null) {
+            return { ranges: null, count: vertexCount, key: "" };
+        }
+        const rangePairs = [];
+        let totalCount = 0;
+        let key = "";
+        for (const range of ranges) {
+            const start = Math.max(0, Math.floor(range.offset));
+            const count = Math.max(0, Math.floor(range.count));
+            const end = Math.min(vertexCount, start + count);
+            const rangeCount = Math.max(0, end - start);
+            if (rangeCount === 0) {
+                continue;
+            }
+            rangePairs.push(start, rangeCount);
+            totalCount += rangeCount;
+            key += `${start}:${rangeCount};`;
+        }
+        return { ranges: new Uint32Array(rangePairs), count: totalCount, key };
+    }
     /**
      * If true, disables depth sorting of the splats (default: false)
      */
@@ -326,6 +348,100 @@ export class GaussianSplattingMeshBase extends Mesh {
     get splatCount() {
         return this._splatIndex?.length;
     }
+    /**
+     * Number of source splats currently selected for rendering.
+     * When no range filter is active, this is the mesh's full source splat count.
+     */
+    get renderedSplatCount() {
+        return this._activeSplatRanges ? this._activeSplatRenderCount : this._vertexCount;
+    }
+    /**
+     * Restricts rendering to the provided source splat ranges.
+     * Passing `null` clears the range filter and renders the full source splat set.
+     * @param ranges contiguous source ranges to render, or null to render all splats
+     */
+    setSplatIndexRanges(ranges) {
+        this._setSplatIndexRanges(ranges);
+    }
+    _setSplatIndexRanges(ranges) {
+        const rangeData = GaussianSplattingMeshBase._BuildSplatRangeData(ranges, this._vertexCount);
+        const isSameRangeSet = this._activeSplatRanges === null ? rangeData.ranges === null : rangeData.ranges !== null && this._activeSplatRangeKey === rangeData.key;
+        if (isSameRangeSet) {
+            return;
+        }
+        this._activeSplatRanges = rangeData.ranges;
+        this._activeSplatRangeKey = rangeData.key;
+        this._activeSplatRenderCount = rangeData.count;
+        this._activeRangeVersion++;
+        this._postIntervalsToWorker();
+        if (this._worker) {
+            // Defer swapping the rendered index buffer until the worker returns a depth sort computed for
+            // this exact range set (see the worker `onmessage` handler). Until then we keep rendering the
+            // previous fully-sorted state, so a range/LOD change never shows an unsorted flash nor a stale
+            // index buffer (rendering indices that belong to a different active set, which caused the
+            // disappear/reappear flicker). Only the worker's depth buffer is resized here so the next sort
+            // produces the right number of entries.
+            this._ensureDepthMixSize(Math.max((this._activeSplatRenderCount + 15) & ~0xf, 16));
+            this._sortIsDirty = true;
+            this._postToWorker(true);
+        }
+        else {
+            // Synchronous sort paths (disabled depth sort / Native): swap the index buffer immediately.
+            this._updateSplatIndexBuffer(this._vertexCount);
+            this._postToWorker(true);
+        }
+    }
+    // (Re)allocates the worker depth buffer to the given padded size. A fresh array is allocated when the
+    // size differs or the current buffer is detached (in-flight in the worker), so a queued sort can be
+    // re-posted with a correctly-sized buffer without disturbing the in-flight one.
+    _ensureDepthMixSize(paddedCount) {
+        if (IsNative) {
+            return;
+        }
+        if (!this._depthMix || this._depthMix.length !== paddedCount || this._depthMix.buffer.byteLength === 0) {
+            this._depthMix = new BigInt64Array(paddedCount);
+        }
+    }
+    /**
+     * Sends the active source-splat intervals to the sort worker. When no range filter is active,
+     * a single interval covering all source splats is sent so the worker never assumes the full set.
+     */
+    _postIntervalsToWorker() {
+        if (!this._worker) {
+            return;
+        }
+        const intervals = this._activeSplatRanges ? new Uint32Array(this._activeSplatRanges) : new Uint32Array([0, this._vertexCount]);
+        this._worker.postMessage({ command: GaussianSplattingSortWorkerCommand.INTERVALS, intervals }, [intervals.buffer]);
+    }
+    /**
+     * Initializes this mesh to render from an externally-provided, GPU-decoded work buffer, bypassing the
+     * CPU `updateData` path. The four textures must hold the standard decoded GS layout addressed by linear
+     * splat index over a square texture: centers (x,y,z,1), covariance A (Sigma00,01,02,11) and B
+     * (Sigma12,22,*,*) as full covariance (so `center.w` is 1), and RGBA color. `splatPositions` are the
+     * stride-4 CPU centers consumed by the depth-sort worker.
+     * @param centers centers texture
+     * @param covariancesA covariance A texture
+     * @param covariancesB covariance B texture
+     * @param colors color texture
+     * @param splatPositions stride-4 CPU centers for depth sorting (length vertexCount*4)
+     * @param vertexCount number of splats addressable in the work buffer
+     */
+    _setExternalWorkBuffer(centers, covariancesA, covariancesB, colors, splatPositions, vertexCount) {
+        this._covariancesATexture = covariancesA;
+        this._covariancesBTexture = covariancesB;
+        this._centersTexture = centers;
+        this._colorsTexture = colors;
+        this._splatPositions = splatPositions;
+        this._vertexCount = vertexCount;
+        this._activeSplatRanges = null;
+        this._activeSplatRangeKey = "";
+        this._activeSplatRenderCount = 0;
+        this._readyToDisplay = false;
+        // Sizes _splatIndex/_depthMix, starts the sort worker, and posts positions + intervals.
+        this._instantiateWorker();
+        // updateData (bypassed here) normally enables the mesh; do it explicitly for the work-buffer path.
+        this.setEnabled(true);
+    }
     /**
      * returns the splats data array buffer that contains in order : postions (3 floats), size (3 floats), color (4 bytes), orientation quaternion (4 bytes)
      * Only available if the mesh was created with keepInRam: true
@@ -525,6 +641,18 @@ export class GaussianSplattingMeshBase extends Mesh {
     get compensation() {
         return this._material instanceof GaussianSplattingMaterial ? this._material.compensation : false;
     }
+    /**
+     * Minimum projected splat size, in pixels, below which a splat is discarded (0 = disabled).
+     * Applied in real time; no rebuild required.
+     */
+    get minPixelSize() {
+        return this._material instanceof GaussianSplattingMaterial ? this._material.minPixelSize : 0;
+    }
+    set minPixelSize(value) {
+        if (this._material instanceof GaussianSplattingMaterial) {
+            this._material.minPixelSize = Math.max(0, value);
+        }
+    }
     /**
      * set rendering material
      */
@@ -577,6 +705,9 @@ export class GaussianSplattingMeshBase extends Mesh {
         this._canPostToWorker = true;
         this._readyToDisplay = false;
         this._sortRequestId = 0;
+        // Incremented on every active-range change. A worker sort result is only applied when it was computed
+        // for the current range version (and size), so a sort for stale ranges is never rendered.
+        this._activeRangeVersion = 0;
         this._hasRenderedOnce = false;
         this._covariancesATexture = null;
         this._covariancesBTexture = null;
@@ -609,6 +740,9 @@ export class GaussianSplattingMeshBase extends Mesh {
         this._splatSizeMin = Infinity;
         this._splatSizeMax = -Infinity;
         this._sortIsDirty = false;
+        this._activeSplatRanges = null;
+        this._activeSplatRangeKey = "";
+        this._activeSplatRenderCount = 0;
         // Cached bounding box for incremental addPart updates (O(1) vs O(N) scan of positions)
         this._cachedBoundingMin = null;
         this._cachedBoundingMax = null;
@@ -910,16 +1044,26 @@ export class GaussianSplattingMeshBase extends Mesh {
                     this._canPostToWorker = false;
                     if (this._worker) {
                         this._worker.postMessage({
+                            command: GaussianSplattingSortWorkerCommand.SORT,
                             worldMatrix: worldMatrix.m,
                             cameraForward: [cameraViewMatrix.m[2], cameraViewMatrix.m[6], cameraViewMatrix.m[10]],
                             cameraPosition: [camera.globalPosition.x, camera.globalPosition.y, camera.globalPosition.z],
                             depthMix: this._depthMix,
                             cameraId: camera.uniqueId,
                             sortRequestId: cameraViewInfos.sortRequestId,
+                            rangeVersion: this._activeRangeVersion,
+                            useCountingSort: GaussianSplattingMeshBase.UseCountingSort,
+                            logSortPerformance: GaussianSplattingMeshBase.LogSortPerformance,
                         }, [this._depthMix.buffer]);
                     }
                     else if (Native?.sortSplats) {
-                        Native.sortSplats(this._modelViewProjectionMatrix, this._splatPositions, this._splatIndex, this._scene.useRightHandedSystem);
+                        if (this._activeSplatRanges) {
+                            // Native sort can't filter ranges: fall back to the (already range-filtered) identity index buffer.
+                            this._updateSplatIndexBuffer(this._vertexCount);
+                        }
+                        else {
+                            Native.sortSplats(this._modelViewProjectionMatrix, this._splatPositions, this._splatIndex, this._scene.useRightHandedSystem);
+                        }
                         if (cameraViewInfos.splatIndexBufferSet) {
                             cameraViewInfos.mesh.thinInstanceBufferUpdated("splatIndex");
                         }
@@ -1960,7 +2104,9 @@ export class GaussianSplattingMeshBase extends Mesh {
             const positions = Float32Array.from(this._splatPositions);
             const vertexCount = this._vertexCount;
             if (this._worker) {
-                this._worker.postMessage({ positions, vertexCount }, [positions.buffer]);
+                this._worker.postMessage({ command: GaussianSplattingSortWorkerCommand.POSITIONS, positions, vertexCount }, [positions.buffer]);
+                // Re-sync the active interval set in case the source splat count changed.
+                this._postIntervalsToWorker();
             }
             // Handle SH textures in update path - create if they don't exist
             if (sh && !this._shTextures) {
@@ -2038,7 +2184,9 @@ export class GaussianSplattingMeshBase extends Mesh {
                 if (this._worker) {
                     const positions = Float32Array.from(this._splatPositions);
                     const vertexCount = this._vertexCount;
-                    this._worker.postMessage({ positions, vertexCount }, [positions.buffer]);
+                    this._worker.postMessage({ command: GaussianSplattingSortWorkerCommand.POSITIONS, positions, vertexCount }, [positions.buffer]);
+                    // Re-sync the active interval set in case the source splat count changed.
+                    this._postIntervalsToWorker();
                 }
                 this._postToWorker(true);
             }
@@ -2075,10 +2223,32 @@ export class GaussianSplattingMeshBase extends Mesh {
         if (this._worker) {
             const positions = Float32Array.from(this._splatPositions);
             const vertexCount = this._vertexCount;
-            this._worker.postMessage({ positions, vertexCount }, [positions.buffer]);
+            this._worker.postMessage({ command: GaussianSplattingSortWorkerCommand.POSITIONS, positions, vertexCount }, [positions.buffer]);
+            // The source splat count may have changed (e.g. addPart): re-sync the worker's active
+            // interval set so it covers the current splats instead of a stale (smaller) range.
+            this._postIntervalsToWorker();
         }
         this._sortIsDirty = true;
     }
+    /**
+     * Patches only a contiguous range of source-splat centers in the sort worker, instead of re-copying and
+     * transferring the entire position buffer (which is hundreds of MB for large streamed datasets and caused
+     * a multi-frame freeze on every LOD decode). The worker must already hold a full-size position buffer (from
+     * the initial {@link GaussianSplattingSortWorkerCommand.POSITIONS} message at worker creation). Marks the
+     * sort dirty so the new splats are sorted in; the caller is responsible for any interval/range refresh.
+     * @param splatOffset first splat index of the updated range
+     * @param splatCount number of splats in the updated range
+     */
+    _postWorkerPositionsRange(splatOffset, splatCount) {
+        if (!this._worker || !this._splatPositions || splatCount <= 0) {
+            return;
+        }
+        const floatOffset = splatOffset * 4;
+        // Copy just the changed region (stride 4) so the main thread keeps its own _splatPositions intact.
+        const data = this._splatPositions.slice(floatOffset, floatOffset + splatCount * 4);
+        this._worker.postMessage({ command: GaussianSplattingSortWorkerCommand.POSITIONS_UPDATE, offset: floatOffset, data }, [data.buffer]);
+        this._sortIsDirty = true;
+    }
     *_updateData(data, isAsync, sh, partIndices, { flipY = false, previousVertexCount = 0 } = {}, shDegree) {
         if (!this._covariancesATexture) {
             this._readyToDisplay = false;
@@ -2100,6 +2270,11 @@ export class GaussianSplattingMeshBase extends Mesh {
         }
         const vertexCount = uBuffer.length / GaussianSplattingMeshBase._RowOutputLength;
         if (vertexCount != this._vertexCount) {
+            // The source set changed: drop any active range filter so the buffers resize to the full
+            // set. Callers (e.g. streaming LOD) re-apply their ranges after the data is committed.
+            this._activeSplatRanges = null;
+            this._activeSplatRangeKey = "";
+            this._activeSplatRenderCount = 0;
             this._updateSplatIndexBuffer(vertexCount);
         }
         this._vertexCount = vertexCount;
@@ -2241,19 +2416,40 @@ export class GaussianSplattingMeshBase extends Mesh {
     }
     // in case size is different
     _updateSplatIndexBuffer(vertexCount) {
-        const paddedVertexCount = (vertexCount + 15) & ~0xf;
-        if (!this._splatIndex || vertexCount != this._splatIndex.length) {
+        const renderedSplatCount = this._activeSplatRanges ? this._activeSplatRenderCount : vertexCount;
+        const paddedVertexCount = Math.max((renderedSplatCount + 15) & ~0xf, 16);
+        const previousIndex = this._splatIndex;
+        if (!previousIndex || paddedVertexCount !== previousIndex.length) {
             this._splatIndex = new Float32Array(paddedVertexCount);
-            for (let i = 0; i < paddedVertexCount; i++) {
-                this._splatIndex[i] = i;
-            }
             // update meshes for knowns cameras
             this._cameraViewInfos.forEach((cameraViewInfos) => {
                 cameraViewInfos.mesh.thinInstanceSetBuffer("splatIndex", this._splatIndex, 16, false);
             });
         }
+        const splatIndex = this._splatIndex;
+        // Populate the buffer with the current active source indices (identity when unfiltered) so every
+        // rendered slot points at a valid splat. This is the synchronous (no async sort worker) path; the
+        // worker path instead defers the index-buffer swap until a matching sort lands (see _onWorkerCreated).
+        if (this._activeSplatRanges) {
+            let index = 0;
+            for (let rangeIndex = 0; rangeIndex < this._activeSplatRanges.length; rangeIndex += 2) {
+                const start = this._activeSplatRanges[rangeIndex];
+                const count = this._activeSplatRanges[rangeIndex + 1];
+                for (let sourceIndex = start; sourceIndex < start + count; sourceIndex++) {
+                    splatIndex[index++] = sourceIndex;
+                }
+            }
+            for (; index < paddedVertexCount; index++) {
+                splatIndex[index] = 0;
+            }
+        }
+        else {
+            for (let i = 0; i < paddedVertexCount; i++) {
+                splatIndex[i] = i;
+            }
+        }
         // Update depthMix
-        if ((!this._depthMix || vertexCount != this._depthMix.length) && !IsNative) {
+        if ((!this._depthMix || paddedVertexCount !== this._depthMix.length) && !IsNative) {
             this._depthMix = new BigInt64Array(paddedVertexCount);
         }
         this.forcedInstanceCount = Math.max(paddedVertexCount >> 4, 1);
@@ -2349,21 +2545,28 @@ export class GaussianSplattingMeshBase extends Mesh {
         // If the previous worker was terminated mid-sort it would never have set _canPostToWorker
         // back to true, leaving the sort permanently frozen on the new worker.
         this._canPostToWorker = true;
-        this._worker = new Worker(URL.createObjectURL(new Blob(["(", GaussianSplattingMeshBase._CreateWorker.toString(), ")(self)"], {
+        this._worker = new Worker(URL.createObjectURL(new Blob(["(", GaussianSplattingSortWorker.toString(), ")(self)"], {
             type: "application/javascript",
         })));
         const positions = Float32Array.from(this._splatPositions);
-        this._worker.postMessage({ positions }, [positions.buffer]);
+        this._worker.postMessage({ command: GaussianSplattingSortWorkerCommand.POSITIONS, positions }, [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();
         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;
-            // If the vertex count changed, we discard this result and trigger a new sort
-            if (e.data.depthMix.length != vertexCountPadded) {
+            // Size the result against the active (rendered) splat count, which may be a subset of the
+            // full source set when an interval/LOD filter is active.
+            const renderedPadded = Math.max((this.renderedSplatCount + 15) & ~0xf, 16);
+            // Discard the result and trigger a fresh sort if it no longer matches the current active set:
+            // either the active count changed since it was posted, or it was computed for a stale range
+            // version (the active ranges changed while it was in flight). Applying it would render indices
+            // that belong to a different active set.
+            if (e.data.depthMix.length != renderedPadded || e.data.rangeVersion !== this._activeRangeVersion) {
                 // 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.
@@ -2377,13 +2580,25 @@ export class GaussianSplattingMeshBase extends Mesh {
             this._depthMix = e.data.depthMix;
             const cameraId = e.data.cameraId;
             const sortRequestId = e.data.sortRequestId;
+            // The index buffer swap is deferred to here so the previous fully-sorted state stays on screen
+            // until this matching sort lands. Resize it now (the active count may have grown/shrunk since the
+            // last applied sort) and rebind it for every known camera.
+            if (!this._splatIndex || this._splatIndex.length !== renderedPadded) {
+                this._splatIndex = new Float32Array(renderedPadded);
+                this._cameraViewInfos.forEach((info) => {
+                    info.mesh.thinInstanceSetBuffer("splatIndex", this._splatIndex, 16, false);
+                    info.splatIndexBufferSet = true;
+                });
+            }
             const indexMix = new Uint32Array(e.data.depthMix.buffer);
             if (this._splatIndex) {
-                for (let j = 0; j < vertexCountPadded; j++) {
+                for (let j = 0; j < renderedPadded; j++) {
                     this._splatIndex[j] = indexMix[2 * j];
                 }
             }
+            this.forcedInstanceCount = Math.max(renderedPadded >> 4, 1);
             if (this._delayedTextureUpdate) {
+                const vertexCountPadded = (this._vertexCount + 15) & ~0xf;
                 const textureSize = this._getTextureSize(vertexCountPadded);
                 this._updateSubTextures(this._delayedTextureUpdate.centers, this._delayedTextureUpdate.covA, this._delayedTextureUpdate.covB, this._delayedTextureUpdate.colors, 0, textureSize.y, this._delayedTextureUpdate.sh);
                 this._delayedTextureUpdate = null;
@@ -2545,6 +2760,17 @@ export class GaussianSplattingMeshBase extends Mesh {
         return this;
     }
 }
+/**
+ * When true (default), the depth-sort worker uses the fast O(n) counting (radix) sort. Set to false to
+ * fall back to the legacy comparison sort (useful for A/B comparison or as a safety fallback). The change
+ * takes effect on the next sort.
+ */
+GaussianSplattingMeshBase.UseCountingSort = true;
+/**
+ * When true, the depth-sort worker logs each sort's duration (ms) and active splat count to the console.
+ * Off by default; intended for performance investigation only.
+ */
+GaussianSplattingMeshBase.LogSortPerformance = false;
 GaussianSplattingMeshBase._RowOutputLength = 3 * 4 + 3 * 4 + 4 + 4; // Vector3 position, Vector3 scale, 1 u8 quaternion, 1 color with alpha
 GaussianSplattingMeshBase._SH_C0 = 0.28209479177387814;
 // batch size between 2 yield calls. This value is a tradeoff between updates overhead and framerate hiccups
@@ -2559,93 +2785,6 @@ GaussianSplattingMeshBase._DefaultViewUpdateThreshold = 1e-4;
  * A value of 0 (default) means display update will not happens before splat is ready.
  */
 GaussianSplattingMeshBase.ProgressiveUpdateAmount = 0;
-GaussianSplattingMeshBase._CreateWorker = function (self) {
-    let positions;
-    let depthMix;
-    let indices;
-    let floatMix;
-    let partIndices;
-    let partMatrices;
-    self.onmessage = (e) => {
-        // updated on init
-        if (e.data.positions) {
-            positions = e.data.positions;
-        }
-        // update on rig node changed
-        else if (e.data.partMatrices) {
-            partMatrices = e.data.partMatrices;
-        }
-        // update on rig node indices changed
-        else if (e.data.partIndices !== undefined) {
-            partIndices = e.data.partIndices;
-        }
-        // update on view changed
-        else {
-            const cameraId = e.data.cameraId;
-            const sortRequestId = e.data.sortRequestId;
-            const globalWorldMatrix = e.data.worldMatrix;
-            const cameraForward = e.data.cameraForward;
-            const cameraPosition = e.data.cameraPosition;
-            depthMix = e.data.depthMix;
-            if (!positions || !cameraForward) {
-                // Sort request arrived before positions were initialized — return the buffer unchanged so the main thread can unlock _canPostToWorker.
-                self.postMessage({ depthMix, cameraId, sortRequestId }, [depthMix.buffer]);
-                return;
-            }
-            const vertexCountPadded = (positions.length / 4 + 15) & ~0xf;
-            indices = new Uint32Array(depthMix.buffer);
-            floatMix = new Float32Array(depthMix.buffer);
-            // Sort
-            for (let j = 0; j < vertexCountPadded; j++) {
-                indices[2 * j] = j;
-            }
-            // depth = dot(cameraForward, worldPos - cameraPos)
-            const camDot = cameraForward[0] * cameraPosition[0] + cameraForward[1] * cameraPosition[1] + cameraForward[2] * cameraPosition[2];
-            const computeDepthCoeffs = (m) => {
-                return [
-                    cameraForward[0] * m[0] + cameraForward[1] * m[1] + cameraForward[2] * m[2],
-                    cameraForward[0] * m[4] + cameraForward[1] * m[5] + cameraForward[2] * m[6],
-                    cameraForward[0] * m[8] + cameraForward[1] * m[9] + cameraForward[2] * m[10],
-                    cameraForward[0] * m[12] + cameraForward[1] * m[13] + cameraForward[2] * m[14] - camDot,
-                ];
-            };
-            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];
-                    }
-                }
-                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);
-            }
-            self.postMessage({ depthMix, cameraId, sortRequestId }, [depthMix.buffer]);
-        }
-    };
-};
 /**
  * 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