@babylonjs/lite 0.1.1

package/gs-picking-pipeline-DzfMASL9.js

@@ -0,0 +1,280 @@
+import { J as getRenderTargetSize, K as getViewMatrix, L as getProjectionMatrix, W as encodeIdToColor, X as getPickingSceneBGL, H as applyGsFragments, Y as gsGpuPickingFragment } from "./index-C8HOR2sB.js";
+let _cache = null;
+function buildPickingWgsl() {
+  const wgsl = (
+    /* wgsl */
+    `
+struct GsPickScene { pickMatrix: mat4x4<f32> };
+@group(0) @binding(0) var<uniform> gsPickScene: GsPickScene;
+
+struct U {
+  world: mat4x4<f32>,
+  view: mat4x4<f32>,
+  projection: mat4x4<f32>,
+  viewport: vec2<f32>,
+  focal: vec2<f32>,
+  dataSize: vec2<f32>,
+  alpha: f32,
+  _pad: f32,
+};
+@group(1) @binding(0) var<uniform> u: U;
+@group(1) @binding(1) var samp: sampler;
+@group(1) @binding(2) var centersTex: texture_2d<f32>;
+@group(1) @binding(3) var covATex: texture_2d<f32>;
+@group(1) @binding(4) var covBTex: texture_2d<f32>;
+@group(1) @binding(5) var colorsTex: texture_2d<f32>;
+
+struct VOut {
+  @builtin(position) pos: vec4<f32>,
+  @location(0) vColor: vec4<f32>,
+  @location(1) vPos: vec2<f32>,
+};
+
+fn dataUv(idx: f32) -> vec2<f32> {
+  let y = floor(idx / u.dataSize.x);
+  let x = idx - y * u.dataSize.x;
+  return vec2<f32>((x + 0.5) / u.dataSize.x, (y + 0.5) / u.dataSize.y);
+}
+
+@vertex
+fn vs(@location(0) corner: vec2<f32>, @location(1) splatIndex: f32) -> VOut {
+  var out: VOut;
+  let uv = dataUv(splatIndex);
+  let center = textureSampleLevel(centersTex, samp, uv, 0.0).xyz;
+  let color  = textureSampleLevel(colorsTex,  samp, uv, 0.0);
+  let covA   = textureSampleLevel(covATex,    samp, uv, 0.0).xyz;
+  let covB   = textureSampleLevel(covBTex,    samp, uv, 0.0).xyz;
+
+  let worldPos  = u.world * vec4<f32>(center, 1.0);
+  let modelView = u.view  * u.world;
+  let camspace  = u.view  * worldPos;
+  let pos2d     = u.projection * camspace;
+
+  let bounds = 1.2 * pos2d.w;
+  if (pos2d.z < 0.0
+      || pos2d.x < -bounds || pos2d.x > bounds
+      || pos2d.y < -bounds || pos2d.y > bounds) {
+    out.pos = vec4<f32>(0.0, 0.0, 2.0, 1.0);
+    out.vColor = vec4<f32>(0.0);
+    out.vPos = vec2<f32>(0.0);
+    return out;
+  }
+
+  let Vrk = mat3x3<f32>(
+    vec3<f32>(covA.x, covA.y, covA.z),
+    vec3<f32>(covA.y, covB.x, covB.y),
+    vec3<f32>(covA.z, covB.y, covB.z));
+
+  let invZ  = 1.0 / camspace.z;
+  let invZ2 = invZ * invZ;
+  let J = mat3x3<f32>(
+    vec3<f32>(u.focal.x * invZ, 0.0, -u.focal.x * camspace.x * invZ2),
+    vec3<f32>(0.0, u.focal.y * invZ, -u.focal.y * camspace.y * invZ2),
+    vec3<f32>(0.0, 0.0, 0.0));
+
+  let mv3 = mat3x3<f32>(modelView[0].xyz, modelView[1].xyz, modelView[2].xyz);
+  let T = transpose(mv3) * J;
+  var cov2d = transpose(T) * Vrk * T;
+
+  let kernelSize: f32 = 0.3;
+  cov2d[0][0] += kernelSize;
+  cov2d[1][1] += kernelSize;
+
+  let mid = (cov2d[0][0] + cov2d[1][1]) * 0.5;
+  let dxy = (cov2d[0][0] - cov2d[1][1]) * 0.5;
+  let radius = length(vec2<f32>(dxy, cov2d[0][1]));
+  let epsilon: f32 = 0.0001;
+  let lambda1 = mid + radius + epsilon;
+  let lambda2 = mid - radius + epsilon;
+  if (lambda2 < 0.0) {
+    out.pos = vec4<f32>(0.0, 0.0, 2.0, 1.0);
+    out.vColor = vec4<f32>(0.0);
+    out.vPos = vec2<f32>(0.0);
+    return out;
+  }
+
+  let diag = normalize(vec2<f32>(cov2d[0][1], lambda1 - cov2d[0][0]));
+  let majorAxis = min(sqrt(2.0 * lambda1), 1024.0) * diag;
+  let minorAxis = min(sqrt(2.0 * lambda2), 1024.0) * vec2<f32>(diag.y, -diag.x);
+
+  let vCenter = pos2d.xy;
+  out.pos = gsPickScene.pickMatrix * vec4<f32>(
+    vCenter + (corner.x * majorAxis + corner.y * minorAxis) * pos2d.w / u.viewport,
+    pos2d.z, pos2d.w);
+  out.vColor = vec4<f32>(color.rgb, color.a * u.alpha);
+  out.vPos = corner;
+  return out;
+}
+
+/*GS_FRAGMENT_DEFINITIONS*/
+struct FsOut { @location(0) color: vec4<f32>, @location(1) depth: vec4<f32> };
+@fragment
+fn fs(in: VOut) -> FsOut {
+  /*GS_FRAGMENT_MAIN_BEGIN*/
+  let A = -dot(in.vPos, in.vPos);
+  var finalColor: vec4<f32>;
+  if (A > -4.0) {
+    let B = exp(A) * in.vColor.a;
+    finalColor = vec4<f32>(in.vColor.rgb, B);
+  } else {
+    finalColor = vec4<f32>(0.0);
+  }
+  /*GS_FRAGMENT_BEFORE_FRAGCOLOR*/
+  /*GS_FRAGMENT_MAIN_END*/
+  return FsOut(finalColor, vec4<f32>(in.pos.z, 0.0, 0.0, 0.0));
+}
+`
+  );
+  return applyGsFragments(wgsl, [gsGpuPickingFragment]);
+}
+function getCache(engine) {
+  const device = engine._device;
+  if (_cache && _cache.device === device) {
+    return _cache;
+  }
+  const meshBGL = device.createBindGroupLayout({
+    label: "gs-picking-mesh-bgl",
+    entries: [
+      { 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" } }
+    ]
+  });
+  const pickingBGL = device.createBindGroupLayout({
+    label: "gs-picking-pick-bgl",
+    entries: [{ binding: 0, visibility: GPUShaderStage.FRAGMENT, buffer: { type: "uniform" } }]
+  });
+  const module = device.createShaderModule({ label: "gs-picking-shader", code: buildPickingWgsl() });
+  const pipeline = device.createRenderPipeline({
+    label: "gs-picking-pipeline",
+    layout: device.createPipelineLayout({ bindGroupLayouts: [getPickingSceneBGL(engine), meshBGL, pickingBGL] }),
+    vertex: {
+      module,
+      entryPoint: "vs",
+      buffers: [
+        { arrayStride: 8, stepMode: "vertex", attributes: [{ shaderLocation: 0, offset: 0, format: "float32x2" }] },
+        { arrayStride: 4, stepMode: "instance", attributes: [{ shaderLocation: 1, offset: 0, format: "float32" }] }
+      ]
+    },
+    fragment: {
+      module,
+      entryPoint: "fs",
+      targets: [{ format: "rgba8unorm" }, { format: "r32float" }]
+    },
+    primitive: { topology: "triangle-list", cullMode: "none" },
+    depthStencil: { format: "depth24plus", depthCompare: "less", depthWriteEnabled: true },
+    multisample: { count: 1 }
+  });
+  const pickMatrixUbo = device.createBuffer({ size: 64, usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST, label: "gs-picking-scene-ubo" });
+  const sceneBG = device.createBindGroup({
+    label: "gs-picking-scene-bg",
+    layout: getPickingSceneBGL(engine),
+    entries: [{ binding: 0, resource: { buffer: pickMatrixUbo } }]
+  });
+  _cache = { device, pipeline, meshBGL, pickingBGL, pickMatrixUbo, sceneBG };
+  return _cache;
+}
+function gsPickWritePickMatrixAndBind(pass, engine, pickMatrix) {
+  const cache = getCache(engine);
+  engine._device.queue.writeBuffer(cache.pickMatrixUbo, 0, pickMatrix.buffer, pickMatrix.byteOffset, pickMatrix.byteLength);
+  pass.setBindGroup(0, cache.sceneBG);
+}
+function createGsPickMeshResources(engine, mesh) {
+  const device = engine._device;
+  const cache = getCache(engine);
+  const UBO_BYTES = 16 * 4 * 3 + 8 * 4;
+  const meshUbo = device.createBuffer({ size: UBO_BYTES, usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST, label: "gs-picking-mesh-ubo" });
+  const meshCpu = new Float32Array(UBO_BYTES / 4);
+  meshCpu[48 + 4] = mesh.textureWidth;
+  meshCpu[48 + 5] = mesh.textureHeight;
+  meshCpu[48 + 6] = 1;
+  const meshBG = device.createBindGroup({
+    label: "gs-picking-mesh-bg",
+    layout: cache.meshBGL,
+    entries: [
+      { binding: 0, resource: { buffer: meshUbo } },
+      { binding: 1, resource: mesh._gs._sampler },
+      { binding: 2, resource: mesh._gs._centersView },
+      { binding: 3, resource: mesh._gs._covAView },
+      { binding: 4, resource: mesh._gs._covBView },
+      { binding: 5, resource: mesh._gs._colorsView }
+    ]
+  });
+  const pickingUbo = device.createBuffer({ size: 16, usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST, label: "gs-picking-color-ubo" });
+  const pickingCpu = new Float32Array(4);
+  const pickingBG = device.createBindGroup({
+    label: "gs-picking-color-bg",
+    layout: cache.pickingBGL,
+    entries: [{ binding: 0, resource: { buffer: pickingUbo } }]
+  });
+  return { meshUbo, meshBG, pickingUbo, pickingBG, meshCpu, pickingCpu };
+}
+function disposeGsPickMeshResources(res) {
+  res.meshUbo.destroy();
+  res.pickingUbo.destroy();
+}
+function drawGsForPicking(pass, engine, scene, mesh, res, pickId, targetWidth, targetHeight) {
+  const cache = getCache(engine);
+  const cam = scene.camera;
+  if (!cam) {
+    return;
+  }
+  const size = getRenderTargetSize(engine);
+  const aspect = (targetWidth || size.width) / (targetHeight || size.height);
+  const view = getViewMatrix(cam);
+  const proj = getProjectionMatrix(cam, aspect);
+  const world = mesh.worldMatrix;
+  const cpu = res.meshCpu;
+  cpu.set(world, 0);
+  cpu.set(view, 16);
+  cpu.set(proj, 32);
+  cpu[48] = size.width;
+  cpu[48 + 1] = size.height;
+  cpu[48 + 2] = size.width * 0.5 * proj[0];
+  cpu[48 + 3] = size.height * 0.5 * proj[5];
+  engine._device.queue.writeBuffer(res.meshUbo, 0, cpu.buffer, 0, cpu.byteLength);
+  const [r, g, b] = encodeIdToColor(pickId);
+  res.pickingCpu[0] = r;
+  res.pickingCpu[1] = g;
+  res.pickingCpu[2] = b;
+  res.pickingCpu[3] = 0;
+  engine._device.queue.writeBuffer(res.pickingUbo, 0, res.pickingCpu.buffer, 0, 16);
+  pass.setPipeline(cache.pipeline);
+  pass.setBindGroup(1, res.meshBG);
+  pass.setBindGroup(2, res.pickingBG);
+  pass.setVertexBuffer(0, mesh._gs._quadBuffer);
+  pass.setVertexBuffer(1, mesh._gs._splatIndexBuffer);
+  pass.setIndexBuffer(mesh._gs._indexBuffer, "uint16");
+  pass.drawIndexed(6, mesh.vertexCount);
+}
+function computeGsPickMatrix(out, px, py, w, h) {
+  const ndcX = 2 * (px + 0.5) / w - 1;
+  const ndcY = 1 - 2 * (py + 0.5) / h;
+  out[0] = w;
+  out[1] = 0;
+  out[2] = 0;
+  out[3] = 0;
+  out[4] = 0;
+  out[5] = h;
+  out[6] = 0;
+  out[7] = 0;
+  out[8] = 0;
+  out[9] = 0;
+  out[10] = 1;
+  out[11] = 0;
+  out[12] = -ndcX * w;
+  out[13] = -ndcY * h;
+  out[14] = 0;
+  out[15] = 1;
+}
+export {
+  computeGsPickMatrix,
+  createGsPickMeshResources,
+  disposeGsPickMeshResources,
+  drawGsForPicking,
+  gsPickWritePickMatrixAndBind
+};
+//# sourceMappingURL=gs-picking-pipeline-DzfMASL9.js.map

package/gs-picking-pipeline-DzfMASL9.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gs-picking-pipeline-DzfMASL9.js","sources":["../src/picking/gs-picking-pipeline.ts"],"sourcesContent":["/** GS GPU-picking pipeline — dynamic-imported by `gpu-picker.ts` when a scene\n *  contains a Gaussian-Splatting mesh.\n *\n *  The pipeline is a variant of the base Gaussian-splatting render pipeline\n *  (`gaussian-splatting.wgsl`) with three modifications, applied via string\n *  substitution + the `applyGsFragments` plugin system so the base shader stays\n *  untouched:\n *\n *  1.  A scene UBO at `@group(0) @binding(0)` carries a `pickMatrix`\n *      (column-major 4x4) that zooms NDC onto the pick pixel — same maths as\n *      `computePickVP` in `gpu-picker.ts`, but applied *after* the GS-specific\n *      projection so the EWA Jacobian / `u.focal` math is untouched.\n *  2.  The fragment returns `FsOut { @location(0) color, @location(1) depth }`\n *      so the picker can read a pick id + NDC z from the 1×1 render target.\n *  3.  `gsGpuPickingFragment` is applied (via `applyGsFragments`) to inject the\n *      per-mesh `pickingColor` UBO at `@group(2) @binding(0)` and override the\n *      fragment color with the encoded pick id.  This mirrors BJS\n *      `GaussianSplattingGpuPickingMaterialPlugin`'s `getCustomCode`/`bindForSubMesh`\n *      split.\n *\n *  The pipeline has no blending and `depthWriteEnabled = true`, so the\n *  closest-splat wins at each pick pixel (matching BJS GPU picker behaviour). */\n\nimport type { EngineContext } from \"../engine/engine.js\";\nimport type { GaussianSplattingMesh } from \"../mesh/GaussianSplatting/gaussian-splatting-mesh.js\";\nimport { applyGsFragments } from \"../mesh/GaussianSplatting/gaussian-splatting-pipeline.js\";\nimport { gsGpuPickingFragment, encodeIdToColor } from \"../mesh/GaussianSplatting/gs-gpu-picking-fragment.js\";\nimport { getPickingSceneBGL } from \"./picking-pipeline.js\";\nimport { getRenderTargetSize } from \"../engine/engine.js\";\nimport { getViewMatrix, getProjectionMatrix } from \"../camera/camera.js\";\nimport type { SceneContext } from \"../scene/scene-core.js\";\n\ninterface GsPickingCache {\n    device: GPUDevice;\n    pipeline: GPURenderPipeline;\n    meshBGL: GPUBindGroupLayout;\n    pickingBGL: GPUBindGroupLayout;\n    /** Shared \"pick scene\" UBO holding the 4x4 pickMatrix (set per pick). */\n    pickMatrixUbo: GPUBuffer;\n    /** Bind group exposing `pickMatrixUbo` at group(0) binding(0). */\n    sceneBG: GPUBindGroup;\n}\n\nlet _cache: GsPickingCache | null = null;\n\n/** Build the GS picking WGSL as a self-contained template literal.\n *\n *  This is a variant of the base GS shader (`gaussian-splatting.wgsl`) with two\n *  modifications baked in directly (rather than string-patched at runtime), so\n *  it survives identifier-mangling minification in production bundles:\n *\n *  1. The final `out.pos` is pre-multiplied by `gsPickScene.pickMatrix` (a 4×4\n *     UBO at `@group(0) @binding(0)`) — applied *after* the GS-specific\n *     projection so the EWA Jacobian / `u.focal` math is untouched.\n *  2. The fragment returns `FsOut { @location(0) color, @location(1) depth }`\n *     so the picker can read pick id + NDC z from the 1×1 render target.\n *\n *  The fragment keeps the `/* GS_FRAGMENT_* *\\/` slot markers so\n *  `gsGpuPickingFragment` is still spliced in via `applyGsFragments` to\n *  override `finalColor` with the encoded pick id.  Template-literal WGSL\n *  goes through `minifyTemplateWgsl` (preserves block comments) in the\n *  bundle pipeline, so the slot markers survive minification.\n */\nfunction buildPickingWgsl(): string {\n    const wgsl = /* wgsl */ `\nstruct GsPickScene { pickMatrix: mat4x4<f32> };\n@group(0) @binding(0) var<uniform> gsPickScene: GsPickScene;\n\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  _pad: 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\nstruct VOut {\n  @builtin(position) pos: vec4<f32>,\n  @location(0) vColor: vec4<f32>,\n  @location(1) vPos: vec2<f32>,\n};\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\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 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  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 = gsPickScene.pickMatrix * 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, color.a * u.alpha);\n  out.vPos = corner;\n  return out;\n}\n\n/*GS_FRAGMENT_DEFINITIONS*/\nstruct FsOut { @location(0) color: vec4<f32>, @location(1) depth: vec4<f32> };\n@fragment\nfn fs(in: VOut) -> FsOut {\n  /*GS_FRAGMENT_MAIN_BEGIN*/\n  let A = -dot(in.vPos, in.vPos);\n  var finalColor: vec4<f32>;\n  if (A > -4.0) {\n    let B = exp(A) * in.vColor.a;\n    finalColor = vec4<f32>(in.vColor.rgb, B);\n  } else {\n    finalColor = vec4<f32>(0.0);\n  }\n  /*GS_FRAGMENT_BEFORE_FRAGCOLOR*/\n  /*GS_FRAGMENT_MAIN_END*/\n  return FsOut(finalColor, vec4<f32>(in.pos.z, 0.0, 0.0, 0.0));\n}\n`;\n    return applyGsFragments(wgsl, [gsGpuPickingFragment]);\n}\n\nfunction getCache(engine: EngineContext): GsPickingCache {\n    const device = engine._device;\n    if (_cache && _cache.device === device) {\n        return _cache;\n    }\n    const meshBGL = device.createBindGroupLayout({\n        label: \"gs-picking-mesh-bgl\",\n        entries: [\n            { binding: 0, visibility: GPUShaderStage.VERTEX | GPUShaderStage.FRAGMENT, buffer: { type: \"uniform\" } },\n            { binding: 1, visibility: GPUShaderStage.VERTEX, sampler: { type: \"non-filtering\" } },\n            { binding: 2, visibility: GPUShaderStage.VERTEX, texture: { sampleType: \"unfilterable-float\" } },\n            { binding: 3, visibility: GPUShaderStage.VERTEX, texture: { sampleType: \"unfilterable-float\" } },\n            { binding: 4, visibility: GPUShaderStage.VERTEX, texture: { sampleType: \"unfilterable-float\" } },\n            { binding: 5, visibility: GPUShaderStage.VERTEX, texture: { sampleType: \"unfilterable-float\" } },\n        ],\n    });\n    const pickingBGL = device.createBindGroupLayout({\n        label: \"gs-picking-pick-bgl\",\n        entries: [{ binding: 0, visibility: GPUShaderStage.FRAGMENT, buffer: { type: \"uniform\" } }],\n    });\n    const module = device.createShaderModule({ label: \"gs-picking-shader\", code: buildPickingWgsl() });\n    const pipeline = device.createRenderPipeline({\n        label: \"gs-picking-pipeline\",\n        layout: device.createPipelineLayout({ bindGroupLayouts: [getPickingSceneBGL(engine), meshBGL, pickingBGL] }),\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: [{ format: \"rgba8unorm\" }, { format: \"r32float\" }],\n        },\n        primitive: { topology: \"triangle-list\", cullMode: \"none\" },\n        depthStencil: { format: \"depth24plus\", depthCompare: \"less\", depthWriteEnabled: true },\n        multisample: { count: 1 },\n    });\n    const pickMatrixUbo = device.createBuffer({ size: 64, usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST, label: \"gs-picking-scene-ubo\" });\n    const sceneBG = device.createBindGroup({\n        label: \"gs-picking-scene-bg\",\n        layout: getPickingSceneBGL(engine),\n        entries: [{ binding: 0, resource: { buffer: pickMatrixUbo } }],\n    });\n    _cache = { device, pipeline, meshBGL, pickingBGL, pickMatrixUbo, sceneBG };\n    return _cache;\n}\n\n/** Write a 4x4 pickMatrix into the shared scene UBO and bind group 0 on `pass`. */\nexport function gsPickWritePickMatrixAndBind(pass: GPURenderPassEncoder, engine: EngineContext, pickMatrix: Float32Array): void {\n    const cache = getCache(engine);\n    engine._device.queue.writeBuffer(cache.pickMatrixUbo, 0, pickMatrix.buffer, pickMatrix.byteOffset, pickMatrix.byteLength);\n    pass.setBindGroup(0, cache.sceneBG);\n}\n\n/** Per-GS-mesh state allocated on first pick of that mesh. */\nexport interface GsPickMeshResources {\n    /** Per-mesh UBO (same 224-byte layout as the regular GS pipeline UBO). */\n    meshUbo: GPUBuffer;\n    /** Group 1 bind group: per-mesh UBO + sampler + 4 textures. */\n    meshBG: GPUBindGroup;\n    /** Per-pick picking-color UBO (16 bytes: vec3<f32> + pad). */\n    pickingUbo: GPUBuffer;\n    /** Group 2 bind group with the picking-color UBO. */\n    pickingBG: GPUBindGroup;\n    /** Scratch buffer for the per-mesh UBO. */\n    meshCpu: Float32Array;\n    /** Scratch buffer for the picking-color UBO. */\n    pickingCpu: Float32Array;\n}\n\nexport function createGsPickMeshResources(engine: EngineContext, mesh: GaussianSplattingMesh): GsPickMeshResources {\n    const device = engine._device;\n    const cache = getCache(engine);\n\n    const UBO_BYTES = 16 * 4 * 3 + 8 * 4;\n    const meshUbo = device.createBuffer({ size: UBO_BYTES, usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST, label: \"gs-picking-mesh-ubo\" });\n    const meshCpu = new Float32Array(UBO_BYTES / 4);\n    meshCpu[48 + 4] = mesh.textureWidth;\n    meshCpu[48 + 5] = mesh.textureHeight;\n    meshCpu[48 + 6] = 1;\n\n    const meshBG = device.createBindGroup({\n        label: \"gs-picking-mesh-bg\",\n        layout: cache.meshBGL,\n        entries: [\n            { binding: 0, resource: { buffer: meshUbo } },\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    });\n\n    const pickingUbo = device.createBuffer({ size: 16, usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST, label: \"gs-picking-color-ubo\" });\n    const pickingCpu = new Float32Array(4);\n\n    const pickingBG = device.createBindGroup({\n        label: \"gs-picking-color-bg\",\n        layout: cache.pickingBGL,\n        entries: [{ binding: 0, resource: { buffer: pickingUbo } }],\n    });\n\n    return { meshUbo, meshBG, pickingUbo, pickingBG, meshCpu, pickingCpu };\n}\n\nexport function disposeGsPickMeshResources(res: GsPickMeshResources): void {\n    res.meshUbo.destroy();\n    res.pickingUbo.destroy();\n}\n\n/** Issue a pick draw for a single GS mesh.  The caller must have already bound\n *  the scene bind group (`pickMatrix` at group 0) on the pass; `pickId` is the\n *  24-bit pick id assigned by the picker. */\nexport function drawGsForPicking(\n    pass: GPURenderPassEncoder,\n    engine: EngineContext,\n    scene: SceneContext,\n    mesh: GaussianSplattingMesh,\n    res: GsPickMeshResources,\n    pickId: number,\n    targetWidth: number,\n    targetHeight: number\n): void {\n    const cache = getCache(engine);\n\n    // ── Per-mesh UBO ────────────────────────────────────────────────\n    const cam = scene.camera;\n    if (!cam) {\n        return;\n    }\n    const size = getRenderTargetSize(engine);\n    const aspect = (targetWidth || size.width) / (targetHeight || 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 cpu = res.meshCpu;\n    cpu.set(world, 0);\n    cpu.set(view, 16);\n    cpu.set(proj, 32);\n    // Note: the GS picking pipeline still runs over the full-canvas viewport;\n    // the picker output is a 1×1 target reached via the scene pickMatrix.\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    // dataSize/alpha already written at construction.\n    engine._device.queue.writeBuffer(res.meshUbo, 0, cpu.buffer, 0, cpu.byteLength);\n\n    // ── Picking-color UBO ───────────────────────────────────────────\n    const [r, g, b] = encodeIdToColor(pickId);\n    res.pickingCpu[0] = r;\n    res.pickingCpu[1] = g;\n    res.pickingCpu[2] = b;\n    res.pickingCpu[3] = 0;\n    engine._device.queue.writeBuffer(res.pickingUbo, 0, res.pickingCpu.buffer, 0, 16);\n\n    pass.setPipeline(cache.pipeline);\n    pass.setBindGroup(1, res.meshBG);\n    pass.setBindGroup(2, res.pickingBG);\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}\n\n/** Compute the pickMatrix for GS picking — same matrix `computePickVP` builds,\n *  but applied to the clip-space output of the GS shader rather than the world.\n *\n *  Maps canvas-NDC (px, py) ↦ (0, 0), and scales by (w, h) so a single canvas\n *  pixel covers the full 1×1 pick render target. */\nexport function computeGsPickMatrix(out: Float32Array, px: number, py: number, w: number, h: number): void {\n    const ndcX = (2 * (px + 0.5)) / w - 1;\n    const ndcY = 1 - (2 * (py + 0.5)) / h;\n    // column-major mat4\n    out[0] = w;\n    out[1] = 0;\n    out[2] = 0;\n    out[3] = 0;\n    out[4] = 0;\n    out[5] = h;\n    out[6] = 0;\n    out[7] = 0;\n    out[8] = 0;\n    out[9] = 0;\n    out[10] = 1;\n    out[11] = 0;\n    out[12] = -ndcX * w;\n    out[13] = -ndcY * h;\n    out[14] = 0;\n    out[15] = 1;\n}\n"],"names":[],"mappings":"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"}

