@onerjs/loaders 8.53.5 → 8.53.7

package/SPLAT/gaussianSplattingWorkBuffer.js

@@ -0,0 +1,361 @@
+import { MultiRenderTarget } from "@onerjs/core/Materials/Textures/multiRenderTarget.js";
+import { ShaderMaterial } from "@onerjs/core/Materials/shaderMaterial.js";
+import { Constants } from "@onerjs/core/Engines/constants.js";
+import { Mesh } from "@onerjs/core/Meshes/mesh.js";
+import { VertexData } from "@onerjs/core/Meshes/mesh.vertexData.js";
+import { Color4 } from "@onerjs/core/Maths/math.color.js";
+import { Vector3, Vector4 } from "@onerjs/core/Maths/math.vector.js";
+import { GaussianSplattingWorkBufferVertexShaderGLSL, GaussianSplattingWorkBufferFragmentShaderGLSL, GaussianSplattingWorkBufferVertexShaderWGSL, GaussianSplattingWorkBufferFragmentShaderWGSL, GaussianSplattingWorkBufferRelayoutFragmentShaderGLSL, GaussianSplattingWorkBufferRelayoutFragmentShaderWGSL, GaussianSplattingWorkBufferRelayoutShaderName, } from "./gaussianSplattingWorkBufferShaders.js";
+import { RawTexture } from "@onerjs/core/Materials/Textures/rawTexture.js";
+/**
+ * A unified, GPU-decoded Gaussian Splatting work buffer.
+ *
+ * Holds a square MRT texture set (centers / covA / covB / colors) sized to a fixed splat capacity
+ * (PlayCanvas-style: `ceil(sqrt(capacity))`). Each streamed SOG file is decoded directly on the GPU
+ * (no CPU readback) into its allocated pixel range. The decoded textures are consumed unchanged by the
+ * standard (non-SOG) Gaussian Splatting draw path.
+ *
+ * @experimental
+ */
+export class GaussianSplattingWorkBuffer {
+    /**
+     * True when the engine supports the non-blocking GPU readback used by {@link readCentersRangeAsync}:
+     * WebGL2 (PBO + fence) or WebGPU (copyTextureToBuffer + mapAsync). When false (e.g. WebGL1), callers must
+     * decode positions on the CPU instead.
+     */
+    get supportsAsyncCentersReadback() {
+        const engine = this._scene.getEngine();
+        if (engine.isWebGPU) {
+            return true;
+        }
+        const glEngine = engine;
+        return !!glEngine._gl && typeof glEngine._readPixelsAsync === "function" && (glEngine.webGLVersion ?? 0) >= 2;
+    }
+    /**
+     * Square edge length (in pixels) of the work-buffer textures.
+     */
+    get textureSize() {
+        return this._textureSize;
+    }
+    /**
+     * The decoded work-buffer textures: [centers, covA, covB, colors].
+     */
+    get textures() {
+        return this._mrt.textures;
+    }
+    /**
+     * Creates a work buffer sized to hold `capacity` splats.
+     * @param scene hosting scene
+     * @param capacity total number of splats the work buffer must address
+     */
+    constructor(scene, capacity) {
+        // Relayout (defrag) copy material, created lazily on first relayout.
+        this._copyMaterial = null;
+        // Reusable destination->source index map for the relayout pass (created lazily, sized to the work buffer).
+        this._relayoutMapData = null;
+        this._relayoutMapTexture = null;
+        this._disposed = false;
+        // Reused WebGL framebuffer for the async centers readback (created lazily, freed in dispose).
+        this._readFbo = null;
+        this._scene = scene;
+        this._shaderLanguage = scene.getEngine().isWebGPU ? 1 /* ShaderLanguage.WGSL */ : 0 /* ShaderLanguage.GLSL */;
+        this._textureSize = Math.max(1, Math.ceil(Math.sqrt(Math.max(1, capacity))));
+        // The decode buffer accumulates (clear disabled) so each decode preserves previously-decoded files.
+        this._mrt = this._createMrt("gsWorkBuffer", true);
+        // One persistent decode material + fullscreen-triangle quad, reused (with per-file uniforms)
+        // for every decode so the shader is compiled only once.
+        this._material = this._createMaterial();
+        this._quad = this._createQuad();
+        this._quad.material = this._material;
+    }
+    /**
+     * Creates a 4-attachment MRT (centers F32 / covA F32 / covB F32 / colors U8) sized to the work buffer.
+     * @param name MRT and attachment base name
+     * @param disableClear when true, clearing is suppressed so renders accumulate (the decode buffer); when
+     *   false the MRT clears to zero on each render (the temporary relayout buffer, so gaps stay zeroed)
+     * @returns the created MRT
+     */
+    _createMrt(name, disableClear) {
+        const mrt = new MultiRenderTarget(name, { width: this._textureSize, height: this._textureSize }, 4, this._scene, {
+            types: [Constants.TEXTURETYPE_FLOAT, Constants.TEXTURETYPE_FLOAT, Constants.TEXTURETYPE_FLOAT, Constants.TEXTURETYPE_UNSIGNED_BYTE],
+            samplingModes: [
+                Constants.TEXTURE_NEAREST_SAMPLINGMODE,
+                Constants.TEXTURE_NEAREST_SAMPLINGMODE,
+                Constants.TEXTURE_NEAREST_SAMPLINGMODE,
+                Constants.TEXTURE_NEAREST_SAMPLINGMODE,
+            ],
+            formats: [Constants.TEXTUREFORMAT_RGBA, Constants.TEXTUREFORMAT_RGBA, Constants.TEXTUREFORMAT_RGBA, Constants.TEXTUREFORMAT_RGBA],
+            generateDepthBuffer: false,
+            generateDepthTexture: false,
+            generateMipMaps: false,
+        }, [`${name}Centers`, `${name}CovA`, `${name}CovB`, `${name}Colors`]);
+        mrt.clearColor = new Color4(0, 0, 0, 0);
+        mrt.renderList = [];
+        if (disableClear) {
+            mrt.onClearObservable.add(() => { });
+        }
+        return mrt;
+    }
+    /**
+     * Decodes one SOG file into the work buffer at the given splat offset (accumulating; previously
+     * decoded files are preserved). Resolves once the GPU decode has been issued. The caller may
+     * dispose the source pack textures after this resolves.
+     * @param pack the SOG texture pack (GPU source textures + per-file decode parameters)
+     * @param offset first splat index (pixel offset) for this file in the work buffer
+     */
+    async decodeAsync(pack, offset) {
+        if (this._disposed) {
+            return;
+        }
+        this._applyPack(pack, offset);
+        // Render the decode pass at the start of a frame (the safe point for custom render targets),
+        // once the shader is compiled — never re-entrantly from a promise/observable continuation.
+        await new Promise((resolve) => {
+            const attempt = () => {
+                if (this._disposed) {
+                    resolve();
+                    return;
+                }
+                if (!this._material.isReady(this._quad)) {
+                    this._scene.onBeforeRenderObservable.addOnce(attempt);
+                    return;
+                }
+                this._mrt.renderList = [this._quad];
+                this._mrt.render();
+                resolve();
+            };
+            this._scene.onBeforeRenderObservable.addOnce(attempt);
+        });
+    }
+    /**
+     * Whether the relayout copy shader is compiled and ready. Lazily creates the copy material on first call.
+     * Callers should poll this before {@link relayoutSync} (which must only run when ready).
+     * @returns true when {@link relayoutSync} can run this frame
+     */
+    isRelayoutReady() {
+        if (this._disposed) {
+            return false;
+        }
+        if (!this._copyMaterial) {
+            this._copyMaterial = this._createCopyMaterial();
+        }
+        return this._copyMaterial.isReady(this._quad);
+    }
+    /**
+     * Relayouts the decoded work-buffer textures to a new (defragmented) splat layout, keeping the same
+     * texture instances so the consuming mesh does not need to re-bind. `srcIndexByDst[d]` is the source splat
+     * index whose decoded data should end up at destination index `d`, or a negative value for a gap (left
+     * zeroed). Uses a temporary MRT ping-pong (old -> temp via the map, then temp -> old identity) so
+     * overlapping moves stay correct. Must be called at a frame-safe point (inside `onBeforeRender`) and only
+     * when {@link isRelayoutReady} returns true.
+     * @param srcIndexByDst per-destination source splat index (negative = gap)
+     */
+    relayoutSync(srcIndexByDst) {
+        if (this._disposed || !this._copyMaterial) {
+            return;
+        }
+        const size = this._textureSize;
+        // Reuse the map buffer and its GPU texture across relayouts (the work-buffer size is fixed).
+        if (!this._relayoutMapData) {
+            this._relayoutMapData = new Float32Array(size * size);
+        }
+        const mapData = this._relayoutMapData;
+        mapData.fill(-1);
+        mapData.set(srcIndexByDst.subarray(0, Math.min(srcIndexByDst.length, mapData.length)));
+        if (!this._relayoutMapTexture) {
+            this._relayoutMapTexture = new RawTexture(mapData, size, size, Constants.TEXTUREFORMAT_R, this._scene, false, false, Constants.TEXTURE_NEAREST_SAMPLINGMODE, Constants.TEXTURETYPE_FLOAT);
+        }
+        else {
+            this._relayoutMapTexture.update(mapData);
+        }
+        const mapTexture = this._relayoutMapTexture;
+        // The temporary ping-pong MRT is (re)created per relayout rather than kept resident: it is the same size
+        // as the work buffer, so a persistent copy would double GPU memory and defeat the streaming memory budget.
+        const temp = this._createMrt("gsRelayoutTemp", false);
+        try {
+            // Pass 1: old -> temp using the map (temp gets the new layout; gaps stay zeroed by the clear).
+            this._renderRelayoutPass(temp, this._mrt.textures, mapTexture, 1);
+            // Pass 2: temp -> old, identity (old textures get the new layout, full overwrite).
+            this._renderRelayoutPass(this._mrt, temp.textures, mapTexture, 0);
+        }
+        finally {
+            temp.dispose();
+            this._quad.material = this._material;
+        }
+    }
+    /**
+     * Renders one relayout copy pass into the target MRT, sampling the given source textures.
+     * @param target destination MRT
+     * @param sources the four source work-buffer textures
+     * @param mapTexture the R32F destination-to-source index map
+     * @param useMap 1 to read source indices from the map (gaps discarded), 0 for an identity copy
+     */
+    _renderRelayoutPass(target, sources, mapTexture, useMap) {
+        const material = this._copyMaterial;
+        material.setTexture("uMapTex", mapTexture);
+        material.setTexture("uSrc0", sources[0]);
+        material.setTexture("uSrc1", sources[1]);
+        material.setTexture("uSrc2", sources[2]);
+        material.setTexture("uSrc3", sources[3]);
+        material.setInt("uDstWidth", this._textureSize);
+        material.setInt("uSrcWidth", this._textureSize);
+        material.setInt("uUseMap", useMap);
+        this._quad.material = material;
+        target.renderList = [this._quad];
+        target.render();
+    }
+    _createCopyMaterial() {
+        const isWGSL = this._shaderLanguage === 1 /* ShaderLanguage.WGSL */;
+        const material = new ShaderMaterial(GaussianSplattingWorkBufferRelayoutShaderName, this._scene, {
+            vertexSource: isWGSL ? GaussianSplattingWorkBufferVertexShaderWGSL : GaussianSplattingWorkBufferVertexShaderGLSL,
+            fragmentSource: isWGSL ? GaussianSplattingWorkBufferRelayoutFragmentShaderWGSL : GaussianSplattingWorkBufferRelayoutFragmentShaderGLSL,
+        }, {
+            attributes: ["position"],
+            uniforms: ["uDstWidth", "uSrcWidth", "uUseMap"],
+            samplers: ["uMapTex", "uSrc0", "uSrc1", "uSrc2", "uSrc3"],
+            shaderLanguage: this._shaderLanguage,
+        });
+        material.backFaceCulling = false;
+        material.disableDepthWrite = true;
+        return material;
+    }
+    /**
+     * Asynchronously reads back the decoded splat centers (stride-4 xyzw, w=1) for a contiguous splat range
+     * from the work buffer's centers texture, using a non-blocking GPU readback (WebGL2 PBO + fence, or WebGPU
+     * copyTextureToBuffer + mapAsync) so it never stalls the frame the way a CPU image decode does. The centers
+     * texture already holds the GPU-decoded positions (identical to the CPU decode), so this replaces decoding
+     * positions on the CPU from the means images. Returns null when async readback is unsupported (caller should
+     * fall back to CPU decoding).
+     * @param splatOffset first splat index of the range
+     * @param splatCount number of splats in the range
+     * @returns a stride-4 Float32Array of length `splatCount * 4`, or null when unsupported/failed
+     */
+    async readCentersRangeAsync(splatOffset, splatCount) {
+        if (this._disposed || splatCount <= 0 || !this.supportsAsyncCentersReadback) {
+            return null;
+        }
+        const width = this._textureSize;
+        // The range maps to whole texel rows [rowStart, rowEnd); read that rectangle and slice the exact range.
+        // Splat i lives at texel (i % width, floor(i / width)) in both decode and draw, so the readback (which
+        // indexes the same texture storage directly, with no UV/flip) yields splat i at buffer position
+        // i - rowStart * width on every backend.
+        const rowStart = Math.floor(splatOffset / width);
+        const rowEnd = Math.ceil((splatOffset + splatCount) / width);
+        const rowCount = rowEnd - rowStart;
+        const startInBuffer = (splatOffset - rowStart * width) * 4;
+        const sliceEnd = startInBuffer + splatCount * 4;
+        const centers = this._mrt.textures[0];
+        const engine = this._scene.getEngine();
+        if (engine.isWebGPU) {
+            // WebGPU: copyTextureToBuffer of the row span + mapAsync (genuinely non-blocking). noDataConversion
+            // returns the raw RGBA32F floats tightly packed (the 256-byte row alignment is removed internally).
+            const result = await centers.readPixels(0, 0, null, true, true, 0, rowStart, width, rowCount);
+            if (this._disposed || !result) {
+                return null;
+            }
+            const floats = result instanceof Float32Array ? result : new Float32Array(result.buffer, result.byteOffset, result.byteLength / 4);
+            return floats.length >= sliceEnd ? floats.subarray(startInBuffer, sliceEnd) : null;
+        }
+        // WebGL2: read directly from the centers texture via a reused FBO + async PBO readback.
+        const glEngine = engine;
+        const gl = glEngine._gl;
+        const hardware = centers.getInternalTexture()?._hardwareTexture?.underlyingResource;
+        if (!hardware) {
+            return null;
+        }
+        const buffer = new Float32Array(width * rowCount * 4);
+        if (!this._readFbo) {
+            this._readFbo = gl.createFramebuffer();
+        }
+        const previousFbo = glEngine._currentFramebuffer;
+        gl.bindFramebuffer(gl.FRAMEBUFFER, this._readFbo);
+        gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, hardware, 0);
+        gl.readBuffer(gl.COLOR_ATTACHMENT0);
+        // _readPixelsAsync issues the readPixels into a PBO synchronously, then resolves once the GPU fence
+        // signals — so the framebuffer can be restored immediately while the transfer completes off-thread.
+        const promise = glEngine._readPixelsAsync(0, rowStart, width, rowCount, gl.RGBA, gl.FLOAT, buffer);
+        gl.bindFramebuffer(gl.FRAMEBUFFER, previousFbo);
+        // gl.readBuffer is global state: restore the default-framebuffer read source (BACK) so later
+        // readPixels on the default framebuffer aren't left pointing at COLOR_ATTACHMENT0. When restoring to
+        // another FBO, COLOR_ATTACHMENT0 is the correct default read buffer, so only reset for the default one.
+        if (!previousFbo) {
+            gl.readBuffer(gl.BACK);
+        }
+        if (!promise) {
+            return null;
+        }
+        await promise;
+        if (this._disposed || buffer.length < sliceEnd) {
+            return null;
+        }
+        return buffer.subarray(startInBuffer, sliceEnd);
+    }
+    /**
+     * Disposes the work buffer and its decode resources.
+     */
+    dispose() {
+        this._disposed = true;
+        if (this._readFbo) {
+            this._scene.getEngine()._gl?.deleteFramebuffer(this._readFbo);
+            this._readFbo = null;
+        }
+        this._quad.dispose();
+        this._material.dispose(true, false);
+        this._copyMaterial?.dispose(true, false);
+        this._relayoutMapTexture?.dispose();
+        this._mrt.dispose();
+    }
+    _createQuad() {
+        const quad = new Mesh("gsWorkBufferQuad", this._scene);
+        const vertexData = new VertexData();
+        // Fullscreen triangle in clip space (the vertex shader passes positions straight through).
+        vertexData.positions = [-1, -1, 0, 3, -1, 0, -1, 3, 0];
+        vertexData.indices = [0, 1, 2];
+        vertexData.applyToMesh(quad);
+        // Render only inside the work-buffer MRT, never in the main scene pass.
+        this._scene.removeMesh(quad);
+        return quad;
+    }
+    _createMaterial() {
+        const isWGSL = this._shaderLanguage === 1 /* ShaderLanguage.WGSL */;
+        const material = new ShaderMaterial("gsSogDecode", this._scene, {
+            vertexSource: isWGSL ? GaussianSplattingWorkBufferVertexShaderWGSL : GaussianSplattingWorkBufferVertexShaderGLSL,
+            fragmentSource: isWGSL ? GaussianSplattingWorkBufferFragmentShaderWGSL : GaussianSplattingWorkBufferFragmentShaderGLSL,
+        }, {
+            attributes: ["position"],
+            uniforms: ["sogMeansMin", "sogMeansMax", "sogScalesMin", "sogScalesMax", "sogSh0Min", "sogSh0Max", "uVersion", "uOffset", "uCount", "uDestWidth", "uSrcWidth"],
+            samplers: ["sogMeansLTex", "sogMeansUTex", "sogScalesTex", "sogQuatsTex", "sogSh0Tex", "sogCodebookTex"],
+            shaderLanguage: this._shaderLanguage,
+        });
+        material.backFaceCulling = false;
+        material.disableDepthWrite = true;
+        return material;
+    }
+    _applyPack(pack, offset) {
+        const material = this._material;
+        const srcWidth = pack.meansTextureL.getSize().width;
+        material.setTexture("sogMeansLTex", pack.meansTextureL);
+        material.setTexture("sogMeansUTex", pack.meansTextureU);
+        material.setTexture("sogScalesTex", pack.scalesTexture);
+        material.setTexture("sogQuatsTex", pack.quatsTexture);
+        material.setTexture("sogSh0Tex", pack.sh0Texture);
+        // Codebook only used for v2; bind a harmless placeholder otherwise so the sampler is always set.
+        material.setTexture("sogCodebookTex", pack.codebookTexture ?? pack.sh0Texture);
+        material.setVector3("sogMeansMin", new Vector3(pack.meansMin[0], pack.meansMin[1], pack.meansMin[2]));
+        material.setVector3("sogMeansMax", new Vector3(pack.meansMax[0], pack.meansMax[1], pack.meansMax[2]));
+        const sMin = pack.scalesMin ?? [0, 0, 0];
+        const sMax = pack.scalesMax ?? [0, 0, 0];
+        material.setVector3("sogScalesMin", new Vector3(sMin[0], sMin[1], sMin[2]));
+        material.setVector3("sogScalesMax", new Vector3(sMax[0], sMax[1], sMax[2]));
+        const c0Min = pack.sh0Min ?? [0, 0, 0, 0];
+        const c0Max = pack.sh0Max ?? [0, 0, 0, 0];
+        material.setVector4("sogSh0Min", new Vector4(c0Min[0], c0Min[1], c0Min[2], c0Min[3]));
+        material.setVector4("sogSh0Max", new Vector4(c0Max[0], c0Max[1], c0Max[2], c0Max[3]));
+        material.setInt("uVersion", pack.version);
+        material.setInt("uOffset", offset);
+        material.setInt("uCount", pack.splatCount);
+        material.setInt("uDestWidth", this._textureSize);
+        material.setInt("uSrcWidth", srcWidth);
+    }
+}
+//# sourceMappingURL=gaussianSplattingWorkBuffer.js.map

