@onerjs/loaders 8.53.5 → 8.53.7

package/SPLAT/gaussianSplattingWorkBufferShaders.js

@@ -0,0 +1,337 @@
+/** 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);
+}
+`;
+/**
+ * Shader name for the work-buffer relayout (defrag/compaction) copy pass.
+ */
+export 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 const GaussianSplattingWorkBufferRelayoutFragmentShaderGLSL = `precision highp float;
+precision highp int;
+
+uniform sampler2D uMapTex;
+uniform sampler2D uSrc0;
+uniform sampler2D uSrc1;
+uniform sampler2D uSrc2;
+uniform sampler2D uSrc3;
+uniform int uDstWidth;
+uniform int uSrcWidth;
+uniform int uUseMap;
+
+layout(location = 0) out vec4 glFragData[4];
+
+void main() {
+    ivec2 p = ivec2(gl_FragCoord.xy);
+    int srcIdx;
+    if (uUseMap == 1) {
+        float m = texelFetch(uMapTex, p, 0).r;
+        if (m < 0.0) {
+            discard;
+        }
+        srcIdx = int(m + 0.5);
+    } else {
+        srcIdx = p.y * uDstWidth + p.x;
+    }
+    ivec2 s = ivec2(srcIdx - (srcIdx / uSrcWidth) * uSrcWidth, srcIdx / uSrcWidth);
+    glFragData[0] = texelFetch(uSrc0, s, 0);
+    glFragData[1] = texelFetch(uSrc1, s, 0);
+    glFragData[2] = texelFetch(uSrc2, s, 0);
+    glFragData[3] = texelFetch(uSrc3, s, 0);
+}
+`;
+/**
+ * Relayout copy fragment shader (WGSL/WebGPU) — same copy as the GLSL variant.
+ */
+export const GaussianSplattingWorkBufferRelayoutFragmentShaderWGSL = `
+var uMapTexSampler : sampler;
+var uMapTex : texture_2d<f32>;
+var uSrc0Sampler : sampler;
+var uSrc0 : texture_2d<f32>;
+var uSrc1Sampler : sampler;
+var uSrc1 : texture_2d<f32>;
+var uSrc2Sampler : sampler;
+var uSrc2 : texture_2d<f32>;
+var uSrc3Sampler : sampler;
+var uSrc3 : texture_2d<f32>;
+
+uniform uDstWidth : i32;
+uniform uSrcWidth : i32;
+uniform uUseMap : i32;
+
+@fragment
+fn main(input : FragmentInputs) -> FragmentOutputs {
+    let p : vec2<i32> = vec2<i32>(i32(fragmentInputs.position.x), i32(fragmentInputs.position.y));
+    var srcIdx : i32;
+    if (uniforms.uUseMap == 1) {
+        let m : f32 = textureLoad(uMapTex, p, 0).r;
+        if (m < 0.0) {
+            discard;
+        }
+        srcIdx = i32(m + 0.5);
+    } else {
+        srcIdx = p.y * uniforms.uDstWidth + p.x;
+    }
+    let s : vec2<i32> = vec2<i32>(srcIdx - (srcIdx / uniforms.uSrcWidth) * uniforms.uSrcWidth, srcIdx / uniforms.uSrcWidth);
+    fragmentOutputs.fragData0 = textureLoad(uSrc0, s, 0);
+    fragmentOutputs.fragData1 = textureLoad(uSrc1, s, 0);
+    fragmentOutputs.fragData2 = textureLoad(uSrc2, s, 0);
+    fragmentOutputs.fragData3 = textureLoad(uSrc3, s, 0);
+}
+`;
+//# 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;AAEF;;GAEG;AACH,MAAM,CAAC,MAAM,6CAA6C,GAAG,sBAAsB,CAAC;AAEpF;;;;;GAKG;AACH,MAAM,CAAC,MAAM,qDAAqD,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgCpE,CAAC;AAEF;;GAEG;AACH,MAAM,CAAC,MAAM,qDAAqD,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmCpE,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\r\n/**\r\n * Shader name for the work-buffer relayout (defrag/compaction) copy pass.\r\n */\r\nexport const GaussianSplattingWorkBufferRelayoutShaderName = \"gsWorkBufferRelayout\";\r\n\r\n/**\r\n * Relayout copy fragment shader (GLSL/WebGL2). Copies the four decoded work-buffer textures from a source\r\n * layout to a destination layout, one output texel per draw. In map mode (`uUseMap == 1`) each destination\r\n * texel reads its source splat index from `uMapTex` (R32F; a negative value marks a gap and is discarded so\r\n * the cleared destination stays zero). In identity mode the source texel equals the destination texel.\r\n */\r\nexport const GaussianSplattingWorkBufferRelayoutFragmentShaderGLSL = `precision highp float;\r\nprecision highp int;\r\n\r\nuniform sampler2D uMapTex;\r\nuniform sampler2D uSrc0;\r\nuniform sampler2D uSrc1;\r\nuniform sampler2D uSrc2;\r\nuniform sampler2D uSrc3;\r\nuniform int uDstWidth;\r\nuniform int uSrcWidth;\r\nuniform int uUseMap;\r\n\r\nlayout(location = 0) out vec4 glFragData[4];\r\n\r\nvoid main() {\r\n    ivec2 p = ivec2(gl_FragCoord.xy);\r\n    int srcIdx;\r\n    if (uUseMap == 1) {\r\n        float m = texelFetch(uMapTex, p, 0).r;\r\n        if (m < 0.0) {\r\n            discard;\r\n        }\r\n        srcIdx = int(m + 0.5);\r\n    } else {\r\n        srcIdx = p.y * uDstWidth + p.x;\r\n    }\r\n    ivec2 s = ivec2(srcIdx - (srcIdx / uSrcWidth) * uSrcWidth, srcIdx / uSrcWidth);\r\n    glFragData[0] = texelFetch(uSrc0, s, 0);\r\n    glFragData[1] = texelFetch(uSrc1, s, 0);\r\n    glFragData[2] = texelFetch(uSrc2, s, 0);\r\n    glFragData[3] = texelFetch(uSrc3, s, 0);\r\n}\r\n`;\r\n\r\n/**\r\n * Relayout copy fragment shader (WGSL/WebGPU) — same copy as the GLSL variant.\r\n */\r\nexport const GaussianSplattingWorkBufferRelayoutFragmentShaderWGSL = `\r\nvar uMapTexSampler : sampler;\r\nvar uMapTex : texture_2d<f32>;\r\nvar uSrc0Sampler : sampler;\r\nvar uSrc0 : texture_2d<f32>;\r\nvar uSrc1Sampler : sampler;\r\nvar uSrc1 : texture_2d<f32>;\r\nvar uSrc2Sampler : sampler;\r\nvar uSrc2 : texture_2d<f32>;\r\nvar uSrc3Sampler : sampler;\r\nvar uSrc3 : texture_2d<f32>;\r\n\r\nuniform uDstWidth : i32;\r\nuniform uSrcWidth : i32;\r\nuniform uUseMap : 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    var srcIdx : i32;\r\n    if (uniforms.uUseMap == 1) {\r\n        let m : f32 = textureLoad(uMapTex, p, 0).r;\r\n        if (m < 0.0) {\r\n            discard;\r\n        }\r\n        srcIdx = i32(m + 0.5);\r\n    } else {\r\n        srcIdx = p.y * uniforms.uDstWidth + p.x;\r\n    }\r\n    let s : vec2<i32> = vec2<i32>(srcIdx - (srcIdx / uniforms.uSrcWidth) * uniforms.uSrcWidth, srcIdx / uniforms.uSrcWidth);\r\n    fragmentOutputs.fragData0 = textureLoad(uSrc0, s, 0);\r\n    fragmentOutputs.fragData1 = textureLoad(uSrc1, s, 0);\r\n    fragmentOutputs.fragData2 = textureLoad(uSrc2, s, 0);\r\n    fragmentOutputs.fragData3 = textureLoad(uSrc3, s, 0);\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/pure.d.ts