package/height-to-normal-block-DhPHkDFg.js

@@ -0,0 +1,65 @@
+const HELPER_KEY = "nme_heightToNormal";
+const HELPER_WGSL = `
+fn nme_heightToNormal(height: f32, position: vec3<f32>, tangent: vec3<f32>, normal: vec3<f32>, generateInWorldSpace: bool, normalizeNormal: bool, normalizeTangent: bool) -> vec4<f32> {
+    let norm = select(normal, normalize(normal), normalizeNormal);
+    let tgt = select(tangent, normalize(tangent), normalizeTangent);
+    let worlddX = dpdx(position);
+    let worlddY = dpdy(position);
+    let crossX = cross(norm, worlddX);
+    let crossY = cross(worlddY, norm);
+    let d = abs(dot(crossY, worlddX));
+    var inToNormal = (((height + dpdx(height)) - height) * crossY + ((height + dpdy(height)) - height) * crossX) * sign(d);
+    inToNormal.y = -inToNormal.y;
+    var result = normalize(d * norm - inToNormal);
+    if (!generateInWorldSpace) {
+        let biTangent = cross(norm, tgt);
+        let tbn = mat3x3<f32>(tgt, biTangent, norm);
+        result = tbn * result;
+        result = result * vec3<f32>(0.5) + vec3<f32>(0.5);
+    }
+    return vec4<f32>(result, 0.0);
+}
+`;
+function boolLiteral(value, fallback) {
+  return (typeof value === "boolean" ? value : fallback) ? "true" : "false";
+}
+function emitHeightNormal(block, stage, state, ctx) {
+  const stageState = stage === "vertex" ? state.vertex : state.fragment;
+  const memoKey = `_heightToNormal_${block.id}`;
+  const existing = stageState.memo.get(memoKey);
+  if (existing) {
+    return existing;
+  }
+  state.fragment.helpers.set(HELPER_KEY, HELPER_WGSL);
+  const height = ctx.cast(ctx.resolve(block, "input", stage, state), "f32").expr;
+  const pos = ctx.cast(ctx.resolve(block, "worldPosition", stage, state), "vec3f").expr;
+  const normal = ctx.cast(ctx.resolve(block, "worldNormal", stage, state), "vec3f").expr;
+  const tangentInput = block.inputs.get("worldTangent");
+  const generateInWorldSpace = block.serialized.generateInWorldSpace === true;
+  if (!generateInWorldSpace && !(tangentInput == null ? void 0 : tangentInput.source)) {
+    throw new Error(`NodeMaterial: HeightToNormalBlock "${block.name}" requires worldTangent when generateInWorldSpace is false`);
+  }
+  const tangent = (tangentInput == null ? void 0 : tangentInput.source) ? ctx.cast(ctx.resolve(block, "worldTangent", stage, state), "vec3f").expr : "vec3<f32>(0.0)";
+  const out = `_hn${ctx.temp(state, "heightNormal")}`;
+  stageState.body.push(
+    `let ${out} = nme_heightToNormal(${height}, ${pos}, ${tangent}, ${normal}, ${boolLiteral(block.serialized.generateInWorldSpace, false)}, ${boolLiteral(block.serialized.automaticNormalizationNormal, true)}, ${boolLiteral(block.serialized.automaticNormalizationTangent, true)});`
+  );
+  const result = { expr: out, type: "vec4f" };
+  stageState.memo.set(memoKey, result);
+  return result;
+}
+const emitter = {
+  className: "HeightToNormalBlock",
+  stage: "fragment",
+  emit(block, outputName, stage, state, ctx) {
+    const value = emitHeightNormal(block, stage, state, ctx);
+    if (outputName === "xyz") {
+      return { expr: `${value.expr}.xyz`, type: "vec3f" };
+    }
+    return value;
+  }
+};
+export {
+  emitter
+};
+//# sourceMappingURL=height-to-normal-block-DhPHkDFg.js.map

