@babylonjs/loaders 9.12.0 → 9.13.0

package/SPLAT/gaussianSplattingWorkBufferShaders.d.ts

@@ -0,0 +1,25 @@
+/** 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";

package/SPLAT/gaussianSplattingWorkBufferShaders.js

@@ -0,0 +1,255 @@
+/** This file must only contain pure code and pure imports */
+/**
+ * Shared shader names for the SOG -> decoded work-buffer copy pass.
+ */
+export const GaussianSplattingWorkBufferShaderName = "gsSogDecodeToWorkBuffer";
+/**
+ * Pass-through vertex shader (GLSL): the geometry is a fullscreen triangle already in NDC.
+ */
+export const GaussianSplattingWorkBufferVertexShaderGLSL = `precision highp float;
+attribute vec3 position;
+void main() {
+    gl_Position = vec4(position.xy, 0.0, 1.0);
+}
+`;
+/**
+ * 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 const GaussianSplattingWorkBufferFragmentShaderGLSL = `precision highp float;
+precision highp int;
+
+uniform sampler2D sogMeansLTex;
+uniform sampler2D sogMeansUTex;
+uniform sampler2D sogScalesTex;
+uniform sampler2D sogQuatsTex;
+uniform sampler2D sogSh0Tex;
+uniform sampler2D sogCodebookTex;
+
+uniform vec3 sogMeansMin;
+uniform vec3 sogMeansMax;
+uniform vec3 sogScalesMin;
+uniform vec3 sogScalesMax;
+uniform vec4 sogSh0Min;
+uniform vec4 sogSh0Max;
+uniform int uVersion;
+uniform int uOffset;
+uniform int uCount;
+uniform int uDestWidth;
+uniform int uSrcWidth;
+
+layout(location = 0) out vec4 glFragData[4];
+
+mat3 transposeM(mat3 m) {
+    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]);
+}
+
+void main() {
+    ivec2 p = ivec2(gl_FragCoord.xy);
+    int global = p.y * uDestWidth + p.x;
+    if (global < uOffset || global >= uOffset + uCount) {
+        discard;
+    }
+    int k = global - uOffset;
+    ivec2 src = ivec2(k - (k / uSrcWidth) * uSrcWidth, k / uSrcWidth);
+
+    vec3 mL = texelFetch(sogMeansLTex, src, 0).xyz;
+    vec3 mU = texelFetch(sogMeansUTex, src, 0).xyz;
+    vec3 sRaw = texelFetch(sogScalesTex, src, 0).xyz;
+    vec4 qRaw = texelFetch(sogQuatsTex, src, 0);
+    vec4 c0 = texelFetch(sogSh0Tex, src, 0);
+
+    // Position: q16 = (u<<8)|l normalized; n = lerp(min,max,q16); pos = sign(n)*(exp(|n|)-1)
+    vec3 q16 = (mU * 256.0 + mL) * (255.0 / 65535.0);
+    vec3 nPos = mix(sogMeansMin, sogMeansMax, q16);
+    vec3 center = sign(nPos) * (exp(abs(nPos)) - vec3(1.0));
+
+    // Scale (v1: lerp+exp ; v2: codebook lookup)
+    vec3 splatScale;
+    if (uVersion == 2) {
+        vec3 sIdx = floor(sRaw * 255.0 + 0.5);
+        splatScale.x = exp(texelFetch(sogCodebookTex, ivec2(int(sIdx.x), 0), 0).r);
+        splatScale.y = exp(texelFetch(sogCodebookTex, ivec2(int(sIdx.y), 0), 0).r);
+        splatScale.z = exp(texelFetch(sogCodebookTex, ivec2(int(sIdx.z), 0), 0).r);
+    } else {
+        splatScale = exp(mix(sogScalesMin, sogScalesMax, sRaw));
+    }
+
+    // Quaternion (largest-omitted, mode in alpha as 252 + omitted-index)
+    const float invSqrt2 = 0.70710678118;
+    vec3 qabc = (qRaw.xyz - vec3(0.5)) * 2.0 * invSqrt2;
+    int qMode = int(qRaw.w * 255.0 + 0.5) - 252;
+    float qd = sqrt(max(0.0, 1.0 - dot(qabc, qabc)));
+    vec4 quat;
+    if (qMode == 0) {
+        quat = vec4(qd, qabc.x, qabc.y, qabc.z);
+    } else if (qMode == 1) {
+        quat = vec4(qabc.x, qd, qabc.y, qabc.z);
+    } else if (qMode == 2) {
+        quat = vec4(qabc.x, qabc.y, qd, qabc.z);
+    } else {
+        quat = vec4(qabc.x, qabc.y, qabc.z, qd);
+    }
+
+    float qw = quat.x, qx = quat.y, qy = quat.z, qz = quat.w;
+    mat3 R = mat3(
+        1.0 - 2.0 * (qy * qy + qz * qz), 2.0 * (qx * qy + qw * qz), 2.0 * (qx * qz - qw * qy),
+        2.0 * (qx * qy - qw * qz), 1.0 - 2.0 * (qx * qx + qz * qz), 2.0 * (qy * qz + qw * qx),
+        2.0 * (qx * qz + qw * qy), 2.0 * (qy * qz - qw * qx), 1.0 - 2.0 * (qx * qx + qy * qy)
+    );
+    mat3 S2 = mat3(
+        4.0 * splatScale.x * splatScale.x, 0.0, 0.0,
+        0.0, 4.0 * splatScale.y * splatScale.y, 0.0,
+        0.0, 0.0, 4.0 * splatScale.z * splatScale.z
+    );
+    mat3 Sigma = R * S2 * transposeM(R);
+
+    // Color (sh0)
+    const float SH_C0 = 0.28209479177387814;
+    vec3 colRgb;
+    float colA;
+    if (uVersion == 2) {
+        vec3 c3;
+        c3.x = texelFetch(sogCodebookTex, ivec2(256 + int(c0.x * 255.0 + 0.5), 0), 0).r;
+        c3.y = texelFetch(sogCodebookTex, ivec2(256 + int(c0.y * 255.0 + 0.5), 0), 0).r;
+        c3.z = texelFetch(sogCodebookTex, ivec2(256 + int(c0.z * 255.0 + 0.5), 0), 0).r;
+        colRgb = vec3(0.5) + c3 * SH_C0;
+        colA = c0.w;
+    } else {
+        vec4 cLerp = mix(sogSh0Min, sogSh0Max, c0);
+        colRgb = vec3(0.5) + cLerp.xyz * SH_C0;
+        colA = 1.0 / (1.0 + exp(-cLerp.w));
+    }
+
+    glFragData[0] = vec4(center, 1.0);
+    glFragData[1] = vec4(Sigma[0][0], Sigma[0][1], Sigma[0][2], Sigma[1][1]);
+    glFragData[2] = vec4(Sigma[1][2], Sigma[2][2], 0.0, 0.0);
+    glFragData[3] = vec4(colRgb, colA);
+}
+`;
+/**
+ * Pass-through vertex shader (WGSL).
+ */
+export const GaussianSplattingWorkBufferVertexShaderWGSL = `
+attribute position : vec3<f32>;
+@vertex
+fn main(input : VertexInputs) -> FragmentInputs {
+    vertexOutputs.position = vec4<f32>(input.position.xy, 0.0, 1.0);
+}
+`;
+/**
+ * Fragment shader (WGSL/WebGPU) — same decode as the GLSL variant, writing 4 MRT attachments.
+ */
+export const GaussianSplattingWorkBufferFragmentShaderWGSL = `
+var sogMeansLTexSampler : sampler;
+var sogMeansLTex : texture_2d<f32>;
+var sogMeansUTexSampler : sampler;
+var sogMeansUTex : texture_2d<f32>;
+var sogScalesTexSampler : sampler;
+var sogScalesTex : texture_2d<f32>;
+var sogQuatsTexSampler : sampler;
+var sogQuatsTex : texture_2d<f32>;
+var sogSh0TexSampler : sampler;
+var sogSh0Tex : texture_2d<f32>;
+var sogCodebookTexSampler : sampler;
+var sogCodebookTex : texture_2d<f32>;
+
+uniform sogMeansMin : vec3<f32>;
+uniform sogMeansMax : vec3<f32>;
+uniform sogScalesMin : vec3<f32>;
+uniform sogScalesMax : vec3<f32>;
+uniform sogSh0Min : vec4<f32>;
+uniform sogSh0Max : vec4<f32>;
+uniform uVersion : i32;
+uniform uOffset : i32;
+uniform uCount : i32;
+uniform uDestWidth : i32;
+uniform uSrcWidth : i32;
+
+@fragment
+fn main(input : FragmentInputs) -> FragmentOutputs {
+    let p : vec2<i32> = vec2<i32>(i32(fragmentInputs.position.x), i32(fragmentInputs.position.y));
+    let global : i32 = p.y * uniforms.uDestWidth + p.x;
+    if (global < uniforms.uOffset || global >= uniforms.uOffset + uniforms.uCount) {
+        discard;
+    }
+    let k : i32 = global - uniforms.uOffset;
+    let src : vec2<i32> = vec2<i32>(k - (k / uniforms.uSrcWidth) * uniforms.uSrcWidth, k / uniforms.uSrcWidth);
+
+    let mL : vec3<f32> = textureLoad(sogMeansLTex, src, 0).xyz;
+    let mU : vec3<f32> = textureLoad(sogMeansUTex, src, 0).xyz;
+    let sRaw : vec3<f32> = textureLoad(sogScalesTex, src, 0).xyz;
+    let qRaw : vec4<f32> = textureLoad(sogQuatsTex, src, 0);
+    let c0 : vec4<f32> = textureLoad(sogSh0Tex, src, 0);
+
+    let q16 : vec3<f32> = (mU * 256.0 + mL) * (255.0 / 65535.0);
+    let nPos : vec3<f32> = mix(uniforms.sogMeansMin, uniforms.sogMeansMax, q16);
+    let center : vec3<f32> = sign(nPos) * (exp(abs(nPos)) - vec3<f32>(1.0));
+
+    var splatScale : vec3<f32>;
+    if (uniforms.uVersion == 2) {
+        let sIdx : vec3<f32> = floor(sRaw * 255.0 + 0.5);
+        splatScale.x = exp(textureLoad(sogCodebookTex, vec2<i32>(i32(sIdx.x), 0), 0).r);
+        splatScale.y = exp(textureLoad(sogCodebookTex, vec2<i32>(i32(sIdx.y), 0), 0).r);
+        splatScale.z = exp(textureLoad(sogCodebookTex, vec2<i32>(i32(sIdx.z), 0), 0).r);
+    } else {
+        splatScale = exp(mix(uniforms.sogScalesMin, uniforms.sogScalesMax, sRaw));
+    }
+
+    let invSqrt2 : f32 = 0.70710678118;
+    let qabc : vec3<f32> = (qRaw.xyz - vec3<f32>(0.5)) * 2.0 * invSqrt2;
+    let qMode : i32 = i32(qRaw.w * 255.0 + 0.5) - 252;
+    let qd : f32 = sqrt(max(0.0, 1.0 - dot(qabc, qabc)));
+    var quat : vec4<f32>;
+    if (qMode == 0) {
+        quat = vec4<f32>(qd, qabc.x, qabc.y, qabc.z);
+    } else if (qMode == 1) {
+        quat = vec4<f32>(qabc.x, qd, qabc.y, qabc.z);
+    } else if (qMode == 2) {
+        quat = vec4<f32>(qabc.x, qabc.y, qd, qabc.z);
+    } else {
+        quat = vec4<f32>(qabc.x, qabc.y, qabc.z, qd);
+    }
+
+    let qw : f32 = quat.x;
+    let qx : f32 = quat.y;
+    let qy : f32 = quat.z;
+    let qz : f32 = quat.w;
+    let R : mat3x3<f32> = mat3x3<f32>(
+        1.0 - 2.0 * (qy * qy + qz * qz), 2.0 * (qx * qy + qw * qz), 2.0 * (qx * qz - qw * qy),
+        2.0 * (qx * qy - qw * qz), 1.0 - 2.0 * (qx * qx + qz * qz), 2.0 * (qy * qz + qw * qx),
+        2.0 * (qx * qz + qw * qy), 2.0 * (qy * qz - qw * qx), 1.0 - 2.0 * (qx * qx + qy * qy)
+    );
+    let S2 : mat3x3<f32> = mat3x3<f32>(
+        4.0 * splatScale.x * splatScale.x, 0.0, 0.0,
+        0.0, 4.0 * splatScale.y * splatScale.y, 0.0,
+        0.0, 0.0, 4.0 * splatScale.z * splatScale.z
+    );
+    let Sigma : mat3x3<f32> = R * S2 * transpose(R);
+
+    let SH_C0 : f32 = 0.28209479177387814;
+    var colRgb : vec3<f32>;
+    var colA : f32;
+    if (uniforms.uVersion == 2) {
+        var c3 : vec3<f32>;
+        c3.x = textureLoad(sogCodebookTex, vec2<i32>(256 + i32(c0.x * 255.0 + 0.5), 0), 0).r;
+        c3.y = textureLoad(sogCodebookTex, vec2<i32>(256 + i32(c0.y * 255.0 + 0.5), 0), 0).r;
+        c3.z = textureLoad(sogCodebookTex, vec2<i32>(256 + i32(c0.z * 255.0 + 0.5), 0), 0).r;
+        colRgb = vec3<f32>(0.5) + c3 * SH_C0;
+        colA = c0.w;
+    } else {
+        let cLerp : vec4<f32> = mix(uniforms.sogSh0Min, uniforms.sogSh0Max, c0);
+        colRgb = vec3<f32>(0.5) + cLerp.xyz * SH_C0;
+        colA = 1.0 / (1.0 + exp(-cLerp.w));
+    }
+
+    fragmentOutputs.fragData0 = vec4<f32>(center, 1.0);
+    fragmentOutputs.fragData1 = vec4<f32>(Sigma[0][0], Sigma[0][1], Sigma[0][2], Sigma[1][1]);
+    fragmentOutputs.fragData2 = vec4<f32>(Sigma[1][2], Sigma[2][2], 0.0, 0.0);
+    fragmentOutputs.fragData3 = vec4<f32>(colRgb, colA);
+}
+`;
+//# sourceMappingURL=gaussianSplattingWorkBufferShaders.js.map

