@babylonjs/loaders 9.19.1 → 9.20.1

package/SPLAT/gaussianSplattingWorkBufferShaders.js

@@ -252,6 +252,300 @@ fn main(input : FragmentInputs) -> FragmentOutputs {
     fragmentOutputs.fragData3 = vec4<f32>(colRgb, colA);
 }
 `;
+/**
+ * Shader name for the rotation/scale decode pass (the three half-float textures voxel-IBL shadowing consumes).
+ */
+export const GaussianSplattingWorkBufferRotationDecodeShaderName = "gsSogRotDecodeToWorkBuffer";
+/**
+ * Rotation/scale decode fragment shader (GLSL/WebGL2). Reconstructs each splat's rotation matrix R and scale and
+ * writes the three half-float textures the voxel shader samples (rotationsATexture/B/Scale). The layout lets the
+ * voxel shader reconstruct the same R and scale, so streamed splats get the same ellipsoid the draw path renders:
+ *   rotA     = (R col0.xyz, R col1.x)
+ *   rotB     = (R col1.yz, R col2.xy)
+ *   rotScale = (R col2.z, 2*scale.x, 2*scale.y, 2*scale.z)
+ */
+export const GaussianSplattingWorkBufferRotationDecodeFragmentShaderGLSL = `precision highp float;
+precision highp int;
+
+uniform sampler2D sogScalesTex;
+uniform sampler2D sogQuatsTex;
+uniform sampler2D sogCodebookTex;
+
+uniform vec3 sogScalesMin;
+uniform vec3 sogScalesMax;
+uniform int uVersion;
+uniform int uOffset;
+uniform int uCount;
+uniform int uDestWidth;
+uniform int uSrcWidth;
+
+layout(location = 0) out vec4 glFragData[3];
+
+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 sRaw = texelFetch(sogScalesTex, src, 0).xyz;
+    vec4 qRaw = texelFetch(sogQuatsTex, src, 0);
+
+    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));
+    }
+
+    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)
+    );
+
+    glFragData[0] = vec4(R[0], R[1].x);
+    glFragData[1] = vec4(R[1].y, R[1].z, R[2].x, R[2].y);
+    glFragData[2] = vec4(R[2].z, 2.0 * splatScale.x, 2.0 * splatScale.y, 2.0 * splatScale.z);
+}
+`;
+/**
+ * Rotation/scale decode fragment shader (WGSL/WebGPU) — same decode as the GLSL variant, writing 3 half-float MRT
+ * attachments.
+ */
+export const GaussianSplattingWorkBufferRotationDecodeFragmentShaderWGSL = `
+var sogScalesTexSampler : sampler;
+var sogScalesTex : texture_2d<f32>;
+var sogQuatsTexSampler : sampler;
+var sogQuatsTex : texture_2d<f32>;
+var sogCodebookTexSampler : sampler;
+var sogCodebookTex : texture_2d<f32>;
+
+uniform sogScalesMin : vec3<f32>;
+uniform sogScalesMax : vec3<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 sRaw : vec3<f32> = textureLoad(sogScalesTex, src, 0).xyz;
+    let qRaw : vec4<f32> = textureLoad(sogQuatsTex, src, 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)
+    );
+
+    fragmentOutputs.fragData0 = vec4<f32>(R[0], R[1].x);
+    fragmentOutputs.fragData1 = vec4<f32>(R[1].y, R[1].z, R[2].x, R[2].y);
+    fragmentOutputs.fragData2 = vec4<f32>(R[2].z, 2.0 * splatScale.x, 2.0 * splatScale.y, 2.0 * splatScale.z);
+}
+`;
+/**
+ * Shader name for the SOG higher-order SH decode pass (bakes one packed-u32 SH texture per pass).
+ */
+export const GaussianSplattingWorkBufferShDecodeShaderName = "gsSogShDecodeToWorkBuffer";
+/**
+ * SH decode fragment shader (GLSL/WebGL2). Decodes one SOG file's higher-order spherical-harmonics into one
+ * packed-u32 SH texture at the region offset, in the layout the draw path's `computeSHWeighted`/`decompose`
+ * expects (16 SH scalar-bytes per RGBA-u32 texel, little-endian; one texel per splat). Run once per SH texture
+ * (`uShTextureIndex` selects the 16 scalars written this pass). Coefficients this file lacks are written neutral
+ * (128 == 0 after `decompose`), so a lower-band file mixes correctly with higher-band ones.
+ */
+export const GaussianSplattingWorkBufferShDecodeFragmentShaderGLSL = `precision highp float;
+precision highp int;
+
+uniform sampler2D sogShLabelsTex;
+uniform sampler2D sogShCentroidsTex;
+uniform sampler2D sogCodebookTex;
+uniform float sogShnMin;
+uniform float sogShnMax;
+uniform int uVersion;
+uniform int uOffset;
+uniform int uCount;
+uniform int uDestWidth;
+uniform int uSrcWidth;
+uniform int uCoeffs;
+uniform int uShTextureIndex;
+
+layout(location = 0) out uvec4 outSh;
+
+void main() {
+    ivec2 p = ivec2(gl_FragCoord.xy);
+    int global = p.y * uDestWidth + p.x;
+    if (global < uOffset || global >= uOffset + uCount) {
+        discard;
+    }
+    int kLocal = global - uOffset;
+
+    // 16-bit label for this source splat (LSB in r, MSB in g), indexed over the labels texture's own width.
+    ivec2 lsz = textureSize(sogShLabelsTex, 0);
+    ivec2 lsrc = ivec2(kLocal - (kLocal / lsz.x) * lsz.x, kLocal / lsz.x);
+    vec4 labelRaw = texelFetch(sogShLabelsTex, lsrc, 0);
+    int n = int(labelRaw.r * 255.0 + 0.5) + int(labelRaw.g * 255.0 + 0.5) * 256;
+    int u = (n - (n / 64) * 64) * uCoeffs;
+    int v = n / 64;
+
+    uint packed0 = 0u;
+    uint packed1 = 0u;
+    uint packed2 = 0u;
+    uint packed3 = 0u;
+
+    for (int b = 0; b < 16; b++) {
+        int s = uShTextureIndex * 16 + b; // flat SH scalar index
+        int kc = s / 3;                    // higher-order coefficient (0-based)
+        int j = s - kc * 3;                // channel (0=r,1=g,2=b)
+        float byteVal = 128.0;             // neutral (decompose(128) ~= 0)
+        if (kc < uCoeffs) {
+            vec4 centroidRaw = texelFetch(sogShCentroidsTex, ivec2(u + kc, v), 0);
+            float ch = (j == 0) ? centroidRaw.r : ((j == 1) ? centroidRaw.g : centroidRaw.b);
+            float coeff;
+            if (uVersion == 2) {
+                int cidx = int(ch * 255.0 + 0.5);
+                coeff = texelFetch(sogCodebookTex, ivec2(512 + cidx, 0), 0).r;
+            } else {
+                coeff = mix(sogShnMin, sogShnMax, ch);
+            }
+            byteVal = clamp(coeff * 127.5 + 127.5, 0.0, 255.0);
+        }
+        uint bv = uint(byteVal + 0.5);
+        int comp = b / 4;
+        uint contrib = bv << uint((b - comp * 4) * 8);
+        if (comp == 0) { packed0 |= contrib; }
+        else if (comp == 1) { packed1 |= contrib; }
+        else if (comp == 2) { packed2 |= contrib; }
+        else { packed3 |= contrib; }
+    }
+    outSh = uvec4(packed0, packed1, packed2, packed3);
+}
+`;
+/**
+ * SH decode fragment shader (WGSL/WebGPU) — same as the GLSL variant. The integer output (`vec4<u32>` fragData)
+ * requires the WGSL processor's integer-fragData support.
+ */
+export const GaussianSplattingWorkBufferShDecodeFragmentShaderWGSL = `
+var sogShLabelsTexSampler : sampler;
+var sogShLabelsTex : texture_2d<f32>;
+var sogShCentroidsTexSampler : sampler;
+var sogShCentroidsTex : texture_2d<f32>;
+var sogCodebookTexSampler : sampler;
+var sogCodebookTex : texture_2d<f32>;
+
+uniform sogShnMin : f32;
+uniform sogShnMax : f32;
+uniform uVersion : i32;
+uniform uOffset : i32;
+uniform uCount : i32;
+uniform uDestWidth : i32;
+uniform uSrcWidth : i32;
+uniform uCoeffs : i32;
+uniform uShTextureIndex : 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 kLocal : i32 = global - uniforms.uOffset;
+
+    let lsz : vec2<i32> = vec2<i32>(textureDimensions(sogShLabelsTex, 0));
+    let lsrc : vec2<i32> = vec2<i32>(kLocal - (kLocal / lsz.x) * lsz.x, kLocal / lsz.x);
+    let labelRaw : vec4<f32> = textureLoad(sogShLabelsTex, lsrc, 0);
+    let n : i32 = i32(labelRaw.r * 255.0 + 0.5) + i32(labelRaw.g * 255.0 + 0.5) * 256;
+    let u : i32 = (n - (n / 64) * 64) * uniforms.uCoeffs;
+    let v : i32 = n / 64;
+
+    var packed : array<u32, 4> = array<u32, 4>(0u, 0u, 0u, 0u);
+
+    for (var b : i32 = 0; b < 16; b = b + 1) {
+        let s : i32 = uniforms.uShTextureIndex * 16 + b;
+        let kc : i32 = s / 3;
+        let j : i32 = s - kc * 3;
+        var byteVal : f32 = 128.0;
+        if (kc < uniforms.uCoeffs) {
+            let centroidRaw : vec4<f32> = textureLoad(sogShCentroidsTex, vec2<i32>(u + kc, v), 0);
+            var ch : f32 = centroidRaw.b;
+            if (j == 0) { ch = centroidRaw.r; } else if (j == 1) { ch = centroidRaw.g; }
+            var coeff : f32;
+            if (uniforms.uVersion == 2) {
+                let cidx : i32 = i32(ch * 255.0 + 0.5);
+                coeff = textureLoad(sogCodebookTex, vec2<i32>(512 + cidx, 0), 0).r;
+            } else {
+                coeff = mix(uniforms.sogShnMin, uniforms.sogShnMax, ch);
+            }
+            byteVal = clamp(coeff * 127.5 + 127.5, 0.0, 255.0);
+        }
+        let bv : u32 = u32(byteVal + 0.5);
+        let comp : i32 = b / 4;
+        packed[comp] = packed[comp] | (bv << u32((b - comp * 4) * 8));
+    }
+    fragmentOutputs.fragData0 = vec4<u32>(packed[0], packed[1], packed[2], packed[3]);
+}
+`;
 /**
  * Shader name for the work-buffer relayout (defrag/compaction) copy pass.
  */
@@ -273,6 +567,11 @@ uniform sampler2D uSrc3;
 uniform int uDstWidth;
 uniform int uSrcWidth;
 uniform int uUseMap;
+// Region-scoped relayout (hosted compound atlas), both default 0 (standalone square path unchanged):
+//   uSrcBaseOffset — added to the map's (region-local) source index so pass 1 reads the correct GLOBAL atlas texel.
+//   uDstBaseRow    — subtracted from the atlas destination row so pass 2's identity copy reads the region-local temp.
+uniform int uSrcBaseOffset;
+uniform int uDstBaseRow;
 
 layout(location = 0) out vec4 glFragData[4];
 
@@ -284,9 +583,9 @@ void main() {
         if (m < 0.0) {
             discard;
         }
-        srcIdx = int(m + 0.5);
+        srcIdx = uSrcBaseOffset + int(m + 0.5);
     } else {
-        srcIdx = p.y * uDstWidth + p.x;
+        srcIdx = (p.y - uDstBaseRow) * uDstWidth + p.x;
     }
     ivec2 s = ivec2(srcIdx - (srcIdx / uSrcWidth) * uSrcWidth, srcIdx / uSrcWidth);
     glFragData[0] = texelFetch(uSrc0, s, 0);
@@ -295,6 +594,165 @@ void main() {
     glFragData[3] = texelFetch(uSrc3, s, 0);
 }
 `;