package/height-to-normal-block-DhPHkDFg.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"height-to-normal-block-DhPHkDFg.js","sources":["../src/material/node/blocks/height-to-normal-block.ts"],"sourcesContent":["import type { BlockEmitter, NodeExpr } from \"../node-types.js\";\n\nconst HELPER_KEY = \"nme_heightToNormal\";\nconst HELPER_WGSL = `\nfn nme_heightToNormal(height: f32, position: vec3<f32>, tangent: vec3<f32>, normal: vec3<f32>, generateInWorldSpace: bool, normalizeNormal: bool, normalizeTangent: bool) -> vec4<f32> {\n    let norm = select(normal, normalize(normal), normalizeNormal);\n    let tgt = select(tangent, normalize(tangent), normalizeTangent);\n    let worlddX = dpdx(position);\n    let worlddY = dpdy(position);\n    let crossX = cross(norm, worlddX);\n    let crossY = cross(worlddY, norm);\n    let d = abs(dot(crossY, worlddX));\n    var inToNormal = (((height + dpdx(height)) - height) * crossY + ((height + dpdy(height)) - height) * crossX) * sign(d);\n    inToNormal.y = -inToNormal.y;\n    var result = normalize(d * norm - inToNormal);\n    if (!generateInWorldSpace) {\n        let biTangent = cross(norm, tgt);\n        let tbn = mat3x3<f32>(tgt, biTangent, norm);\n        result = tbn * result;\n        result = result * vec3<f32>(0.5) + vec3<f32>(0.5);\n    }\n    return vec4<f32>(result, 0.0);\n}\n`;\n\nfunction boolLiteral(value: unknown, fallback: boolean): string {\n    return (typeof value === \"boolean\" ? value : fallback) ? \"true\" : \"false\";\n}\n\nfunction emitHeightNormal(\n    block: Parameters<BlockEmitter[\"emit\"]>[0],\n    stage: Parameters<BlockEmitter[\"emit\"]>[2],\n    state: Parameters<BlockEmitter[\"emit\"]>[3],\n    ctx: Parameters<BlockEmitter[\"emit\"]>[4]\n): NodeExpr {\n    const stageState = stage === \"vertex\" ? state.vertex : state.fragment;\n    const memoKey = `_heightToNormal_${block.id}`;\n    const existing = stageState.memo.get(memoKey);\n    if (existing) {\n        return existing;\n    }\n\n    state.fragment.helpers.set(HELPER_KEY, HELPER_WGSL);\n    const height = ctx.cast(ctx.resolve(block, \"input\", stage, state), \"f32\").expr;\n    const pos = ctx.cast(ctx.resolve(block, \"worldPosition\", stage, state), \"vec3f\").expr;\n    const normal = ctx.cast(ctx.resolve(block, \"worldNormal\", stage, state), \"vec3f\").expr;\n    const tangentInput = block.inputs.get(\"worldTangent\");\n    const generateInWorldSpace = block.serialized.generateInWorldSpace === true;\n    if (!generateInWorldSpace && !tangentInput?.source) {\n        throw new Error(`NodeMaterial: HeightToNormalBlock \"${block.name}\" requires worldTangent when generateInWorldSpace is false`);\n    }\n    const tangent = tangentInput?.source ? ctx.cast(ctx.resolve(block, \"worldTangent\", stage, state), \"vec3f\").expr : \"vec3<f32>(0.0)\";\n    const out = `_hn${ctx.temp(state, \"heightNormal\")}`;\n    stageState.body.push(\n        `let ${out} = nme_heightToNormal(${height}, ${pos}, ${tangent}, ${normal}, ${boolLiteral(block.serialized.generateInWorldSpace, false)}, ${boolLiteral(block.serialized.automaticNormalizationNormal, true)}, ${boolLiteral(block.serialized.automaticNormalizationTangent, true)});`\n    );\n    const result = { expr: out, type: \"vec4f\" } as const;\n    stageState.memo.set(memoKey, result);\n    return result;\n}\n\nexport const emitter: BlockEmitter = {\n    className: \"HeightToNormalBlock\",\n    stage: \"fragment\",\n    emit(block, outputName, stage, state, ctx) {\n        const value = emitHeightNormal(block, stage, state, ctx);\n        if (outputName === \"xyz\") {\n            return { expr: `${value.expr}.xyz`, type: \"vec3f\" };\n        }\n        return value;\n    },\n};\n"],"names":[],"mappings":"AAEA,MAAM,aAAa;AACnB,MAAM,cAAc;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAsBpB,SAAS,YAAY,OAAgB,UAA2B;AAC5D,UAAQ,OAAO,UAAU,YAAY,QAAQ,YAAY,SAAS;AACtE;AAEA,SAAS,iBACL,OACA,OACA,OACA,KACQ;AACR,QAAM,aAAa,UAAU,WAAW,MAAM,SAAS,MAAM;AAC7D,QAAM,UAAU,mBAAmB,MAAM,EAAE;AAC3C,QAAM,WAAW,WAAW,KAAK,IAAI,OAAO;AAC5C,MAAI,UAAU;AACV,WAAO;AAAA,EACX;AAEA,QAAM,SAAS,QAAQ,IAAI,YAAY,WAAW;AAClD,QAAM,SAAS,IAAI,KAAK,IAAI,QAAQ,OAAO,SAAS,OAAO,KAAK,GAAG,KAAK,EAAE;AAC1E,QAAM,MAAM,IAAI,KAAK,IAAI,QAAQ,OAAO,iBAAiB,OAAO,KAAK,GAAG,OAAO,EAAE;AACjF,QAAM,SAAS,IAAI,KAAK,IAAI,QAAQ,OAAO,eAAe,OAAO,KAAK,GAAG,OAAO,EAAE;AAClF,QAAM,eAAe,MAAM,OAAO,IAAI,cAAc;AACpD,QAAM,uBAAuB,MAAM,WAAW,yBAAyB;AACvE,MAAI,CAAC,wBAAwB,EAAC,6CAAc,SAAQ;AAChD,UAAM,IAAI,MAAM,sCAAsC,MAAM,IAAI,4DAA4D;AAAA,EAChI;AACA,QAAM,WAAU,6CAAc,UAAS,IAAI,KAAK,IAAI,QAAQ,OAAO,gBAAgB,OAAO,KAAK,GAAG,OAAO,EAAE,OAAO;AAClH,QAAM,MAAM,MAAM,IAAI,KAAK,OAAO,cAAc,CAAC;AACjD,aAAW,KAAK;AAAA,IACZ,OAAO,GAAG,yBAAyB,MAAM,KAAK,GAAG,KAAK,OAAO,KAAK,MAAM,KAAK,YAAY,MAAM,WAAW,sBAAsB,KAAK,CAAC,KAAK,YAAY,MAAM,WAAW,8BAA8B,IAAI,CAAC,KAAK,YAAY,MAAM,WAAW,+BAA+B,IAAI,CAAC;AAAA,EAAA;AAErR,QAAM,SAAS,EAAE,MAAM,KAAK,MAAM,QAAA;AAClC,aAAW,KAAK,IAAI,SAAS,MAAM;AACnC,SAAO;AACX;AAEO,MAAM,UAAwB;AAAA,EACjC,WAAW;AAAA,EACX,OAAO;AAAA,EACP,KAAK,OAAO,YAAY,OAAO,OAAO,KAAK;AACvC,UAAM,QAAQ,iBAAiB,OAAO,OAAO,OAAO,GAAG;AACvD,QAAI,eAAe,OAAO;AACtB,aAAO,EAAE,MAAM,GAAG,MAAM,IAAI,QAAQ,MAAM,QAAA;AAAA,IAC9C;AACA,WAAO;AAAA,EACX;AACJ;"}