package/SPLAT/gaussianSplattingWorkBuffer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gaussianSplattingWorkBuffer.js","sourceRoot":"","sources":["../../../../dev/loaders/src/SPLAT/gaussianSplattingWorkBuffer.ts"],"names":[],"mappings":"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","sourcesContent":["import { MultiRenderTarget } from \"core/Materials/Textures/multiRenderTarget\";\r\nimport { ShaderMaterial } from \"core/Materials/shaderMaterial\";\r\nimport { ShaderLanguage } from \"core/Materials/shaderLanguage\";\r\nimport { Constants } from \"core/Engines/constants\";\r\nimport { Mesh } from \"core/Meshes/mesh\";\r\nimport { VertexData } from \"core/Meshes/mesh.vertexData\";\r\nimport { Color4 } from \"core/Maths/math.color\";\r\nimport { Vector3, Vector4 } from \"core/Maths/math.vector\";\r\nimport { type Texture } from \"core/Materials/Textures/texture\";\r\nimport { type Scene } from \"core/scene\";\r\nimport { type Nullable } from \"core/types\";\r\nimport { type ISogTexturePack } from \"./splatDefs\";\r\nimport {\r\n    GaussianSplattingWorkBufferVertexShaderGLSL,\r\n    GaussianSplattingWorkBufferFragmentShaderGLSL,\r\n    GaussianSplattingWorkBufferVertexShaderWGSL,\r\n    GaussianSplattingWorkBufferFragmentShaderWGSL,\r\n    GaussianSplattingWorkBufferRelayoutFragmentShaderGLSL,\r\n    GaussianSplattingWorkBufferRelayoutFragmentShaderWGSL,\r\n    GaussianSplattingWorkBufferRelayoutShaderName,\r\n} from \"./gaussianSplattingWorkBufferShaders\";\r\nimport { RawTexture } from \"core/Materials/Textures/rawTexture\";\r\n\r\n/**\r\n * A unified, GPU-decoded Gaussian Splatting work buffer.\r\n *\r\n * Holds a square MRT texture set (centers / covA / covB / colors) sized to a fixed splat capacity\r\n * (PlayCanvas-style: `ceil(sqrt(capacity))`). Each streamed SOG file is decoded directly on the GPU\r\n * (no CPU readback) into its allocated pixel range. The decoded textures are consumed unchanged by the\r\n * standard (non-SOG) Gaussian Splatting draw path.\r\n *\r\n * @experimental\r\n */\r\nexport class GaussianSplattingWorkBuffer {\r\n    private readonly _scene: Scene;\r\n    private readonly _mrt: MultiRenderTarget;\r\n    private readonly _textureSize: number;\r\n    private readonly _shaderLanguage: ShaderLanguage;\r\n    private readonly _material: ShaderMaterial;\r\n    private readonly _quad: Mesh;\r\n    // Relayout (defrag) copy material, created lazily on first relayout.\r\n    private _copyMaterial: Nullable<ShaderMaterial> = null;\r\n    // Reusable destination->source index map for the relayout pass (created lazily, sized to the work buffer).\r\n    private _relayoutMapData: Nullable<Float32Array> = null;\r\n    private _relayoutMapTexture: Nullable<RawTexture> = null;\r\n    private _disposed = false;\r\n    // Reused WebGL framebuffer for the async centers readback (created lazily, freed in dispose).\r\n    private _readFbo: Nullable<WebGLFramebuffer> = null;\r\n\r\n    /**\r\n     * True when the engine supports the non-blocking GPU readback used by {@link readCentersRangeAsync}:\r\n     * WebGL2 (PBO + fence) or WebGPU (copyTextureToBuffer + mapAsync). When false (e.g. WebGL1), callers must\r\n     * decode positions on the CPU instead.\r\n     */\r\n    public get supportsAsyncCentersReadback(): boolean {\r\n        const engine = this._scene.getEngine();\r\n        if (engine.isWebGPU) {\r\n            return true;\r\n        }\r\n        const glEngine = engine as unknown as { _gl?: WebGL2RenderingContext; _readPixelsAsync?: unknown; webGLVersion?: number };\r\n        return !!glEngine._gl && typeof glEngine._readPixelsAsync === \"function\" && (glEngine.webGLVersion ?? 0) >= 2;\r\n    }\r\n\r\n    /**\r\n     * Square edge length (in pixels) of the work-buffer textures.\r\n     */\r\n    public get textureSize(): number {\r\n        return this._textureSize;\r\n    }\r\n\r\n    /**\r\n     * The decoded work-buffer textures: [centers, covA, covB, colors].\r\n     */\r\n    public get textures(): Texture[] {\r\n        return this._mrt.textures;\r\n    }\r\n\r\n    /**\r\n     * Creates a work buffer sized to hold `capacity` splats.\r\n     * @param scene hosting scene\r\n     * @param capacity total number of splats the work buffer must address\r\n     */\r\n    constructor(scene: Scene, capacity: number) {\r\n        this._scene = scene;\r\n        this._shaderLanguage = scene.getEngine().isWebGPU ? ShaderLanguage.WGSL : ShaderLanguage.GLSL;\r\n        this._textureSize = Math.max(1, Math.ceil(Math.sqrt(Math.max(1, capacity))));\r\n\r\n        // The decode buffer accumulates (clear disabled) so each decode preserves previously-decoded files.\r\n        this._mrt = this._createMrt(\"gsWorkBuffer\", true);\r\n\r\n        // One persistent decode material + fullscreen-triangle quad, reused (with per-file uniforms)\r\n        // for every decode so the shader is compiled only once.\r\n        this._material = this._createMaterial();\r\n        this._quad = this._createQuad();\r\n        this._quad.material = this._material;\r\n    }\r\n\r\n    /**\r\n     * Creates a 4-attachment MRT (centers F32 / covA F32 / covB F32 / colors U8) sized to the work buffer.\r\n     * @param name MRT and attachment base name\r\n     * @param disableClear when true, clearing is suppressed so renders accumulate (the decode buffer); when\r\n     *   false the MRT clears to zero on each render (the temporary relayout buffer, so gaps stay zeroed)\r\n     * @returns the created MRT\r\n     */\r\n    private _createMrt(name: string, disableClear: boolean): MultiRenderTarget {\r\n        const mrt = new MultiRenderTarget(\r\n            name,\r\n            { width: this._textureSize, height: this._textureSize },\r\n            4,\r\n            this._scene,\r\n            {\r\n                types: [Constants.TEXTURETYPE_FLOAT, Constants.TEXTURETYPE_FLOAT, Constants.TEXTURETYPE_FLOAT, Constants.TEXTURETYPE_UNSIGNED_BYTE],\r\n                samplingModes: [\r\n                    Constants.TEXTURE_NEAREST_SAMPLINGMODE,\r\n                    Constants.TEXTURE_NEAREST_SAMPLINGMODE,\r\n                    Constants.TEXTURE_NEAREST_SAMPLINGMODE,\r\n                    Constants.TEXTURE_NEAREST_SAMPLINGMODE,\r\n                ],\r\n                formats: [Constants.TEXTUREFORMAT_RGBA, Constants.TEXTUREFORMAT_RGBA, Constants.TEXTUREFORMAT_RGBA, Constants.TEXTUREFORMAT_RGBA],\r\n                generateDepthBuffer: false,\r\n                generateDepthTexture: false,\r\n                generateMipMaps: false,\r\n            },\r\n            [`${name}Centers`, `${name}CovA`, `${name}CovB`, `${name}Colors`]\r\n        );\r\n        mrt.clearColor = new Color4(0, 0, 0, 0);\r\n        mrt.renderList = [];\r\n        if (disableClear) {\r\n            mrt.onClearObservable.add(() => {});\r\n        }\r\n        return mrt;\r\n    }\r\n\r\n    /**\r\n     * Decodes one SOG file into the work buffer at the given splat offset (accumulating; previously\r\n     * decoded files are preserved). Resolves once the GPU decode has been issued. The caller may\r\n     * dispose the source pack textures after this resolves.\r\n     * @param pack the SOG texture pack (GPU source textures + per-file decode parameters)\r\n     * @param offset first splat index (pixel offset) for this file in the work buffer\r\n     */\r\n    public async decodeAsync(pack: ISogTexturePack, offset: number): Promise<void> {\r\n        if (this._disposed) {\r\n            return;\r\n        }\r\n        this._applyPack(pack, offset);\r\n        // Render the decode pass at the start of a frame (the safe point for custom render targets),\r\n        // once the shader is compiled — never re-entrantly from a promise/observable continuation.\r\n        await new Promise<void>((resolve) => {\r\n            const attempt = () => {\r\n                if (this._disposed) {\r\n                    resolve();\r\n                    return;\r\n                }\r\n                if (!this._material.isReady(this._quad)) {\r\n                    this._scene.onBeforeRenderObservable.addOnce(attempt);\r\n                    return;\r\n                }\r\n                this._mrt.renderList = [this._quad];\r\n                this._mrt.render();\r\n                resolve();\r\n            };\r\n            this._scene.onBeforeRenderObservable.addOnce(attempt);\r\n        });\r\n    }\r\n\r\n    /**\r\n     * Whether the relayout copy shader is compiled and ready. Lazily creates the copy material on first call.\r\n     * Callers should poll this before {@link relayoutSync} (which must only run when ready).\r\n     * @returns true when {@link relayoutSync} can run this frame\r\n     */\r\n    public isRelayoutReady(): boolean {\r\n        if (this._disposed) {\r\n            return false;\r\n        }\r\n        if (!this._copyMaterial) {\r\n            this._copyMaterial = this._createCopyMaterial();\r\n        }\r\n        return this._copyMaterial.isReady(this._quad);\r\n    }\r\n\r\n    /**\r\n     * Relayouts the decoded work-buffer textures to a new (defragmented) splat layout, keeping the same\r\n     * texture instances so the consuming mesh does not need to re-bind. `srcIndexByDst[d]` is the source splat\r\n     * index whose decoded data should end up at destination index `d`, or a negative value for a gap (left\r\n     * zeroed). Uses a temporary MRT ping-pong (old -> temp via the map, then temp -> old identity) so\r\n     * overlapping moves stay correct. Must be called at a frame-safe point (inside `onBeforeRender`) and only\r\n     * when {@link isRelayoutReady} returns true.\r\n     * @param srcIndexByDst per-destination source splat index (negative = gap)\r\n     */\r\n    public relayoutSync(srcIndexByDst: Float32Array): void {\r\n        if (this._disposed || !this._copyMaterial) {\r\n            return;\r\n        }\r\n        const size = this._textureSize;\r\n        // Reuse the map buffer and its GPU texture across relayouts (the work-buffer size is fixed).\r\n        if (!this._relayoutMapData) {\r\n            this._relayoutMapData = new Float32Array(size * size);\r\n        }\r\n        const mapData = this._relayoutMapData;\r\n        mapData.fill(-1);\r\n        mapData.set(srcIndexByDst.subarray(0, Math.min(srcIndexByDst.length, mapData.length)));\r\n        if (!this._relayoutMapTexture) {\r\n            this._relayoutMapTexture = new RawTexture(\r\n                mapData,\r\n                size,\r\n                size,\r\n                Constants.TEXTUREFORMAT_R,\r\n                this._scene,\r\n                false,\r\n                false,\r\n                Constants.TEXTURE_NEAREST_SAMPLINGMODE,\r\n                Constants.TEXTURETYPE_FLOAT\r\n            );\r\n        } else {\r\n            this._relayoutMapTexture.update(mapData);\r\n        }\r\n        const mapTexture = this._relayoutMapTexture;\r\n        // The temporary ping-pong MRT is (re)created per relayout rather than kept resident: it is the same size\r\n        // as the work buffer, so a persistent copy would double GPU memory and defeat the streaming memory budget.\r\n        const temp = this._createMrt(\"gsRelayoutTemp\", false);\r\n        try {\r\n            // Pass 1: old -> temp using the map (temp gets the new layout; gaps stay zeroed by the clear).\r\n            this._renderRelayoutPass(temp, this._mrt.textures, mapTexture, 1);\r\n            // Pass 2: temp -> old, identity (old textures get the new layout, full overwrite).\r\n            this._renderRelayoutPass(this._mrt, temp.textures, mapTexture, 0);\r\n        } finally {\r\n            temp.dispose();\r\n            this._quad.material = this._material;\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Renders one relayout copy pass into the target MRT, sampling the given source textures.\r\n     * @param target destination MRT\r\n     * @param sources the four source work-buffer textures\r\n     * @param mapTexture the R32F destination-to-source index map\r\n     * @param useMap 1 to read source indices from the map (gaps discarded), 0 for an identity copy\r\n     */\r\n    private _renderRelayoutPass(target: MultiRenderTarget, sources: Texture[], mapTexture: RawTexture, useMap: number): void {\r\n        const material = this._copyMaterial!;\r\n        material.setTexture(\"uMapTex\", mapTexture);\r\n        material.setTexture(\"uSrc0\", sources[0]);\r\n        material.setTexture(\"uSrc1\", sources[1]);\r\n        material.setTexture(\"uSrc2\", sources[2]);\r\n        material.setTexture(\"uSrc3\", sources[3]);\r\n        material.setInt(\"uDstWidth\", this._textureSize);\r\n        material.setInt(\"uSrcWidth\", this._textureSize);\r\n        material.setInt(\"uUseMap\", useMap);\r\n        this._quad.material = material;\r\n        target.renderList = [this._quad];\r\n        target.render();\r\n    }\r\n\r\n    private _createCopyMaterial(): ShaderMaterial {\r\n        const isWGSL = this._shaderLanguage === ShaderLanguage.WGSL;\r\n        const material = new ShaderMaterial(\r\n            GaussianSplattingWorkBufferRelayoutShaderName,\r\n            this._scene,\r\n            {\r\n                vertexSource: isWGSL ? GaussianSplattingWorkBufferVertexShaderWGSL : GaussianSplattingWorkBufferVertexShaderGLSL,\r\n                fragmentSource: isWGSL ? GaussianSplattingWorkBufferRelayoutFragmentShaderWGSL : GaussianSplattingWorkBufferRelayoutFragmentShaderGLSL,\r\n            },\r\n            {\r\n                attributes: [\"position\"],\r\n                uniforms: [\"uDstWidth\", \"uSrcWidth\", \"uUseMap\"],\r\n                samplers: [\"uMapTex\", \"uSrc0\", \"uSrc1\", \"uSrc2\", \"uSrc3\"],\r\n                shaderLanguage: this._shaderLanguage,\r\n            }\r\n        );\r\n        material.backFaceCulling = false;\r\n        material.disableDepthWrite = true;\r\n        return material;\r\n    }\r\n\r\n    /**\r\n     * Asynchronously reads back the decoded splat centers (stride-4 xyzw, w=1) for a contiguous splat range\r\n     * from the work buffer's centers texture, using a non-blocking GPU readback (WebGL2 PBO + fence, or WebGPU\r\n     * copyTextureToBuffer + mapAsync) so it never stalls the frame the way a CPU image decode does. The centers\r\n     * texture already holds the GPU-decoded positions (identical to the CPU decode), so this replaces decoding\r\n     * positions on the CPU from the means images. Returns null when async readback is unsupported (caller should\r\n     * fall back to CPU decoding).\r\n     * @param splatOffset first splat index of the range\r\n     * @param splatCount number of splats in the range\r\n     * @returns a stride-4 Float32Array of length `splatCount * 4`, or null when unsupported/failed\r\n     */\r\n    public async readCentersRangeAsync(splatOffset: number, splatCount: number): Promise<Nullable<Float32Array>> {\r\n        if (this._disposed || splatCount <= 0 || !this.supportsAsyncCentersReadback) {\r\n            return null;\r\n        }\r\n\r\n        const width = this._textureSize;\r\n        // The range maps to whole texel rows [rowStart, rowEnd); read that rectangle and slice the exact range.\r\n        // Splat i lives at texel (i % width, floor(i / width)) in both decode and draw, so the readback (which\r\n        // indexes the same texture storage directly, with no UV/flip) yields splat i at buffer position\r\n        // i - rowStart * width on every backend.\r\n        const rowStart = Math.floor(splatOffset / width);\r\n        const rowEnd = Math.ceil((splatOffset + splatCount) / width);\r\n        const rowCount = rowEnd - rowStart;\r\n        const startInBuffer = (splatOffset - rowStart * width) * 4;\r\n        const sliceEnd = startInBuffer + splatCount * 4;\r\n        const centers = this._mrt.textures[0];\r\n\r\n        const engine = this._scene.getEngine();\r\n\r\n        if (engine.isWebGPU) {\r\n            // WebGPU: copyTextureToBuffer of the row span + mapAsync (genuinely non-blocking). noDataConversion\r\n            // returns the raw RGBA32F floats tightly packed (the 256-byte row alignment is removed internally).\r\n            const result = await centers.readPixels(0, 0, null, true, true, 0, rowStart, width, rowCount);\r\n            if (this._disposed || !result) {\r\n                return null;\r\n            }\r\n            const floats = result instanceof Float32Array ? result : new Float32Array(result.buffer, result.byteOffset, result.byteLength / 4);\r\n            return floats.length >= sliceEnd ? (floats.subarray(startInBuffer, sliceEnd) as Float32Array) : null;\r\n        }\r\n\r\n        // WebGL2: read directly from the centers texture via a reused FBO + async PBO readback.\r\n        const glEngine = engine as unknown as {\r\n            _gl: WebGL2RenderingContext;\r\n            _currentFramebuffer: Nullable<WebGLFramebuffer>;\r\n            _readPixelsAsync(x: number, y: number, w: number, h: number, format: number, type: number, o: ArrayBufferView): Nullable<Promise<ArrayBufferView>>;\r\n        };\r\n        const gl = glEngine._gl;\r\n        const hardware = centers.getInternalTexture()?._hardwareTexture?.underlyingResource as Nullable<WebGLTexture>;\r\n        if (!hardware) {\r\n            return null;\r\n        }\r\n        const buffer = new Float32Array(width * rowCount * 4);\r\n        if (!this._readFbo) {\r\n            this._readFbo = gl.createFramebuffer();\r\n        }\r\n        const previousFbo = glEngine._currentFramebuffer;\r\n        gl.bindFramebuffer(gl.FRAMEBUFFER, this._readFbo);\r\n        gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, hardware, 0);\r\n        gl.readBuffer(gl.COLOR_ATTACHMENT0);\r\n\r\n        // _readPixelsAsync issues the readPixels into a PBO synchronously, then resolves once the GPU fence\r\n        // signals — so the framebuffer can be restored immediately while the transfer completes off-thread.\r\n        const promise = glEngine._readPixelsAsync(0, rowStart, width, rowCount, gl.RGBA, gl.FLOAT, buffer);\r\n        gl.bindFramebuffer(gl.FRAMEBUFFER, previousFbo);\r\n        // gl.readBuffer is global state: restore the default-framebuffer read source (BACK) so later\r\n        // readPixels on the default framebuffer aren't left pointing at COLOR_ATTACHMENT0. When restoring to\r\n        // another FBO, COLOR_ATTACHMENT0 is the correct default read buffer, so only reset for the default one.\r\n        if (!previousFbo) {\r\n            gl.readBuffer(gl.BACK);\r\n        }\r\n        if (!promise) {\r\n            return null;\r\n        }\r\n        await promise;\r\n        if (this._disposed || buffer.length < sliceEnd) {\r\n            return null;\r\n        }\r\n        return buffer.subarray(startInBuffer, sliceEnd) as Float32Array;\r\n    }\r\n\r\n    /**\r\n     * Disposes the work buffer and its decode resources.\r\n     */\r\n    public dispose(): void {\r\n        this._disposed = true;\r\n        if (this._readFbo) {\r\n            (this._scene.getEngine() as unknown as { _gl?: WebGL2RenderingContext })._gl?.deleteFramebuffer(this._readFbo);\r\n            this._readFbo = null;\r\n        }\r\n        this._quad.dispose();\r\n        this._material.dispose(true, false);\r\n        this._copyMaterial?.dispose(true, false);\r\n        this._relayoutMapTexture?.dispose();\r\n        this._mrt.dispose();\r\n    }\r\n\r\n    private _createQuad(): Mesh {\r\n        const quad = new Mesh(\"gsWorkBufferQuad\", this._scene);\r\n        const vertexData = new VertexData();\r\n        // Fullscreen triangle in clip space (the vertex shader passes positions straight through).\r\n        vertexData.positions = [-1, -1, 0, 3, -1, 0, -1, 3, 0];\r\n        vertexData.indices = [0, 1, 2];\r\n        vertexData.applyToMesh(quad);\r\n        // Render only inside the work-buffer MRT, never in the main scene pass.\r\n        this._scene.removeMesh(quad);\r\n        return quad;\r\n    }\r\n\r\n    private _createMaterial(): ShaderMaterial {\r\n        const isWGSL = this._shaderLanguage === ShaderLanguage.WGSL;\r\n        const material = new ShaderMaterial(\r\n            \"gsSogDecode\",\r\n            this._scene,\r\n            {\r\n                vertexSource: isWGSL ? GaussianSplattingWorkBufferVertexShaderWGSL : GaussianSplattingWorkBufferVertexShaderGLSL,\r\n                fragmentSource: isWGSL ? GaussianSplattingWorkBufferFragmentShaderWGSL : GaussianSplattingWorkBufferFragmentShaderGLSL,\r\n            },\r\n            {\r\n                attributes: [\"position\"],\r\n                uniforms: [\"sogMeansMin\", \"sogMeansMax\", \"sogScalesMin\", \"sogScalesMax\", \"sogSh0Min\", \"sogSh0Max\", \"uVersion\", \"uOffset\", \"uCount\", \"uDestWidth\", \"uSrcWidth\"],\r\n                samplers: [\"sogMeansLTex\", \"sogMeansUTex\", \"sogScalesTex\", \"sogQuatsTex\", \"sogSh0Tex\", \"sogCodebookTex\"],\r\n                shaderLanguage: this._shaderLanguage,\r\n            }\r\n        );\r\n        material.backFaceCulling = false;\r\n        material.disableDepthWrite = true;\r\n        return material;\r\n    }\r\n\r\n    private _applyPack(pack: ISogTexturePack, offset: number): void {\r\n        const material = this._material;\r\n        const srcWidth = (pack.meansTextureL as Texture).getSize().width;\r\n\r\n        material.setTexture(\"sogMeansLTex\", pack.meansTextureL);\r\n        material.setTexture(\"sogMeansUTex\", pack.meansTextureU);\r\n        material.setTexture(\"sogScalesTex\", pack.scalesTexture);\r\n        material.setTexture(\"sogQuatsTex\", pack.quatsTexture);\r\n        material.setTexture(\"sogSh0Tex\", pack.sh0Texture);\r\n        // Codebook only used for v2; bind a harmless placeholder otherwise so the sampler is always set.\r\n        material.setTexture(\"sogCodebookTex\", pack.codebookTexture ?? pack.sh0Texture);\r\n\r\n        material.setVector3(\"sogMeansMin\", new Vector3(pack.meansMin[0], pack.meansMin[1], pack.meansMin[2]));\r\n        material.setVector3(\"sogMeansMax\", new Vector3(pack.meansMax[0], pack.meansMax[1], pack.meansMax[2]));\r\n        const sMin = pack.scalesMin ?? [0, 0, 0];\r\n        const sMax = pack.scalesMax ?? [0, 0, 0];\r\n        material.setVector3(\"sogScalesMin\", new Vector3(sMin[0], sMin[1], sMin[2]));\r\n        material.setVector3(\"sogScalesMax\", new Vector3(sMax[0], sMax[1], sMax[2]));\r\n        const c0Min = pack.sh0Min ?? [0, 0, 0, 0];\r\n        const c0Max = pack.sh0Max ?? [0, 0, 0, 0];\r\n        material.setVector4(\"sogSh0Min\", new Vector4(c0Min[0], c0Min[1], c0Min[2], c0Min[3]));\r\n        material.setVector4(\"sogSh0Max\", new Vector4(c0Max[0], c0Max[1], c0Max[2], c0Max[3]));\r\n\r\n        material.setInt(\"uVersion\", pack.version);\r\n        material.setInt(\"uOffset\", offset);\r\n        material.setInt(\"uCount\", pack.splatCount);\r\n        material.setInt(\"uDestWidth\", this._textureSize);\r\n        material.setInt(\"uSrcWidth\", srcWidth);\r\n    }\r\n}\r\n"]}