package/SPLAT/gaussianSplattingWorkBufferShaders.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gaussianSplattingWorkBufferShaders.js","sourceRoot":"","sources":["../../../../dev/loaders/src/SPLAT/gaussianSplattingWorkBufferShaders.ts"],"names":[],"mappings":"AAAA,6DAA6D;AAE7D;;GAEG;AACH,MAAM,CAAC,MAAM,qCAAqC,GAAG,yBAAyB,CAAC;AAE/E;;GAEG;AACH,MAAM,CAAC,MAAM,2CAA2C,GAAG;;;;;CAK1D,CAAC;AAEF;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,6CAA6C,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8G5D,CAAC;AAEF;;GAEG;AACH,MAAM,CAAC,MAAM,2CAA2C,GAAG;;;;;;CAM1D,CAAC;AAEF;;GAEG;AACH,MAAM,CAAC,MAAM,6CAA6C,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4G5D,CAAC","sourcesContent":["/** This file must only contain pure code and pure imports */\r\n\r\n/**\r\n * Shared shader names for the SOG -> decoded work-buffer copy pass.\r\n */\r\nexport const GaussianSplattingWorkBufferShaderName = \"gsSogDecodeToWorkBuffer\";\r\n\r\n/**\r\n * Pass-through vertex shader (GLSL): the geometry is a fullscreen triangle already in NDC.\r\n */\r\nexport const GaussianSplattingWorkBufferVertexShaderGLSL = `precision highp float;\r\nattribute vec3 position;\r\nvoid main() {\r\n    gl_Position = vec4(position.xy, 0.0, 1.0);\r\n}\r\n`;\r\n\r\n/**\r\n * Fragment shader (GLSL/WebGL2): decodes one SOG source file into the decoded GS work-buffer layout,\r\n * writing each splat into its allocated pixel. Mirrors the USE_SOG decode in ShadersInclude/gaussianSplatting.fx\r\n * but outputs the decoded MRT (center, covA, covB, color) consumed by the standard (non-SOG) draw path.\r\n *\r\n * MRT layout: 0 = center (x,y,z,1), 1 = covA (Sigma00,01,02,11), 2 = covB (Sigma12,22,0,0), 3 = color (rgba).\r\n */\r\nexport const GaussianSplattingWorkBufferFragmentShaderGLSL = `precision highp float;\r\nprecision highp int;\r\n\r\nuniform sampler2D sogMeansLTex;\r\nuniform sampler2D sogMeansUTex;\r\nuniform sampler2D sogScalesTex;\r\nuniform sampler2D sogQuatsTex;\r\nuniform sampler2D sogSh0Tex;\r\nuniform sampler2D sogCodebookTex;\r\n\r\nuniform vec3 sogMeansMin;\r\nuniform vec3 sogMeansMax;\r\nuniform vec3 sogScalesMin;\r\nuniform vec3 sogScalesMax;\r\nuniform vec4 sogSh0Min;\r\nuniform vec4 sogSh0Max;\r\nuniform int uVersion;\r\nuniform int uOffset;\r\nuniform int uCount;\r\nuniform int uDestWidth;\r\nuniform int uSrcWidth;\r\n\r\nlayout(location = 0) out vec4 glFragData[4];\r\n\r\nmat3 transposeM(mat3 m) {\r\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]);\r\n}\r\n\r\nvoid main() {\r\n    ivec2 p = ivec2(gl_FragCoord.xy);\r\n    int global = p.y * uDestWidth + p.x;\r\n    if (global < uOffset || global >= uOffset + uCount) {\r\n        discard;\r\n    }\r\n    int k = global - uOffset;\r\n    ivec2 src = ivec2(k - (k / uSrcWidth) * uSrcWidth, k / uSrcWidth);\r\n\r\n    vec3 mL = texelFetch(sogMeansLTex, src, 0).xyz;\r\n    vec3 mU = texelFetch(sogMeansUTex, src, 0).xyz;\r\n    vec3 sRaw = texelFetch(sogScalesTex, src, 0).xyz;\r\n    vec4 qRaw = texelFetch(sogQuatsTex, src, 0);\r\n    vec4 c0 = texelFetch(sogSh0Tex, src, 0);\r\n\r\n    // Position: q16 = (u<<8)|l normalized; n = lerp(min,max,q16); pos = sign(n)*(exp(|n|)-1)\r\n    vec3 q16 = (mU * 256.0 + mL) * (255.0 / 65535.0);\r\n    vec3 nPos = mix(sogMeansMin, sogMeansMax, q16);\r\n    vec3 center = sign(nPos) * (exp(abs(nPos)) - vec3(1.0));\r\n\r\n    // Scale (v1: lerp+exp ; v2: codebook lookup)\r\n    vec3 splatScale;\r\n    if (uVersion == 2) {\r\n        vec3 sIdx = floor(sRaw * 255.0 + 0.5);\r\n        splatScale.x = exp(texelFetch(sogCodebookTex, ivec2(int(sIdx.x), 0), 0).r);\r\n        splatScale.y = exp(texelFetch(sogCodebookTex, ivec2(int(sIdx.y), 0), 0).r);\r\n        splatScale.z = exp(texelFetch(sogCodebookTex, ivec2(int(sIdx.z), 0), 0).r);\r\n    } else {\r\n        splatScale = exp(mix(sogScalesMin, sogScalesMax, sRaw));\r\n    }\r\n\r\n    // Quaternion (largest-omitted, mode in alpha as 252 + omitted-index)\r\n    const float invSqrt2 = 0.70710678118;\r\n    vec3 qabc = (qRaw.xyz - vec3(0.5)) * 2.0 * invSqrt2;\r\n    int qMode = int(qRaw.w * 255.0 + 0.5) - 252;\r\n    float qd = sqrt(max(0.0, 1.0 - dot(qabc, qabc)));\r\n    vec4 quat;\r\n    if (qMode == 0) {\r\n        quat = vec4(qd, qabc.x, qabc.y, qabc.z);\r\n    } else if (qMode == 1) {\r\n        quat = vec4(qabc.x, qd, qabc.y, qabc.z);\r\n    } else if (qMode == 2) {\r\n        quat = vec4(qabc.x, qabc.y, qd, qabc.z);\r\n    } else {\r\n        quat = vec4(qabc.x, qabc.y, qabc.z, qd);\r\n    }\r\n\r\n    float qw = quat.x, qx = quat.y, qy = quat.z, qz = quat.w;\r\n    mat3 R = mat3(\r\n        1.0 - 2.0 * (qy * qy + qz * qz), 2.0 * (qx * qy + qw * qz), 2.0 * (qx * qz - qw * qy),\r\n        2.0 * (qx * qy - qw * qz), 1.0 - 2.0 * (qx * qx + qz * qz), 2.0 * (qy * qz + qw * qx),\r\n        2.0 * (qx * qz + qw * qy), 2.0 * (qy * qz - qw * qx), 1.0 - 2.0 * (qx * qx + qy * qy)\r\n    );\r\n    mat3 S2 = mat3(\r\n        4.0 * splatScale.x * splatScale.x, 0.0, 0.0,\r\n        0.0, 4.0 * splatScale.y * splatScale.y, 0.0,\r\n        0.0, 0.0, 4.0 * splatScale.z * splatScale.z\r\n    );\r\n    mat3 Sigma = R * S2 * transposeM(R);\r\n\r\n    // Color (sh0)\r\n    const float SH_C0 = 0.28209479177387814;\r\n    vec3 colRgb;\r\n    float colA;\r\n    if (uVersion == 2) {\r\n        vec3 c3;\r\n        c3.x = texelFetch(sogCodebookTex, ivec2(256 + int(c0.x * 255.0 + 0.5), 0), 0).r;\r\n        c3.y = texelFetch(sogCodebookTex, ivec2(256 + int(c0.y * 255.0 + 0.5), 0), 0).r;\r\n        c3.z = texelFetch(sogCodebookTex, ivec2(256 + int(c0.z * 255.0 + 0.5), 0), 0).r;\r\n        colRgb = vec3(0.5) + c3 * SH_C0;\r\n        colA = c0.w;\r\n    } else {\r\n        vec4 cLerp = mix(sogSh0Min, sogSh0Max, c0);\r\n        colRgb = vec3(0.5) + cLerp.xyz * SH_C0;\r\n        colA = 1.0 / (1.0 + exp(-cLerp.w));\r\n    }\r\n\r\n    glFragData[0] = vec4(center, 1.0);\r\n    glFragData[1] = vec4(Sigma[0][0], Sigma[0][1], Sigma[0][2], Sigma[1][1]);\r\n    glFragData[2] = vec4(Sigma[1][2], Sigma[2][2], 0.0, 0.0);\r\n    glFragData[3] = vec4(colRgb, colA);\r\n}\r\n`;\r\n\r\n/**\r\n * Pass-through vertex shader (WGSL).\r\n */\r\nexport const GaussianSplattingWorkBufferVertexShaderWGSL = `\r\nattribute position : vec3<f32>;\r\n@vertex\r\nfn main(input : VertexInputs) -> FragmentInputs {\r\n    vertexOutputs.position = vec4<f32>(input.position.xy, 0.0, 1.0);\r\n}\r\n`;\r\n\r\n/**\r\n * Fragment shader (WGSL/WebGPU) — same decode as the GLSL variant, writing 4 MRT attachments.\r\n */\r\nexport const GaussianSplattingWorkBufferFragmentShaderWGSL = `\r\nvar sogMeansLTexSampler : sampler;\r\nvar sogMeansLTex : texture_2d<f32>;\r\nvar sogMeansUTexSampler : sampler;\r\nvar sogMeansUTex : texture_2d<f32>;\r\nvar sogScalesTexSampler : sampler;\r\nvar sogScalesTex : texture_2d<f32>;\r\nvar sogQuatsTexSampler : sampler;\r\nvar sogQuatsTex : texture_2d<f32>;\r\nvar sogSh0TexSampler : sampler;\r\nvar sogSh0Tex : texture_2d<f32>;\r\nvar sogCodebookTexSampler : sampler;\r\nvar sogCodebookTex : texture_2d<f32>;\r\n\r\nuniform sogMeansMin : vec3<f32>;\r\nuniform sogMeansMax : vec3<f32>;\r\nuniform sogScalesMin : vec3<f32>;\r\nuniform sogScalesMax : vec3<f32>;\r\nuniform sogSh0Min : vec4<f32>;\r\nuniform sogSh0Max : vec4<f32>;\r\nuniform uVersion : i32;\r\nuniform uOffset : i32;\r\nuniform uCount : i32;\r\nuniform uDestWidth : i32;\r\nuniform uSrcWidth : i32;\r\n\r\n@fragment\r\nfn main(input : FragmentInputs) -> FragmentOutputs {\r\n    let p : vec2<i32> = vec2<i32>(i32(fragmentInputs.position.x), i32(fragmentInputs.position.y));\r\n    let global : i32 = p.y * uniforms.uDestWidth + p.x;\r\n    if (global < uniforms.uOffset || global >= uniforms.uOffset + uniforms.uCount) {\r\n        discard;\r\n    }\r\n    let k : i32 = global - uniforms.uOffset;\r\n    let src : vec2<i32> = vec2<i32>(k - (k / uniforms.uSrcWidth) * uniforms.uSrcWidth, k / uniforms.uSrcWidth);\r\n\r\n    let mL : vec3<f32> = textureLoad(sogMeansLTex, src, 0).xyz;\r\n    let mU : vec3<f32> = textureLoad(sogMeansUTex, src, 0).xyz;\r\n    let sRaw : vec3<f32> = textureLoad(sogScalesTex, src, 0).xyz;\r\n    let qRaw : vec4<f32> = textureLoad(sogQuatsTex, src, 0);\r\n    let c0 : vec4<f32> = textureLoad(sogSh0Tex, src, 0);\r\n\r\n    let q16 : vec3<f32> = (mU * 256.0 + mL) * (255.0 / 65535.0);\r\n    let nPos : vec3<f32> = mix(uniforms.sogMeansMin, uniforms.sogMeansMax, q16);\r\n    let center : vec3<f32> = sign(nPos) * (exp(abs(nPos)) - vec3<f32>(1.0));\r\n\r\n    var splatScale : vec3<f32>;\r\n    if (uniforms.uVersion == 2) {\r\n        let sIdx : vec3<f32> = floor(sRaw * 255.0 + 0.5);\r\n        splatScale.x = exp(textureLoad(sogCodebookTex, vec2<i32>(i32(sIdx.x), 0), 0).r);\r\n        splatScale.y = exp(textureLoad(sogCodebookTex, vec2<i32>(i32(sIdx.y), 0), 0).r);\r\n        splatScale.z = exp(textureLoad(sogCodebookTex, vec2<i32>(i32(sIdx.z), 0), 0).r);\r\n    } else {\r\n        splatScale = exp(mix(uniforms.sogScalesMin, uniforms.sogScalesMax, sRaw));\r\n    }\r\n\r\n    let invSqrt2 : f32 = 0.70710678118;\r\n    let qabc : vec3<f32> = (qRaw.xyz - vec3<f32>(0.5)) * 2.0 * invSqrt2;\r\n    let qMode : i32 = i32(qRaw.w * 255.0 + 0.5) - 252;\r\n    let qd : f32 = sqrt(max(0.0, 1.0 - dot(qabc, qabc)));\r\n    var quat : vec4<f32>;\r\n    if (qMode == 0) {\r\n        quat = vec4<f32>(qd, qabc.x, qabc.y, qabc.z);\r\n    } else if (qMode == 1) {\r\n        quat = vec4<f32>(qabc.x, qd, qabc.y, qabc.z);\r\n    } else if (qMode == 2) {\r\n        quat = vec4<f32>(qabc.x, qabc.y, qd, qabc.z);\r\n    } else {\r\n        quat = vec4<f32>(qabc.x, qabc.y, qabc.z, qd);\r\n    }\r\n\r\n    let qw : f32 = quat.x;\r\n    let qx : f32 = quat.y;\r\n    let qy : f32 = quat.z;\r\n    let qz : f32 = quat.w;\r\n    let R : mat3x3<f32> = mat3x3<f32>(\r\n        1.0 - 2.0 * (qy * qy + qz * qz), 2.0 * (qx * qy + qw * qz), 2.0 * (qx * qz - qw * qy),\r\n        2.0 * (qx * qy - qw * qz), 1.0 - 2.0 * (qx * qx + qz * qz), 2.0 * (qy * qz + qw * qx),\r\n        2.0 * (qx * qz + qw * qy), 2.0 * (qy * qz - qw * qx), 1.0 - 2.0 * (qx * qx + qy * qy)\r\n    );\r\n    let S2 : mat3x3<f32> = mat3x3<f32>(\r\n        4.0 * splatScale.x * splatScale.x, 0.0, 0.0,\r\n        0.0, 4.0 * splatScale.y * splatScale.y, 0.0,\r\n        0.0, 0.0, 4.0 * splatScale.z * splatScale.z\r\n    );\r\n    let Sigma : mat3x3<f32> = R * S2 * transpose(R);\r\n\r\n    let SH_C0 : f32 = 0.28209479177387814;\r\n    var colRgb : vec3<f32>;\r\n    var colA : f32;\r\n    if (uniforms.uVersion == 2) {\r\n        var c3 : vec3<f32>;\r\n        c3.x = textureLoad(sogCodebookTex, vec2<i32>(256 + i32(c0.x * 255.0 + 0.5), 0), 0).r;\r\n        c3.y = textureLoad(sogCodebookTex, vec2<i32>(256 + i32(c0.y * 255.0 + 0.5), 0), 0).r;\r\n        c3.z = textureLoad(sogCodebookTex, vec2<i32>(256 + i32(c0.z * 255.0 + 0.5), 0), 0).r;\r\n        colRgb = vec3<f32>(0.5) + c3 * SH_C0;\r\n        colA = c0.w;\r\n    } else {\r\n        let cLerp : vec4<f32> = mix(uniforms.sogSh0Min, uniforms.sogSh0Max, c0);\r\n        colRgb = vec3<f32>(0.5) + cLerp.xyz * SH_C0;\r\n        colA = 1.0 / (1.0 + exp(-cLerp.w));\r\n    }\r\n\r\n    fragmentOutputs.fragData0 = vec4<f32>(center, 1.0);\r\n    fragmentOutputs.fragData1 = vec4<f32>(Sigma[0][0], Sigma[0][1], Sigma[0][2], Sigma[1][1]);\r\n    fragmentOutputs.fragData2 = vec4<f32>(Sigma[1][2], Sigma[2][2], 0.0, 0.0);\r\n    fragmentOutputs.fragData3 = vec4<f32>(colRgb, colA);\r\n}\r\n`;\r\n"]}

