@babylonjs/lite 0.1.1 → 1.0.0

package/{gaussian-splatting-pipeline-sh-DgJl7l56.js → gaussian-splatting-pipeline-sh-7J31V23x.js}

@@ -1,4 +1,4 @@
-import { G as disposeGaussianSplattingMesh, H as applyGsFragments, D as targetSignatureKey, F as getSceneBindGroupLayout, J as getRenderTargetSize, K as getViewMatrix, L as getProjectionMatrix, O as getCameraPosition } from "./index-C8HOR2sB.js";
+import { e as U8, T as TU, A as disposeGaussianSplattingMesh, B as BU, a as F32, C as applyGsFragments, x as targetSignatureKey, S as SS, E as CW, z as getSceneBindGroupLayout, H as getRenderTargetSize, I as getViewMatrix, J as getProjectionMatrix, K as getCameraPosition } from "./index-CLElg2Bo.js";
 const SH_TEXTURE_COUNT = [0, 1, 2, 3, 5];
 let _cache = null;
 function buildShShaderSource(shDegree) {
@@ -274,15 +274,15 @@ function getOrCreateShPipeline(engine, sig, shDegree, fragments) {
   }
   const shTextureCount = SH_TEXTURE_COUNT[shDegree];
   const layoutEntries = [
-    { binding: 0, visibility: GPUShaderStage.VERTEX | GPUShaderStage.FRAGMENT, buffer: { type: "uniform" } },
-    { binding: 1, visibility: GPUShaderStage.VERTEX, sampler: { type: "non-filtering" } },
-    { binding: 2, visibility: GPUShaderStage.VERTEX, texture: { sampleType: "unfilterable-float" } },
-    { binding: 3, visibility: GPUShaderStage.VERTEX, texture: { sampleType: "unfilterable-float" } },
-    { binding: 4, visibility: GPUShaderStage.VERTEX, texture: { sampleType: "unfilterable-float" } },
-    { binding: 5, visibility: GPUShaderStage.VERTEX, texture: { sampleType: "unfilterable-float" } }
+    { binding: 0, visibility: SS.VERTEX | SS.FRAGMENT, buffer: { type: "uniform" } },
+    { binding: 1, visibility: SS.VERTEX, sampler: { type: "non-filtering" } },
+    { binding: 2, visibility: SS.VERTEX, texture: { sampleType: "unfilterable-float" } },
+    { binding: 3, visibility: SS.VERTEX, texture: { sampleType: "unfilterable-float" } },
+    { binding: 4, visibility: SS.VERTEX, texture: { sampleType: "unfilterable-float" } },
+    { binding: 5, visibility: SS.VERTEX, texture: { sampleType: "unfilterable-float" } }
   ];
   for (let i = 0; i < shTextureCount; i++) {
-    layoutEntries.push({ binding: 6 + i, visibility: GPUShaderStage.VERTEX, texture: { sampleType: "uint" } });
+    layoutEntries.push({ binding: 6 + i, visibility: SS.VERTEX, texture: { sampleType: "uint" } });
   }
   const meshBindGroupLayout = device.createBindGroupLayout({ entries: layoutEntries });
   const pipeline = device.createRenderPipeline({
@@ -305,7 +305,7 @@ function getOrCreateShPipeline(engine, sig, shDegree, fragments) {
             color: { srcFactor: "src-alpha", dstFactor: "one-minus-src-alpha", operation: "add" },
             alpha: { srcFactor: "one", dstFactor: "one-minus-src-alpha", operation: "add" }
           },
-          writeMask: GPUColorWrite.ALL
+          writeMask: CW.ALL
         }
       ]
     },