package/ibl-fragment-DqQVi8k0.js

@@ -0,0 +1,91 @@
+const STAGE_FRAGMENT = 2;
+const IBL_HELPERS = `
+fn environmentHorizonOcclusion(V: vec3<f32>, N: vec3<f32>, geoN: vec3<f32>) -> f32 {
+let R = reflect(V, N);
+let temp = saturate(1.0 + 1.1 * dot(R, geoN));
+return temp * temp;
+}
+fn getEnergyConservationFactor(F0: vec3<f32>, brdfY: f32) -> vec3<f32> {
+return 1.0 + F0 * (1.0 / brdfY - 1.0);
+}
+fn rotateY(v: vec3<f32>, angle: f32) -> vec3<f32> {
+let c = cos(angle);
+let s = sin(angle);
+return vec3<f32>(v.x * c + v.z * s, v.y, -v.x * s + v.z * c);
+}
+`;
+function makeIblCalculation(hasNormalMap, anisoBentNormalCode = "", skyboxCalculation = "") {
+  if (skyboxCalculation) {
+    return skyboxCalculation;
+  }
+  const ehoLine = hasNormalMap ? `let eho = environmentHorizonOcclusion(-V, N, N_geom);` : `let eho = 1.0;`;
+  const reflectionDir = anisoBentNormalCode ? anisoBentNormalCode : `let R_raw = reflect(-V, N);`;
+  const irradianceCode = `let environmentIrradiance = (scene.vSphericalL00.rgb
+  + scene.vSphericalL1_1.rgb * N_env.y + scene.vSphericalL10.rgb * N_env.z + scene.vSphericalL11.rgb * N_env.x
+  + scene.vSphericalL2_2.rgb * (N_env.y * N_env.x) + scene.vSphericalL2_1.rgb * (N_env.y * N_env.z)
+  + scene.vSphericalL20.rgb * (3.0 * N_env.z * N_env.z - 1.0) + scene.vSphericalL21.rgb * (N_env.z * N_env.x)
+  + scene.vSphericalL22.rgb * (N_env.x * N_env.x - N_env.y * N_env.y)) * material.environmentIntensity;`;
+  return `${reflectionDir}
+let R = rotateY(R_raw, scene.envRotationY);
+let N_env = rotateY(N, scene.envRotationY);
+let brdf = textureSample(brdfLUT, brdfSampler_, vec2<f32>(NdotV, roughness));
+let environmentBrdf = brdf.rgb;
+let specularEnvironmentReflectance = (colorF90 - colorF0) * environmentBrdf.x + colorF0 * environmentBrdf.y;
+let seo = clamp((NdotVUnclamped + occlusion) * (NdotVUnclamped + occlusion) - 1.0 + occlusion, 0.0, 1.0);
+${ehoLine}
+let colorSpecularEnvReflectance = specularEnvironmentReflectance * seo * eho;
+let energyConservation = getEnergyConservationFactor(colorF0, max(environmentBrdf.y, 0.001));
+${irradianceCode}
+let maxLod = f32(textureNumLevels(iblTexture) - 1);
+let cubemapDim = f32(textureDimensions(iblTexture).x);
+var specLod = log2(cubemapDim * alphaG) * scene.vImageInfos.z;
+var environmentRadiance = textureSampleLevel(iblTexture, iblSampler, R, clamp(specLod, 0.0, maxLod)).rgb * material.environmentIntensity;
+environmentRadiance = mix(environmentRadiance, environmentIrradiance, alphaG);
+let finalIrradiance = environmentIrradiance * surfaceAlbedo * occlusion;
+let finalSpecularScaled = directSpecular * energyConservation;
+let finalRadianceScaled = environmentRadiance * colorSpecularEnvReflectance * energyConservation;
+color = finalIrradiance + finalRadianceScaled + finalSpecularScaled + directDiffuse + emissive;`;
+}
+function createIblFragment(hasNormalMap, anisoBentNormalCode = "", skyboxCalculation = "") {
+  return {
+    _id: "ibl",
+    // SH coefficients are in the PBR template's baseSceneUboFields (not here)
+    // to preserve fixed scene UBO layout compatibility.
+    _bindings: [
+      { _name: "brdfLUT", _type: { _kind: "texture", _textureType: "texture_2d<f32>" }, _visibility: STAGE_FRAGMENT },
+      { _name: "brdfSampler_", _type: { _kind: "sampler", _samplerType: "sampler" }, _visibility: STAGE_FRAGMENT },
+      { _name: "iblTexture", _type: { _kind: "texture", _textureType: "texture_cube<f32>" }, _visibility: STAGE_FRAGMENT },
+      { _name: "iblSampler", _type: { _kind: "sampler", _samplerType: "sampler" }, _visibility: STAGE_FRAGMENT }
+    ],
+    _helperFunctions: IBL_HELPERS,
+    _fragmentSlots: {
+      AI: makeIblCalculation(hasNormalMap, anisoBentNormalCode, skyboxCalculation),
+      BA: `luminanceOverAlpha += dot(finalRadianceScaled, vec3<f32>(0.2126, 0.7152, 0.0722));`
+    }
+  };
+}
+const pbrExt = {
+  id: "ibl",
+  phase: "ibl",
+  frag(ctx) {
+    if (!ctx._hasIbl) {
+      return null;
+    }
+    return createIblFragment(ctx._hasAnyNormal, ctx._anisoBentNormalCode ?? "", ctx._iblSkyboxCalc ?? "");
+  },
+  bind(ctx, entries, b) {
+    if (!ctx._env) {
+      return b;
+    }
+    entries.push({ binding: b++, resource: ctx._env.brdfLutView });
+    entries.push({ binding: b++, resource: ctx._env.brdfSampler });
+    entries.push({ binding: b++, resource: ctx._env.specularCubeView });
+    entries.push({ binding: b++, resource: ctx._env.cubeSampler });
+    return b;
+  }
+};
+export {
+  createIblFragment,
+  pbrExt
+};
+//# sourceMappingURL=ibl-fragment-DqQVi8k0.js.map