package/SPLAT/index.d.ts

@@ -1,2 +1,3 @@
 export * from "./splatLoadingOptions.js";
 export * from "./splatFileLoader.js";
+export * from "./gaussianSplattingStream.js";

package/SPLAT/index.js

@@ -1,4 +1,5 @@
 /* eslint-disable @typescript-eslint/no-restricted-imports */
 export * from "./splatLoadingOptions.js";
 export * from "./splatFileLoader.js";
+export * from "./gaussianSplattingStream.js";
 //# sourceMappingURL=index.js.map

package/SPLAT/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../dev/loaders/src/SPLAT/index.ts"],"names":[],"mappings":"AAAA,6DAA6D;AAC7D,cAAc,uBAAuB,CAAC;AACtC,cAAc,mBAAmB,CAAC","sourcesContent":["/* eslint-disable @typescript-eslint/no-restricted-imports */\r\nexport * from \"./splatLoadingOptions\";\r\nexport * from \"./splatFileLoader\";\r\n"]}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../dev/loaders/src/SPLAT/index.ts"],"names":[],"mappings":"AAAA,6DAA6D;AAC7D,cAAc,uBAAuB,CAAC;AACtC,cAAc,mBAAmB,CAAC;AAClC,cAAc,2BAA2B,CAAC","sourcesContent":["/* eslint-disable @typescript-eslint/no-restricted-imports */\r\nexport * from \"./splatLoadingOptions\";\r\nexport * from \"./splatFileLoader\";\r\nexport * from \"./gaussianSplattingStream\";\r\n"]}