+/**
+ * Shader name for the INTEGER (packed-u32 SH) relayout/backup copy pass. Same index/map/base math as the float
+ * relayout shader, but samples ONE integer SH source texture (`usampler2D`) and writes ONE integer attachment,
+ * so it moves one baked SH texture per pass (parallel to the four-out float copy).
+ */
+export const GaussianSplattingWorkBufferShCopyShaderName = "gsWorkBufferShCopy";
+/**
+ * Integer SH relayout/backup copy fragment shader (GLSL/WebGL2). Copies one packed-u32 SH texture from a source
+ * layout to a destination layout, one output texel per draw. Map mode (`uUseMap == 1`) reads each destination
+ * texel's source splat index from `uMapTex` (R32F; negative = gap, discarded); identity mode copies texel-for-texel
+ * (region backup/restore). `uSrcBaseOffset`/`uDstBaseRow` scope the copy to a hosted region's atlas rows (default 0).
+ */
+export const GaussianSplattingWorkBufferShCopyFragmentShaderGLSL = `precision highp float;
+precision highp int;
+precision highp usampler2D;
+
+uniform sampler2D uMapTex;
+uniform usampler2D uSrcSh;
+uniform int uDstWidth;
+uniform int uSrcWidth;
+uniform int uUseMap;
+uniform int uSrcBaseOffset;
+uniform int uDstBaseRow;
+
+layout(location = 0) out uvec4 outSh;
+
+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 = uSrcBaseOffset + int(m + 0.5);
+    } else {
+        srcIdx = (p.y - uDstBaseRow) * uDstWidth + p.x;
+    }
+    ivec2 s = ivec2(srcIdx - (srcIdx / uSrcWidth) * uSrcWidth, srcIdx / uSrcWidth);
+    outSh = texelFetch(uSrcSh, s, 0);
+}
+`;
+/**
+ * Integer SH relayout/backup copy fragment shader (WGSL/WebGPU) — same copy as the GLSL variant. The integer output
+ * (`vec4<u32>` fragData) requires the WGSL processor's integer-fragData support.
+ */
+export const GaussianSplattingWorkBufferShCopyFragmentShaderWGSL = `
+var uMapTexSampler : sampler;
+var uMapTex : texture_2d<f32>;
+// Integer source sampled via textureLoad only — NO paired sampler (a sampler on a Uint texture fails WebGPU
+// validation: "None of the supported sample types (Uint)"). Mirrors the draw shader's shTexture0 declaration.
+var uSrcSh : texture_2d<u32>;
+
+uniform uDstWidth : i32;
+uniform uSrcWidth : i32;
+uniform uUseMap : i32;
+uniform uSrcBaseOffset : i32;
+uniform uDstBaseRow : 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 = uniforms.uSrcBaseOffset + i32(m + 0.5);
+    } else {
+        srcIdx = (p.y - uniforms.uDstBaseRow) * uniforms.uDstWidth + p.x;
+    }
+    let s : vec2<i32> = vec2<i32>(srcIdx - (srcIdx / uniforms.uSrcWidth) * uniforms.uSrcWidth, srcIdx / uniforms.uSrcWidth);
+    // Wrap in an explicit vec4<u32> so the WGSL processor emits an integer fragData location (its detection keys
+    // off a literal vec4<u32>/vec4u in the assignment; a bare textureLoad(...) would default to vec4<f32>).
+    fragmentOutputs.fragData0 = vec4<u32>(textureLoad(uSrcSh, s, 0));
+}
+`;
+/**
+ * Shader name for the rotation/scale relayout/backup copy pass. Same index/map/base math as the four-out float
+ * relayout shader, but moves the THREE half-float rotation/scale textures in one pass (their own separate atlas).
+ */
+export const GaussianSplattingWorkBufferRotCopyShaderName = "gsWorkBufferRotCopy";
+/**
+ * Rotation/scale relayout/backup copy fragment shader (GLSL/WebGL2). Copies the three half-float rotation/scale
+ * textures from a source layout to a destination layout, one output texel per draw. Identical to the four-out
+ * float relayout shader but with three attachments (the rotation atlas has no fourth texture).
+ */
+export const GaussianSplattingWorkBufferRotCopyFragmentShaderGLSL = `precision highp float;
+precision highp int;
+
+uniform sampler2D uMapTex;
+uniform sampler2D uSrc0;
+uniform sampler2D uSrc1;
+uniform sampler2D uSrc2;
+uniform int uDstWidth;
+uniform int uSrcWidth;
+uniform int uUseMap;
+uniform int uSrcBaseOffset;
+uniform int uDstBaseRow;
+
+layout(location = 0) out vec4 glFragData[3];
+
+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 = uSrcBaseOffset + int(m + 0.5);
+    } else {
+        srcIdx = (p.y - uDstBaseRow) * 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);
+}
+`;
+/**
+ * Rotation/scale relayout/backup copy fragment shader (WGSL/WebGPU) — same copy as the GLSL variant, 3 attachments.
+ */
+export const GaussianSplattingWorkBufferRotCopyFragmentShaderWGSL = `
+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>;
+
+uniform uDstWidth : i32;
+uniform uSrcWidth : i32;
+uniform uUseMap : i32;
+uniform uSrcBaseOffset : i32;
+uniform uDstBaseRow : 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 = uniforms.uSrcBaseOffset + i32(m + 0.5);
+    } else {
+        srcIdx = (p.y - uniforms.uDstBaseRow) * 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);
+}
+`;
 /**
  * Relayout copy fragment shader (WGSL/WebGPU) — same copy as the GLSL variant.
  */