package/ibl-fragment-DqQVi8k0.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ibl-fragment-DqQVi8k0.js","sources":["../src/material/pbr/fragments/ibl-fragment.ts"],"sourcesContent":["/**\n * IBL/Environment Fragment\n *\n * Adds image-based lighting via spherical harmonics irradiance + specular\n * cubemap. Only bundled when a scene loads an environment.\n *\n * Provides: scene UBO SH fields, BRDF LUT + IBL cube bindings,\n * horizon occlusion / energy conservation helpers, IBL calculation.\n */\n\nimport type { ShaderFragment } from \"../../../shader/fragment-types.js\";\n\n// WebGPU shader stage constants\nconst STAGE_FRAGMENT = 0x2;\n\nconst IBL_HELPERS = `\nfn environmentHorizonOcclusion(V: vec3<f32>, N: vec3<f32>, geoN: vec3<f32>) -> f32 {\nlet R = reflect(V, N);\nlet temp = saturate(1.0 + 1.1 * dot(R, geoN));\nreturn temp * temp;\n}\nfn getEnergyConservationFactor(F0: vec3<f32>, brdfY: f32) -> vec3<f32> {\nreturn 1.0 + F0 * (1.0 / brdfY - 1.0);\n}\nfn rotateY(v: vec3<f32>, angle: f32) -> vec3<f32> {\nlet c = cos(angle);\nlet s = sin(angle);\nreturn vec3<f32>(v.x * c + v.z * s, v.y, -v.x * s + v.z * c);\n}\n`;\n\nfunction makeIblCalculation(hasNormalMap: boolean, anisoBentNormalCode: string = \"\", skyboxCalculation: string = \"\"): string {\n    // Skybox mode: caller passes pre-baked WGSL (from ibl-skybox-wgsl.ts) to avoid\n    // bundling that ~1 KB string into scenes that don't use skyboxMode.\n    if (skyboxCalculation) {\n        return skyboxCalculation;\n    }\n\n    const ehoLine = hasNormalMap ? `let eho = environmentHorizonOcclusion(-V, N, N_geom);` : `let eho = 1.0;`;\n\n    // Normal PBR: use reflected view or anisotropy bent normal.\n    const reflectionDir = anisoBentNormalCode ? anisoBentNormalCode : `let R_raw = reflect(-V, N);`;\n\n    const irradianceCode = `let environmentIrradiance = (scene.vSphericalL00.rgb\n  + scene.vSphericalL1_1.rgb * N_env.y + scene.vSphericalL10.rgb * N_env.z + scene.vSphericalL11.rgb * N_env.x\n  + scene.vSphericalL2_2.rgb * (N_env.y * N_env.x) + scene.vSphericalL2_1.rgb * (N_env.y * N_env.z)\n  + scene.vSphericalL20.rgb * (3.0 * N_env.z * N_env.z - 1.0) + scene.vSphericalL21.rgb * (N_env.z * N_env.x)\n  + scene.vSphericalL22.rgb * (N_env.x * N_env.x - N_env.y * N_env.y)) * material.environmentIntensity;`;\n\n    return `${reflectionDir}\nlet R = rotateY(R_raw, scene.envRotationY);\nlet N_env = rotateY(N, scene.envRotationY);\nlet brdf = textureSample(brdfLUT, brdfSampler_, vec2<f32>(NdotV, roughness));\nlet environmentBrdf = brdf.rgb;\nlet specularEnvironmentReflectance = (colorF90 - colorF0) * environmentBrdf.x + colorF0 * environmentBrdf.y;\nlet seo = clamp((NdotVUnclamped + occlusion) * (NdotVUnclamped + occlusion) - 1.0 + occlusion, 0.0, 1.0);\n${ehoLine}\nlet colorSpecularEnvReflectance = specularEnvironmentReflectance * seo * eho;\nlet energyConservation = getEnergyConservationFactor(colorF0, max(environmentBrdf.y, 0.001));\n${irradianceCode}\nlet maxLod = f32(textureNumLevels(iblTexture) - 1);\nlet cubemapDim = f32(textureDimensions(iblTexture).x);\nvar specLod = log2(cubemapDim * alphaG) * scene.vImageInfos.z;\nvar environmentRadiance = textureSampleLevel(iblTexture, iblSampler, R, clamp(specLod, 0.0, maxLod)).rgb * material.environmentIntensity;\nenvironmentRadiance = mix(environmentRadiance, environmentIrradiance, alphaG);\nlet finalIrradiance = environmentIrradiance * surfaceAlbedo * occlusion;\nlet finalSpecularScaled = directSpecular * energyConservation;\nlet finalRadianceScaled = environmentRadiance * colorSpecularEnvReflectance * energyConservation;\ncolor = finalIrradiance + finalRadianceScaled + finalSpecularScaled + directDiffuse + emissive;`;\n}\n\n/**\n * Create an IBL/environment fragment.\n * @param hasNormalMap - Whether the material uses a normal map (enables horizon occlusion).\n * @param anisoBentNormalCode - WGSL code for anisotropic bent normal (empty string = standard reflection).\n * @param skyboxCalculation - Pre-baked skybox-mode WGSL from ibl-skybox-wgsl.ts (empty string = normal PBR).\n */\nexport function createIblFragment(hasNormalMap: boolean, anisoBentNormalCode: string = \"\", skyboxCalculation: string = \"\"): ShaderFragment {\n    return {\n        _id: \"ibl\",\n\n        // SH coefficients are in the PBR template's baseSceneUboFields (not here)\n        // to preserve fixed scene UBO layout compatibility.\n\n        _bindings: [\n            { _name: \"brdfLUT\", _type: { _kind: \"texture\", _textureType: \"texture_2d<f32>\" }, _visibility: STAGE_FRAGMENT },\n            { _name: \"brdfSampler_\", _type: { _kind: \"sampler\", _samplerType: \"sampler\" }, _visibility: STAGE_FRAGMENT },\n            { _name: \"iblTexture\", _type: { _kind: \"texture\", _textureType: \"texture_cube<f32>\" }, _visibility: STAGE_FRAGMENT },\n            { _name: \"iblSampler\", _type: { _kind: \"sampler\", _samplerType: \"sampler\" }, _visibility: STAGE_FRAGMENT },\n        ],\n\n        _helperFunctions: IBL_HELPERS,\n\n        _fragmentSlots: {\n            AI: makeIblCalculation(hasNormalMap, anisoBentNormalCode, skyboxCalculation),\n            BA: `luminanceOverAlpha += dot(finalRadianceScaled, vec3<f32>(0.2126, 0.7152, 0.0722));`,\n        },\n    };\n}\n\nimport type { PbrExt } from \"../pbr-flags.js\";\n\nexport const pbrExt: PbrExt = {\n    id: \"ibl\",\n    phase: \"ibl\",\n    frag(ctx) {\n        if (!ctx._hasIbl) {\n            return null;\n        }\n        return createIblFragment(ctx._hasAnyNormal, ctx._anisoBentNormalCode ?? \"\", ctx._iblSkyboxCalc ?? \"\");\n    },\n    bind(ctx, entries, b) {\n        if (!ctx._env) {\n            return b;\n        }\n        entries.push({ binding: b++, resource: ctx._env.brdfLutView });\n        entries.push({ binding: b++, resource: ctx._env.brdfSampler });\n        entries.push({ binding: b++, resource: ctx._env.specularCubeView });\n        entries.push({ binding: b++, resource: ctx._env.cubeSampler });\n        return b;\n    },\n};\n"],"names":[],"mappings":"AAaA,MAAM,iBAAiB;AAEvB,MAAM,cAAc;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAgBpB,SAAS,mBAAmB,cAAuB,sBAA8B,IAAI,oBAA4B,IAAY;AAGzH,MAAI,mBAAmB;AACnB,WAAO;AAAA,EACX;AAEA,QAAM,UAAU,eAAe,0DAA0D;AAGzF,QAAM,gBAAgB,sBAAsB,sBAAsB;AAElE,QAAM,iBAAiB;AAAA;AAAA;AAAA;AAAA;AAMvB,SAAO,GAAG,aAAa;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOzB,OAAO;AAAA;AAAA;AAAA,EAGP,cAAc;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAUhB;AAQO,SAAS,kBAAkB,cAAuB,sBAA8B,IAAI,oBAA4B,IAAoB;AACvI,SAAO;AAAA,IACH,KAAK;AAAA;AAAA;AAAA,IAKL,WAAW;AAAA,MACP,EAAE,OAAO,WAAW,OAAO,EAAE,OAAO,WAAW,cAAc,kBAAA,GAAqB,aAAa,eAAA;AAAA,MAC/F,EAAE,OAAO,gBAAgB,OAAO,EAAE,OAAO,WAAW,cAAc,UAAA,GAAa,aAAa,eAAA;AAAA,MAC5F,EAAE,OAAO,cAAc,OAAO,EAAE,OAAO,WAAW,cAAc,oBAAA,GAAuB,aAAa,eAAA;AAAA,MACpG,EAAE,OAAO,cAAc,OAAO,EAAE,OAAO,WAAW,cAAc,aAAa,aAAa,eAAA;AAAA,IAAe;AAAA,IAG7G,kBAAkB;AAAA,IAElB,gBAAgB;AAAA,MACZ,IAAI,mBAAmB,cAAc,qBAAqB,iBAAiB;AAAA,MAC3E,IAAI;AAAA,IAAA;AAAA,EACR;AAER;AAIO,MAAM,SAAiB;AAAA,EAC1B,IAAI;AAAA,EACJ,OAAO;AAAA,EACP,KAAK,KAAK;AACN,QAAI,CAAC,IAAI,SAAS;AACd,aAAO;AAAA,IACX;AACA,WAAO,kBAAkB,IAAI,eAAe,IAAI,wBAAwB,IAAI,IAAI,kBAAkB,EAAE;AAAA,EACxG;AAAA,EACA,KAAK,KAAK,SAAS,GAAG;AAClB,QAAI,CAAC,IAAI,MAAM;AACX,aAAO;AAAA,IACX;AACA,YAAQ,KAAK,EAAE,SAAS,KAAK,UAAU,IAAI,KAAK,aAAa;AAC7D,YAAQ,KAAK,EAAE,SAAS,KAAK,UAAU,IAAI,KAAK,aAAa;AAC7D,YAAQ,KAAK,EAAE,SAAS,KAAK,UAAU,IAAI,KAAK,kBAAkB;AAClE,YAAQ,KAAK,EAAE,SAAS,KAAK,UAAU,IAAI,KAAK,aAAa;AAC7D,WAAO;AAAA,EACX;AACJ;"}