@@ -0,0 +1,5 @@
+/** Pure barrel — re-exports only side-effect-free modules */
+export * from "./splatLoadingOptions.js";
+export * from "./splatFileLoader.pure.js";
+export * from "./gaussianSplattingStream.js";
+export * from "./sog.pure.js";

package/SPLAT/pure.js

@@ -0,0 +1,7 @@
+/** Pure barrel — re-exports only side-effect-free modules */
+/* eslint-disable @typescript-eslint/no-restricted-imports */
+export * from "./splatLoadingOptions.js";
+export * from "./splatFileLoader.pure.js";
+export * from "./gaussianSplattingStream.js";
+export * from "./sog.pure.js";
+//# sourceMappingURL=pure.js.map

package/SPLAT/pure.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pure.js","sourceRoot":"","sources":["../../../../dev/loaders/src/SPLAT/pure.ts"],"names":[],"mappings":"AAAA,6DAA6D;AAC7D,6DAA6D;AAC7D,cAAc,uBAAuB,CAAC;AACtC,cAAc,wBAAwB,CAAC;AACvC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,YAAY,CAAC","sourcesContent":["/** Pure barrel — re-exports only side-effect-free modules */\n/* eslint-disable @typescript-eslint/no-restricted-imports */\nexport * from \"./splatLoadingOptions\";\nexport * from \"./splatFileLoader.pure\";\nexport * from \"./gaussianSplattingStream\";\nexport * from \"./sog.pure\";\n"]}