package/SPLAT/sog.d.ts

@@ -1,5 +1,6 @@
 import { type Scene } from "@babylonjs/core/scene.js";
 import { type IParsedSplat } from "./splatDefs.js";
+import "@babylonjs/core/Engines/Extensions/engine.dynamicTexture.js";
 /**
  * Definition of a SOG data file
  */
@@ -88,6 +89,10 @@ export declare function ParseSogMeta(dataOrFiles: SOGRootData | Map<string, Uint
  * @param dataOrFiles Either the SOGRootData or a Map of filenames to Uint8Array file data (including meta.json)
  * @param rootUrl Base URL to load webp files from (if dataOrFiles is SOGRootData)
  * @param scene The Babylon.js scene
+ * @param computeCpuPositions When true (default), means_l/means_u are read back on the CPU and `pack.positions`
+ *   is decoded for the sort worker / bounding box. Pass false when the caller will instead read the decoded
+ *   centers back from the GPU work buffer — then every attribute (including means) uses the fast direct
+ *   ImageBitmap upload (no `getImageData` readback) and `pack.positions` is left empty.
  * @returns Parsed splat info with `sogTextures` populated.
  */
-export declare function ParseSogMetaAsTextures(dataOrFiles: SOGRootData | Map<string, Uint8Array>, rootUrl: string, scene: Scene): Promise<IParsedSplat>;
+export declare function ParseSogMetaAsTextures(dataOrFiles: SOGRootData | Map<string, Uint8Array>, rootUrl: string, scene: Scene, computeCpuPositions?: boolean): Promise<IParsedSplat>;

package/SPLAT/sog.js

@@ -2,6 +2,10 @@ import { AllocateShBuffers } from "@babylonjs/core/Meshes/GaussianSplatting/gaus
 import { Scalar } from "@babylonjs/core/Maths/math.scalar.js";
 import { RawTexture } from "@babylonjs/core/Materials/Textures/rawTexture.js";
 import { Constants } from "@babylonjs/core/Engines/constants.js";
+import { Tools } from "@babylonjs/core/Misc/tools.js";
+// updateDynamicTexture is a prototype-augmented engine extension; import its side effect so the ImageBitmap
+// fast path in LoadSogTextureDirectAsync doesn't hit an undefined method under tree-shaken/pure engine builds.
+import "@babylonjs/core/Engines/Extensions/engine.dynamicTexture.js";
 const SH_C0 = 0.28209479177387814;
 async function LoadWebpImageData(rootUrlOrData, filename, engine) {
     const promise = new Promise((resolve, reject) => {
@@ -23,7 +27,7 @@ async function LoadWebpImageData(rootUrlOrData, filename, engine) {
                 ctx.drawImage(image, 0, 0);
                 // Extract pixel data (RGBA per pixel)
                 const imageData = ctx.getImageData(0, 0, canvas.width, canvas.height);
-                resolve({ bits: new Uint8Array(imageData.data.buffer), width: imageData.width });
+                resolve({ bits: new Uint8Array(imageData.data.buffer), width: imageData.width, height: imageData.height });
             }
             catch (error) {
                 // eslint-disable-next-line @typescript-eslint/prefer-promise-reject-errors
@@ -296,6 +300,59 @@ function CreateSogTexture(scene, bits, width, height) {
     tex.wrapV = Constants.TEXTURE_CLAMP_ADDRESSMODE;
     return tex;
 }
+function CreateSogTextureFromImage(scene, image) {
+    return CreateSogTexture(scene, image.bits, image.width, image.height);
+}
+/**
+ * Loads a SOG attribute image straight onto a GPU texture using `createImageBitmap` (decoded off the main
+ * thread, with `premultiplyAlpha`/`colorSpaceConversion` set to "none" so the raw data bytes are preserved)
+ * and a direct `texImage2D` upload — avoiding the `<img>` + 2D-canvas `getImageData` readback that stalls the
+ * frame. Falls back to the canvas path when `createImageBitmap` is unavailable or fails. Use only for textures
+ * whose pixels are never read back on the CPU (scales, quats, sh0, shN); means_l/means_u still go through the
+ * readback path because their bytes are needed to decode positions for the sort worker.
+ * @param rootUrlOrData base URL (string) or the raw file bytes (Uint8Array)
+ * @param filename file name (used only with a URL)
+ * @param scene hosting scene
+ * @returns a GPU texture holding the raw image bytes
+ */
+async function LoadSogTextureDirectAsync(rootUrlOrData, filename, scene) {
+    const engine = scene.getEngine();
+    if (typeof createImageBitmap === "function") {
+        try {
+            // A typed blob is required: createImageBitmap can fail to decode a typeless blob (and the
+            // content-type is lost when loading via LoadFileAsync), which would force the slow canvas fallback.
+            const mimeType = filename.toLowerCase().endsWith(".png") ? "image/png" : "image/webp";
+            let blob;
+            if (typeof rootUrlOrData === "string") {
+                const buffer = (await Tools.LoadFileAsync(rootUrlOrData + filename, true));
+                blob = new Blob([buffer], { type: mimeType });
+            }
+            else {
+                blob = new Blob([rootUrlOrData], { type: mimeType });
+            }
+            const bitmap = await createImageBitmap(blob, { premultiplyAlpha: "none", colorSpaceConversion: "none" });
+            try {
+                const tex = new RawTexture(null, bitmap.width, bitmap.height, Constants.TEXTUREFORMAT_RGBA, scene, false, false, Constants.TEXTURE_NEAREST_SAMPLINGMODE, Constants.TEXTURETYPE_UNSIGNED_BYTE);
+                tex.wrapU = Constants.TEXTURE_CLAMP_ADDRESSMODE;
+                tex.wrapV = Constants.TEXTURE_CLAMP_ADDRESSMODE;
+                const internal = tex.getInternalTexture();
+                if (internal) {
+                    // invertY=false / premulAlpha=false keep the byte layout identical to the canvas path.
+                    engine.updateDynamicTexture(internal, bitmap, false, false);
+                }
+                return tex;
+            }
+            finally {
+                bitmap.close();
+            }
+        }
+        catch {
+            // Fall through to the canvas readback path below.
+        }
+    }
+    const image = await LoadWebpImageData(rootUrlOrData, filename, engine);
+    return CreateSogTextureFromImage(scene, image);
+}
 function DecodeSogPositions(data, meansl, meansu, splatCount) {
     const unlog = (n) => Math.sign(n) * (Math.exp(Math.abs(n)) - 1);
     if (!Array.isArray(data.means.mins) || !Array.isArray(data.means.maxs)) {
@@ -320,10 +377,14 @@ function DecodeSogPositions(data, meansl, meansu, splatCount) {
  * @param dataOrFiles Either the SOGRootData or a Map of filenames to Uint8Array file data (including meta.json)
  * @param rootUrl Base URL to load webp files from (if dataOrFiles is SOGRootData)
  * @param scene The Babylon.js scene
+ * @param computeCpuPositions When true (default), means_l/means_u are read back on the CPU and `pack.positions`
+ *   is decoded for the sort worker / bounding box. Pass false when the caller will instead read the decoded
+ *   centers back from the GPU work buffer — then every attribute (including means) uses the fast direct
+ *   ImageBitmap upload (no `getImageData` readback) and `pack.positions` is left empty.
  * @returns Parsed splat info with `sogTextures` populated.
  */
 // eslint-disable-next-line @typescript-eslint/no-restricted-types
-export async function ParseSogMetaAsTextures(dataOrFiles, rootUrl, scene) {
+export async function ParseSogMetaAsTextures(dataOrFiles, rootUrl, scene, computeCpuPositions = true) {
     let data;
     let files;
     if (dataOrFiles instanceof Map) {
@@ -337,37 +398,62 @@ export async function ParseSogMetaAsTextures(dataOrFiles, rootUrl, scene) {
     else {
         data = dataOrFiles;
     }
-    const urls = [...data.means.files, ...data.scales.files, ...data.quats.files, ...data.sh0.files];
-    if (data.shN) {
-        urls.push(...data.shN.files);
-    }
-    const images = await Promise.all(urls.map(async (fileName) => {
+    // Attribute textures (scales/quats/sh0/shN) are only sampled on the GPU, so they always upload straight
+    // from a decoded ImageBitmap (no getImageData readback). means_l/means_u additionally need their CPU bytes
+    // when computeCpuPositions is set (to decode positions for the sort worker) — those go through the
+    // <img>+canvas path; otherwise means also use the fast direct upload. All loads run in parallel.
+    const loadMeansImageAsync = async (fileName) => {
         if (files && files.has(fileName)) {
             return await LoadWebpImageData(files.get(fileName), fileName, scene.getEngine());
         }
         return await LoadWebpImageData(rootUrl, fileName, scene.getEngine());
-    }));
+    };
+    const loadGpuTextureAsync = async (fileName) => {
+        if (files && files.has(fileName)) {
+            return await LoadSogTextureDirectAsync(files.get(fileName), fileName, scene);
+        }
+        return await LoadSogTextureDirectAsync(rootUrl, fileName, scene);
+    };
+    const gpuFiles = [...data.scales.files, ...data.quats.files, ...data.sh0.files, ...(data.shN?.files ?? [])];
+    let meansL;
+    let meansU;
+    let meansWidth;
+    let meansHeight;
+    let meansImages = null;
+    let gpuTextures;
+    if (computeCpuPositions) {
+        const [images, gpu] = await Promise.all([Promise.all(data.means.files.map(loadMeansImageAsync)), Promise.all(gpuFiles.map(loadGpuTextureAsync))]);
+        meansImages = [images[0], images[1]];
+        gpuTextures = gpu;
+        meansL = CreateSogTextureFromImage(scene, images[0]);
+        meansU = CreateSogTextureFromImage(scene, images[1]);
+        meansWidth = images[0].width;
+        meansHeight = images[0].height;
+    }
+    else {
+        const [meansTex, gpu] = await Promise.all([Promise.all(data.means.files.map(loadGpuTextureAsync)), Promise.all(gpuFiles.map(loadGpuTextureAsync))]);
+        gpuTextures = gpu;
+        meansL = meansTex[0];
+        meansU = meansTex[1];
+        const size = meansL.getSize();
+        meansWidth = size.width;
+        meansHeight = size.height;
+    }
     const splatCount = data.count ?? data.means.shape[0];
-    const engine = scene.getEngine();
-    const splatTextureWidth = Math.min(splatCount, engine.getCaps().maxTextureSize);
-    const splatTextureHeight = Math.ceil(splatCount / splatTextureWidth);
-    // means_l, means_u, scales, quats, sh0 share the same (w,h)
-    const meansL = CreateSogTexture(scene, images[0].bits, splatTextureWidth, splatTextureHeight);
-    const meansU = CreateSogTexture(scene, images[1].bits, splatTextureWidth, splatTextureHeight);
-    const scales = CreateSogTexture(scene, images[2].bits, splatTextureWidth, splatTextureHeight);
-    const quats = CreateSogTexture(scene, images[3].bits, splatTextureWidth, splatTextureHeight);
-    const sh0 = CreateSogTexture(scene, images[4].bits, splatTextureWidth, splatTextureHeight);
+    const splatTexelCount = meansWidth * meansHeight;
+    if (splatTexelCount < splatCount) {
+        throw new Error(`SOG texture contains ${splatTexelCount} texels, but metadata references ${splatCount} splats.`);
+    }
+    const scales = gpuTextures[0];
+    const quats = gpuTextures[1];
+    const sh0 = gpuTextures[2];
     let shCentroids;
     let shLabels;
     let shCoeffCount = 0;
     let shDegree = 0;
-    if (data.shN && images.length >= 7) {
-        const centroidsImage = images[5];
-        const labelsImage = images[6];
-        const centroidsHeight = centroidsImage.bits.length / 4 / centroidsImage.width;
-        shCentroids = CreateSogTexture(scene, centroidsImage.bits, centroidsImage.width, centroidsHeight);
-        const labelsHeight = labelsImage.bits.length / 4 / labelsImage.width;
-        shLabels = CreateSogTexture(scene, labelsImage.bits, labelsImage.width, labelsHeight);
+    if (data.shN && gpuTextures.length >= 5) {
+        shCentroids = gpuTextures[3];
+        shLabels = gpuTextures[4];
         shCoeffCount = data.shN.bands ? (data.shN.bands + 1) ** 2 - 1 : data.shN.shape[1] / 3;
         shDegree = data.shN.bands ?? Math.round(Math.sqrt(shCoeffCount + 1) - 1);
     }
@@ -412,7 +498,7 @@ export async function ParseSogMetaAsTextures(dataOrFiles, rootUrl, scene) {
         shnMin: typeof data.shN?.mins === "number" ? data.shN.mins : undefined,
         shnMax: typeof data.shN?.maxs === "number" ? data.shN.maxs : undefined,
         shCoeffCount,
-        positions: DecodeSogPositions(data, images[0].bits, images[1].bits, splatCount),
+        positions: meansImages ? DecodeSogPositions(data, meansImages[0].bits, meansImages[1].bits, splatCount) : new Float32Array(0),
     };
     return { mode: 0 /* Mode.Splat */, data: new ArrayBuffer(0), hasVertexColors: false, shDegree, sogTextures: pack };
 }