package/ibl-skybox-wgsl-DCah0kWV.js

@@ -0,0 +1,13 @@
+const IBL_SKYBOX_CALCULATION = `let R = input.worldPos - scene.vEyePosition.xyz;
+let maxLod = f32(textureNumLevels(iblTexture) - 1);
+let cubemapDim = f32(textureDimensions(iblTexture).x);
+let skyboxAlphaG = max(roughness * roughness, 0.000001);
+var specLod = log2(cubemapDim * skyboxAlphaG) * scene.vImageInfos.z;
+var environmentRadiance = textureSampleLevel(iblTexture, iblSampler, R, clamp(specLod, 0.0, maxLod)).rgb * material.environmentIntensity;
+let finalSpecularScaled = vec3<f32>(0.0);
+let finalRadianceScaled = environmentRadiance;
+color = finalRadianceScaled + emissive;`;
+export {
+  IBL_SKYBOX_CALCULATION
+};
+//# sourceMappingURL=ibl-skybox-wgsl-DCah0kWV.js.map

package/ibl-skybox-wgsl-DCah0kWV.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ibl-skybox-wgsl-DCah0kWV.js","sources":["../src/material/pbr/fragments/ibl-skybox-wgsl.ts"],"sourcesContent":["/**\n * Skybox-mode IBL calculation (camera→fragment cubemap direction). Kept in a\n * separate module so scenes that don't use PBR skyboxMode don't pay the\n * ~1 KB string cost in their bundle. Dynamic-imported by pbr-renderable.ts\n * when PBR_HAS_SKYBOX is set.\n *\n * Matches BJS's disableLighting skybox-material path, where\n * MIX_IBL_RADIANCE_WITH_IRRADIANCE is not defined and the skybox uses the\n * sampled prefiltered radiance directly.\n */\n\nexport const IBL_SKYBOX_CALCULATION = `let R = input.worldPos - scene.vEyePosition.xyz;\nlet maxLod = f32(textureNumLevels(iblTexture) - 1);\nlet cubemapDim = f32(textureDimensions(iblTexture).x);\nlet skyboxAlphaG = max(roughness * roughness, 0.000001);\nvar specLod = log2(cubemapDim * skyboxAlphaG) * scene.vImageInfos.z;\nvar environmentRadiance = textureSampleLevel(iblTexture, iblSampler, R, clamp(specLod, 0.0, maxLod)).rgb * material.environmentIntensity;\nlet finalSpecularScaled = vec3<f32>(0.0);\nlet finalRadianceScaled = environmentRadiance;\ncolor = finalRadianceScaled + emissive;`;\n"],"names":[],"mappings":"AAWO,MAAM,yBAAyB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;"}

