@onerjs/core 9.0.2 → 9.0.4

package/Meshes/GaussianSplatting/gaussianSplattingMeshBase.pure.js

@@ -16,6 +16,25 @@ import { runCoroutineSync, runCoroutineAsync, createYieldingScheduler } from "..
 import { EngineStore } from "../../Engines/engineStore.js";
 import { ImportMeshAsync } from "../../Loading/sceneLoader.js";
 import { GaussianSplattingSortWorker, GaussianSplattingSortWorkerCommand } from "./gaussianSplattingSortWorker.js";
+import { GaussianSplattingGpuSorter } from "./gaussianSplattingGpuSorter.js";
+// The compute shaders of the GPU sorter are loaded lazily, only when a WebGPU mesh uses the GPU sort.
+let _GpuSortDependenciesReady = false;
+let _GpuSortDependenciesFailed = false;
+let _GpuSortDependenciesLoading = false;
+async function _LoadGpuSortDependenciesAsync() {
+    if (_GpuSortDependenciesLoading) {
+        return;
+    }
+    _GpuSortDependenciesLoading = true;
+    try {
+        await GaussianSplattingGpuSorter.LoadDependenciesAsync();
+        _GpuSortDependenciesReady = true;
+    }
+    catch (e) {
+        _GpuSortDependenciesFailed = true;
+        Logger.Warn("Gaussian Splatting GPU sort shaders failed to load, falling back to the CPU sort: " + e);
+    }
+}
 const IsNative = typeof _native !== "undefined";
 const Native = IsNative ? _native : null;
 // @internal