package/SPLAT/sog.d.ts

@@ -1,93 +1,2 @@
-import { type Scene } from "@onerjs/core/scene.js";
-import { type IParsedSplat } from "./splatDefs.js";
-/**
- * Definition of a SOG data file
- */
-export interface SOGDataFile {
-    /**
-     * index 0 is number of splats index 1 is number of components per splat (3 for vec3, 4 for vec4, etc.)
-     */
-    shape: number[];
-    /**
-     * type of components
-     */
-    dtype: string;
-    /**
-     * min range of data
-     */
-    mins?: number | number[];
-    /**
-     * max range of data
-     */
-    maxs?: number | number[];
-    /**
-     * palette for indexed data (quantized)
-     */
-    codebook?: number[];
-    /**
-     * type of encoding
-     */
-    encoding?: string;
-    /**
-     * number of bits for quantization (if any)
-     */
-    quantization?: number;
-    /**
-     * webp file names
-     */
-    files: string[];
-    /**
-     * SH band count (if applicable)
-     */
-    bands?: number;
-}
-/**
- * Definition of the root SOG data file
- */
-export interface SOGRootData {
-    /**
-     * version of the SOG format
-     */
-    version?: number;
-    /**
-     * mean positions of the splats
-     */
-    means: SOGDataFile;
-    /**
-     * scales of the splats
-     */
-    scales: SOGDataFile;
-    /**
-     * quaternions of the splats
-     */
-    quats: SOGDataFile;
-    /**
-     * SH0 coefficients of the splats (base color)
-     */
-    sh0: SOGDataFile;
-    /**
-     *  Optional higher order SH coefficients of the splats (lighting information)
-     */
-    shN?: SOGDataFile;
-    /**
-     * number of splats (optional, can be inferred from means.shape[0])
-     */
-    count?: number;
-}
-/**
- * Parse SOG data from either a SOGRootData object (with webp files loaded from rootUrl) or from a Map of filenames to Uint8Array file data (including meta.json)
- * @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
- * @returns Parsed data
- */
-export declare function ParseSogMeta(dataOrFiles: SOGRootData | Map<string, Uint8Array>, rootUrl: string, scene: Scene): Promise<IParsedSplat>;
-/**
- * Parse SOG data and produce a set of GPU textures + dequantization parameters.
- * The shader will sample these raw RGBA8 textures and reconstruct positions/scales/rotations/colors/SH on the GPU.
- * @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
- * @returns Parsed splat info with `sogTextures` populated.
- */
-export declare function ParseSogMetaAsTextures(dataOrFiles: SOGRootData | Map<string, Uint8Array>, rootUrl: string, scene: Scene): Promise<IParsedSplat>;
+export * from "./sog.pure.js";
+import "@onerjs/core/Engines/Extensions/engine.dynamicTexture.js";