package/image-processing-block-DwrhhmuF.js

@@ -0,0 +1,40 @@
+function imageProcessingHelper(convertInputToLinearSpace) {
+  const linearize = convertInputToLinearSpace ? `rgb = pow(max(rgb, vec3<f32>(0.0)), vec3<f32>(2.2));` : ``;
+  return `fn nme_apply_image_processing(inputColor: vec4<f32>) -> vec4<f32> {
+    var rgb = inputColor.rgb;
+    ${linearize}
+    rgb = rgb * sceneU.vImageInfos.x;
+    if (sceneU.vImageInfos.w > 0.5) {
+        rgb = 1.0 - exp2(-1.590579 * rgb);
+    }
+    rgb = pow(max(rgb, vec3<f32>(0.0)), vec3<f32>(0.45454545));
+    rgb = clamp(rgb, vec3<f32>(0.0), vec3<f32>(1.0));
+    let highContrast = rgb * rgb * (vec3<f32>(3.0) - rgb * 2.0);
+    if (sceneU.vImageInfos.y < 1.0) {
+        rgb = mix(vec3<f32>(0.5), rgb, sceneU.vImageInfos.y);
+    } else {
+        rgb = mix(rgb, highContrast, sceneU.vImageInfos.y - 1.0);
+    }
+    return vec4<f32>(max(rgb, vec3<f32>(0.0)), inputColor.a);
+}`;
+}
+const emitter = {
+  className: "ImageProcessingBlock",
+  stage: "fragment",
+  emit(block, outputName, stage, state, ctx) {
+    const convertInput = block.serialized.convertInputToLinearSpace !== false;
+    const helperKey = `nme_image_processing_${convertInput ? "linear" : "as_is"}`;
+    state.fragment.helpers.set(helperKey, imageProcessingHelper(convertInput));
+    const color = ctx.cast(ctx.resolve(block, "color", stage, state), "vec4f");
+    const t = ctx.temp(state, "ip");
+    state.fragment.body.push(`let ${t} = nme_apply_image_processing(${color.expr});`);
+    if (outputName === "rgb") {
+      return { expr: `${t}.rgb`, type: "vec3f" };
+    }
+    return { expr: t, type: "vec4f" };
+  }
+};
+export {
+  emitter
+};
+//# sourceMappingURL=image-processing-block-DwrhhmuF.js.map