@@ -301,6 +320,8 @@ export class GaussianSplattingMeshBase extends Mesh {
     /**
      * If true, disables depth sorting of the splats (default: false)
      * Disabling sorting also discards deferred forced-sort requests.
+     * A mesh sorted on the GPU (see {@link GaussianSplattingMeshBase.UseGpuSort}) leaves the GPU sort when it is disabled at runtime
+     * and uses the identity index buffer of the CPU path. It does not return to the GPU sort when sorting is enabled again: the CPU worker is used instead.
      */
     get disableDepthSort() {
         return this._disableDepthSort;
@@ -311,6 +332,10 @@ export class GaussianSplattingMeshBase extends Mesh {
             this._worker = null;
             this._disableDepthSort = true;
             this._forcedSortPending = false;
+            if (this._gpuMode) {
+                // The GPU sort has no identity output: the CPU path provides valid indices for every view and data update.
+                this._switchToWorkerSort();
+            }
         }
         else if (this._disableDepthSort && !value) {
             this._disableDepthSort = false;
@@ -351,7 +376,7 @@ export class GaussianSplattingMeshBase extends Mesh {
      * Number of splats in the mesh
      */
     get splatCount() {
-        return this._splatIndex?.length;
+        return this._gpuMode ? this._gpuPaddedCount : this._splatIndex?.length;
     }
     /**
      * Number of source splats currently selected for rendering.
@@ -378,6 +403,13 @@ export class GaussianSplattingMeshBase extends Mesh {
         this._activeSplatRangeKey = rangeData.key;
         this._activeSplatRenderCount = rangeData.count;
         this._activeRangeVersion++;
+        if (this._gpuMode) {
+            this._gpuIntervalsDirty = true;
+            this._gpuDataRevision++;
+            this._sortIsDirty = true;
+            this._postToWorker(true);
+            return;
+        }
         this._postIntervalsToWorker();
         if (this._worker) {
             // Defer swapping the rendered index buffer until the worker returns a depth sort computed for
@@ -406,6 +438,9 @@ export class GaussianSplattingMeshBase extends Mesh {
      * @internal
      */
     get _isDepthSortSettled() {
+        if (this._gpuMode) {
+            return this._readyToDisplay && !this._gpuSortPending && !this._forcedSortPending && this._canPostToWorker;
+        }
         return this._readyToDisplay && !this._sortIsDirty && !this._forcedSortPending && this._canPostToWorker;
     }
     // (Re)allocates the worker depth buffer to the given padded size. A fresh array is allocated when the
@@ -424,6 +459,11 @@ export class GaussianSplattingMeshBase extends Mesh {
      * a single interval covering all source splats is sent so the worker never assumes the full set.
      */
     _postIntervalsToWorker() {
+        if (this._gpuMode) {
+            this._gpuIntervalsDirty = true;
+            this._gpuDataRevision++;
+            return;
+        }
         if (!this._worker) {
             return;
         }
@@ -470,6 +510,8 @@ export class GaussianSplattingMeshBase extends Mesh {
             this._rotationScaleTexture = rotationTextures[2];
             this._needsRotationScaleTextures = true;
         }
+        // The centers are an external render target: only the CPU worker sorts this mesh for now.
+        this._gpuSortForbidden = true;
         this._activeSplatRanges = null;
         this._activeSplatRangeKey = "";
         this._activeSplatRenderCount = 0;
@@ -505,43 +547,50 @@ export class GaussianSplattingMeshBase extends Mesh {
         return { min: this._splatSizeMin, max: this._splatSizeMax };
     }
     /**
-     * Gets the covariancesA texture
+     * Gets the covariancesA texture.
+     * On WebGPU it is created as a sampled-data-only texture (no render attachment usage), so it cannot be used as a render target.
      */
     get covariancesATexture() {
         return this._covariancesATexture;
     }
     /**
-     * Gets the covariancesB texture
+     * Gets the covariancesB texture.
+     * On WebGPU it is created as a sampled-data-only texture (no render attachment usage), so it cannot be used as a render target.
      */
     get covariancesBTexture() {
         return this._covariancesBTexture;
     }
     /**
-     * Gets the centers texture
+     * Gets the centers texture.
+     * On WebGPU it is created as a sampled-data-only texture (no render attachment usage), so it cannot be used as a render target.
      */
     get centersTexture() {
         return this._centersTexture;
     }
     /**
-     * Gets the colors texture
+     * Gets the colors texture.
+     * On WebGPU it is created as a sampled-data-only texture (no render attachment usage), so it cannot be used as a render target.
      */
     get colorsTexture() {
         return this._colorsTexture;
     }
     /**
-     * Gets the rotation matrix A texture (rotation elements m[0],m[1],m[2],m[4])
+     * Gets the rotation matrix A texture (rotation elements m[0],m[1],m[2],m[4]).
+     * On WebGPU it is created as a sampled-data-only texture (no render attachment usage), so it cannot be used as a render target.
      */
     get rotationsATexture() {
         return this._rotationsATexture;
     }
     /**
-     * Gets the rotation matrix B texture (rotation elements m[5],m[6],m[8],m[9])
+     * Gets the rotation matrix B texture (rotation elements m[5],m[6],m[8],m[9]).
+     * On WebGPU it is created as a sampled-data-only texture (no render attachment usage), so it cannot be used as a render target.
      */
     get rotationsBTexture() {
         return this._rotationsBTexture;
     }
     /**
-     * Gets the rotation scale texture (rotation element m[10] followed by scale diagonal sx,sy,sz)
+     * Gets the rotation scale texture (rotation element m[10] followed by scale diagonal sx,sy,sz).
+     * On WebGPU it is created as a sampled-data-only texture (no render attachment usage), so it cannot be used as a render target.
      */
     get rotationScaleTexture() {
         return this._rotationScaleTexture;
@@ -568,7 +617,8 @@ export class GaussianSplattingMeshBase extends Mesh {
         }
     }
     /**
-     * Gets the SH textures
+     * Gets the SH textures.
+     * On WebGPU these are created as sampled-data-only textures (no render attachment usage), so they cannot be used as render targets.
      */
     get shTextures() {
         return this._shTextures;
@@ -744,6 +794,11 @@ export class GaussianSplattingMeshBase extends Mesh {
      */
     constructor(name, url = null, scene = null, keepInRam = false) {
         super(name, scene);
+        /**
+         * Overrides {@link GaussianSplattingMeshBase.UseGpuSort} for this mesh when not null. Set it before loading data.
+         * @experimental
+         */
+        this.useGpuSort = null;
         /**
          * Safe-orbit camera limits parsed from the source file's metadata, or `null` when the file
          * carries none. The loader also auto-applies these to an active ArcRotateCamera at load time
@@ -814,6 +869,31 @@ export class GaussianSplattingMeshBase extends Mesh {
         this._sortIsDirty = false;
         // A forced sort requested while no classic pass needed sorting; runs on the next classic pass.
         this._forcedSortPending = false;
+        // GPU sort state. `_gpuMode` is true when this mesh sorts with the GPU sorter instead of the worker.
+        this._gpuMode = false;
+        this._gpuSorter = null;
+        this._gpuObserver = null;
+        this._gpuRestoreObserver = null;
+        // Incremented whenever the sort inputs change (data, ranges, part matrices): every camera output is then sorted again.
+        this._gpuDataRevision = 1;
+        this._gpuSourceDirty = true;
+        this._gpuIntervalsDirty = true;
+        // Null outside progressive loading; otherwise only this prefix of the source has been uploaded.
+        this._gpuProgressiveCount = null;
+        this._gpuSortPending = false;
+        this._gpuPaddedCount = 0;
+        this._gpuBoundsMin = null;
+        this._gpuBoundsMax = null;
+        this._gpuBoundsDirty = true;
+        this._gpuSortOptions = {};
+        this._gpuViewInfos = [];
+        this._gpuCollectFrameId = 0;
+        this._gpuCameraPosition = [0, 0, 0];
+        // Set when the worker has to be (re)created lazily after leaving the GPU sort mode.
+        this._workerPending = false;
+        this._gpuPartMatricesDirty = false;
+        // Set when the mesh cannot use the GPU sort (e.g. an external work buffer is used as centers).
+        this._gpuSortForbidden = false;
         this._activeSplatRanges = null;
         this._activeSplatRangeKey = "";
         this._activeSplatRenderCount = 0;
@@ -828,6 +908,7 @@ export class GaussianSplattingMeshBase extends Mesh {
         this._splatDataPending = false;
         this._maxShDegree = 0;
         this._cameraViewInfos = new Map();
+        this._cameraRemovedObserver = null;
         /** Fired after parts are added or the mesh is rebuilt following a removal. Payload is the new part count. */
         this.onPartCountChangedObservable = new Observable();
         /** Fired after part-removal validation passes but before the mesh is rebuilt.
@@ -852,6 +933,12 @@ export class GaussianSplattingMeshBase extends Mesh {
         this.viewUpdateThreshold = GaussianSplattingMeshBase._DefaultViewUpdateThreshold;
         this._disableDepthSort = false;
         this._loadingPromise = null;
+        // Collects the view infos that were rendered or prepared during the previous or current frame.
+        this._collectRecentViewInfo = (info) => {
+            if (this._gpuCollectFrameId - info.frameIdLastUpdate <= 1 && this._gpuViewInfos.indexOf(info) < 0) {
+                this._gpuViewInfos.push(info);
+            }
+        };
         this._updateTextureFromData = (texture, data, width, lineStart, lineCount) => {
             const engine = this._getTextureDataUpdateEngine();
             const internalTexture = texture.getInternalTexture();
@@ -882,7 +969,7 @@ export class GaussianSplattingMeshBase extends Mesh {
         gaussianSplattingMaterial.doNotSerialize = true;
         this._material = gaussianSplattingMaterial;
         // delete meshes created for cameras on camera removal
-        this._scene.onCameraRemovedObservable.add((camera) => {
+        this._cameraRemovedObserver = this._scene.onCameraRemovedObservable.add((camera) => {
             const cameraId = camera.uniqueId;
             // delete mesh for this camera
             const cameraViewInfos = this._cameraViewInfos.get(cameraId);
@@ -894,6 +981,8 @@ export class GaussianSplattingMeshBase extends Mesh {
                     this._geometry = null;
                 }
                 cameraViewInfos.mesh.dispose();
+                cameraViewInfos.gpuOutput?.dispose();
+                cameraViewInfos.gpuOutput = null;
                 this._cameraViewInfos.delete(cameraId);
             }
         });
@@ -1070,8 +1159,15 @@ export class GaussianSplattingMeshBase extends Mesh {
     }
     /** @internal */
     _postToWorker(forced = false) {
-        const scene = this._scene;
-        const frameId = scene.getFrameId();
+        if (this._gpuMode) {
+            this._postToGpuSort(forced);
+            return;
+        }
+        if (this._workerPending && this._vertexCount && this._splatPositions) {
+            // Left the GPU sort mode: the worker is created lazily.
+            this._instantiateWorker();
+        }
+        const frameId = this._scene.getFrameId();
         // force update or at least frame update for camera is outdated
         let outdated = false;
         this._cameraViewInfos.forEach((cameraViewInfos) => {
@@ -1079,54 +1175,9 @@ export class GaussianSplattingMeshBase extends Mesh {
                 outdated = true;
             }
         });
-        // array of cameras used for rendering
-        const cameras = this._scene.activeCameras?.length ? this._scene.activeCameras : [this._scene.activeCamera];
-        // list view infos for active cameras
+        // list view infos for active cameras, creating the missing ones
         const activeViewInfos = [];
-        cameras.forEach((camera) => {
-            if (!camera) {
-                return;
-            }
-            const cameraId = camera.uniqueId;
-            const cameraViewInfos = this._cameraViewInfos.get(cameraId);
-            if (cameraViewInfos) {
-                activeViewInfos.push(cameraViewInfos);
-            }
-            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, _gaussianSplattingSourceMesh: this };
-                cameraMesh.setEnabled(false);
-                cameraMesh.material = this.material;
-                if (cameraMesh.material && cameraMesh.material instanceof GaussianSplattingMaterial) {
-                    const gsMaterial = cameraMesh.material;
-                    // GaussianSplattingMaterial source mesh may not have been set yet.
-                    // This happens for cloned resources from asset containers for instance,
-                    // where material is cloned before mesh.
-                    if (!gsMaterial.getSourceMesh()) {
-                        // Cast is safe: see constructor comment above.
-                        gsMaterial.setSourceMesh(this);
-                    }
-                }
-                GaussianSplattingMeshBase._MakeSplatGeometryForMesh(cameraMesh);
-                const newViewInfos = {
-                    camera: camera,
-                    cameraDirection: new Vector3(0, 0, 0),
-                    sortWorldMatrix: Matrix.Identity(),
-                    sortCameraForward: new Vector3(0, 0, 0),
-                    sortCameraPosition: new Vector3(0, 0, 0),
-                    sortRequestId: 0,
-                    sortAppliedId: 0,
-                    mesh: cameraMesh,
-                    frameIdLastUpdate: frameId,
-                    splatIndexBufferSet: false,
-                };
-                activeViewInfos.push(newViewInfos);
-                this._cameraViewInfos.set(cameraId, newViewInfos);
-            }
-        });
+        this._collectActiveViewInfos(frameId, false, activeViewInfos);
         // Sort view infos: cameras without a completed initial sort come first so they don't get starved
         // by a `forced` re-sort of an already-initialized camera (which would consume `_canPostToWorker`).
         // A camera can already have the shared index buffer bound when another camera's first sort resizes it,
@@ -1204,6 +1255,7 @@ export class GaussianSplattingMeshBase extends Mesh {
                         cameraViewInfos.sortAppliedId = cameraViewInfos.sortRequestId;
                         this._canPostToWorker = true;
                         this._readyToDisplay = true;
+                        this._sortIsDirty = false;
                     }
                 }
             });
@@ -1234,6 +1286,475 @@ export class GaussianSplattingMeshBase extends Mesh {
             }
         }
     }
+    // Fills `out` with the view infos of the active cameras, creating the missing ones.
+    _collectActiveViewInfos(frameId, stampFrame, out) {
+        out.length = 0;
+        const activeCameras = this._scene.activeCameras;
+        if (activeCameras && activeCameras.length) {
+            for (let i = 0; i < activeCameras.length; i++) {
+                this._collectCameraViewInfo(activeCameras[i], frameId, stampFrame, out);
+            }
+        }
+        else {
+            this._collectCameraViewInfo(this._scene.activeCamera, frameId, stampFrame, out);
+        }
+    }
+    _collectCameraViewInfo(camera, frameId, stampFrame, out) {
+        if (!camera) {
+            return;
+        }
+        const cameraId = camera.uniqueId;
+        const existingViewInfos = this._cameraViewInfos.get(cameraId);
+        if (existingViewInfos) {
+            if (stampFrame) {
+                existingViewInfos.frameIdLastUpdate = frameId;
+            }
+            out.push(existingViewInfos);
+            return;
+        }
+        // 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, _gaussianSplattingSourceMesh: this };
+        cameraMesh.setEnabled(false);
+        cameraMesh.material = this.material;
+        if (cameraMesh.material && cameraMesh.material instanceof GaussianSplattingMaterial) {
+            const gsMaterial = cameraMesh.material;
+            // GaussianSplattingMaterial source mesh may not have been set yet.
+            // This happens for cloned resources from asset containers for instance,
+            // where material is cloned before mesh.
+            if (!gsMaterial.getSourceMesh()) {
+                // Cast is safe: see constructor comment above.
+                gsMaterial.setSourceMesh(this);
+            }
+        }
+        GaussianSplattingMeshBase._MakeSplatGeometryForMesh(cameraMesh);
+        const newViewInfos = {
+            camera: camera,
+            cameraDirection: new Vector3(0, 0, 0),
+            sortWorldMatrix: Matrix.Identity(),
+            sortCameraForward: new Vector3(0, 0, 0),
+            sortCameraPosition: new Vector3(0, 0, 0),
+            sortRequestId: 0,
+            sortAppliedId: 0,
+            mesh: cameraMesh,
+            frameIdLastUpdate: frameId,
+            splatIndexBufferSet: false,
+            gpuOutput: null,
+            gpuAppliedRevision: 0,
+            gpuBuffersVersion: 0,
+            gpuLastSortFrameId: 0,
+        };
+        out.push(newViewInfos);
+        this._cameraViewInfos.set(cameraId, newViewInfos);
+    }
+    /**
+     * Whether the sort of this mesh runs on the GPU (WebGPU compute) instead of the CPU worker.
+     * @internal
+     */
+    get _isGpuSortActive() {
+        return this._gpuMode;
+    }
+    // Tells the GPU sorter its source (textures, bounds, intervals, part matrices) changed and every camera must be sorted again.
+    /** @internal */
+    _markGpuSourceDirty() {
+        this._gpuSourceDirty = true;
+        this._gpuIntervalsDirty = true;
+        this._gpuBoundsDirty = true;
+        this._gpuDataRevision++;
+    }
+    // Tells the GPU sorter the part transforms of a compound mesh changed.
+    /** @internal */
+    _markGpuPartMatricesDirty() {
+        this._gpuPartMatricesDirty = true;
+        this._gpuDataRevision++;
+    }
+    /**
+     * Texture holding the part index of each splat, for compound meshes. Null for a regular mesh.
+     * @returns the part indices texture
+     */
+    _getGpuSortPartIndicesTexture() {
+        return null;
+    }
+    /**
+     * Transforms of the parts of a compound mesh. They replace the world matrix when sorting. Null for a regular mesh.
+     * @returns the part matrices
+     */
+    _getGpuSortPartMatrices() {
+        return null;
+    }
+    /**
+     * Synchronizes compound part transforms before checking whether the GPU sort is up to date.
+     */
+    _syncPartProxyWorldMatrices() { }
+    // Whether this mesh can use the GPU sorter. `vertexCount` is the (possibly upcoming) source splat count.
+    _isGpuSortEligible(vertexCount) {
+        if (!(this.useGpuSort ?? GaussianSplattingMeshBase.UseGpuSort) || IsNative || this._gpuSortForbidden || _GpuSortDependenciesFailed) {
+            return false;
+        }
+        // Streaming parts decode into a render-target atlas: they keep using the CPU worker.
+        if (this._useMrtAtlas || this._mrtAtlas) {
+            return false;
+        }
+        // A custom render function (other than the frame graph one) does not notify onBeforeRenderObservable, where the sort is dispatched.
+        const scene = this._scene;
+        if (scene.customRenderFunction && !scene.frameGraph) {
+            return false;
+        }
+        const engine = scene.getEngine();
+        if (!GaussianSplattingGpuSorter.IsSupported(engine) || vertexCount > GaussianSplattingGpuSorter.GetMaxSupportedSplatCount(engine)) {
+            return false;
+        }
+        // The mode is chosen when the sort buffers are first created: a mesh already bound to an identity index buffer keeps its worker.
+        return this._gpuMode || (!this._disableDepthSort && !this._splatIndex);
+    }
+    _enterGpuMode() {
+        this._gpuMode = true;
+        this._workerPending = false;
+        this._worker?.terminate();
+        this._worker = null;
+        this._canPostToWorker = true;
+        this._markGpuSourceDirty();
+        if (!this._gpuObserver) {
+            this._gpuObserver = this._scene.onBeforeRenderObservable.add(() => this._runGpuSort());
+        }
+        if (!this._gpuRestoreObserver) {
+            this._gpuRestoreObserver = this._scene.getEngine().onContextRestoredObservable.add(() => this._onGpuContextRestored());
+        }
+        // The compute shaders are loaded lazily: the first sort waits for them.
+        void _LoadGpuSortDependenciesAsync();
+    }
+    // After a device restoration the rebuilt storage buffers are empty, the sorter caches (radix parameters, intervals, bindings) describe the lost buffers,
+    // and the geometry rebuild recreates the vertex buffer wrappers separately from the storage buffers they alias.
+    // The sorter is dropped with all its outputs and every view is invalidated: the next sort recreates and rebinds everything from the current source.
+    _onGpuContextRestored() {
+        if (!this._gpuMode) {
+            return;
+        }
+        this._resetGpuViews();
+        this._gpuSorter?.dispose();
+        this._gpuSorter = null;
+        this._readyToDisplay = false;
+        this._gpuSortPending = true;
+        this._canPostToWorker = true;
+        this._markGpuSourceDirty();
+    }
+    // Drops the sort output bound to each view: they must be sorted and bound again.
+    _resetGpuViews() {
+        this._cameraViewInfos.forEach((info) => {
+            info.gpuOutput = null;
+            info.gpuAppliedRevision = 0;
+            info.gpuBuffersVersion = 0;
+            info.splatIndexBufferSet = false;
+            info.sortAppliedId = 0;
+            info.sortRequestId = 0;
+            info.mesh.forcedInstanceCount = 0;
+        });
+    }
+    // Leaves the GPU sort mode. The worker is created by the next _postToWorker call.
+    _exitGpuMode() {
+        if (!this._gpuMode) {
+            return;
+        }
+        this._gpuMode = false;
+        if (this._gpuObserver) {
+            this._scene.onBeforeRenderObservable.remove(this._gpuObserver);
+            this._gpuObserver = null;
+        }
+        if (this._gpuRestoreObserver) {
+            this._scene.getEngine().onContextRestoredObservable.remove(this._gpuRestoreObserver);
+            this._gpuRestoreObserver = null;
+        }
+        this._resetGpuViews();
+        this._gpuSorter?.dispose();
+        this._gpuSorter = null;
+        this._gpuSortPending = false;
+        this._readyToDisplay = false;
+        this._canPostToWorker = true;
+        this._sortIsDirty = true;
+        this._workerPending = true;
+    }
+    /**
+     * Switches a mesh sorted on the GPU to the CPU worker (e.g. when it starts streaming, which needs a render-target atlas).
+     * @internal
+     */
+    _switchToWorkerSort() {
+        this._gpuSortForbidden = true;
+        this._exitGpuMode();
+    }
+    _postToGpuSort(forced) {
+        if (this._scene.customRenderFunction && !this._scene.frameGraph) {
+            this._switchToWorkerSort();
+            this._postToWorker(forced);
+            return;
+        }
+        const frameId = this._scene.getFrameId();
+        this._collectActiveViewInfos(frameId, true, this._gpuViewInfos);
+        const sortRequired = this._isSortRequired();
+        if (forced) {
+            if (!sortRequired) {
+                // Deferred to the next classic pass, like the worker path.
+                if (!this._disableDepthSort) {
+                    this._forcedSortPending = true;
+                }
+            }
+            else if (!this._gpuSortPending) {
+                this._gpuDataRevision++;
+            }
+            this._gpuSortPending = true;
+        }
+        else if (sortRequired && this._forcedSortPending && !this._disableDepthSort) {
+            this._forcedSortPending = false;
+            if (!this._gpuSortPending) {
+                this._gpuDataRevision++;
+            }
+            this._gpuSortPending = true;
+        }
+        if (!sortRequired) {
+            this._commitDelayedTextureUpdate();
+            this._canPostToWorker = true;
+            return;
+        }
+        // Readiness polling must progress without a render loop. Once rendered, coalesce mutations at scene pre-render.
+        if ((!this._readyToDisplay || !this._hasRenderedOnce) && !this._scene._isInRenderingMeshEvaluation() && !this._scene.getEngine()._currentRenderTarget) {
+            this._runGpuSort();
+        }
+    }
+    _gpuViewNeedsSort(info, world) {
+        if (info.gpuAppliedRevision !== this._gpuDataRevision || info.sortAppliedId === 0) {
+            return true;
+        }
+        const minInterval = GaussianSplattingMeshBase.GpuSortMinFrameInterval;
+        if (minInterval > 1 && this._scene.getFrameId() - info.gpuLastSortFrameId < minInterval) {
+            return false;
+        }
+        return !this._disableDepthSort && this._isSortStateDirty(info, world, info.camera);
+    }
+    _ensureGpuSorter() {
+        if (this._gpuSorter) {
+            return true;
+        }
+        if (_GpuSortDependenciesFailed) {
+            this._exitGpuMode();
+            return false;
+        }
+        if (!_GpuSortDependenciesReady) {
+            void _LoadGpuSortDependenciesAsync();
+            return false;
+        }
+        this._gpuSorter = new GaussianSplattingGpuSorter(this._scene.getEngine(), this.name + "_gpuSort");
+        this._gpuSourceDirty = true;
+        return true;
+    }
+    // Local-space bounds of the splat centers, used by the sorter to derive the depth range.
+    _updateGpuBounds() {
+        const positions = this._splatPositions;
+        if (!positions) {
+            return false;
+        }
+        if (!this._gpuBoundsDirty && this._gpuBoundsMin) {
+            return true;
+        }
+        const min = (this._gpuBoundsMin ?? (this._gpuBoundsMin = new Vector3()));
+        const max = (this._gpuBoundsMax ?? (this._gpuBoundsMax = new Vector3()));
+        min.setAll(Number.MAX_VALUE);
+        max.setAll(-Number.MAX_VALUE);
+        const count = Math.min(this._gpuProgressiveCount ?? this._vertexCount, Math.floor(positions.length / 4));
+        for (let i = 0; i < count; i++) {
+            const x = positions[i * 4];
+            const y = positions[i * 4 + 1];
+            const z = positions[i * 4 + 2];
+            if (x < min.x) {
+                min.x = x;
+            }
+            if (y < min.y) {
+                min.y = y;
+            }
+            if (z < min.z) {
+                min.z = z;
+            }
+            if (x > max.x) {
+                max.x = x;
+            }
+            if (y > max.y) {
+                max.y = y;
+            }
+            if (z > max.z) {
+                max.z = z;
+            }
+        }
+        if (count === 0) {
+            min.setAll(0);
+            max.setAll(0);
+        }
+        this._gpuBoundsDirty = false;
+        return true;
+    }
+    _applyGpuIntervals(sorter) {
+        let intervals = this._activeSplatRanges;
+        const uploaded = this._gpuProgressiveCount;
+        if (uploaded !== null) {
+            if (intervals) {
+                intervals = new Uint32Array(intervals);
+                for (let i = 0; i < intervals.length; i += 2) {
+                    intervals[i + 1] = Math.max(0, Math.min(intervals[i + 1], uploaded - intervals[i]));
+                }
+            }
+            else {
+                intervals = new Uint32Array([0, uploaded]);
+            }
+        }
+        if (!sorter.setIntervals(intervals)) {
+            this._switchToWorkerSort();
+            return false;
+        }
+        this._gpuIntervalsDirty = false;
+        return true;
+    }
+    _applyGpuSource(sorter) {
+        const sog = this._useSog ? this._sogParams : null;
+        const centersTexture = sog ? sog.meansTextureL : this._centersTexture;
+        if (!centersTexture) {
+            return false;
+        }
+        const partIndicesTexture = this._getGpuSortPartIndicesTexture();
+        let accepted;
+        if (sog) {
+            accepted = sorter.setSource({
+                vertexCount: this._vertexCount,
+                textureWidth: this._textureSize.x,
+                centersTexture,
+                sog: { meansHighTexture: sog.meansTextureU, meansMin: sog.meansMin, meansMax: sog.meansMax },
+            });
+        }
+        else {
+            if (!this._updateGpuBounds()) {
+                return false;
+            }
+            accepted = sorter.setSource({
+                vertexCount: this._vertexCount,
+                textureWidth: this._textureSize.x,
+                centersTexture,
+                partIndicesTexture: partIndicesTexture ?? undefined,
+                boundsMin: this._gpuBoundsMin.asArray(),
+                boundsMax: this._gpuBoundsMax.asArray(),
+            });
+        }
+        if (!accepted) {
+            this._switchToWorkerSort();
+            return false;
+        }
+        if (!this._applyGpuIntervals(sorter)) {
+            return false;
+        }
+        sorter.setPartMatrices(partIndicesTexture ? this._getGpuSortPartMatrices() : null);
+        this._gpuSourceDirty = false;
+        this._gpuPartMatricesDirty = false;
+        return true;
+    }
+    _bindGpuOutput(info, output) {
+        const mesh = info.mesh;
+        if (info.gpuBuffersVersion !== output.buffersVersion || !info.splatIndexBufferSet) {
+            const vertexBuffers = output.vertexBuffers;
+            for (let i = 0; i < vertexBuffers.length; i++) {
+                // The sort output owns the vertex buffers
+                mesh.setVerticesBuffer(vertexBuffers[i], false);
+            }
+            info.gpuBuffersVersion = output.buffersVersion;
+        }
+        mesh.forcedInstanceCount = Math.max(output.instanceCount, 1);
+    }
+    // Sorts the splats of every view that needs it. Runs before the scene renders: compute work cannot be dispatched during a render pass.
+    _runGpuSort() {
+        if (!this._gpuMode ||
+            !this._canPostToWorker ||
+            !this._vertexCount ||
+            !this._centersTexture ||
+            (this._splatDataPending && !this._gpuProgressiveCount) ||
+            !this._isSortRequired()) {
+            return;
+        }
+        this._syncPartProxyWorldMatrices();
+        const scene = this._scene;
+        const frameId = scene.getFrameId();
+        const views = this._gpuViewInfos;
+        views.length = 0;
+        this._gpuCollectFrameId = frameId;
+        this._cameraViewInfos.forEach(this._collectRecentViewInfo);
+        if (views.length === 0) {
+            return;
+        }
+        const world = this.computeWorldMatrix(true);
+        let needsSort = false;
+        for (let i = 0; i < views.length && !needsSort; i++) {
+            needsSort = this._gpuViewNeedsSort(views[i], world);
+        }
+        if (!needsSort) {
+            return;
+        }
+        if (!this._ensureGpuSorter()) {
+            return;
+        }
+        const sorter = this._gpuSorter;
+        // The pending texture rows are uploaded right before sorting so the centers match the sort source.
+        this._commitDelayedTextureUpdate();
+        if (this._gpuSourceDirty && !this._applyGpuSource(sorter)) {
+            return;
+        }
+        if (this._gpuIntervalsDirty && !this._applyGpuIntervals(sorter)) {
+            return;
+        }
+        if (this._gpuPartMatricesDirty) {
+            sorter.setPartMatrices(this._getGpuSortPartIndicesTexture() ? this._getGpuSortPartMatrices() : null);
+            this._gpuPartMatricesDirty = false;
+        }
+        const options = this._gpuSortOptions;
+        options.rightHanded = scene.useRightHandedSystem;
+        const cameraPosition = this._gpuCameraPosition;
+        options.cameraPosition = cameraPosition;
+        const revision = this._gpuDataRevision;
+        let allApplied = true;
+        for (let i = 0; i < views.length; i++) {
+            const info = views[i];
+            if (!this._gpuViewNeedsSort(info, world)) {
+                continue;
+            }
+            const camera = info.camera;
+            const viewMatrix = camera.getViewMatrix();
+            const position = camera.globalPosition;
+            cameraPosition[0] = position.x;
+            cameraPosition[1] = position.y;
+            cameraPosition[2] = position.z;
+            const output = (info.gpuOutput ?? (info.gpuOutput = sorter.createOutput()));
+            if (!sorter.sort(output, world, viewMatrix, options)) {
+                allApplied = false;
+                if (info.gpuBuffersVersion !== output.buffersVersion) {
+                    // The output buffers were recreated: the bound ones are gone, so wait for the next successful sort to render this view.
+                    this._bindGpuOutput(info, output);
+                    info.splatIndexBufferSet = false;
+                    info.sortAppliedId = 0;
+                }
+                continue;
+            }
+            this._bindGpuOutput(info, output);
+            info.sortWorldMatrix.copyFrom(world);
+            info.sortCameraForward.set(viewMatrix.m[2], viewMatrix.m[6], viewMatrix.m[10]);
+            info.sortCameraPosition.copyFrom(position);
+            info.sortRequestId = info.sortAppliedId = ++this._sortRequestId;
+            info.gpuAppliedRevision = revision;
+            info.gpuLastSortFrameId = frameId;
+            info.splatIndexBufferSet = true;
+            this._gpuPaddedCount = output.paddedCount;
+            this.forcedInstanceCount = Math.max(output.instanceCount, 1);
+            this._readyToDisplay = true;
+            this._sortIsDirty = false;
+        }
+        if (allApplied) {
+            this._gpuSortPending = false;
+            this._forcedSortPending = false;
+        }
+    }
     /**
      * Triggers the draw call for the mesh. Usually, you don't need to call this method by your own because the mesh rendering is handled by the scene rendering manager
      * @param subMesh defines the subMesh to render
@@ -2117,13 +2638,30 @@ export class GaussianSplattingMeshBase extends Mesh {
         this._worker = null;
         this.onPartCountChangedObservable.clear();
         this.onPartRemovedObservable.clear();
+        this._scene.onCameraRemovedObservable.remove(this._cameraRemovedObserver);
+        this._cameraRemovedObserver = null;
         // delete meshes created for each camera
         this._cameraViewInfos.forEach((cameraViewInfo) => {
             cameraViewInfo.mesh.dispose();
+            cameraViewInfo.gpuOutput?.dispose();
+            cameraViewInfo.gpuOutput = null;
         });
+        if (this._gpuObserver) {
+            this._scene.onBeforeRenderObservable.remove(this._gpuObserver);
+            this._gpuObserver = null;
+        }
+        if (this._gpuRestoreObserver) {
+            this._scene.getEngine().onContextRestoredObservable.remove(this._gpuRestoreObserver);
+            this._gpuRestoreObserver = null;
+        }
+        this._gpuSorter?.dispose();
+        this._gpuSorter = null;
+        this._gpuMode = false;
         super.dispose(doNotRecurse, true);
     }
     _copyTextures(source) {
+        // The texture dimensions are not copied with the underscore-prefixed fields: the sort source and incremental updates read them.
+        this._textureSize.copyFrom(source._textureSize);
         this._covariancesATexture = source.covariancesATexture?.clone();
         this._covariancesBTexture = source.covariancesBTexture?.clone();
         this._centersTexture = source.centersTexture?.clone();
@@ -2156,6 +2694,7 @@ export class GaussianSplattingMeshBase extends Mesh {
         newGS._readyToDisplay = false;
         newGS._hasRenderedOnce = false;
         newGS._disableDepthSort = this._disableDepthSort;
+        newGS.useGpuSort = this.useGpuSort;
         newGS._instantiateWorker();
         const binfo = this.getBoundingInfo();
         newGS.getBoundingInfo().reConstruct(binfo.minimum, binfo.maximum, this.getWorldMatrix());
@@ -2452,16 +2991,16 @@ export class GaussianSplattingMeshBase extends Mesh {
         const textureSize = this._getTextureSize(this._vertexCount);
         // Update the textures
         const createTextureFromData = (data, width, height, format) => {
-            return new RawTexture(data, width, height, format, this._scene, false, false, 1, 1);
+            return new RawTexture(data, width, height, format, this._scene, false, false, 1, 1, 2);
         };
         const createTextureFromDataU8 = (data, width, height, format) => {
-            return new RawTexture(data, width, height, format, this._scene, false, false, 1, 0);
+            return new RawTexture(data, width, height, format, this._scene, false, false, 1, 0, 2);
         };
         const createEmptyTextureU32 = (width, height, format) => {
-            return new RawTexture(null, width, height, format, this._scene, false, false, 1, 7);
+            return new RawTexture(null, width, height, format, this._scene, false, false, 1, 7, 2);
         };
         const createTextureFromDataF16 = (data, width, height, format) => {
-            return new RawTexture(data, width, height, format, this._scene, false, false, 1, 2);
+            return new RawTexture(data, width, height, format, this._scene, false, false, 1, 2, 2);
         };
         const firstTime = this._covariancesATexture === null;
         const textureSizeChanged = this._textureSize.y != textureSize.y;
@@ -2481,30 +3020,47 @@ export class GaussianSplattingMeshBase extends Mesh {
             (this._useRotMrtAtlas && !this._rotMrtAtlas);
         if (!firstTime && !textureSizeChanged && !needsMrtConversion) {
             this._setDelayedTextureUpdate(covA, covB, colorArray, sh);
-            const positions = Float32Array.from(this._splatPositions);
-            const vertexCount = this._vertexCount;
             if (this._worker) {
+                const positions = Float32Array.from(this._splatPositions);
+                const vertexCount = this._vertexCount;
                 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. Skip when the SH atlas is
-            // render-backed (_useShMrtAtlas): those targets are created/managed by _createShMrtAtlas, not here.
-            if (sh && !this._shTextures && !this._useShMrtAtlas) {
-                this._shTextures = [];
-                for (let textureIndex = 0; textureIndex < sh.length; textureIndex++) {
+            else if (this._gpuMode) {
+                this._markGpuSourceDirty();
+            }
+            // No sort-worker reply will flush the delayed upload (Native / no-worker path), so it is committed
+            // below. That commit uploads every existing data, rotation and SH texture, so don't upload them here too.
+            const commitWithoutWorker = !this._worker;
+            // Handle SH textures in update path - create any that don't exist yet (including when a higher SH
+            // degree needs more textures than are allocated). Skip when the SH atlas is render-backed
+            // (_useShMrtAtlas): those targets are created/managed by _createShMrtAtlas, not here.
+            if (sh && !this._useShMrtAtlas && (!this._shTextures || this._shTextures.length < sh.length)) {
+                this._shTextures ?? (this._shTextures = []);
+                for (let textureIndex = this._shTextures.length; textureIndex < sh.length; textureIndex++) {
                     const shTexture = createEmptyTextureU32(textureSize.x, textureSize.y, 11);
                     shTexture.wrapU = 0;
                     shTexture.wrapV = 0;
                     this._shTextures.push(shTexture);
-                    this._updateShTextureData(shTexture, sh[textureIndex], textureSize.x, 0, textureSize.y);
+                    if (!commitWithoutWorker) {
+                        this._updateShTextureData(shTexture, sh[textureIndex], textureSize.x, 0, textureSize.y);
+                    }
                 }
             }
+            if (commitWithoutWorker) {
+                // Commit after the SH textures exist (the upload writes them) but before any rotation textures
+                // are created below, since those are created with their data already.
+                this._commitDelayedTextureUpdate();
+            }
             if (this._needsRotationScaleTextures && this._rotationDataA) {
                 if (this._rotationsATexture) {
-                    this._updateTextureFromData(this._rotationsATexture, this._rotationDataA, textureSize.x, 0, textureSize.y);
-                    this._updateTextureFromData(this._rotationsBTexture, this._rotationDataB, textureSize.x, 0, textureSize.y);
-                    this._updateTextureFromData(this._rotationScaleTexture, this._rotationScaleData, textureSize.x, 0, textureSize.y);
+                    // Without a worker, the commit above already uploaded the rotation data.
+                    if (!commitWithoutWorker) {
+                        this._updateTextureFromData(this._rotationsATexture, this._rotationDataA, textureSize.x, 0, textureSize.y);
+                        this._updateTextureFromData(this._rotationsBTexture, this._rotationDataB, textureSize.x, 0, textureSize.y);
+                        this._updateTextureFromData(this._rotationScaleTexture, this._rotationScaleData, textureSize.x, 0, textureSize.y);
+                    }
                 }
                 else {
                     // Rotation textures not yet created (needsRotationScaleTextures was enabled after initial load).
@@ -2667,6 +3223,9 @@ export class GaussianSplattingMeshBase extends Mesh {
                     // Re-sync the active interval set in case the source splat count changed.
                     this._postIntervalsToWorker();
                 }
+                else if (this._gpuMode) {
+                    this._markGpuSourceDirty();
+                }
                 this._postToWorker(true);
             }
         }
@@ -2725,6 +3284,9 @@ export class GaussianSplattingMeshBase extends Mesh {
             // interval set so it covers the current splats instead of a stale (smaller) range.
             this._postIntervalsToWorker();
         }
+        else if (this._gpuMode) {
+            this._markGpuSourceDirty();
+        }
         this._sortIsDirty = true;
     }
     /**
@@ -2737,6 +3299,11 @@ export class GaussianSplattingMeshBase extends Mesh {
      * @param splatCount number of splats in the updated range
      */
     _postWorkerPositionsRange(splatOffset, splatCount) {
+        if (this._gpuMode && splatCount > 0) {
+            this._markGpuSourceDirty();
+            this._sortIsDirty = true;
+            return;
+        }
         if (!this._worker || !this._splatPositions || splatCount <= 0) {
             return;
         }
@@ -2827,6 +3394,7 @@ export class GaussianSplattingMeshBase extends Mesh {
         this._flipY = flipY;
         this._splatDataRevision++;
         this._splatDataPending = true;
+        this._gpuProgressiveCount = GaussianSplattingMeshBase.ProgressiveUpdateAmount ? 0 : null;
         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
@@ -2917,6 +3485,14 @@ export class GaussianSplattingMeshBase extends Mesh {
                 }
                 this._updateSubTextures(this._splatPositions, covA, covB, colorArray, uploadStartLine, batchEndLine - uploadStartLine, sh);
                 this.getBoundingInfo().reConstruct(minimum, maximum, this.getWorldMatrix());
+                if (this._gpuMode) {
+                    this._gpuProgressiveCount = Math.min(batchEndTexel, vertexCount);
+                    this._markGpuSourceDirty();
+                    // The batch loop already accumulated the bounds of the uploaded centers.
+                    (this._gpuBoundsMin ?? (this._gpuBoundsMin = new Vector3())).copyFrom(minimum);
+                    (this._gpuBoundsMax ?? (this._gpuBoundsMax = new Vector3())).copyFrom(maximum);
+                    this._gpuBoundsDirty = false;
+                }
                 if (isAsync) {
                     yield;
                 }
@@ -2955,6 +3531,7 @@ export class GaussianSplattingMeshBase extends Mesh {
         this._cachedBoundingMin = minimum.clone();
         this._cachedBoundingMax = maximum.clone();
         this._splatDataPending = false;
+        this._gpuProgressiveCount = null;
         this._postToWorker(true);
     }
     /**
@@ -2992,6 +3569,19 @@ export class GaussianSplattingMeshBase extends Mesh {
     _updateSplatIndexBuffer(vertexCount) {
         const renderedSplatCount = this._activeSplatRanges ? this._activeSplatRenderCount : vertexCount;
         const paddedVertexCount = Math.max((renderedSplatCount + 15) & ~0xf, 16);
+        const gpuEligible = this._isGpuSortEligible(vertexCount);
+        if (!this._gpuMode && gpuEligible) {
+            this._enterGpuMode();
+        }
+        else if (this._gpuMode && !gpuEligible) {
+            this._exitGpuMode();
+        }
+        if (this._gpuMode) {
+            // The sort output holds the indices: no CPU index buffer is needed.
+            this._gpuPaddedCount = paddedVertexCount;
+            this.forcedInstanceCount = Math.max(paddedVertexCount >> 4, 1);
+            return;
+        }
         const previousIndex = this._splatIndex;
         if (!previousIndex || paddedVertexCount !== previousIndex.length) {
             this._splatIndex = new Float32Array(paddedVertexCount);
@@ -3110,6 +3700,14 @@ export class GaussianSplattingMeshBase extends Mesh {
         // 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._gpuMode) {
+            // The sort runs on the GPU: no worker. The sorter picks up the (new) source before its next sort.
+            this._markGpuSourceDirty();
+            this._sortIsDirty = true;
+            this._canPostToWorker = true;
+            return;
+        }
+        this._workerPending = false;
         if (this._disableDepthSort) {
             return;
         }
@@ -3361,6 +3959,30 @@ GaussianSplattingMeshBase.UseCountingSort = true;
  * Off by default; intended for performance investigation only.
  */
 GaussianSplattingMeshBase.LogSortPerformance = false;
+/**
+ * When true, meshes sort their splats on the GPU with a compute shader when the engine is WebGPU with compute shader support
+ * and the splat count is within the GPU sorter limit. The CPU worker is then not created. False by default: the asynchronous CPU
+ * worker is usually faster on low-end GPUs while the camera moves, because the GPU sort competes with rendering. Other engines
+ * (WebGL, Native) always use the CPU worker. Meshes of a scene using a custom render function (`scene.customRenderFunction`, other than
+ * the frame graph one) also keep the CPU worker, because the GPU sort is dispatched from `onBeforeRenderObservable`.
+ * A mesh leaves the GPU sort for the CPU worker, and does not come back to it, when depth sorting is disabled at runtime
+ * (see {@link GaussianSplattingMeshBase.disableDepthSort}), when point splatting is enabled, or when it starts streaming parts.
+ * After a WebGPU device restoration, the sorter and its buffers are recreated.
+ * Progressive loading sorts only the batches already uploaded, making them displayable before loading completes.
+ * Read when the mesh instantiates its sort, so set it before loading data.
+ * See also {@link GaussianSplattingMeshBase.useGpuSort} to override it on a single mesh.
+ * @experimental
+ */
+GaussianSplattingMeshBase.UseGpuSort = false;
+/**
+ * Minimum number of frames between two GPU sorts of the same camera view when only the view changed (the camera moved or the mesh world
+ * transform changed). Sorts caused by data changes (new splat data, parts, ranges) and the first sort of a view bypass this throttle.
+ * After the first render, requests are coalesced at the next scene pre-render; initial readiness checks can sort synchronously.
+ * The default of 1 re-sorts whenever the view changed. On a slow GPU the sort competes with rendering; a value of 2 or
+ * more trades a slightly stale order during camera motion for a lower GPU cost, like the asynchronous CPU worker does.
+ * @experimental
+ */
+GaussianSplattingMeshBase.GpuSortMinFrameInterval = 1;
 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