@@ -313,6 +771,9 @@ var uSrc3 : texture_2d<f32>;
 uniform uDstWidth : i32;
 uniform uSrcWidth : i32;
 uniform uUseMap : i32;
+// Region-scoped relayout (hosted compound atlas), both default 0 (standalone square path unchanged).
+uniform uSrcBaseOffset : i32;
+uniform uDstBaseRow : i32;
 
 @fragment
 fn main(input : FragmentInputs) -> FragmentOutputs {
@@ -323,9 +784,9 @@ fn main(input : FragmentInputs) -> FragmentOutputs {
         if (m < 0.0) {
             discard;
         }
-        srcIdx = i32(m + 0.5);
+        srcIdx = uniforms.uSrcBaseOffset + i32(m + 0.5);
     } else {
-        srcIdx = p.y * uniforms.uDstWidth + p.x;
+        srcIdx = (p.y - uniforms.uDstBaseRow) * 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);

package/SPLAT/gaussianSplattingWorkBufferShaders.js.map

@@ -1 +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"]}
+{"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,mDAAmD,GAAG,4BAA4B,CAAC;AAEhG;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,2DAA2D,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiE1E,CAAC;AAEF;;;GAGG;AACH,MAAM,CAAC,MAAM,2DAA2D,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoE1E,CAAC;AAEF;;GAEG;AACH,MAAM,CAAC,MAAM,6CAA6C,GAAG,2BAA2B,CAAC;AAEzF;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,qDAAqD,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkEpE,CAAC;AAEF;;;GAGG;AACH,MAAM,CAAC,MAAM,qDAAqD,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4DpE,CAAC;AAEF;;GAEG;AACH,MAAM,CAAC,MAAM,6CAA6C,GAAG,sBAAsB,CAAC;AAEpF;;;;;GAKG;AACH,MAAM,CAAC,MAAM,qDAAqD,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqCpE,CAAC;AAEF;;;;GAIG;AACH,MAAM,CAAC,MAAM,2CAA2C,GAAG,oBAAoB,CAAC;AAEhF;;;;;GAKG;AACH,MAAM,CAAC,MAAM,mDAAmD,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6BlE,CAAC;AAEF;;;GAGG;AACH,MAAM,CAAC,MAAM,mDAAmD,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+BlE,CAAC;AAEF;;;GAGG;AACH,MAAM,CAAC,MAAM,4CAA4C,GAAG,qBAAqB,CAAC;AAElF;;;;GAIG;AACH,MAAM,CAAC,MAAM,oDAAoD,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgCnE,CAAC;AAEF;;GAEG;AACH,MAAM,CAAC,MAAM,oDAAoD,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkCnE,CAAC;AAEF;;GAEG;AACH,MAAM,CAAC,MAAM,qDAAqD,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsCpE,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 rotation/scale decode pass (the three half-float textures voxel-IBL shadowing consumes).\r\n */\r\nexport const GaussianSplattingWorkBufferRotationDecodeShaderName = \"gsSogRotDecodeToWorkBuffer\";\r\n\r\n/**\r\n * Rotation/scale decode fragment shader (GLSL/WebGL2). Reconstructs each splat's rotation matrix R and scale and\r\n * writes the three half-float textures the voxel shader samples (rotationsATexture/B/Scale). The layout lets the\r\n * voxel shader reconstruct the same R and scale, so streamed splats get the same ellipsoid the draw path renders:\r\n *   rotA     = (R col0.xyz, R col1.x)\r\n *   rotB     = (R col1.yz, R col2.xy)\r\n *   rotScale = (R col2.z, 2*scale.x, 2*scale.y, 2*scale.z)\r\n */\r\nexport const GaussianSplattingWorkBufferRotationDecodeFragmentShaderGLSL = `precision highp float;\r\nprecision highp int;\r\n\r\nuniform sampler2D sogScalesTex;\r\nuniform sampler2D sogQuatsTex;\r\nuniform sampler2D sogCodebookTex;\r\n\r\nuniform vec3 sogScalesMin;\r\nuniform vec3 sogScalesMax;\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[3];\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 sRaw = texelFetch(sogScalesTex, src, 0).xyz;\r\n    vec4 qRaw = texelFetch(sogQuatsTex, src, 0);\r\n\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    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\r\n    glFragData[0] = vec4(R[0], R[1].x);\r\n    glFragData[1] = vec4(R[1].y, R[1].z, R[2].x, R[2].y);\r\n    glFragData[2] = vec4(R[2].z, 2.0 * splatScale.x, 2.0 * splatScale.y, 2.0 * splatScale.z);\r\n}\r\n`;\r\n\r\n/**\r\n * Rotation/scale decode fragment shader (WGSL/WebGPU) — same decode as the GLSL variant, writing 3 half-float MRT\r\n * attachments.\r\n */\r\nexport const GaussianSplattingWorkBufferRotationDecodeFragmentShaderWGSL = `\r\nvar sogScalesTexSampler : sampler;\r\nvar sogScalesTex : texture_2d<f32>;\r\nvar sogQuatsTexSampler : sampler;\r\nvar sogQuatsTex : texture_2d<f32>;\r\nvar sogCodebookTexSampler : sampler;\r\nvar sogCodebookTex : texture_2d<f32>;\r\n\r\nuniform sogScalesMin : vec3<f32>;\r\nuniform sogScalesMax : vec3<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 sRaw : vec3<f32> = textureLoad(sogScalesTex, src, 0).xyz;\r\n    let qRaw : vec4<f32> = textureLoad(sogQuatsTex, src, 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\r\n    fragmentOutputs.fragData0 = vec4<f32>(R[0], R[1].x);\r\n    fragmentOutputs.fragData1 = vec4<f32>(R[1].y, R[1].z, R[2].x, R[2].y);\r\n    fragmentOutputs.fragData2 = vec4<f32>(R[2].z, 2.0 * splatScale.x, 2.0 * splatScale.y, 2.0 * splatScale.z);\r\n}\r\n`;\r\n\r\n/**\r\n * Shader name for the SOG higher-order SH decode pass (bakes one packed-u32 SH texture per pass).\r\n */\r\nexport const GaussianSplattingWorkBufferShDecodeShaderName = \"gsSogShDecodeToWorkBuffer\";\r\n\r\n/**\r\n * SH decode fragment shader (GLSL/WebGL2). Decodes one SOG file's higher-order spherical-harmonics into one\r\n * packed-u32 SH texture at the region offset, in the layout the draw path's `computeSHWeighted`/`decompose`\r\n * expects (16 SH scalar-bytes per RGBA-u32 texel, little-endian; one texel per splat). Run once per SH texture\r\n * (`uShTextureIndex` selects the 16 scalars written this pass). Coefficients this file lacks are written neutral\r\n * (128 == 0 after `decompose`), so a lower-band file mixes correctly with higher-band ones.\r\n */\r\nexport const GaussianSplattingWorkBufferShDecodeFragmentShaderGLSL = `precision highp float;\r\nprecision highp int;\r\n\r\nuniform sampler2D sogShLabelsTex;\r\nuniform sampler2D sogShCentroidsTex;\r\nuniform sampler2D sogCodebookTex;\r\nuniform float sogShnMin;\r\nuniform float sogShnMax;\r\nuniform int uVersion;\r\nuniform int uOffset;\r\nuniform int uCount;\r\nuniform int uDestWidth;\r\nuniform int uSrcWidth;\r\nuniform int uCoeffs;\r\nuniform int uShTextureIndex;\r\n\r\nlayout(location = 0) out uvec4 outSh;\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 kLocal = global - uOffset;\r\n\r\n    // 16-bit label for this source splat (LSB in r, MSB in g), indexed over the labels texture's own width.\r\n    ivec2 lsz = textureSize(sogShLabelsTex, 0);\r\n    ivec2 lsrc = ivec2(kLocal - (kLocal / lsz.x) * lsz.x, kLocal / lsz.x);\r\n    vec4 labelRaw = texelFetch(sogShLabelsTex, lsrc, 0);\r\n    int n = int(labelRaw.r * 255.0 + 0.5) + int(labelRaw.g * 255.0 + 0.5) * 256;\r\n    int u = (n - (n / 64) * 64) * uCoeffs;\r\n    int v = n / 64;\r\n\r\n    uint packed0 = 0u;\r\n    uint packed1 = 0u;\r\n    uint packed2 = 0u;\r\n    uint packed3 = 0u;\r\n\r\n    for (int b = 0; b < 16; b++) {\r\n        int s = uShTextureIndex * 16 + b; // flat SH scalar index\r\n        int kc = s / 3;                    // higher-order coefficient (0-based)\r\n        int j = s - kc * 3;                // channel (0=r,1=g,2=b)\r\n        float byteVal = 128.0;             // neutral (decompose(128) ~= 0)\r\n        if (kc < uCoeffs) {\r\n            vec4 centroidRaw = texelFetch(sogShCentroidsTex, ivec2(u + kc, v), 0);\r\n            float ch = (j == 0) ? centroidRaw.r : ((j == 1) ? centroidRaw.g : centroidRaw.b);\r\n            float coeff;\r\n            if (uVersion == 2) {\r\n                int cidx = int(ch * 255.0 + 0.5);\r\n                coeff = texelFetch(sogCodebookTex, ivec2(512 + cidx, 0), 0).r;\r\n            } else {\r\n                coeff = mix(sogShnMin, sogShnMax, ch);\r\n            }\r\n            byteVal = clamp(coeff * 127.5 + 127.5, 0.0, 255.0);\r\n        }\r\n        uint bv = uint(byteVal + 0.5);\r\n        int comp = b / 4;\r\n        uint contrib = bv << uint((b - comp * 4) * 8);\r\n        if (comp == 0) { packed0 |= contrib; }\r\n        else if (comp == 1) { packed1 |= contrib; }\r\n        else if (comp == 2) { packed2 |= contrib; }\r\n        else { packed3 |= contrib; }\r\n    }\r\n    outSh = uvec4(packed0, packed1, packed2, packed3);\r\n}\r\n`;\r\n\r\n/**\r\n * SH decode fragment shader (WGSL/WebGPU) — same as the GLSL variant. The integer output (`vec4<u32>` fragData)\r\n * requires the WGSL processor's integer-fragData support.\r\n */\r\nexport const GaussianSplattingWorkBufferShDecodeFragmentShaderWGSL = `\r\nvar sogShLabelsTexSampler : sampler;\r\nvar sogShLabelsTex : texture_2d<f32>;\r\nvar sogShCentroidsTexSampler : sampler;\r\nvar sogShCentroidsTex : texture_2d<f32>;\r\nvar sogCodebookTexSampler : sampler;\r\nvar sogCodebookTex : texture_2d<f32>;\r\n\r\nuniform sogShnMin : f32;\r\nuniform sogShnMax : f32;\r\nuniform uVersion : i32;\r\nuniform uOffset : i32;\r\nuniform uCount : i32;\r\nuniform uDestWidth : i32;\r\nuniform uSrcWidth : i32;\r\nuniform uCoeffs : i32;\r\nuniform uShTextureIndex : 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 kLocal : i32 = global - uniforms.uOffset;\r\n\r\n    let lsz : vec2<i32> = vec2<i32>(textureDimensions(sogShLabelsTex, 0));\r\n    let lsrc : vec2<i32> = vec2<i32>(kLocal - (kLocal / lsz.x) * lsz.x, kLocal / lsz.x);\r\n    let labelRaw : vec4<f32> = textureLoad(sogShLabelsTex, lsrc, 0);\r\n    let n : i32 = i32(labelRaw.r * 255.0 + 0.5) + i32(labelRaw.g * 255.0 + 0.5) * 256;\r\n    let u : i32 = (n - (n / 64) * 64) * uniforms.uCoeffs;\r\n    let v : i32 = n / 64;\r\n\r\n    var packed : array<u32, 4> = array<u32, 4>(0u, 0u, 0u, 0u);\r\n\r\n    for (var b : i32 = 0; b < 16; b = b + 1) {\r\n        let s : i32 = uniforms.uShTextureIndex * 16 + b;\r\n        let kc : i32 = s / 3;\r\n        let j : i32 = s - kc * 3;\r\n        var byteVal : f32 = 128.0;\r\n        if (kc < uniforms.uCoeffs) {\r\n            let centroidRaw : vec4<f32> = textureLoad(sogShCentroidsTex, vec2<i32>(u + kc, v), 0);\r\n            var ch : f32 = centroidRaw.b;\r\n            if (j == 0) { ch = centroidRaw.r; } else if (j == 1) { ch = centroidRaw.g; }\r\n            var coeff : f32;\r\n            if (uniforms.uVersion == 2) {\r\n                let cidx : i32 = i32(ch * 255.0 + 0.5);\r\n                coeff = textureLoad(sogCodebookTex, vec2<i32>(512 + cidx, 0), 0).r;\r\n            } else {\r\n                coeff = mix(uniforms.sogShnMin, uniforms.sogShnMax, ch);\r\n            }\r\n            byteVal = clamp(coeff * 127.5 + 127.5, 0.0, 255.0);\r\n        }\r\n        let bv : u32 = u32(byteVal + 0.5);\r\n        let comp : i32 = b / 4;\r\n        packed[comp] = packed[comp] | (bv << u32((b - comp * 4) * 8));\r\n    }\r\n    fragmentOutputs.fragData0 = vec4<u32>(packed[0], packed[1], packed[2], packed[3]);\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// Region-scoped relayout (hosted compound atlas), both default 0 (standalone square path unchanged):\r\n//   uSrcBaseOffset — added to the map's (region-local) source index so pass 1 reads the correct GLOBAL atlas texel.\r\n//   uDstBaseRow    — subtracted from the atlas destination row so pass 2's identity copy reads the region-local temp.\r\nuniform int uSrcBaseOffset;\r\nuniform int uDstBaseRow;\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 = uSrcBaseOffset + int(m + 0.5);\r\n    } else {\r\n        srcIdx = (p.y - uDstBaseRow) * 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 * Shader name for the INTEGER (packed-u32 SH) relayout/backup copy pass. Same index/map/base math as the float\r\n * relayout shader, but samples ONE integer SH source texture (`usampler2D`) and writes ONE integer attachment,\r\n * so it moves one baked SH texture per pass (parallel to the four-out float copy).\r\n */\r\nexport const GaussianSplattingWorkBufferShCopyShaderName = \"gsWorkBufferShCopy\";\r\n\r\n/**\r\n * Integer SH relayout/backup copy fragment shader (GLSL/WebGL2). Copies one packed-u32 SH texture from a source\r\n * layout to a destination layout, one output texel per draw. Map mode (`uUseMap == 1`) reads each destination\r\n * texel's source splat index from `uMapTex` (R32F; negative = gap, discarded); identity mode copies texel-for-texel\r\n * (region backup/restore). `uSrcBaseOffset`/`uDstBaseRow` scope the copy to a hosted region's atlas rows (default 0).\r\n */\r\nexport const GaussianSplattingWorkBufferShCopyFragmentShaderGLSL = `precision highp float;\r\nprecision highp int;\r\nprecision highp usampler2D;\r\n\r\nuniform sampler2D uMapTex;\r\nuniform usampler2D uSrcSh;\r\nuniform int uDstWidth;\r\nuniform int uSrcWidth;\r\nuniform int uUseMap;\r\nuniform int uSrcBaseOffset;\r\nuniform int uDstBaseRow;\r\n\r\nlayout(location = 0) out uvec4 outSh;\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 = uSrcBaseOffset + int(m + 0.5);\r\n    } else {\r\n        srcIdx = (p.y - uDstBaseRow) * uDstWidth + p.x;\r\n    }\r\n    ivec2 s = ivec2(srcIdx - (srcIdx / uSrcWidth) * uSrcWidth, srcIdx / uSrcWidth);\r\n    outSh = texelFetch(uSrcSh, s, 0);\r\n}\r\n`;\r\n\r\n/**\r\n * Integer SH relayout/backup copy fragment shader (WGSL/WebGPU) — same copy as the GLSL variant. The integer output\r\n * (`vec4<u32>` fragData) requires the WGSL processor's integer-fragData support.\r\n */\r\nexport const GaussianSplattingWorkBufferShCopyFragmentShaderWGSL = `\r\nvar uMapTexSampler : sampler;\r\nvar uMapTex : texture_2d<f32>;\r\n// Integer source sampled via textureLoad only — NO paired sampler (a sampler on a Uint texture fails WebGPU\r\n// validation: \"None of the supported sample types (Uint)\"). Mirrors the draw shader's shTexture0 declaration.\r\nvar uSrcSh : texture_2d<u32>;\r\n\r\nuniform uDstWidth : i32;\r\nuniform uSrcWidth : i32;\r\nuniform uUseMap : i32;\r\nuniform uSrcBaseOffset : i32;\r\nuniform uDstBaseRow : 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 = uniforms.uSrcBaseOffset + i32(m + 0.5);\r\n    } else {\r\n        srcIdx = (p.y - uniforms.uDstBaseRow) * 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    // Wrap in an explicit vec4<u32> so the WGSL processor emits an integer fragData location (its detection keys\r\n    // off a literal vec4<u32>/vec4u in the assignment; a bare textureLoad(...) would default to vec4<f32>).\r\n    fragmentOutputs.fragData0 = vec4<u32>(textureLoad(uSrcSh, s, 0));\r\n}\r\n`;\r\n\r\n/**\r\n * Shader name for the rotation/scale relayout/backup copy pass. Same index/map/base math as the four-out float\r\n * relayout shader, but moves the THREE half-float rotation/scale textures in one pass (their own separate atlas).\r\n */\r\nexport const GaussianSplattingWorkBufferRotCopyShaderName = \"gsWorkBufferRotCopy\";\r\n\r\n/**\r\n * Rotation/scale relayout/backup copy fragment shader (GLSL/WebGL2). Copies the three half-float rotation/scale\r\n * textures from a source layout to a destination layout, one output texel per draw. Identical to the four-out\r\n * float relayout shader but with three attachments (the rotation atlas has no fourth texture).\r\n */\r\nexport const GaussianSplattingWorkBufferRotCopyFragmentShaderGLSL = `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 int uDstWidth;\r\nuniform int uSrcWidth;\r\nuniform int uUseMap;\r\nuniform int uSrcBaseOffset;\r\nuniform int uDstBaseRow;\r\n\r\nlayout(location = 0) out vec4 glFragData[3];\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 = uSrcBaseOffset + int(m + 0.5);\r\n    } else {\r\n        srcIdx = (p.y - uDstBaseRow) * 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}\r\n`;\r\n\r\n/**\r\n * Rotation/scale relayout/backup copy fragment shader (WGSL/WebGPU) — same copy as the GLSL variant, 3 attachments.\r\n */\r\nexport const GaussianSplattingWorkBufferRotCopyFragmentShaderWGSL = `\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\n\r\nuniform uDstWidth : i32;\r\nuniform uSrcWidth : i32;\r\nuniform uUseMap : i32;\r\nuniform uSrcBaseOffset : i32;\r\nuniform uDstBaseRow : 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 = uniforms.uSrcBaseOffset + i32(m + 0.5);\r\n    } else {\r\n        srcIdx = (p.y - uniforms.uDstBaseRow) * 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}\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// Region-scoped relayout (hosted compound atlas), both default 0 (standalone square path unchanged).\r\nuniform uSrcBaseOffset : i32;\r\nuniform uDstBaseRow : 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 = uniforms.uSrcBaseOffset + i32(m + 0.5);\r\n    } else {\r\n        srcIdx = (p.y - uniforms.uDstBaseRow) * 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/glTF/2.0/Extensions/KHR_interactivity/declarationMapper.d.ts

@@ -45,7 +45,22 @@ interface IGLTFToFlowGraphMappingObject {
      * Used in configuration values. If defined, this will be the default value, if no value is provided.
      */
     defaultValue?: any;
+    /**
+     * When the input value comes from a connection (an upstream node output) rather than a literal,
+     * the parse-time {@link dataTransformer} cannot run. If this is `true`, the importer inserts a
+     * runtime multiply block that scales the connected value by the animation target fps, converting
+     * a KHR animation time (seconds) into Babylon animation frames. Literal values keep using the
+     * {@link dataTransformer}. Used by `animation/start` / `animation/stopAt` time inputs, which may
+     * be fed by a `pointer/get` (e.g. the read-only `maxTime` animation pointer).
+     */
+    convertConnectedTimeToFrames?: boolean;
 }
+/**
+ * Description of how a KHR_interactivity declaration (op such as
+ * `pointer/get`, `event/onSelect`, `math/add`) maps to one or more
+ * FlowGraph blocks. Used by {@link InteractivityGraphToFlowGraphParser}
+ * to translate the source glTF graph into the serialized FlowGraph form.
+ */
 export interface IGLTFToFlowGraphMapping {
     /**
      * The type of the FlowGraph block(s).
@@ -337,7 +352,7 @@ export {};
    - Effective JSON Pointer Generation (`pointer/set`) [FlowGraphBlockNames.SetProperty, FlowGraphBlockNames.JsonPointerParser]
    - Pointer Get (`pointer/get`) [FlowGraphBlockNames.GetProperty, FlowGraphBlockNames.JsonPointerParser]
    - Pointer Set (`pointer/set`) [FlowGraphBlockNames.SetProperty, FlowGraphBlockNames.JsonPointerParser]
-   - Pointer Interpolate (`pointer/interpolate`) [FlowGraphBlockNames.ValueInterpolation, FlowGraphBlockNames.JsonPointerParser, FlowGraphBlockNames.PlayAnimation, FlowGraphBlockNames.Easing]
+   - Pointer Interpolate (`pointer/interpolate`) [FlowGraphBlockNames.ValueInterpolation, FlowGraphBlockNames.JsonPointerParser, FlowGraphBlockNames.PlayAnimation, FlowGraphBlockNames.BezierCurveEasing]
 
 ### Animation Control Nodes
 1. **Animation Play** (`animation/start`) FlowGraphBlockNames.PlayAnimation