package/image-processing-block-DwrhhmuF.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"image-processing-block-DwrhhmuF.js","sources":["../src/material/node/blocks/image-processing-block.ts"],"sourcesContent":["/** ImageProcessingBlock — scene image-processing output path.\n *\n *  Matches Babylon.js' NME ImageProcessingBlock for the image-processing state\n *  currently exposed by Lite's canonical scene UBO (sceneU.vImageInfos):\n *  optional input `gamma->linear` conversion, exposure, standard exponential\n *  tone mapping, gamma encode, clamp, and contrast. Color grading/vignette/\n *  dither are intentionally absent because Lite does not expose those scene\n *  states yet.\n */\n\nimport type { BlockEmitter, NodeExpr } from \"../node-types.js\";\n\nfunction imageProcessingHelper(convertInputToLinearSpace: boolean): string {\n    const linearize = convertInputToLinearSpace ? `rgb = pow(max(rgb, vec3<f32>(0.0)), vec3<f32>(2.2));` : ``;\n    return `fn nme_apply_image_processing(inputColor: vec4<f32>) -> vec4<f32> {\n    var rgb = inputColor.rgb;\n    ${linearize}\n    rgb = rgb * sceneU.vImageInfos.x;\n    if (sceneU.vImageInfos.w > 0.5) {\n        rgb = 1.0 - exp2(-1.590579 * rgb);\n    }\n    rgb = pow(max(rgb, vec3<f32>(0.0)), vec3<f32>(0.45454545));\n    rgb = clamp(rgb, vec3<f32>(0.0), vec3<f32>(1.0));\n    let highContrast = rgb * rgb * (vec3<f32>(3.0) - rgb * 2.0);\n    if (sceneU.vImageInfos.y < 1.0) {\n        rgb = mix(vec3<f32>(0.5), rgb, sceneU.vImageInfos.y);\n    } else {\n        rgb = mix(rgb, highContrast, sceneU.vImageInfos.y - 1.0);\n    }\n    return vec4<f32>(max(rgb, vec3<f32>(0.0)), inputColor.a);\n}`;\n}\n\nexport const emitter: BlockEmitter = {\n    className: \"ImageProcessingBlock\",\n    stage: \"fragment\",\n    emit(block, outputName, stage, state, ctx): NodeExpr {\n        const convertInput = (block.serialized as { convertInputToLinearSpace?: boolean }).convertInputToLinearSpace !== false;\n        const helperKey = `nme_image_processing_${convertInput ? \"linear\" : \"as_is\"}`;\n        state.fragment.helpers.set(helperKey, imageProcessingHelper(convertInput));\n        const color = ctx.cast(ctx.resolve(block, \"color\", stage, state), \"vec4f\");\n        const t = ctx.temp(state, \"ip\");\n        state.fragment.body.push(`let ${t} = nme_apply_image_processing(${color.expr});`);\n        if (outputName === \"rgb\") {\n            return { expr: `${t}.rgb`, type: \"vec3f\" };\n        }\n        return { expr: t, type: \"vec4f\" };\n    },\n};\n"],"names":[],"mappings":"AAYA,SAAS,sBAAsB,2BAA4C;AACvE,QAAM,YAAY,4BAA4B,yDAAyD;AACvG,SAAO;AAAA;AAAA,MAEL,SAAS;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAef;AAEO,MAAM,UAAwB;AAAA,EACjC,WAAW;AAAA,EACX,OAAO;AAAA,EACP,KAAK,OAAO,YAAY,OAAO,OAAO,KAAe;AACjD,UAAM,eAAgB,MAAM,WAAuD,8BAA8B;AACjH,UAAM,YAAY,wBAAwB,eAAe,WAAW,OAAO;AAC3E,UAAM,SAAS,QAAQ,IAAI,WAAW,sBAAsB,YAAY,CAAC;AACzE,UAAM,QAAQ,IAAI,KAAK,IAAI,QAAQ,OAAO,SAAS,OAAO,KAAK,GAAG,OAAO;AACzE,UAAM,IAAI,IAAI,KAAK,OAAO,IAAI;AAC9B,UAAM,SAAS,KAAK,KAAK,OAAO,CAAC,iCAAiC,MAAM,IAAI,IAAI;AAChF,QAAI,eAAe,OAAO;AACtB,aAAO,EAAE,MAAM,GAAG,CAAC,QAAQ,MAAM,QAAA;AAAA,IACrC;AACA,WAAO,EAAE,MAAM,GAAG,MAAM,QAAA;AAAA,EAC5B;AACJ;"}

package/image-source-BuMJgd9-.js

@@ -0,0 +1,17 @@
+const emitter = {
+  className: "ImageSourceBlock",
+  emit(block, _outputName, _stage, state, _ctx) {
+    const bindingName = sanitize(block.name || `img${block.id}`);
+    if (!state.textures.find((t) => t.name === bindingName)) {
+      state.textures.push({ name: bindingName, kind: "texture2d", texture: null });
+    }
+    return { expr: bindingName, type: "texture2d" };
+  }
+};
+function sanitize(name) {
+  return name.replace(/[^A-Za-z0-9_]/g, "_");
+}
+export {
+  emitter
+};
+//# sourceMappingURL=image-source-BuMJgd9-.js.map

package/image-source-BuMJgd9-.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"image-source-BuMJgd9-.js","sources":["../src/material/node/blocks/image-source.ts"],"sourcesContent":["/** ImageSourceBlock — holds a texture reference and feeds a TextureBlock's `source` input.\n *\n *  The emitter does not emit any WGSL of its own; it just advertises that a\n *  texture binding named after this block exists, so the downstream TextureBlock\n *  can refer to it. The actual texture upload is handled at material-build time.\n */\n\nimport type { BlockEmitter } from \"../node-types.js\";\n\nexport const emitter: BlockEmitter = {\n    className: \"ImageSourceBlock\",\n    emit(block, _outputName, _stage, state, _ctx) {\n        const bindingName = sanitize(block.name || `img${block.id}`);\n        if (!state.textures.find((t) => t.name === bindingName)) {\n            state.textures.push({ name: bindingName, kind: \"texture2d\", texture: null });\n        }\n        // Return a sentinel — the TextureBlock consumes the binding name via this.\n        return { expr: bindingName, type: \"texture2d\" };\n    },\n};\n\nfunction sanitize(name: string): string {\n    return name.replace(/[^A-Za-z0-9_]/g, \"_\");\n}\n"],"names":[],"mappings":"AASO,MAAM,UAAwB;AAAA,EACjC,WAAW;AAAA,EACX,KAAK,OAAO,aAAa,QAAQ,OAAO,MAAM;AAC1C,UAAM,cAAc,SAAS,MAAM,QAAQ,MAAM,MAAM,EAAE,EAAE;AAC3D,QAAI,CAAC,MAAM,SAAS,KAAK,CAAC,MAAM,EAAE,SAAS,WAAW,GAAG;AACrD,YAAM,SAAS,KAAK,EAAE,MAAM,aAAa,MAAM,aAAa,SAAS,MAAM;AAAA,IAC/E;AAEA,WAAO,EAAE,MAAM,aAAa,MAAM,YAAA;AAAA,EACtC;AACJ;AAEA,SAAS,SAAS,MAAsB;AACpC,SAAO,KAAK,QAAQ,kBAAkB,GAAG;AAC7C;"}