package/SPLAT/gaussianSplattingWorkBufferShaders.d.ts

@@ -0,0 +1,40 @@
+/** This file must only contain pure code and pure imports */
+/**
+ * Shared shader names for the SOG -> decoded work-buffer copy pass.
+ */
+export declare const GaussianSplattingWorkBufferShaderName = "gsSogDecodeToWorkBuffer";
+/**
+ * Pass-through vertex shader (GLSL): the geometry is a fullscreen triangle already in NDC.
+ */
+export declare const GaussianSplattingWorkBufferVertexShaderGLSL = "precision highp float;\nattribute vec3 position;\nvoid main() {\n    gl_Position = vec4(position.xy, 0.0, 1.0);\n}\n";
+/**
+ * Fragment shader (GLSL/WebGL2): decodes one SOG source file into the decoded GS work-buffer layout,
+ * writing each splat into its allocated pixel. Mirrors the USE_SOG decode in ShadersInclude/gaussianSplatting.fx
+ * but outputs the decoded MRT (center, covA, covB, color) consumed by the standard (non-SOG) draw path.
+ *
+ * MRT layout: 0 = center (x,y,z,1), 1 = covA (Sigma00,01,02,11), 2 = covB (Sigma12,22,0,0), 3 = color (rgba).
+ */
+export declare const GaussianSplattingWorkBufferFragmentShaderGLSL = "precision highp float;\nprecision highp int;\n\nuniform sampler2D sogMeansLTex;\nuniform sampler2D sogMeansUTex;\nuniform sampler2D sogScalesTex;\nuniform sampler2D sogQuatsTex;\nuniform sampler2D sogSh0Tex;\nuniform sampler2D sogCodebookTex;\n\nuniform vec3 sogMeansMin;\nuniform vec3 sogMeansMax;\nuniform vec3 sogScalesMin;\nuniform vec3 sogScalesMax;\nuniform vec4 sogSh0Min;\nuniform vec4 sogSh0Max;\nuniform int uVersion;\nuniform int uOffset;\nuniform int uCount;\nuniform int uDestWidth;\nuniform int uSrcWidth;\n\nlayout(location = 0) out vec4 glFragData[4];\n\nmat3 transposeM(mat3 m) {\n    return mat3(m[0][0], m[1][0], m[2][0], m[0][1], m[1][1], m[2][1], m[0][2], m[1][2], m[2][2]);\n}\n\nvoid main() {\n    ivec2 p = ivec2(gl_FragCoord.xy);\n    int global = p.y * uDestWidth + p.x;\n    if (global < uOffset || global >= uOffset + uCount) {\n        discard;\n    }\n    int k = global - uOffset;\n    ivec2 src = ivec2(k - (k / uSrcWidth) * uSrcWidth, k / uSrcWidth);\n\n    vec3 mL = texelFetch(sogMeansLTex, src, 0).xyz;\n    vec3 mU = texelFetch(sogMeansUTex, src, 0).xyz;\n    vec3 sRaw = texelFetch(sogScalesTex, src, 0).xyz;\n    vec4 qRaw = texelFetch(sogQuatsTex, src, 0);\n    vec4 c0 = texelFetch(sogSh0Tex, src, 0);\n\n    // Position: q16 = (u<<8)|l normalized; n = lerp(min,max,q16); pos = sign(n)*(exp(|n|)-1)\n    vec3 q16 = (mU * 256.0 + mL) * (255.0 / 65535.0);\n    vec3 nPos = mix(sogMeansMin, sogMeansMax, q16);\n    vec3 center = sign(nPos) * (exp(abs(nPos)) - vec3(1.0));\n\n    // Scale (v1: lerp+exp ; v2: codebook lookup)\n    vec3 splatScale;\n    if (uVersion == 2) {\n        vec3 sIdx = floor(sRaw * 255.0 + 0.5);\n        splatScale.x = exp(texelFetch(sogCodebookTex, ivec2(int(sIdx.x), 0), 0).r);\n        splatScale.y = exp(texelFetch(sogCodebookTex, ivec2(int(sIdx.y), 0), 0).r);\n        splatScale.z = exp(texelFetch(sogCodebookTex, ivec2(int(sIdx.z), 0), 0).r);\n    } else {\n        splatScale = exp(mix(sogScalesMin, sogScalesMax, sRaw));\n    }\n\n    // Quaternion (largest-omitted, mode in alpha as 252 + omitted-index)\n    const float invSqrt2 = 0.70710678118;\n    vec3 qabc = (qRaw.xyz - vec3(0.5)) * 2.0 * invSqrt2;\n    int qMode = int(qRaw.w * 255.0 + 0.5) - 252;\n    float qd = sqrt(max(0.0, 1.0 - dot(qabc, qabc)));\n    vec4 quat;\n    if (qMode == 0) {\n        quat = vec4(qd, qabc.x, qabc.y, qabc.z);\n    } else if (qMode == 1) {\n        quat = vec4(qabc.x, qd, qabc.y, qabc.z);\n    } else if (qMode == 2) {\n        quat = vec4(qabc.x, qabc.y, qd, qabc.z);\n    } else {\n        quat = vec4(qabc.x, qabc.y, qabc.z, qd);\n    }\n\n    float qw = quat.x, qx = quat.y, qy = quat.z, qz = quat.w;\n    mat3 R = mat3(\n        1.0 - 2.0 * (qy * qy + qz * qz), 2.0 * (qx * qy + qw * qz), 2.0 * (qx * qz - qw * qy),\n        2.0 * (qx * qy - qw * qz), 1.0 - 2.0 * (qx * qx + qz * qz), 2.0 * (qy * qz + qw * qx),\n        2.0 * (qx * qz + qw * qy), 2.0 * (qy * qz - qw * qx), 1.0 - 2.0 * (qx * qx + qy * qy)\n    );\n    mat3 S2 = mat3(\n        4.0 * splatScale.x * splatScale.x, 0.0, 0.0,\n        0.0, 4.0 * splatScale.y * splatScale.y, 0.0,\n        0.0, 0.0, 4.0 * splatScale.z * splatScale.z\n    );\n    mat3 Sigma = R * S2 * transposeM(R);\n\n    // Color (sh0)\n    const float SH_C0 = 0.28209479177387814;\n    vec3 colRgb;\n    float colA;\n    if (uVersion == 2) {\n        vec3 c3;\n        c3.x = texelFetch(sogCodebookTex, ivec2(256 + int(c0.x * 255.0 + 0.5), 0), 0).r;\n        c3.y = texelFetch(sogCodebookTex, ivec2(256 + int(c0.y * 255.0 + 0.5), 0), 0).r;\n        c3.z = texelFetch(sogCodebookTex, ivec2(256 + int(c0.z * 255.0 + 0.5), 0), 0).r;\n        colRgb = vec3(0.5) + c3 * SH_C0;\n        colA = c0.w;\n    } else {\n        vec4 cLerp = mix(sogSh0Min, sogSh0Max, c0);\n        colRgb = vec3(0.5) + cLerp.xyz * SH_C0;\n        colA = 1.0 / (1.0 + exp(-cLerp.w));\n    }\n\n    glFragData[0] = vec4(center, 1.0);\n    glFragData[1] = vec4(Sigma[0][0], Sigma[0][1], Sigma[0][2], Sigma[1][1]);\n    glFragData[2] = vec4(Sigma[1][2], Sigma[2][2], 0.0, 0.0);\n    glFragData[3] = vec4(colRgb, colA);\n}\n";
+/**
+ * Pass-through vertex shader (WGSL).
+ */
+export declare const GaussianSplattingWorkBufferVertexShaderWGSL = "\nattribute position : vec3<f32>;\n@vertex\nfn main(input : VertexInputs) -> FragmentInputs {\n    vertexOutputs.position = vec4<f32>(input.position.xy, 0.0, 1.0);\n}\n";
+/**
+ * Fragment shader (WGSL/WebGPU) — same decode as the GLSL variant, writing 4 MRT attachments.
+ */
+export declare const GaussianSplattingWorkBufferFragmentShaderWGSL = "\nvar sogMeansLTexSampler : sampler;\nvar sogMeansLTex : texture_2d<f32>;\nvar sogMeansUTexSampler : sampler;\nvar sogMeansUTex : texture_2d<f32>;\nvar sogScalesTexSampler : sampler;\nvar sogScalesTex : texture_2d<f32>;\nvar sogQuatsTexSampler : sampler;\nvar sogQuatsTex : texture_2d<f32>;\nvar sogSh0TexSampler : sampler;\nvar sogSh0Tex : texture_2d<f32>;\nvar sogCodebookTexSampler : sampler;\nvar sogCodebookTex : texture_2d<f32>;\n\nuniform sogMeansMin : vec3<f32>;\nuniform sogMeansMax : vec3<f32>;\nuniform sogScalesMin : vec3<f32>;\nuniform sogScalesMax : vec3<f32>;\nuniform sogSh0Min : vec4<f32>;\nuniform sogSh0Max : vec4<f32>;\nuniform uVersion : i32;\nuniform uOffset : i32;\nuniform uCount : i32;\nuniform uDestWidth : i32;\nuniform uSrcWidth : i32;\n\n@fragment\nfn main(input : FragmentInputs) -> FragmentOutputs {\n    let p : vec2<i32> = vec2<i32>(i32(fragmentInputs.position.x), i32(fragmentInputs.position.y));\n    let global : i32 = p.y * uniforms.uDestWidth + p.x;\n    if (global < uniforms.uOffset || global >= uniforms.uOffset + uniforms.uCount) {\n        discard;\n    }\n    let k : i32 = global - uniforms.uOffset;\n    let src : vec2<i32> = vec2<i32>(k - (k / uniforms.uSrcWidth) * uniforms.uSrcWidth, k / uniforms.uSrcWidth);\n\n    let mL : vec3<f32> = textureLoad(sogMeansLTex, src, 0).xyz;\n    let mU : vec3<f32> = textureLoad(sogMeansUTex, src, 0).xyz;\n    let sRaw : vec3<f32> = textureLoad(sogScalesTex, src, 0).xyz;\n    let qRaw : vec4<f32> = textureLoad(sogQuatsTex, src, 0);\n    let c0 : vec4<f32> = textureLoad(sogSh0Tex, src, 0);\n\n    let q16 : vec3<f32> = (mU * 256.0 + mL) * (255.0 / 65535.0);\n    let nPos : vec3<f32> = mix(uniforms.sogMeansMin, uniforms.sogMeansMax, q16);\n    let center : vec3<f32> = sign(nPos) * (exp(abs(nPos)) - vec3<f32>(1.0));\n\n    var splatScale : vec3<f32>;\n    if (uniforms.uVersion == 2) {\n        let sIdx : vec3<f32> = floor(sRaw * 255.0 + 0.5);\n        splatScale.x = exp(textureLoad(sogCodebookTex, vec2<i32>(i32(sIdx.x), 0), 0).r);\n        splatScale.y = exp(textureLoad(sogCodebookTex, vec2<i32>(i32(sIdx.y), 0), 0).r);\n        splatScale.z = exp(textureLoad(sogCodebookTex, vec2<i32>(i32(sIdx.z), 0), 0).r);\n    } else {\n        splatScale = exp(mix(uniforms.sogScalesMin, uniforms.sogScalesMax, sRaw));\n    }\n\n    let invSqrt2 : f32 = 0.70710678118;\n    let qabc : vec3<f32> = (qRaw.xyz - vec3<f32>(0.5)) * 2.0 * invSqrt2;\n    let qMode : i32 = i32(qRaw.w * 255.0 + 0.5) - 252;\n    let qd : f32 = sqrt(max(0.0, 1.0 - dot(qabc, qabc)));\n    var quat : vec4<f32>;\n    if (qMode == 0) {\n        quat = vec4<f32>(qd, qabc.x, qabc.y, qabc.z);\n    } else if (qMode == 1) {\n        quat = vec4<f32>(qabc.x, qd, qabc.y, qabc.z);\n    } else if (qMode == 2) {\n        quat = vec4<f32>(qabc.x, qabc.y, qd, qabc.z);\n    } else {\n        quat = vec4<f32>(qabc.x, qabc.y, qabc.z, qd);\n    }\n\n    let qw : f32 = quat.x;\n    let qx : f32 = quat.y;\n    let qy : f32 = quat.z;\n    let qz : f32 = quat.w;\n    let R : mat3x3<f32> = mat3x3<f32>(\n        1.0 - 2.0 * (qy * qy + qz * qz), 2.0 * (qx * qy + qw * qz), 2.0 * (qx * qz - qw * qy),\n        2.0 * (qx * qy - qw * qz), 1.0 - 2.0 * (qx * qx + qz * qz), 2.0 * (qy * qz + qw * qx),\n        2.0 * (qx * qz + qw * qy), 2.0 * (qy * qz - qw * qx), 1.0 - 2.0 * (qx * qx + qy * qy)\n    );\n    let S2 : mat3x3<f32> = mat3x3<f32>(\n        4.0 * splatScale.x * splatScale.x, 0.0, 0.0,\n        0.0, 4.0 * splatScale.y * splatScale.y, 0.0,\n        0.0, 0.0, 4.0 * splatScale.z * splatScale.z\n    );\n    let Sigma : mat3x3<f32> = R * S2 * transpose(R);\n\n    let SH_C0 : f32 = 0.28209479177387814;\n    var colRgb : vec3<f32>;\n    var colA : f32;\n    if (uniforms.uVersion == 2) {\n        var c3 : vec3<f32>;\n        c3.x = textureLoad(sogCodebookTex, vec2<i32>(256 + i32(c0.x * 255.0 + 0.5), 0), 0).r;\n        c3.y = textureLoad(sogCodebookTex, vec2<i32>(256 + i32(c0.y * 255.0 + 0.5), 0), 0).r;\n        c3.z = textureLoad(sogCodebookTex, vec2<i32>(256 + i32(c0.z * 255.0 + 0.5), 0), 0).r;\n        colRgb = vec3<f32>(0.5) + c3 * SH_C0;\n        colA = c0.w;\n    } else {\n        let cLerp : vec4<f32> = mix(uniforms.sogSh0Min, uniforms.sogSh0Max, c0);\n        colRgb = vec3<f32>(0.5) + cLerp.xyz * SH_C0;\n        colA = 1.0 / (1.0 + exp(-cLerp.w));\n    }\n\n    fragmentOutputs.fragData0 = vec4<f32>(center, 1.0);\n    fragmentOutputs.fragData1 = vec4<f32>(Sigma[0][0], Sigma[0][1], Sigma[0][2], Sigma[1][1]);\n    fragmentOutputs.fragData2 = vec4<f32>(Sigma[1][2], Sigma[2][2], 0.0, 0.0);\n    fragmentOutputs.fragData3 = vec4<f32>(colRgb, colA);\n}\n";
+/**
+ * Shader name for the work-buffer relayout (defrag/compaction) copy pass.
+ */
+export declare const GaussianSplattingWorkBufferRelayoutShaderName = "gsWorkBufferRelayout";
+/**
+ * Relayout copy fragment shader (GLSL/WebGL2). Copies the four decoded work-buffer textures from a source
+ * layout to a destination layout, one output texel per draw. In map mode (`uUseMap == 1`) each destination
+ * texel reads its source splat index from `uMapTex` (R32F; a negative value marks a gap and is discarded so
+ * the cleared destination stays zero). In identity mode the source texel equals the destination texel.
+ */
+export declare const GaussianSplattingWorkBufferRelayoutFragmentShaderGLSL = "precision highp float;\nprecision highp int;\n\nuniform sampler2D uMapTex;\nuniform sampler2D uSrc0;\nuniform sampler2D uSrc1;\nuniform sampler2D uSrc2;\nuniform sampler2D uSrc3;\nuniform int uDstWidth;\nuniform int uSrcWidth;\nuniform int uUseMap;\n\nlayout(location = 0) out vec4 glFragData[4];\n\nvoid main() {\n    ivec2 p = ivec2(gl_FragCoord.xy);\n    int srcIdx;\n    if (uUseMap == 1) {\n        float m = texelFetch(uMapTex, p, 0).r;\n        if (m < 0.0) {\n            discard;\n        }\n        srcIdx = int(m + 0.5);\n    } else {\n        srcIdx = p.y * uDstWidth + p.x;\n    }\n    ivec2 s = ivec2(srcIdx - (srcIdx / uSrcWidth) * uSrcWidth, srcIdx / uSrcWidth);\n    glFragData[0] = texelFetch(uSrc0, s, 0);\n    glFragData[1] = texelFetch(uSrc1, s, 0);\n    glFragData[2] = texelFetch(uSrc2, s, 0);\n    glFragData[3] = texelFetch(uSrc3, s, 0);\n}\n";
+/**
+ * Relayout copy fragment shader (WGSL/WebGPU) — same copy as the GLSL variant.
+ */
+export declare const GaussianSplattingWorkBufferRelayoutFragmentShaderWGSL = "\nvar uMapTexSampler : sampler;\nvar uMapTex : texture_2d<f32>;\nvar uSrc0Sampler : sampler;\nvar uSrc0 : texture_2d<f32>;\nvar uSrc1Sampler : sampler;\nvar uSrc1 : texture_2d<f32>;\nvar uSrc2Sampler : sampler;\nvar uSrc2 : texture_2d<f32>;\nvar uSrc3Sampler : sampler;\nvar uSrc3 : texture_2d<f32>;\n\nuniform uDstWidth : i32;\nuniform uSrcWidth : i32;\nuniform uUseMap : i32;\n\n@fragment\nfn main(input : FragmentInputs) -> FragmentOutputs {\n    let p : vec2<i32> = vec2<i32>(i32(fragmentInputs.position.x), i32(fragmentInputs.position.y));\n    var srcIdx : i32;\n    if (uniforms.uUseMap == 1) {\n        let m : f32 = textureLoad(uMapTex, p, 0).r;\n        if (m < 0.0) {\n            discard;\n        }\n        srcIdx = i32(m + 0.5);\n    } else {\n        srcIdx = p.y * uniforms.uDstWidth + p.x;\n    }\n    let s : vec2<i32> = vec2<i32>(srcIdx - (srcIdx / uniforms.uSrcWidth) * uniforms.uSrcWidth, srcIdx / uniforms.uSrcWidth);\n    fragmentOutputs.fragData0 = textureLoad(uSrc0, s, 0);\n    fragmentOutputs.fragData1 = textureLoad(uSrc1, s, 0);\n    fragmentOutputs.fragData2 = textureLoad(uSrc2, s, 0);\n    fragmentOutputs.fragData3 = textureLoad(uSrc3, s, 0);\n}\n";