@@ -322,14 +322,14 @@ function getOrCreateShPipeline(engine, sig, shDegree, fragments) {
   return entry;
 }
 function buildGaussianSplattingRenderableSH(scene, mesh, fragments) {
-  const engine = scene.engine;
+  const engine = scene.surface.engine;
   const device = engine._device;
   const UBO_BYTES = 16 * 4 * 3 + 8 * 4 + 4 * 4;
   const ubo = device.createBuffer({
     size: UBO_BYTES,
-    usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST
+    usage: BU.UNIFORM | BU.COPY_DST
   });
-  const cpu = new Float32Array(UBO_BYTES / 4);
+  const cpu = new F32(UBO_BYTES / 4);
   cpu[48 + 4] = mesh.textureWidth;
   cpu[48 + 5] = mesh.textureHeight;
   cpu[48 + 6] = 1;
@@ -417,9 +417,9 @@ function buildGaussianSplattingRenderableSH(scene, mesh, fragments) {
     mesh._canPostToWorker = false;
     mesh._worker.postMessage(
       {
-        m: new Float32Array(world),
-        f: new Float32Array([cf0, cf1, cf2]),
-        c: new Float32Array([camPos.x, camPos.y, camPos.z]),
+        m: new F32(world),
+        f: new F32([cf0, cf1, cf2]),
+        c: new F32([camPos.x, camPos.y, camPos.z]),
         d: mesh._depthMix
       },
       [mesh._depthMix.buffer]
@@ -449,7 +449,7 @@ function buildGaussianSplattingRenderableSH(scene, mesh, fragments) {
   return r;
 }
 function attachGaussianSplattingMeshSH(scene, mesh, shFlat, fragments) {
-  const engine = scene.engine;
+  const engine = scene.surface.engine;
   const device = engine._device;
   const shDegree = mesh.shDegree;
   const shVectorCount = (shDegree + 1) * (shDegree + 1) - 1;
@@ -461,7 +461,7 @@ function attachGaussianSplattingMeshSH(scene, mesh, shFlat, fragments) {
   const views = [];
   const vertexCount = mesh.vertexCount;
   for (let t = 0; t < textureCount; t++) {
-    const dst = new Uint8Array(width * height * 16);
+    const dst = new U8(width * height * 16);
     const tBase = t * 16;
     const bytesThisTex = Math.min(16, shCoefficientCount - tBase);
     for (let i = 0; i < vertexCount; i++) {
@@ -474,7 +474,7 @@ function attachGaussianSplattingMeshSH(scene, mesh, shFlat, fragments) {
     const tex = device.createTexture({
       size: [width, height],
       format: "rgba32uint",
-      usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST
+      usage: TU.TEXTURE_BINDING | TU.COPY_DST
     });
     device.queue.writeTexture({ texture: tex }, dst.buffer, { bytesPerRow: width * 16 }, { width, height });
     textures.push(tex);
@@ -497,4 +497,4 @@ export {
   attachGaussianSplattingMeshSH,
   buildGaussianSplattingRenderableSH
 };
-//# sourceMappingURL=gaussian-splatting-pipeline-sh-DgJl7l56.js.map
+//# sourceMappingURL=gaussian-splatting-pipeline-sh-7J31V23x.js.map

package/gaussian-splatting-pipeline-sh-7J31V23x.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gaussian-splatting-pipeline-sh-7J31V23x.js","sources":["../src/mesh/GaussianSplatting/gaussian-splatting-pipeline-sh.ts"],"sourcesContent":["/** Gaussian-Splatting SH render pipeline + Renderable.\n *\n *  Variant of `gaussian-splatting-pipeline.ts` that adds view-dependent SH\n *  shading. Loaded *only* by `loadSplat` (and the SOG / SPZ loaders) via a\n *  dynamic `import(...)` when the parsed splat asset includes SH coefficients\n *  (`mesh.shDegree > 0`), so plain `.ply` / `.splat` scenes (e.g. scene 120)\n *  never pull this module's WGSL or runtime cost into their bundle.\n *\n *  WGSL source is generated per-shDegree by `buildShShaderSource`: SH textures,\n *  byte-to-vec3 unpacking, and the polynomial evaluation in\n *  `computeColorFromSHDegree` all expand to the right size — mirrors the\n *  `#if SH_DEGREE > N` blocks in BJS `gaussianSplatting.fx`. Pipeline cache is\n *  keyed by `(targetSignatureKey, shDegree)`.\n *\n *  The UBO grows by 16 bytes vs the base pipeline to carry `eyePosition`\n *  (world-space camera position; see `computeSH(dir)` below).\n *\n *  ── Why the Y-flip on the SH direction? ─────────────────────────────────\n *  BJS sets `mesh.scaling.y *= -1` to fix coordinate-system handedness; Lite\n *  pre-flips Y in `splat-data.ts` at parse time so the runtime mesh transform\n *  is identity. World-space splat positions agree across both engines, but\n *  the BJS world rotation absorbs an extra `diag(1,-1,1)` factor — i.e.\n *      worldRot_bjs = worldRot_user · diag(1,-1,1)\n *  which means\n *      inverse(worldRot_bjs) · v = diag(1,-1,1) · inverse(worldRot_user) · v\n *  so Lite reproduces the BJS SH direction by computing\n *  `inverseMat3(worldRot) · (worldPos − eye)` and then negating `.y`. */\n\nimport { F32, U8 } from \"../../engine/typed-arrays.js\";\nimport { TU, BU, SS, CW } from \"../../engine/gpu-flags.js\";\nimport type { EngineContext } from \"../../engine/engine.js\";\nimport type { SceneContext } from \"../../scene/scene-core.js\";\nimport type { Renderable, DrawBinding } from \"../../render/renderable.js\";\nimport type { RenderTargetSignature } from \"../../engine/render-target.js\";\nimport { targetSignatureKey } from \"../../engine/render-target.js\";\nimport { getViewMatrix, getProjectionMatrix, getCameraPosition } from \"../../camera/camera.js\";\nimport { getSceneBindGroupLayout } from \"../../render/scene-helpers.js\";\nimport { getRenderTargetSize } from \"../../engine/engine.js\";\nimport { disposeGaussianSplattingMesh, type GaussianSplattingMesh, type GsShaderFragment } from \"./gaussian-splatting-mesh.js\";\nimport { applyGsFragments } from \"./gaussian-splatting-pipeline.js\";\n\ninterface PipelineEntry {\n    pipeline: GPURenderPipeline;\n    meshBindGroupLayout: GPUBindGroupLayout;\n    shTextureCount: number;\n}\n\n// shDegree → number of rgba32uint SH textures: 1→1, 2→2, 3→3, 4→5.\nconst SH_TEXTURE_COUNT = [0, 1, 2, 3, 5];\n\nlet _cache: { device: GPUDevice; modules: Map<string, GPUShaderModule>; entries: Map<string, PipelineEntry> } | null = null;\n\n/** Build the WGSL source for a given SH degree (1..4). Mirrors the BJS\n *  preprocessor-driven shader structure: declares only the SH textures used\n *  by the degree, emits exactly the byte-stream unpacking for that degree,\n *  and inlines only the SH polynomial terms up to that degree. */\nfunction buildShShaderSource(shDegree: number): string {\n    const shVectorCount = (shDegree + 1) * (shDegree + 1) - 1;\n    const shCoefficientCount = shVectorCount * 3;\n    const textureCount = Math.ceil(shCoefficientCount / 16);\n\n    // ── SH texture bindings (6, 7, …) ───────────────────────────────\n    let textureBindings = \"\";\n    for (let i = 0; i < textureCount; i++) {\n        textureBindings += `@group(1) @binding(${6 + i}) var shTexture${i}: texture_2d<u32>;\\n`;\n    }\n\n    // ── textureLoad calls inside readSplat ──────────────────────────\n    let textureLoads = \"\";\n    for (let i = 0; i < textureCount; i++) {\n        textureLoads += `  let sh${i}_u32 = textureLoad(shTexture${i}, splatUVi32, 0);\\n`;\n    }\n\n    // ── Unpack the byte stream into sh[1..shVectorCount] vec3 values.\n    //\n    // Each rgba32uint texel carries 16 bytes (4 u32s × 4 bytes). The bytes\n    // are stored in BJS-coefficient order: byte j of splat i is the j-th\n    // component of the [R0,G0,B0, R1,G1,B1, …, R(N-1),G(N-1),B(N-1)] sequence.\n    // sh[k+1] (k = 0..shVectorCount-1) reads bytes [3k, 3k+1, 3k+2]. `decompose`\n    // returns `(byte * 2/255) - 1`, matching BJS exactly.\n    let shUnpack = `  var sh: array<vec3<f32>, ${shVectorCount + 1}>;\\n  sh[0] = vec3<f32>(0.0);\\n`;\n    const byteRef = (j: number): string => {\n        // texture index, u32 index within texel (0..3), byte index within u32 (0..3 == x/y/z/w).\n        const tex = (j / 16) | 0;\n        const u32Idx = ((j % 16) / 4) | 0;\n        const byteIdx = j % 4;\n        const u32Field = [\"x\", \"y\", \"z\", \"w\"][u32Idx]!;\n        const byteField = [\"x\", \"y\", \"z\", \"w\"][byteIdx]!;\n        return `decompose(sh${tex}_u32.${u32Field}).${byteField}`;\n    };\n    for (let k = 0; k < shVectorCount; k++) {\n        const j = k * 3;\n        shUnpack += `  sh[${k + 1}] = vec3<f32>(${byteRef(j)}, ${byteRef(j + 1)}, ${byteRef(j + 2)});\\n`;\n    }\n\n    // ── Polynomial evaluation, conditional on shDegree ──────────────\n    let shPoly = \"  result = sh[0];\\n\";\n    if (shDegree >= 1) {\n        shPoly += `  result += -SH_C1 * y * sh[1] + SH_C1 * z * sh[2] - SH_C1 * x * sh[3];\\n`;\n    }\n    if (shDegree >= 2) {\n        shPoly += `  result +=\\n    SH_C2[0] * xy * sh[4] +\\n    SH_C2[1] * yz * sh[5] +\\n    SH_C2[2] * (2.0 * zz - xx - yy) * sh[6] +\\n    SH_C2[3] * xz * sh[7] +\\n    SH_C2[4] * (xx - yy) * sh[8];\\n`;\n    }\n    if (shDegree >= 3) {\n        shPoly += `  result +=\\n    SH_C3[0] * y * (3.0 * xx - yy) * sh[9] +\\n    SH_C3[1] * xy * z * sh[10] +\\n    SH_C3[2] * y * (4.0 * zz - xx - yy) * sh[11] +\\n    SH_C3[3] * z * (2.0 * zz - 3.0 * xx - 3.0 * yy) * sh[12] +\\n    SH_C3[4] * x * (4.0 * zz - xx - yy) * sh[13] +\\n    SH_C3[5] * z * (xx - yy) * sh[14] +\\n    SH_C3[6] * x * (xx - 3.0 * yy) * sh[15];\\n`;\n    }\n    if (shDegree >= 4) {\n        shPoly += `  result +=\\n    SH_C4[0] * x * y * (xx - yy) * sh[16] +\\n    SH_C4[1] * y * z * (3.0 * xx - yy) * sh[17] +\\n    SH_C4[2] * x * y * (7.0 * zz - 1.0) * sh[18] +\\n    SH_C4[3] * y * z * (7.0 * zz - 3.0) * sh[19] +\\n    SH_C4[4] * (zz * (35.0 * zz - 30.0) + 3.0) * sh[20] +\\n    SH_C4[5] * x * z * (7.0 * zz - 3.0) * sh[21] +\\n    SH_C4[6] * (xx - yy) * (7.0 * zz - 1.0) * sh[22] +\\n    SH_C4[7] * x * z * (xx - 3.0 * yy) * sh[23] +\\n    SH_C4[8] * (xx * (xx - 3.0 * yy) - yy * (3.0 * xx - yy)) * sh[24];\\n`;\n    }\n\n    // SH_C2..SH_C4 constants — only declare what's referenced (silences\n    // WGSL \"unused array\" warnings on lower degrees).\n    let constantsBlock = `const SH_C1: f32 = 0.48860251;\\n`;\n    if (shDegree >= 2) {\n        constantsBlock += `const SH_C2: array<f32, 5> = array<f32, 5>(1.092548430, -1.09254843, 0.315391565, -1.09254843, 0.546274215);\\n`;\n    }\n    if (shDegree >= 3) {\n        constantsBlock += `const SH_C3: array<f32, 7> = array<f32, 7>(-0.59004358, 2.890611442, -0.45704579, 0.373176332, -0.45704579, 1.445305721, -0.59004358);\\n`;\n    }\n    if (shDegree >= 4) {\n        constantsBlock += `const SH_C4: array<f32, 9> = array<f32, 9>(2.5033429418, -1.7701307698, 0.9461746958, -0.6690465436, 0.1057855469, -0.6690465436, 0.4730873479, -1.7701307698, 0.6258357354);\\n`;\n    }\n\n    return `// Gaussian Splatting — vertex + fragment WGSL (SH degree ${shDegree}).\n// Generated by buildShShaderSource. Mirrors BJS gaussianSplatting.vertex.fx +\n// gaussianSplatting.fx (SH_DEGREE = ${shDegree}, no compound parts).\nstruct U {\n  world: mat4x4<f32>,\n  view: mat4x4<f32>,\n  projection: mat4x4<f32>,\n  viewport: vec2<f32>,\n  focal: vec2<f32>,\n  dataSize: vec2<f32>,\n  alpha: f32,\n  _pad0: f32,\n  eyePosition: vec3<f32>,\n  _pad1: f32,\n};\n@group(1) @binding(0) var<uniform> u: U;\n@group(1) @binding(1) var samp: sampler;\n@group(1) @binding(2) var centersTex: texture_2d<f32>;\n@group(1) @binding(3) var covATex: texture_2d<f32>;\n@group(1) @binding(4) var covBTex: texture_2d<f32>;\n@group(1) @binding(5) var colorsTex: texture_2d<f32>;\n${textureBindings}\n\nstruct VOut {\n  @builtin(position) pos: vec4<f32>,\n  @location(0) vColor: vec4<f32>,\n  @location(1) vPos: vec2<f32>,\n};\n\n${constantsBlock}\n\nfn dataUv(idx: f32) -> vec2<f32> {\n  let y = floor(idx / u.dataSize.x);\n  let x = idx - y * u.dataSize.x;\n  return vec2<f32>((x + 0.5) / u.dataSize.x, (y + 0.5) / u.dataSize.y);\n}\n\nfn dataUvI(idx: f32) -> vec2<i32> {\n  let y = floor(idx / u.dataSize.x);\n  let x = idx - y * u.dataSize.x;\n  return vec2<i32>(i32(x), i32(y));\n}\n\n// Unpack a u32 of 4 packed bytes into (b0 b1 b2 b3) * 2/255 - 1.\nfn decompose(value: u32) -> vec4<f32> {\n  let v = vec4<f32>(\n    f32((value >> 0u) & 255u),\n    f32((value >> 8u) & 255u),\n    f32((value >> 16u) & 255u),\n    f32((value >> 24u) & 255u));\n  return v * vec4<f32>(2.0 / 255.0) - vec4<f32>(1.0);\n}\n\nfn inverseMat3(m: mat3x3<f32>) -> mat3x3<f32> {\n  let a00 = m[0][0]; let a01 = m[0][1]; let a02 = m[0][2];\n  let a10 = m[1][0]; let a11 = m[1][1]; let a12 = m[1][2];\n  let a20 = m[2][0]; let a21 = m[2][1]; let a22 = m[2][2];\n  let b01 = a22 * a11 - a12 * a21;\n  let b11 = -a22 * a10 + a12 * a20;\n  let b21 = a21 * a10 - a11 * a20;\n  let det = a00 * b01 + a01 * b11 + a02 * b21;\n  return mat3x3<f32>(\n    vec3<f32>(b01 / det, (-a22 * a01 + a02 * a21) / det, (a12 * a01 - a02 * a11) / det),\n    vec3<f32>(b11 / det, (a22 * a00 - a02 * a20) / det, (-a12 * a00 + a02 * a10) / det),\n    vec3<f32>(b21 / det, (-a21 * a00 + a01 * a20) / det, (a11 * a00 - a01 * a10) / det));\n}\n\nfn computeSH(dir: vec3<f32>, splatUVi32: vec2<i32>) -> vec3<f32> {\n${textureLoads}${shUnpack}  let x = dir.x;\n  let y = dir.y;\n  let z = dir.z;\n  let xx = x * x; let yy = y * y; let zz = z * z;\n  let xy = x * y; let yz = y * z; let xz = x * z;\n  var result: vec3<f32>;\n${shPoly}  return result;\n}\n\n@vertex\nfn vs(@location(0) corner: vec2<f32>, @location(1) splatIndex: f32) -> VOut {\n  var out: VOut;\n  let uv = dataUv(splatIndex);\n  let splatUVi32 = dataUvI(splatIndex);\n  let center = textureSampleLevel(centersTex, samp, uv, 0.0).xyz;\n  let color  = textureSampleLevel(colorsTex,  samp, uv, 0.0);\n  let covA   = textureSampleLevel(covATex,    samp, uv, 0.0).xyz;\n  let covB   = textureSampleLevel(covBTex,    samp, uv, 0.0).xyz;\n\n  let worldPos  = u.world * vec4<f32>(center, 1.0);\n  let modelView = u.view  * u.world;\n  let camspace  = u.view  * worldPos;\n  let pos2d     = u.projection * camspace;\n\n  let bounds = 1.2 * pos2d.w;\n  if (pos2d.z < 0.0\n      || pos2d.x < -bounds || pos2d.x > bounds\n      || pos2d.y < -bounds || pos2d.y > bounds) {\n    out.pos = vec4<f32>(0.0, 0.0, 2.0, 1.0);\n    out.vColor = vec4<f32>(0.0);\n    out.vPos = vec2<f32>(0.0);\n    return out;\n  }\n\n  // ── View-dependent SH evaluation ───────────────────────────────────\n  let worldRot = mat3x3<f32>(u.world[0].xyz, u.world[1].xyz, u.world[2].xyz);\n  let normWorldRot = inverseMat3(worldRot);\n  var dir = normalize(normWorldRot * (worldPos.xyz - u.eyePosition));\n  // Lite-side Y-flip: compensates for our data-path Y pre-flip vs BJS's\n  // mesh.scaling.y *= -1 (see file header for derivation).\n  dir.y = -dir.y;\n  let shColor = computeSH(dir, splatUVi32);\n\n  let Vrk = mat3x3<f32>(\n    vec3<f32>(covA.x, covA.y, covA.z),\n    vec3<f32>(covA.y, covB.x, covB.y),\n    vec3<f32>(covA.z, covB.y, covB.z));\n\n  let invZ  = 1.0 / camspace.z;\n  let invZ2 = invZ * invZ;\n  let J = mat3x3<f32>(\n    vec3<f32>(u.focal.x * invZ, 0.0, -u.focal.x * camspace.x * invZ2),\n    vec3<f32>(0.0, u.focal.y * invZ, -u.focal.y * camspace.y * invZ2),\n    vec3<f32>(0.0, 0.0, 0.0));\n\n  let mv3 = mat3x3<f32>(modelView[0].xyz, modelView[1].xyz, modelView[2].xyz);\n  let T = transpose(mv3) * J;\n  var cov2d = transpose(T) * Vrk * T;\n\n  let kernelSize: f32 = 0.3;\n  cov2d[0][0] += kernelSize;\n  cov2d[1][1] += kernelSize;\n\n  let mid = (cov2d[0][0] + cov2d[1][1]) * 0.5;\n  let dxy = (cov2d[0][0] - cov2d[1][1]) * 0.5;\n  let radius = length(vec2<f32>(dxy, cov2d[0][1]));\n  let epsilon: f32 = 0.0001;\n  let lambda1 = mid + radius + epsilon;\n  let lambda2 = mid - radius + epsilon;\n  if (lambda2 < 0.0) {\n    out.pos = vec4<f32>(0.0, 0.0, 2.0, 1.0);\n    out.vColor = vec4<f32>(0.0);\n    out.vPos = vec2<f32>(0.0);\n    return out;\n  }\n\n  let diag = normalize(vec2<f32>(cov2d[0][1], lambda1 - cov2d[0][0]));\n  let majorAxis = min(sqrt(2.0 * lambda1), 1024.0) * diag;\n  let minorAxis = min(sqrt(2.0 * lambda2), 1024.0) * vec2<f32>(diag.y, -diag.x);\n\n  let vCenter = pos2d.xy;\n  out.pos = vec4<f32>(\n    vCenter + (corner.x * majorAxis + corner.y * minorAxis) * pos2d.w / u.viewport,\n    pos2d.z, pos2d.w);\n  out.vColor = vec4<f32>(color.rgb + shColor, color.a * u.alpha);\n  out.vPos = corner;\n  return out;\n}\n\n/*GS_FRAGMENT_DEFINITIONS*/\n@fragment\nfn fs(in: VOut) -> @location(0) vec4<f32> {\n  /*GS_FRAGMENT_MAIN_BEGIN*/\n  let A = -dot(in.vPos, in.vPos);\n  if (A < -4.0) { discard; }\n  let B = exp(A) * in.vColor.a;\n  var finalColor = vec4<f32>(in.vColor.rgb, B);\n  /*GS_FRAGMENT_BEFORE_FRAGCOLOR*/\n  /*GS_FRAGMENT_MAIN_END*/\n  return finalColor;\n}\n`;\n}\n\nfunction getOrCreateShPipeline(engine: EngineContext, sig: RenderTargetSignature, shDegree: number, fragments?: readonly GsShaderFragment[]): PipelineEntry {\n    const device = engine._device;\n    if (!_cache || _cache.device !== device) {\n        _cache = { device, modules: new Map(), entries: new Map() };\n    }\n    const fragKey = fragments && fragments.length > 0 ? \"|\" + fragments.map((f) => f.id).join(\",\") : \"\";\n    let module = _cache.modules.get(shDegree + fragKey);\n    if (!module) {\n        module = device.createShaderModule({\n            code: fragments && fragments.length > 0 ? applyGsFragments(buildShShaderSource(shDegree), fragments) : buildShShaderSource(shDegree),\n        });\n        _cache.modules.set(shDegree + fragKey, module);\n    }\n    const key = `${targetSignatureKey(sig)}|sh${shDegree}${fragKey}`;\n    let entry = _cache.entries.get(key);\n    if (entry) {\n        return entry;\n    }\n    const shTextureCount = SH_TEXTURE_COUNT[shDegree]!;\n    const layoutEntries: GPUBindGroupLayoutEntry[] = [\n        { binding: 0, visibility: SS.VERTEX | SS.FRAGMENT, buffer: { type: \"uniform\" } },\n        { binding: 1, visibility: SS.VERTEX, sampler: { type: \"non-filtering\" } },\n        { binding: 2, visibility: SS.VERTEX, texture: { sampleType: \"unfilterable-float\" } },\n        { binding: 3, visibility: SS.VERTEX, texture: { sampleType: \"unfilterable-float\" } },\n        { binding: 4, visibility: SS.VERTEX, texture: { sampleType: \"unfilterable-float\" } },\n        { binding: 5, visibility: SS.VERTEX, texture: { sampleType: \"unfilterable-float\" } },\n    ];\n    for (let i = 0; i < shTextureCount; i++) {\n        layoutEntries.push({ binding: 6 + i, visibility: SS.VERTEX, texture: { sampleType: \"uint\" } });\n    }\n    const meshBindGroupLayout = device.createBindGroupLayout({ entries: layoutEntries });\n    const pipeline = device.createRenderPipeline({\n        layout: device.createPipelineLayout({ bindGroupLayouts: [getSceneBindGroupLayout(engine), meshBindGroupLayout] }),\n        vertex: {\n            module,\n            entryPoint: \"vs\",\n            buffers: [\n                { arrayStride: 8, stepMode: \"vertex\", attributes: [{ shaderLocation: 0, offset: 0, format: \"float32x2\" }] },\n                { arrayStride: 4, stepMode: \"instance\", attributes: [{ shaderLocation: 1, offset: 0, format: \"float32\" }] },\n            ],\n        },\n        fragment: {\n            module,\n            entryPoint: \"fs\",\n            targets: [\n                {\n                    format: sig._colorFormat!,\n                    blend: {\n                        color: { srcFactor: \"src-alpha\", dstFactor: \"one-minus-src-alpha\", operation: \"add\" },\n                        alpha: { srcFactor: \"one\", dstFactor: \"one-minus-src-alpha\", operation: \"add\" },\n                    },\n                    writeMask: CW.ALL,\n                },\n            ],\n        },\n        primitive: { topology: \"triangle-list\", cullMode: \"none\" },\n        depthStencil: {\n            format: sig._depthStencilFormat ?? \"depth24plus-stencil8\",\n            depthCompare: sig._depthCompare ?? \"greater-equal\",\n            depthWriteEnabled: false,\n        },\n        multisample: { count: sig._sampleCount },\n    });\n    entry = { pipeline, meshBindGroupLayout, shTextureCount };\n    _cache.entries.set(key, entry);\n    return entry;\n}\n\n/** Build the Renderable for a GaussianSplattingMesh with SH coefficients.\n *  Mirrors `buildGaussianSplattingRenderable` but adds eyePosition to the UBO\n *  and binds the SH textures. */\nexport function buildGaussianSplattingRenderableSH(scene: SceneContext, mesh: GaussianSplattingMesh, fragments?: readonly GsShaderFragment[]): Renderable {\n    const engine = scene.surface.engine;\n    const device = engine._device;\n\n    // 3 mat4 + 8 floats (viewport,focal,dataSize,alpha,pad) + 4 floats (eyePosition + pad) = 240 bytes.\n    const UBO_BYTES = 16 * 4 * 3 + 8 * 4 + 4 * 4;\n    const ubo = device.createBuffer({\n        size: UBO_BYTES,\n        usage: BU.UNIFORM | BU.COPY_DST,\n    });\n    const cpu = new F32(UBO_BYTES / 4);\n\n    cpu[48 + 4] = mesh.textureWidth;\n    cpu[48 + 5] = mesh.textureHeight;\n    cpu[48 + 6] = 1; // alpha\n    cpu[48 + 7] = 0; // pad\n\n    const bindGroups = new Map<GPURenderPipeline, GPUBindGroup>();\n\n    const getBindGroup = (entry: PipelineEntry): GPUBindGroup => {\n        let bg = bindGroups.get(entry.pipeline);\n        if (bg) {\n            return bg;\n        }\n        const shViews = mesh._gs._shViews ?? [];\n        const entries: GPUBindGroupEntry[] = [\n            { binding: 0, resource: { buffer: ubo } },\n            { binding: 1, resource: mesh._gs._sampler },\n            { binding: 2, resource: mesh._gs._centersView },\n            { binding: 3, resource: mesh._gs._covAView },\n            { binding: 4, resource: mesh._gs._covBView },\n            { binding: 5, resource: mesh._gs._colorsView },\n        ];\n        for (let i = 0; i < entry.shTextureCount; i++) {\n            entries.push({ binding: 6 + i, resource: shViews[i]! });\n        }\n        bg = device.createBindGroup({ layout: entry.meshBindGroupLayout, entries });\n        bindGroups.set(entry.pipeline, bg);\n        return bg;\n    };\n\n    const SORT_EPS = 1e-4;\n\n    const update = (): void => {\n        const cam = scene.camera;\n        if (!cam) {\n            return;\n        }\n        const size = getRenderTargetSize(engine);\n        const aspect = size.width / size.height;\n        const view = getViewMatrix(cam) as unknown as Float32Array;\n        const proj = getProjectionMatrix(cam, aspect) as unknown as Float32Array;\n        const world = mesh.worldMatrix as unknown as Float32Array;\n        const camPos = getCameraPosition(cam);\n\n        cpu.set(world, 0);\n        cpu.set(view, 16);\n        cpu.set(proj, 32);\n        cpu[48] = size.width;\n        cpu[48 + 1] = size.height;\n        cpu[48 + 2] = size.width * 0.5 * proj[0]!;\n        cpu[48 + 3] = size.height * 0.5 * proj[5]!;\n        cpu[56] = camPos.x;\n        cpu[57] = camPos.y;\n        cpu[58] = camPos.z;\n        cpu[59] = 0;\n        device.queue.writeBuffer(ubo, 0, cpu.buffer, 0, UBO_BYTES);\n\n        if (!mesh._canPostToWorker) {\n            return;\n        }\n\n        const cf0 = view[2]!,\n            cf1 = view[6]!,\n            cf2 = view[10]!;\n\n        let dirty = false;\n        const lastW = mesh._sortWorldMatrix;\n        for (let i = 0; i < 16; i++) {\n            if (Math.abs(lastW[i]! - world[i]!) > SORT_EPS) {\n                dirty = true;\n                break;\n            }\n        }\n        if (!dirty) {\n            const lastCf = mesh._sortCameraForward;\n            if (Math.abs(lastCf[0]! - cf0) > SORT_EPS || Math.abs(lastCf[1]! - cf1) > SORT_EPS || Math.abs(lastCf[2]! - cf2) > SORT_EPS) {\n                dirty = true;\n            }\n        }\n        if (!dirty) {\n            const lastCp = mesh._sortCameraPosition;\n            if (Math.abs(lastCp[0]! - camPos.x) > SORT_EPS || Math.abs(lastCp[1]! - camPos.y) > SORT_EPS || Math.abs(lastCp[2]! - camPos.z) > SORT_EPS) {\n                dirty = true;\n            }\n        }\n        if (!dirty) {\n            return;\n        }\n\n        mesh._sortWorldMatrix.set(world);\n        mesh._sortCameraForward[0] = cf0;\n        mesh._sortCameraForward[1] = cf1;\n        mesh._sortCameraForward[2] = cf2;\n        mesh._sortCameraPosition[0] = camPos.x;\n        mesh._sortCameraPosition[1] = camPos.y;\n        mesh._sortCameraPosition[2] = camPos.z;\n        mesh._canPostToWorker = false;\n        mesh._worker.postMessage(\n            {\n                m: new F32(world),\n                f: new F32([cf0, cf1, cf2]),\n                c: new F32([camPos.x, camPos.y, camPos.z]),\n                d: mesh._depthMix,\n            },\n            [mesh._depthMix.buffer]\n        );\n    };\n\n    const r: Renderable = {\n        order: 200,\n        isTransparent: true,\n        bind(eng: EngineContext, sig: RenderTargetSignature): DrawBinding {\n            const entry = getOrCreateShPipeline(eng as EngineContext, sig, mesh.shDegree, fragments);\n            const bindGroup = getBindGroup(entry);\n            return {\n                renderable: r,\n                pipeline: entry.pipeline,\n                update,\n                draw(pass) {\n                    pass.setBindGroup(1, bindGroup);\n                    pass.setVertexBuffer(0, mesh._gs._quadBuffer);\n                    pass.setVertexBuffer(1, mesh._gs._splatIndexBuffer);\n                    pass.setIndexBuffer(mesh._gs._indexBuffer, \"uint16\");\n                    pass.drawIndexed(6, mesh.vertexCount);\n                    return 1;\n                },\n            };\n        },\n    };\n    return r;\n}\n\n/** SH-aware variant of `attachGaussianSplattingMesh`. Dynamic-imported by\n *  `attachParsedSplat` (in `load-splat.ts`) when the parsed asset carries SH\n *  coefficients. Reads `mesh.shDegree` (set at mesh construction), creates\n *  the `rgba32uint` SH textures (1..5 depending on degree), patches\n *  `mesh._gs` in place, and installs the SH renderable. */\nexport function attachGaussianSplattingMeshSH(scene: SceneContext, mesh: GaussianSplattingMesh, shFlat: Uint8Array, fragments?: readonly GsShaderFragment[]): void {\n    const engine = scene.surface.engine;\n    const device = engine._device;\n    const shDegree = mesh.shDegree;\n    const shVectorCount = (shDegree + 1) * (shDegree + 1) - 1;\n    const shCoefficientCount = shVectorCount * 3;\n    const textureCount = Math.ceil(shCoefficientCount / 16);\n    const width = mesh.textureWidth;\n    const height = mesh.textureHeight;\n\n    // Pack the flat SH byte stream into N textures of 16 bytes per splat each.\n    // splat i's bytes [i*shCC .. i*shCC + shCC] are split across textures\n    // [t=0..textureCount-1], each carrying up to 16 bytes at offset i*16.\n    const textures: GPUTexture[] = [];\n    const views: GPUTextureView[] = [];\n    const vertexCount = mesh.vertexCount;\n    for (let t = 0; t < textureCount; t++) {\n        const dst = new U8(width * height * 16);\n        const tBase = t * 16;\n        const bytesThisTex = Math.min(16, shCoefficientCount - tBase);\n        for (let i = 0; i < vertexCount; i++) {\n            const srcOff = i * shCoefficientCount + tBase;\n            const dstOff = i * 16;\n            for (let b = 0; b < bytesThisTex; b++) {\n                dst[dstOff + b] = shFlat[srcOff + b]!;\n            }\n        }\n        const tex = device.createTexture({\n            size: [width, height],\n            format: \"rgba32uint\",\n            usage: TU.TEXTURE_BINDING | TU.COPY_DST,\n        });\n        device.queue.writeTexture({ texture: tex }, dst.buffer, { bytesPerRow: width * 16 }, { width, height });\n        textures.push(tex);\n        views.push(tex.createView());\n    }\n    mesh._gs._shTextures = textures;\n    mesh._gs._shViews = views;\n\n    const ctx = scene as unknown as { _renderables: Renderable[]; _disposables: (() => void)[]; _gsMeshes: GaussianSplattingMesh[] };\n    ctx._renderables.push(buildGaussianSplattingRenderableSH(scene, mesh, fragments));\n    ctx._gsMeshes.push(mesh);\n    ctx._disposables.push(() => {\n        const i = ctx._gsMeshes.indexOf(mesh);\n        if (i >= 0) {\n            ctx._gsMeshes.splice(i, 1);\n        }\n        disposeGaussianSplattingMesh(mesh);\n    });\n}\n"],"names":[],"mappings":";AAgDA,MAAM,mBAAmB,CAAC,GAAG,GAAG,GAAG,GAAG,CAAC;AAEvC,IAAI,SAAmH;AAMvH,SAAS,oBAAoB,UAA0B;AACnD,QAAM,iBAAiB,WAAW,MAAM,WAAW,KAAK;AACxD,QAAM,qBAAqB,gBAAgB;AAC3C,QAAM,eAAe,KAAK,KAAK,qBAAqB,EAAE;AAGtD,MAAI,kBAAkB;AACtB,WAAS,IAAI,GAAG,IAAI,cAAc,KAAK;AACnC,uBAAmB,sBAAsB,IAAI,CAAC,kBAAkB,CAAC;AAAA;AAAA,EACrE;AAGA,MAAI,eAAe;AACnB,WAAS,IAAI,GAAG,IAAI,cAAc,KAAK;AACnC,oBAAgB,WAAW,CAAC,+BAA+B,CAAC;AAAA;AAAA,EAChE;AASA,MAAI,WAAW,8BAA8B,gBAAgB,CAAC;AAAA;AAAA;AAC9D,QAAM,UAAU,CAAC,MAAsB;AAEnC,UAAM,MAAO,IAAI,KAAM;AACvB,UAAM,SAAW,IAAI,KAAM,IAAK;AAChC,UAAM,UAAU,IAAI;AACpB,UAAM,WAAW,CAAC,KAAK,KAAK,KAAK,GAAG,EAAE,MAAM;AAC5C,UAAM,YAAY,CAAC,KAAK,KAAK,KAAK,GAAG,EAAE,OAAO;AAC9C,WAAO,eAAe,GAAG,QAAQ,QAAQ,KAAK,SAAS;AAAA,EAC3D;AACA,WAAS,IAAI,GAAG,IAAI,eAAe,KAAK;AACpC,UAAM,IAAI,IAAI;AACd,gBAAY,QAAQ,IAAI,CAAC,iBAAiB,QAAQ,CAAC,CAAC,KAAK,QAAQ,IAAI,CAAC,CAAC,KAAK,QAAQ,IAAI,CAAC,CAAC;AAAA;AAAA,EAC9F;AAGA,MAAI,SAAS;AACb,MAAI,YAAY,GAAG;AACf,cAAU;AAAA;AAAA,EACd;AACA,MAAI,YAAY,GAAG;AACf,cAAU;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EACd;AACA,MAAI,YAAY,GAAG;AACf,cAAU;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EACd;AACA,MAAI,YAAY,GAAG;AACf,cAAU;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EACd;AAIA,MAAI,iBAAiB;AAAA;AACrB,MAAI,YAAY,GAAG;AACf,sBAAkB;AAAA;AAAA,EACtB;AACA,MAAI,YAAY,GAAG;AACf,sBAAkB;AAAA;AAAA,EACtB;AACA,MAAI,YAAY,GAAG;AACf,sBAAkB;AAAA;AAAA,EACtB;AAEA,SAAO,6DAA6D,QAAQ;AAAA;AAAA,uCAEzC,QAAQ;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAmB7C,eAAe;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQf,cAAc;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAuCd,YAAY,GAAG,QAAQ;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAMvB,MAAM;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAgGR;AAEA,SAAS,sBAAsB,QAAuB,KAA4B,UAAkB,WAAwD;AACxJ,QAAM,SAAS,OAAO;AACtB,MAAI,CAAC,UAAU,OAAO,WAAW,QAAQ;AACrC,aAAS,EAAE,QAAQ,SAAS,oBAAI,OAAO,SAAS,oBAAI,MAAI;AAAA,EAC5D;AACA,QAAM,UAAU,aAAa,UAAU,SAAS,IAAI,MAAM,UAAU,IAAI,CAAC,MAAM,EAAE,EAAE,EAAE,KAAK,GAAG,IAAI;AACjG,MAAI,SAAS,OAAO,QAAQ,IAAI,WAAW,OAAO;AAClD,MAAI,CAAC,QAAQ;AACT,aAAS,OAAO,mBAAmB;AAAA,MAC/B,MAAM,aAAa,UAAU,SAAS,IAAI,iBAAiB,oBAAoB,QAAQ,GAAG,SAAS,IAAI,oBAAoB,QAAQ;AAAA,IAAA,CACtI;AACD,WAAO,QAAQ,IAAI,WAAW,SAAS,MAAM;AAAA,EACjD;AACA,QAAM,MAAM,GAAG,mBAAmB,GAAG,CAAC,MAAM,QAAQ,GAAG,OAAO;AAC9D,MAAI,QAAQ,OAAO,QAAQ,IAAI,GAAG;AAClC,MAAI,OAAO;AACP,WAAO;AAAA,EACX;AACA,QAAM,iBAAiB,iBAAiB,QAAQ;AAChD,QAAM,gBAA2C;AAAA,IAC7C,EAAE,SAAS,GAAG,YAAY,GAAG,SAAS,GAAG,UAAU,QAAQ,EAAE,MAAM,UAAA,EAAU;AAAA,IAC7E,EAAE,SAAS,GAAG,YAAY,GAAG,QAAQ,SAAS,EAAE,MAAM,kBAAgB;AAAA,IACtE,EAAE,SAAS,GAAG,YAAY,GAAG,QAAQ,SAAS,EAAE,YAAY,uBAAqB;AAAA,IACjF,EAAE,SAAS,GAAG,YAAY,GAAG,QAAQ,SAAS,EAAE,YAAY,uBAAqB;AAAA,IACjF,EAAE,SAAS,GAAG,YAAY,GAAG,QAAQ,SAAS,EAAE,YAAY,uBAAqB;AAAA,IACjF,EAAE,SAAS,GAAG,YAAY,GAAG,QAAQ,SAAS,EAAE,YAAY,qBAAA,EAAqB;AAAA,EAAE;AAEvF,WAAS,IAAI,GAAG,IAAI,gBAAgB,KAAK;AACrC,kBAAc,KAAK,EAAE,SAAS,IAAI,GAAG,YAAY,GAAG,QAAQ,SAAS,EAAE,YAAY,OAAA,GAAU;AAAA,EACjG;AACA,QAAM,sBAAsB,OAAO,sBAAsB,EAAE,SAAS,eAAe;AACnF,QAAM,WAAW,OAAO,qBAAqB;AAAA,IACzC,QAAQ,OAAO,qBAAqB,EAAE,kBAAkB,CAAC,wBAAwB,MAAM,GAAG,mBAAmB,GAAG;AAAA,IAChH,QAAQ;AAAA,MACJ;AAAA,MACA,YAAY;AAAA,MACZ,SAAS;AAAA,QACL,EAAE,aAAa,GAAG,UAAU,UAAU,YAAY,CAAC,EAAE,gBAAgB,GAAG,QAAQ,GAAG,QAAQ,YAAA,CAAa,EAAA;AAAA,QACxG,EAAE,aAAa,GAAG,UAAU,YAAY,YAAY,CAAC,EAAE,gBAAgB,GAAG,QAAQ,GAAG,QAAQ,UAAA,CAAW,EAAA;AAAA,MAAE;AAAA,IAC9G;AAAA,IAEJ,UAAU;AAAA,MACN;AAAA,MACA,YAAY;AAAA,MACZ,SAAS;AAAA,QACL;AAAA,UACI,QAAQ,IAAI;AAAA,UACZ,OAAO;AAAA,YACH,OAAO,EAAE,WAAW,aAAa,WAAW,uBAAuB,WAAW,MAAA;AAAA,YAC9E,OAAO,EAAE,WAAW,OAAO,WAAW,uBAAuB,WAAW,MAAA;AAAA,UAAM;AAAA,UAElF,WAAW,GAAG;AAAA,QAAA;AAAA,MAClB;AAAA,IACJ;AAAA,IAEJ,WAAW,EAAE,UAAU,iBAAiB,UAAU,OAAA;AAAA,IAClD,cAAc;AAAA,MACV,QAAQ,IAAI,uBAAuB;AAAA,MACnC,cAAc,IAAI,iBAAiB;AAAA,MACnC,mBAAmB;AAAA,IAAA;AAAA,IAEvB,aAAa,EAAE,OAAO,IAAI,aAAA;AAAA,EAAa,CAC1C;AACD,UAAQ,EAAE,UAAU,qBAAqB,eAAA;AACzC,SAAO,QAAQ,IAAI,KAAK,KAAK;AAC7B,SAAO;AACX;AAKO,SAAS,mCAAmC,OAAqB,MAA6B,WAAqD;AACtJ,QAAM,SAAS,MAAM,QAAQ;AAC7B,QAAM,SAAS,OAAO;AAGtB,QAAM,YAAY,KAAK,IAAI,IAAI,IAAI,IAAI,IAAI;AAC3C,QAAM,MAAM,OAAO,aAAa;AAAA,IAC5B,MAAM;AAAA,IACN,OAAO,GAAG,UAAU,GAAG;AAAA,EAAA,CAC1B;AACD,QAAM,MAAM,IAAI,IAAI,YAAY,CAAC;AAEjC,MAAI,KAAK,CAAC,IAAI,KAAK;AACnB,MAAI,KAAK,CAAC,IAAI,KAAK;AACnB,MAAI,KAAK,CAAC,IAAI;AACd,MAAI,KAAK,CAAC,IAAI;AAEd,QAAM,iCAAiB,IAAA;AAEvB,QAAM,eAAe,CAAC,UAAuC;AACzD,QAAI,KAAK,WAAW,IAAI,MAAM,QAAQ;AACtC,QAAI,IAAI;AACJ,aAAO;AAAA,IACX;AACA,UAAM,UAAU,KAAK,IAAI,YAAY,CAAA;AACrC,UAAM,UAA+B;AAAA,MACjC,EAAE,SAAS,GAAG,UAAU,EAAE,QAAQ,MAAI;AAAA,MACtC,EAAE,SAAS,GAAG,UAAU,KAAK,IAAI,SAAA;AAAA,MACjC,EAAE,SAAS,GAAG,UAAU,KAAK,IAAI,aAAA;AAAA,MACjC,EAAE,SAAS,GAAG,UAAU,KAAK,IAAI,UAAA;AAAA,MACjC,EAAE,SAAS,GAAG,UAAU,KAAK,IAAI,UAAA;AAAA,MACjC,EAAE,SAAS,GAAG,UAAU,KAAK,IAAI,YAAA;AAAA,IAAY;AAEjD,aAAS,IAAI,GAAG,IAAI,MAAM,gBAAgB,KAAK;AAC3C,cAAQ,KAAK,EAAE,SAAS,IAAI,GAAG,UAAU,QAAQ,CAAC,GAAI;AAAA,IAC1D;AACA,SAAK,OAAO,gBAAgB,EAAE,QAAQ,MAAM,qBAAqB,SAAS;AAC1E,eAAW,IAAI,MAAM,UAAU,EAAE;AACjC,WAAO;AAAA,EACX;AAEA,QAAM,WAAW;AAEjB,QAAM,SAAS,MAAY;AACvB,UAAM,MAAM,MAAM;AAClB,QAAI,CAAC,KAAK;AACN;AAAA,IACJ;AACA,UAAM,OAAO,oBAAoB,MAAM;AACvC,UAAM,SAAS,KAAK,QAAQ,KAAK;AACjC,UAAM,OAAO,cAAc,GAAG;AAC9B,UAAM,OAAO,oBAAoB,KAAK,MAAM;AAC5C,UAAM,QAAQ,KAAK;AACnB,UAAM,SAAS,kBAAkB,GAAG;AAEpC,QAAI,IAAI,OAAO,CAAC;AAChB,QAAI,IAAI,MAAM,EAAE;AAChB,QAAI,IAAI,MAAM,EAAE;AAChB,QAAI,EAAE,IAAI,KAAK;AACf,QAAI,KAAK,CAAC,IAAI,KAAK;AACnB,QAAI,KAAK,CAAC,IAAI,KAAK,QAAQ,MAAM,KAAK,CAAC;AACvC,QAAI,KAAK,CAAC,IAAI,KAAK,SAAS,MAAM,KAAK,CAAC;AACxC,QAAI,EAAE,IAAI,OAAO;AACjB,QAAI,EAAE,IAAI,OAAO;AACjB,QAAI,EAAE,IAAI,OAAO;AACjB,QAAI,EAAE,IAAI;AACV,WAAO,MAAM,YAAY,KAAK,GAAG,IAAI,QAAQ,GAAG,SAAS;AAEzD,QAAI,CAAC,KAAK,kBAAkB;AACxB;AAAA,IACJ;AAEA,UAAM,MAAM,KAAK,CAAC,GACd,MAAM,KAAK,CAAC,GACZ,MAAM,KAAK,EAAE;AAEjB,QAAI,QAAQ;AACZ,UAAM,QAAQ,KAAK;AACnB,aAAS,IAAI,GAAG,IAAI,IAAI,KAAK;AACzB,UAAI,KAAK,IAAI,MAAM,CAAC,IAAK,MAAM,CAAC,CAAE,IAAI,UAAU;AAC5C,gBAAQ;AACR;AAAA,MACJ;AAAA,IACJ;AACA,QAAI,CAAC,OAAO;AACR,YAAM,SAAS,KAAK;AACpB,UAAI,KAAK,IAAI,OAAO,CAAC,IAAK,GAAG,IAAI,YAAY,KAAK,IAAI,OAAO,CAAC,IAAK,GAAG,IAAI,YAAY,KAAK,IAAI,OAAO,CAAC,IAAK,GAAG,IAAI,UAAU;AACzH,gBAAQ;AAAA,MACZ;AAAA,IACJ;AACA,QAAI,CAAC,OAAO;AACR,YAAM,SAAS,KAAK;AACpB,UAAI,KAAK,IAAI,OAAO,CAAC,IAAK,OAAO,CAAC,IAAI,YAAY,KAAK,IAAI,OAAO,CAAC,IAAK,OAAO,CAAC,IAAI,YAAY,KAAK,IAAI,OAAO,CAAC,IAAK,OAAO,CAAC,IAAI,UAAU;AACxI,gBAAQ;AAAA,MACZ;AAAA,IACJ;AACA,QAAI,CAAC,OAAO;AACR;AAAA,IACJ;AAEA,SAAK,iBAAiB,IAAI,KAAK;AAC/B,SAAK,mBAAmB,CAAC,IAAI;AAC7B,SAAK,mBAAmB,CAAC,IAAI;AAC7B,SAAK,mBAAmB,CAAC,IAAI;AAC7B,SAAK,oBAAoB,CAAC,IAAI,OAAO;AACrC,SAAK,oBAAoB,CAAC,IAAI,OAAO;AACrC,SAAK,oBAAoB,CAAC,IAAI,OAAO;AACrC,SAAK,mBAAmB;AACxB,SAAK,QAAQ;AAAA,MACT;AAAA,QACI,GAAG,IAAI,IAAI,KAAK;AAAA,QAChB,GAAG,IAAI,IAAI,CAAC,KAAK,KAAK,GAAG,CAAC;AAAA,QAC1B,GAAG,IAAI,IAAI,CAAC,OAAO,GAAG,OAAO,GAAG,OAAO,CAAC,CAAC;AAAA,QACzC,GAAG,KAAK;AAAA,MAAA;AAAA,MAEZ,CAAC,KAAK,UAAU,MAAM;AAAA,IAAA;AAAA,EAE9B;AAEA,QAAM,IAAgB;AAAA,IAClB,OAAO;AAAA,IACP,eAAe;AAAA,IACf,KAAK,KAAoB,KAAyC;AAC9D,YAAM,QAAQ,sBAAsB,KAAsB,KAAK,KAAK,UAAU,SAAS;AACvF,YAAM,YAAY,aAAa,KAAK;AACpC,aAAO;AAAA,QACH,YAAY;AAAA,QACZ,UAAU,MAAM;AAAA,QAChB;AAAA,QACA,KAAK,MAAM;AACP,eAAK,aAAa,GAAG,SAAS;AAC9B,eAAK,gBAAgB,GAAG,KAAK,IAAI,WAAW;AAC5C,eAAK,gBAAgB,GAAG,KAAK,IAAI,iBAAiB;AAClD,eAAK,eAAe,KAAK,IAAI,cAAc,QAAQ;AACnD,eAAK,YAAY,GAAG,KAAK,WAAW;AACpC,iBAAO;AAAA,QACX;AAAA,MAAA;AAAA,IAER;AAAA,EAAA;AAEJ,SAAO;AACX;AAOO,SAAS,8BAA8B,OAAqB,MAA6B,QAAoB,WAA+C;AAC/J,QAAM,SAAS,MAAM,QAAQ;AAC7B,QAAM,SAAS,OAAO;AACtB,QAAM,WAAW,KAAK;AACtB,QAAM,iBAAiB,WAAW,MAAM,WAAW,KAAK;AACxD,QAAM,qBAAqB,gBAAgB;AAC3C,QAAM,eAAe,KAAK,KAAK,qBAAqB,EAAE;AACtD,QAAM,QAAQ,KAAK;AACnB,QAAM,SAAS,KAAK;AAKpB,QAAM,WAAyB,CAAA;AAC/B,QAAM,QAA0B,CAAA;AAChC,QAAM,cAAc,KAAK;AACzB,WAAS,IAAI,GAAG,IAAI,cAAc,KAAK;AACnC,UAAM,MAAM,IAAI,GAAG,QAAQ,SAAS,EAAE;AACtC,UAAM,QAAQ,IAAI;AAClB,UAAM,eAAe,KAAK,IAAI,IAAI,qBAAqB,KAAK;AAC5D,aAAS,IAAI,GAAG,IAAI,aAAa,KAAK;AAClC,YAAM,SAAS,IAAI,qBAAqB;AACxC,YAAM,SAAS,IAAI;AACnB,eAAS,IAAI,GAAG,IAAI,cAAc,KAAK;AACnC,YAAI,SAAS,CAAC,IAAI,OAAO,SAAS,CAAC;AAAA,MACvC;AAAA,IACJ;AACA,UAAM,MAAM,OAAO,cAAc;AAAA,MAC7B,MAAM,CAAC,OAAO,MAAM;AAAA,MACpB,QAAQ;AAAA,MACR,OAAO,GAAG,kBAAkB,GAAG;AAAA,IAAA,CAClC;AACD,WAAO,MAAM,aAAa,EAAE,SAAS,IAAA,GAAO,IAAI,QAAQ,EAAE,aAAa,QAAQ,GAAA,GAAM,EAAE,OAAO,QAAQ;AACtG,aAAS,KAAK,GAAG;AACjB,UAAM,KAAK,IAAI,YAAY;AAAA,EAC/B;AACA,OAAK,IAAI,cAAc;AACvB,OAAK,IAAI,WAAW;AAEpB,QAAM,MAAM;AACZ,MAAI,aAAa,KAAK,mCAAmC,OAAO,MAAM,SAAS,CAAC;AAChF,MAAI,UAAU,KAAK,IAAI;AACvB,MAAI,aAAa,KAAK,MAAM;AACxB,UAAM,IAAI,IAAI,UAAU,QAAQ,IAAI;AACpC,QAAI,KAAK,GAAG;AACR,UAAI,UAAU,OAAO,GAAG,CAAC;AAAA,IAC7B;AACA,iCAA6B,IAAI;AAAA,EACrC,CAAC;AACL;"}

package/geometry-texture-output-dXk4E9uu.js

@@ -0,0 +1,41 @@
+import { G as GeometryTextureType } from "./index-CLElg2Bo.js";
+const INPUTS = [
+  ["worldPosition", GeometryTextureType.WORLD_POSITION, "vec3f"],
+  ["localPosition", GeometryTextureType.LOCAL_POSITION, "vec3f"],
+  ["worldNormal", GeometryTextureType.WORLD_NORMAL, "vec3f"],
+  ["viewNormal", GeometryTextureType.VIEW_NORMAL, "vec3f"],
+  ["reflectivity", GeometryTextureType.REFLECTIVITY, "vec4f"],
+  ["albedo", GeometryTextureType.ALBEDO, "vec3f"],
+  ["irradiance", GeometryTextureType.IRRADIANCE, "vec3f"],
+  ["viewDepth", GeometryTextureType.VIEW_DEPTH, "f32"],
+  ["normalizedViewDepth", GeometryTextureType.NORMALIZED_VIEW_DEPTH, "f32"],
+  ["screenspaceDepth", GeometryTextureType.SCREENSPACE_DEPTH, "f32"],
+  ["linearVelocity", GeometryTextureType.LINEAR_VELOCITY, "vec3f"]
+];
+function geometryInputs(state) {
+  if (!state._geometryInputs) {
+    state._geometryInputs = /* @__PURE__ */ new Map();
+  }
+  return state._geometryInputs;
+}
+const emitter = {
+  className: "GeometryTextureOutputBlock",
+  stage: "fragment",
+  emit(block, _outputName, stage, state, ctx) {
+    const out = geometryInputs(state);
+    for (const [name, type, cast] of INPUTS) {
+      const conn = block.inputs.get(name);
+      if (conn && conn.source) {
+        const value = ctx.cast(ctx.resolve(block, name, stage, state), cast);
+        const t = ctx.temp(state, "geom");
+        state.fragment.body.push(`let ${t} = ${value.expr};`);
+        out.set(type, { expr: t, type: value.type });
+      }
+    }
+    return { expr: "vec4<f32>(0.0, 0.0, 0.0, 1.0)", type: "vec4f" };
+  }
+};
+export {
+  emitter
+};
+//# sourceMappingURL=geometry-texture-output-dXk4E9uu.js.map

package/geometry-texture-output-dXk4E9uu.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"geometry-texture-output-dXk4E9uu.js","sources":["../src/material/node/blocks/geometry-texture-output.ts"],"sourcesContent":["/** GeometryTextureOutputBlock emitter — the geometry-pass fragment terminal.\n *\n *  Lite analogue of Babylon.js' `PrePassOutputBlock`. Declares one optional\n *  input per {@link GeometryTextureType} (11 total). For every CONNECTED input\n *  it resolves + casts the upstream value and stashes the WGSL expression onto\n *  `state._geometryInputs`, keyed by the geometry texture type. It never writes\n *  `_NME_FRAG_OUTPUT_` — the node pipeline's geometry path (see\n *  node-geometry-view.ts / node-pipeline.ts `_mrtOutput`) turns the stashed\n *  expressions into the multi-attachment `FragmentOutput` writes, filling any\n *  unconnected attachment with the engine default.\n *\n *  This block is only ever emitted when the graph is re-walked from this\n *  terminal during a geometry-renderer pass; the normal colour pass walks the\n *  `FragmentOutputBlock` instead and never touches this code.\n */\n\nimport { GeometryTextureType } from \"../../../frame-graph/geometry-types.js\";\nimport type { BlockEmitter, NodeBuildState, NodeExpr, NodeValueType } from \"../node-types.js\";\n\n/** input name → (geometry texture type, cast target) */\nconst INPUTS: ReadonlyArray<readonly [string, GeometryTextureType, NodeValueType]> = [\n    [\"worldPosition\", GeometryTextureType.WORLD_POSITION, \"vec3f\"],\n    [\"localPosition\", GeometryTextureType.LOCAL_POSITION, \"vec3f\"],\n    [\"worldNormal\", GeometryTextureType.WORLD_NORMAL, \"vec3f\"],\n    [\"viewNormal\", GeometryTextureType.VIEW_NORMAL, \"vec3f\"],\n    [\"reflectivity\", GeometryTextureType.REFLECTIVITY, \"vec4f\"],\n    [\"albedo\", GeometryTextureType.ALBEDO, \"vec3f\"],\n    [\"irradiance\", GeometryTextureType.IRRADIANCE, \"vec3f\"],\n    [\"viewDepth\", GeometryTextureType.VIEW_DEPTH, \"f32\"],\n    [\"normalizedViewDepth\", GeometryTextureType.NORMALIZED_VIEW_DEPTH, \"f32\"],\n    [\"screenspaceDepth\", GeometryTextureType.SCREENSPACE_DEPTH, \"f32\"],\n    [\"linearVelocity\", GeometryTextureType.LINEAR_VELOCITY, \"vec3f\"],\n];\n\nfunction geometryInputs(state: NodeBuildState): Map<GeometryTextureType, NodeExpr> {\n    if (!state._geometryInputs) {\n        state._geometryInputs = new Map<GeometryTextureType, NodeExpr>();\n    }\n    return state._geometryInputs;\n}\n\nexport const emitter: BlockEmitter = {\n    className: \"GeometryTextureOutputBlock\",\n    stage: \"fragment\",\n    emit(block, _outputName, stage, state, ctx) {\n        const out = geometryInputs(state);\n        for (const [name, type, cast] of INPUTS) {\n            const conn = block.inputs.get(name);\n            if (conn && conn.source) {\n                const value = ctx.cast(ctx.resolve(block, name, stage, state), cast);\n                // Stash via an SSA temp so the geometry write site references a\n                // single stable identifier rather than re-evaluating the chain.\n                const t = ctx.temp(state, \"geom\");\n                state.fragment.body.push(`let ${t} = ${value.expr};`);\n                out.set(type, { expr: t, type: value.type });\n            }\n        }\n        // Terminal block — the returned value is never consumed.\n        return { expr: \"vec4<f32>(0.0, 0.0, 0.0, 1.0)\", type: \"vec4f\" };\n    },\n};\n"],"names":[],"mappings":";AAoBA,MAAM,SAA+E;AAAA,EACjF,CAAC,iBAAiB,oBAAoB,gBAAgB,OAAO;AAAA,EAC7D,CAAC,iBAAiB,oBAAoB,gBAAgB,OAAO;AAAA,EAC7D,CAAC,eAAe,oBAAoB,cAAc,OAAO;AAAA,EACzD,CAAC,cAAc,oBAAoB,aAAa,OAAO;AAAA,EACvD,CAAC,gBAAgB,oBAAoB,cAAc,OAAO;AAAA,EAC1D,CAAC,UAAU,oBAAoB,QAAQ,OAAO;AAAA,EAC9C,CAAC,cAAc,oBAAoB,YAAY,OAAO;AAAA,EACtD,CAAC,aAAa,oBAAoB,YAAY,KAAK;AAAA,EACnD,CAAC,uBAAuB,oBAAoB,uBAAuB,KAAK;AAAA,EACxE,CAAC,oBAAoB,oBAAoB,mBAAmB,KAAK;AAAA,EACjE,CAAC,kBAAkB,oBAAoB,iBAAiB,OAAO;AACnE;AAEA,SAAS,eAAe,OAA2D;AAC/E,MAAI,CAAC,MAAM,iBAAiB;AACxB,UAAM,sCAAsB,IAAA;AAAA,EAChC;AACA,SAAO,MAAM;AACjB;AAEO,MAAM,UAAwB;AAAA,EACjC,WAAW;AAAA,EACX,OAAO;AAAA,EACP,KAAK,OAAO,aAAa,OAAO,OAAO,KAAK;AACxC,UAAM,MAAM,eAAe,KAAK;AAChC,eAAW,CAAC,MAAM,MAAM,IAAI,KAAK,QAAQ;AACrC,YAAM,OAAO,MAAM,OAAO,IAAI,IAAI;AAClC,UAAI,QAAQ,KAAK,QAAQ;AACrB,cAAM,QAAQ,IAAI,KAAK,IAAI,QAAQ,OAAO,MAAM,OAAO,KAAK,GAAG,IAAI;AAGnE,cAAM,IAAI,IAAI,KAAK,OAAO,MAAM;AAChC,cAAM,SAAS,KAAK,KAAK,OAAO,CAAC,MAAM,MAAM,IAAI,GAAG;AACpD,YAAI,IAAI,MAAM,EAAE,MAAM,GAAG,MAAM,MAAM,MAAM;AAAA,MAC/C;AAAA,IACJ;AAEA,WAAO,EAAE,MAAM,iCAAiC,MAAM,QAAA;AAAA,EAC1D;AACJ;"}

package/geometry-view-BsFJpBJa.js

@@ -0,0 +1,404 @@
+import { G as GeometryTextureType, Q as MATERIAL_ALPHA_BLEND, ah as SPECULAR_USES_UV2, ag as HAS_SPECULAR_TEXTURE, at as _computeMeshFeatures, a as F32, b as writeMeshLightSelection, av as createUniformBuffer, aw as collectStdBoundTextures, ax as acquireTexture, ay as releaseTexture, bF as _getStdExtsSorted, aD as MSH_HAS_THIN_INSTANCES, z as getSceneBindGroupLayout, am as HAS_OPACITY_TEXTURE, aA as NEEDS_UV, bH as HAS_DIFFUSE_TEXTURE, aB as MSH_HAS_INSTANCE_COLOR, x as targetSignatureKey, bJ as DOUBLE_SIDED, aC as NEEDS_UV2, O as createMaterialView, c0 as GEOMETRY_OUTPUT } from "./index-CLElg2Bo.js";
+import { createThinInstanceFragment } from "./thin-instance-fragment-hsv-RyDs.js";
+import { syncThinInstanceBuffers } from "./thin-instance-gpu-BDdRcNAh.js";
+import { d as composeStandardShader, w as writeStdMaterialData } from "./standard-pipeline-XTbHL7MY.js";
+const STAGE_FRAGMENT = 2;
+const STAGE_VERTEX = 1;
+function needsGpUbo(attachments) {
+  for (const t of attachments) {
+    if (t === GeometryTextureType.NORMALIZED_VIEW_DEPTH || t === GeometryTextureType.LINEAR_VELOCITY) {
+      return true;
+    }
+  }
+  return false;
+}
+function needsVelocity(attachments) {
+  return attachments.includes(GeometryTextureType.LINEAR_VELOCITY);
+}
+function needsLocalPos(attachments) {
+  return attachments.includes(GeometryTextureType.LOCAL_POSITION);
+}
+function attachmentExpr(type, wg, hasSpecular, specularUv) {
+  switch (type) {
+    case GeometryTextureType.IRRADIANCE:
+      return `vec4<f32>(0.0, 0.0, 0.0, ${wg})`;
+    case GeometryTextureType.WORLD_POSITION:
+      return `vec4<f32>(input.vp, ${wg})`;
+    case GeometryTextureType.LOCAL_POSITION:
+      return `vec4<f32>(input.vLocalPos, ${wg})`;
+    case GeometryTextureType.REFLECTIVITY:
+      return hasSpecular ? `(vec4<f32>(pow(textureSample(sT, sS, ${specularUv}).rgb, vec3<f32>(2.2)), textureSample(sT, sS, ${specularUv}).a) * ${wg})` : `vec4<f32>(pow(mat.sc.rgb, vec3<f32>(2.2)), 1.0) * ${wg}`;
+    case GeometryTextureType.VIEW_DEPTH:
+      return `vec4<f32>((scene.view * vec4<f32>(input.vp, 1.0)).z, 0.0, 0.0, ${wg})`;
+    case GeometryTextureType.NORMALIZED_VIEW_DEPTH:
+      return `vec4<f32>(((scene.view * vec4<f32>(input.vp, 1.0)).z - gp.cameraNearFar.x) / (gp.cameraNearFar.y - gp.cameraNearFar.x), 0.0, 0.0, ${wg})`;
+    case GeometryTextureType.SCREENSPACE_DEPTH:
+      return `vec4<f32>(input.clipPos.z, 0.0, 0.0, ${wg})`;
+    case GeometryTextureType.VIEW_NORMAL:
+      return `vec4<f32>(normalize((scene.view * vec4<f32>(normalW, 0.0)).xyz), ${wg})`;
+    case GeometryTextureType.WORLD_NORMAL:
+      return `vec4<f32>(normalW * 0.5 + vec3<f32>(0.5), ${wg})`;
+    case GeometryTextureType.ALBEDO:
+      return `vec4<f32>(baseColor, ${wg})`;
+    case GeometryTextureType.LINEAR_VELOCITY: {
+      const cur = `(input.vCurrentClip.xy / input.vCurrentClip.w)`;
+      const prev = `(input.vPreviousClip.xy / input.vPreviousClip.w)`;
+      return `vec4<f32>(0.5 * (${prev} - ${cur}), 0.0, ${wg})`;
+    }
+  }
+}
+function createGeometryParamsFragment(needsParamsUbo, needsVelocityVaryings, needsLocalPosVarying) {
+  const bindings = needsParamsUbo ? [{ _name: "gp", _type: { _kind: "uniform-buffer" }, _visibility: STAGE_FRAGMENT | STAGE_VERTEX }] : [];
+  const helpers = needsParamsUbo ? `struct gpUniforms { previousViewProjection: mat4x4<f32>, cameraNearFar: vec4<f32>, };` : "";
+  const varyings = [];
+  if (needsVelocityVaryings) {
+    varyings.push({ _name: "vCurrentClip", _type: "vec4<f32>" }, { _name: "vPreviousClip", _type: "vec4<f32>" });
+  }
+  if (needsLocalPosVarying) {
+    varyings.push({ _name: "vLocalPos", _type: "vec3<f32>" });
+  }
+  const vbParts = [];
+  if (needsVelocityVaryings) {
+    vbParts.push(`out.vCurrentClip = scene.viewProjection * vec4<f32>(out.vp, 1.0);`);
+    vbParts.push(`out.vPreviousClip = gp.previousViewProjection * vec4<f32>(out.vp, 1.0);`);
+  }
+  if (needsLocalPosVarying) {
+    vbParts.push(`out.vLocalPos = position;`);
+  }
+  const slots = vbParts.length > 0 ? { VB: vbParts.join("\n") } : {};
+  return {
+    _id: "~geometry-params",
+    _bindings: bindings,
+    _helperFunctions: helpers,
+    // gp UBO is also visible to the vertex stage when present, so the
+    // struct declaration must be available there too.
+    _vertexHelperFunctions: helpers,
+    _varyings: varyings,
+    _vertexSlots: slots
+  };
+}
+function composeStandardGeometryShader(features, meshFeatures, extFragments, attachments, esmShadowDepthCode = "", emitColor = false) {
+  const wantsGp = needsGpUbo(attachments);
+  const wantsVelocity = needsVelocity(attachments);
+  const wantsLocalPos = needsLocalPos(attachments);
+  const fragments = wantsGp || wantsVelocity || wantsLocalPos ? [...extFragments, createGeometryParamsFragment(wantsGp, wantsVelocity, wantsLocalPos)] : extFragments;
+  const stdFeatures = features & ~MATERIAL_ALPHA_BLEND;
+  const base = composeStandardShader(stdFeatures, meshFeatures, fragments, esmShadowDepthCode);
+  const hasSpecular = (features & HAS_SPECULAR_TEXTURE) !== 0;
+  const specularUv = (features & SPECULAR_USES_UV2) !== 0 ? "input.vv" : "input.vu";
+  const fragmentSignatureFrom = "-> @location(0) vec4<f32>";
+  const fragmentSignatureTo = "-> FragmentOutput";
+  if (!base._fragmentWGSL.includes(fragmentSignatureFrom)) {
+    throw new Error("composeStandardGeometryShader: standard fragment signature mismatch — bypass active?");
+  }
+  let frag = base._fragmentWGSL.replace(fragmentSignatureFrom, fragmentSignatureTo);
+  const colorSlot = attachments.length;
+  const extraColorLine = emitColor ? `
+@location(${colorSlot}) color: vec4<f32>,` : "";
+  const outputStruct = `struct FragmentOutput {
+${attachments.map((_, i) => `@location(${i}) f${i}: vec4<f32>,`).join("\n")}${extraColorLine}
+};
+`;
+  frag = frag.replace("@fragment fn main", `${outputStruct}@fragment fn main`);
+  const wg = `select(0.0, 1.0, alpha > 0.4)`;
+  const writes = attachments.map((type, i) => `out.f${i} = ${attachmentExpr(type, wg, hasSpecular, specularUv)};`).join("\n");
+  const extraColorWrite = emitColor ? `
+out.color = color;` : "";
+  const replacement = `var out: FragmentOutput;
+${writes}${extraColorWrite}
+return out;`;
+  if (!frag.includes("return color;")) {
+    throw new Error("composeStandardGeometryShader: 'return color;' not found in composed fragment — template changed?");
+  }
+  frag = frag.replace("return color;", replacement);
+  return { ...base, _fragmentWGSL: frag };
+}
+const standardGeometryGroupBuilder = (async () => {
+  throw new Error("standard-geometry view does not support scene group building");
+});
+standardGeometryGroupBuilder._rebuildSingle = (scene, mesh, materialOverride) => {
+  const view = materialOverride ?? mesh.material;
+  return buildStandardGeometryRenderable(scene, mesh, view);
+};
+standardGeometryGroupBuilder._materialFamily = "standard";
+function _variantKey(meshFeatures) {
+  let k = 0;
+  if (meshFeatures & MSH_HAS_THIN_INSTANCES) {
+    k |= 1;
+  }
+  if (meshFeatures & MSH_HAS_INSTANCE_COLOR) {
+    k |= 2;
+  }
+  return k;
+}
+function buildStandardGeometryRenderable(scene, mesh, view) {
+  const engine = scene.surface.engine;
+  const device = engine._device;
+  const source = view.source;
+  const meshFeatures = _computeMeshFeatures(mesh, false);
+  const variantKey = _variantKey(meshFeatures);
+  const res = _ensureViewResources(view, engine, meshFeatures, variantKey);
+  const features = res._features;
+  const meshUboData = new F32(res._composed._meshUboSpec._totalBytes / 4);
+  meshUboData.set(mesh.worldMatrix, 0);
+  writeMeshLightSelection(mesh, scene.lights, meshUboData);
+  const meshUBO = createUniformBuffer(engine, meshUboData);
+  const bg = _createGeometryMeshBindGroup(engine, view, res, mesh, meshUBO);
+  const boundTextures = collectStdBoundTextures(source);
+  for (const t of boundTextures) {
+    acquireTexture(t);
+  }
+  const prevDisposables = scene._meshDisposables.get(mesh) ?? [];
+  scene._meshDisposables.set(mesh, [
+    ...prevDisposables,
+    () => {
+      for (const t of boundTextures) {
+        releaseTexture(t);
+      }
+    }
+  ]);
+  let _lastWorldVersion = mesh.worldMatrixVersion;
+  let _lastLightsCount = scene.lights.length;
+  const needsUV = (features & NEEDS_UV) !== 0;
+  const needsUV2 = (features & NEEDS_UV2) !== 0;
+  const isAlphaBlend = res._alphaBlend;
+  const hasThinInstances = (meshFeatures & MSH_HAS_THIN_INSTANCES) !== 0;
+  const hasInstanceColor = (meshFeatures & MSH_HAS_INSTANCE_COLOR) !== 0;
+  const sortCenter = [mesh.worldMatrix[12], mesh.worldMatrix[13], mesh.worldMatrix[14]];
+  const update = () => {
+    if (mesh.worldMatrixVersion !== _lastWorldVersion || scene.lights.length !== _lastLightsCount) {
+      sortCenter[0] = mesh.worldMatrix[12];
+      sortCenter[1] = mesh.worldMatrix[13];
+      sortCenter[2] = mesh.worldMatrix[14];
+      meshUboData.set(mesh.worldMatrix, 0);
+      writeMeshLightSelection(mesh, scene.lights, meshUboData);
+      device.queue.writeBuffer(meshUBO, 0, meshUboData);
+      _lastWorldVersion = mesh.worldMatrixVersion;
+      _lastLightsCount = scene.lights.length;
+    }
+    if (source._uboVersion !== res._lastUboVersion) {
+      res._lastUboVersion = source._uboVersion;
+      const textureLevel = (features & HAS_DIFFUSE_TEXTURE) !== 0 ? 1 : 0;
+      res._matData.fill(0);
+      writeStdMaterialData(res._matData, source, textureLevel);
+      device.queue.writeBuffer(res._matUBO, 0, res._matData.buffer, 0, 96);
+    }
+  };
+  const draw = (pass) => {
+    if (mesh.visible === false) {
+      return 0;
+    }
+    pass.setBindGroup(1, bg);
+    const g = mesh._gpu;
+    let slot = 0;
+    pass.setVertexBuffer(slot++, g.positionBuffer);
+    pass.setVertexBuffer(slot++, g.normalBuffer);
+    if (needsUV && g.uvBuffer) {
+      pass.setVertexBuffer(slot++, g.uvBuffer);
+    }
+    if (needsUV2 && g.uv2Buffer) {
+      pass.setVertexBuffer(slot++, g.uv2Buffer);
+    }
+    const ti = hasThinInstances ? mesh.thinInstances : null;
+    if (ti) {
+      slot = syncThinInstanceBuffers(engine, ti, pass, slot, hasInstanceColor);
+    }
+    pass.setIndexBuffer(g.indexBuffer, g.indexFormat);
+    if (ti && ti.count > 0) {
+      pass.drawIndexed(g.indexCount, ti.count);
+    } else {
+      pass.drawIndexed(g.indexCount);
+    }
+    return 1;
+  };
+  const r = {
+    order: mesh.renderOrder ?? (isAlphaBlend ? 200 : 100),
+    isTransparent: isAlphaBlend,
+    mesh,
+    bind(eng, sig) {
+      return {
+        renderable: r,
+        pipeline: _getOrCreateGeometryPipeline(eng, sig, view, res),
+        update,
+        draw
+      };
+    }
+  };
+  r._worldCenter = sortCenter;
+  return r;
+}
+function _ensureViewResources(view, engine, meshFeatures, variantKey) {
+  var _a, _b;
+  let cache = view._geometry;
+  if (!cache) {
+    cache = /* @__PURE__ */ new Map();
+    Object.defineProperty(view, "_geometry", { value: cache, enumerable: false, configurable: true });
+  }
+  const cached = cache.get(variantKey);
+  if (cached) {
+    return cached;
+  }
+  const source = view.source;
+  const features = view._renderFeatures.features;
+  const sortedExts = _getStdExtsSorted();
+  const frags = [];
+  const usedExts = [];
+  for (const ext of sortedExts) {
+    if (features & ext._feature) {
+      const f = ext._frag(features);
+      if (f) {
+        frags.push(f);
+        usedExts.push({ _ext: ext });
+      }
+    }
+  }
+  if (meshFeatures & MSH_HAS_THIN_INSTANCES) {
+    const hasColor = (meshFeatures & MSH_HAS_INSTANCE_COLOR) !== 0;
+    const tiFrag = createThinInstanceFragment(hasColor);
+    if (hasColor) {
+      const { _fragmentSlots: _drop, ...rest } = tiFrag;
+      frags.push({
+        ...rest,
+        _fragmentSlots: {
+          BC: `color = vec4<f32>(color.rgb * input.vInstanceColor.rgb, color.a * input.vInstanceColor.a);`
+        }
+      });
+    } else {
+      frags.push(tiFrag);
+    }
+  }
+  const composed = composeStandardGeometryShader(features, meshFeatures, frags, view._geometryAttachments, "", view._emitColor);
+  const device = engine._device;
+  const meshBGL = device.createBindGroupLayout(composed._meshBGLDescriptor);
+  const sceneBGL = getSceneBindGroupLayout(engine);
+  const pipelineLayout = device.createPipelineLayout({
+    bindGroupLayouts: [sceneBGL, meshBGL]
+  });
+  const vertModule = device.createShaderModule({ code: composed._vertexWGSL });
+  const fragModule = device.createShaderModule({ code: composed._fragmentWGSL });
+  const alphaBlend = source.alpha < 1 || (features & HAS_OPACITY_TEXTURE) !== 0;
+  const matData = new F32(24);
+  const textureLevel = (features & HAS_DIFFUSE_TEXTURE) !== 0 ? 1 : 0;
+  writeStdMaterialData(matData, source, textureLevel);
+  const matUBO = createUniformBuffer(engine, matData);
+  let upUBO = null;
+  if ((features & NEEDS_UV) !== 0) {
+    const uvData = new F32(4);
+    let scaleX = 1;
+    let scaleY = 1;
+    let offsetY = 0;
+    if ((features & HAS_DIFFUSE_TEXTURE) !== 0 && source.diffuseTexture) {
+      scaleX = source.uvScale[0];
+      scaleY = source.uvScale[1];
+      if (source.diffuseTexture.invertY) {
+        offsetY = scaleY;
+        scaleY = -scaleY;
+      }
+    } else if ((features & HAS_OPACITY_TEXTURE) !== 0 && ((_a = source.opacityTexture) == null ? void 0 : _a.invertY)) {
+      offsetY = 1;
+      scaleY = -1;
+    } else if ((_b = source.bumpTexture) == null ? void 0 : _b.invertY) {
+      offsetY = 1;
+      scaleY = -1;
+    }
+    uvData[0] = scaleX;
+    uvData[1] = scaleY;
+    uvData[2] = 0;
+    uvData[3] = offsetY;
+    upUBO = createUniformBuffer(engine, uvData);
+  }
+  const res = {
+    _composed: composed,
+    _features: features,
+    _meshBGL: meshBGL,
+    _pipelineLayout: pipelineLayout,
+    _vertModule: vertModule,
+    _fragModule: fragModule,
+    _pipelines: /* @__PURE__ */ new Map(),
+    _extFragments: usedExts,
+    _alphaBlend: alphaBlend,
+    _matUBO: matUBO,
+    _matData: matData,
+    _lastUboVersion: source._uboVersion,
+    _upUBO: upUBO
+  };
+  cache.set(variantKey, res);
+  return res;
+}
+function _createGeometryMeshBindGroup(engine, view, res, _mesh, meshUBO) {
+  const source = view.source;
+  const features = res._features;
+  let nextBinding = 0;
+  const entries = [
+    { binding: nextBinding++, resource: { buffer: meshUBO } },
+    { binding: nextBinding++, resource: { buffer: res._matUBO } }
+  ];
+  if ((features & HAS_DIFFUSE_TEXTURE) !== 0 && source.diffuseTexture) {
+    const tex = source.diffuseTexture;
+    entries.push({ binding: nextBinding++, resource: tex.texture.createView() }, { binding: nextBinding++, resource: tex.sampler });
+  }
+  if ((features & NEEDS_UV) !== 0 && res._upUBO) {
+    entries.push({ binding: nextBinding++, resource: { buffer: res._upUBO } });
+  }
+  for (const used of res._extFragments) {
+    if (used._ext._bind) {
+      nextBinding = used._ext._bind(source, entries, nextBinding);
+    }
+  }
+  if (view._gpUBO) {
+    entries.push({ binding: nextBinding++, resource: { buffer: view._gpUBO } });
+  }
+  return engine._device.createBindGroup({ layout: res._meshBGL, entries });
+}
+function _getOrCreateGeometryPipeline(engine, sig, view, res) {
+  const key = targetSignatureKey(sig);
+  const cached = res._pipelines.get(key);
+  if (cached) {
+    return cached;
+  }
+  const device = engine._device;
+  const formats = sig._colorFormats ?? (sig._colorFormat ? [sig._colorFormat] : []);
+  if (formats.length === 0) {
+    throw new Error("standard-geometry: render target has no color attachments");
+  }
+  const alphaBlend = res._alphaBlend;
+  const blendState = alphaBlend ? {
+    color: { srcFactor: "src-alpha", dstFactor: "one-minus-src-alpha", operation: "add" },
+    alpha: { srcFactor: "src-alpha", dstFactor: "one-minus-src-alpha", operation: "add" }
+  } : void 0;
+  const colorTargets = formats.map((fmt) => blendState ? { format: fmt, blend: blendState } : { format: fmt });
+  const cullMode = (res._features & DOUBLE_SIDED) !== 0 ? "none" : view._reverseCulling ? "front" : "back";
+  const pipeline = device.createRenderPipeline({
+    layout: res._pipelineLayout,
+    vertex: { module: res._vertModule, entryPoint: "main", buffers: res._composed._vertexBufferLayouts },
+    fragment: { module: res._fragModule, entryPoint: "main", targets: colorTargets },
+    depthStencil: sig._depthStencilFormat ? {
+      format: sig._depthStencilFormat,
+      depthCompare: sig._depthCompare ?? "greater-equal",
+      // BJS disables depth-write for transparent/opacity meshes in the
+      // geometry pass so background depth survives partially-transparent pixels.
+      depthWriteEnabled: !alphaBlend
+    } : void 0,
+    multisample: { count: sig._sampleCount },
+    // Geometry MRT renders to offscreen targets, so it needs the same
+    // Render upright — front face is always "ccw".
+    primitive: { topology: "triangle-list", cullMode, frontFace: "ccw" }
+  });
+  res._pipelines.set(key, pipeline);
+  return pipeline;
+}
+function createStandardGeometryMaterialView(source, config) {
+  var _a;
+  const baseFeatures = ((_a = source._renderFeatures) == null ? void 0 : _a.features) ?? 0;
+  const view = createMaterialView(source, { features: baseFeatures & ~MATERIAL_ALPHA_BLEND | GEOMETRY_OUTPUT });
+  Object.defineProperty(view, "_geometryAttachments", { value: config.attachments, enumerable: false });
+  Object.defineProperty(view, "_emitColor", { value: config.emitColor, enumerable: false });
+  Object.defineProperty(view, "_gpUBO", { value: config.gpUBO ?? null, enumerable: false });
+  Object.defineProperty(view, "_reverseCulling", { value: config.reverseCulling ?? false, enumerable: false });
+  Object.defineProperty(view, "_buildGroup", { value: standardGeometryGroupBuilder, enumerable: false });
+  return view;
+}
+export {
+  createStandardGeometryMaterialView
+};
+//# sourceMappingURL=geometry-view-BsFJpBJa.js.map