@babylonjs/lite 0.1.1

package/node-registry-extra-procedural-5pLQ3Bhz.js

@@ -0,0 +1,45 @@
+function blockLoader(key) {
+  switch (key) {
+    case "ColorMergerBlock":
+      return () => import("./color-merger-CCu21ZII.js");
+    case "ColorConverterBlock":
+      return () => import("./color-converter-block-CvwKiW4k.js");
+    case "DesaturateBlock":
+      return () => import("./desaturate-block-C1RghNSB.js");
+    case "GradientBlock":
+      return () => import("./gradient-block-DL_60sDc.js");
+    case "PosterizeBlock":
+      return () => import("./posterize-block-DfdKsbEf.js");
+    case "ReplaceColorBlock":
+      return () => import("./replace-color-block-1m--hiru.js");
+    case "PannerBlock":
+      return () => import("./panner-block-BwMQq-6Y.js");
+    case "Rotate2dBlock":
+      return () => import("./rotate2d-block-nEe1N2MJ.js");
+    case "TriPlanarBlock":
+      return () => import("./triplanar-block-BZHkD9hX.js");
+    case "BiPlanarBlock":
+      return () => import("./biplanar-block-DZnKuV81.js");
+    case "CloudBlock":
+      return () => import("./cloud-block-BeVrangc.js");
+    case "SimplexPerlin3DBlock":
+      return () => import("./simplex-perlin-3d-block-CcMtofzV.js");
+    case "VoronoiNoiseBlock":
+      return () => import("./voronoi-noise-block-iNQxa_Ls.js");
+    case "WorleyNoise3DBlock":
+      return () => import("./worley-noise-3d-block-CyR2-k4s.js");
+    default:
+      return null;
+  }
+}
+async function loadExtraEmitter(key) {
+  const loader = blockLoader(key);
+  if (!loader) {
+    throw new Error(`NodeMaterial: no procedural extension emitter registered for block "${key}"`);
+  }
+  return (await loader()).emitter;
+}
+export {
+  loadExtraEmitter
+};
+//# sourceMappingURL=node-registry-extra-procedural-5pLQ3Bhz.js.map

package/node-registry-extra-procedural-5pLQ3Bhz.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"node-registry-extra-procedural-5pLQ3Bhz.js","sources":["../src/material/node/node-registry-extra-procedural.ts"],"sourcesContent":["import type { BlockEmitter } from \"./node-types.js\";\nimport type { BlockLoader } from \"./node-registry.js\";\n\nfunction blockLoader(key: string): BlockLoader | null {\n    switch (key) {\n        case \"ColorMergerBlock\":\n            return () => import(\"./blocks/color-merger.js\");\n        case \"ColorConverterBlock\":\n            return () => import(\"./blocks/color-converter-block.js\");\n        case \"DesaturateBlock\":\n            return () => import(\"./blocks/desaturate-block.js\");\n        case \"GradientBlock\":\n            return () => import(\"./blocks/gradient-block.js\");\n        case \"PosterizeBlock\":\n            return () => import(\"./blocks/posterize-block.js\");\n        case \"ReplaceColorBlock\":\n            return () => import(\"./blocks/replace-color-block.js\");\n        case \"PannerBlock\":\n            return () => import(\"./blocks/panner-block.js\");\n        case \"Rotate2dBlock\":\n            return () => import(\"./blocks/rotate2d-block.js\");\n        case \"TriPlanarBlock\":\n            return () => import(\"./blocks/triplanar-block.js\");\n        case \"BiPlanarBlock\":\n            return () => import(\"./blocks/biplanar-block.js\");\n        case \"CloudBlock\":\n            return () => import(\"./blocks/cloud-block.js\");\n        case \"SimplexPerlin3DBlock\":\n            return () => import(\"./blocks/simplex-perlin-3d-block.js\");\n        case \"VoronoiNoiseBlock\":\n            return () => import(\"./blocks/voronoi-noise-block.js\");\n        case \"WorleyNoise3DBlock\":\n            return () => import(\"./blocks/worley-noise-3d-block.js\");\n        default:\n            return null;\n    }\n}\n\nexport async function loadExtraEmitter(key: string): Promise<BlockEmitter> {\n    const loader = blockLoader(key);\n    if (!loader) {\n        throw new Error(`NodeMaterial: no procedural extension emitter registered for block \"${key}\"`);\n    }\n    return (await loader()).emitter;\n}\n"],"names":[],"mappings":"AAGA,SAAS,YAAY,KAAiC;AAClD,UAAQ,KAAA;AAAA,IACJ,KAAK;AACD,aAAO,MAAM,OAAO,4BAA0B;AAAA,IAClD,KAAK;AACD,aAAO,MAAM,OAAO,qCAAmC;AAAA,IAC3D,KAAK;AACD,aAAO,MAAM,OAAO,gCAA8B;AAAA,IACtD,KAAK;AACD,aAAO,MAAM,OAAO,8BAA4B;AAAA,IACpD,KAAK;AACD,aAAO,MAAM,OAAO,+BAA6B;AAAA,IACrD,KAAK;AACD,aAAO,MAAM,OAAO,mCAAiC;AAAA,IACzD,KAAK;AACD,aAAO,MAAM,OAAO,4BAA0B;AAAA,IAClD,KAAK;AACD,aAAO,MAAM,OAAO,8BAA4B;AAAA,IACpD,KAAK;AACD,aAAO,MAAM,OAAO,+BAA6B;AAAA,IACrD,KAAK;AACD,aAAO,MAAM,OAAO,8BAA4B;AAAA,IACpD,KAAK;AACD,aAAO,MAAM,OAAO,2BAAyB;AAAA,IACjD,KAAK;AACD,aAAO,MAAM,OAAO,uCAAqC;AAAA,IAC7D,KAAK;AACD,aAAO,MAAM,OAAO,mCAAiC;AAAA,IACzD,KAAK;AACD,aAAO,MAAM,OAAO,qCAAmC;AAAA,IAC3D;AACI,aAAO;AAAA,EAAA;AAEnB;AAEA,eAAsB,iBAAiB,KAAoC;AACvE,QAAM,SAAS,YAAY,GAAG;AAC9B,MAAI,CAAC,QAAQ;AACT,UAAM,IAAI,MAAM,uEAAuE,GAAG,GAAG;AAAA,EACjG;AACA,UAAQ,MAAM,UAAU;AAC5B;"}

package/node-renderable-DlLIdBmd.js

@@ -0,0 +1,269 @@
+import { c as compileNodePipeline, w as writeNodeUBO, a as writeMeshLightSelection, N as NODE_ESM_SHADOW_OUTPUT, b as NODE_NO_COLOR_OUTPUT, M as MAX_LIGHTS } from "./index-C8HOR2sB.js";
+const emptyMorphByEngine = /* @__PURE__ */ new WeakMap();
+function getEmptyMorph(engine) {
+  const cached = emptyMorphByEngine.get(engine);
+  if (cached) {
+    return cached;
+  }
+  const texture = engine._device.createTexture({
+    label: "node-morph-empty",
+    size: [1, 1],
+    format: "rgba32float",
+    usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST
+  });
+  engine._device.queue.writeTexture({ texture }, new Float32Array([0, 0, 0, 0]).buffer, { bytesPerRow: 16 }, { width: 1, height: 1 });
+  const ubo = new ArrayBuffer(32);
+  const u32 = new Uint32Array(ubo, 16, 4);
+  u32[0] = 0;
+  u32[1] = 1;
+  u32[2] = 1;
+  const weightsBuffer = engine._device.createBuffer({ label: "node-morph-empty-ubo", size: 32, usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST });
+  engine._device.queue.writeBuffer(weightsBuffer, 0, new Uint8Array(ubo));
+  const entry = { texture, weightsBuffer };
+  emptyMorphByEngine.set(engine, entry);
+  return entry;
+}
+function buildNodeMeshRenderables(scene, meshes, materialOverride) {
+  var _a, _b, _c, _d;
+  const engine = scene.engine;
+  const device = engine._device;
+  const byMaterial = /* @__PURE__ */ new Map();
+  for (const m of meshes) {
+    const mat = materialOverride ?? m.material;
+    let list = byMaterial.get(mat);
+    if (!list) {
+      list = [];
+      byMaterial.set(mat, list);
+    }
+    list.push(m);
+  }
+  const renderables = [];
+  for (const [material, matMeshes] of byMaterial) {
+    const featureFlags = ((_a = material._renderFeatures) == null ? void 0 : _a.features) ?? 0;
+    const noColorOutput = (featureFlags & NODE_NO_COLOR_OUTPUT) !== 0;
+    const esmShadowOutput = (featureFlags & NODE_ESM_SHADOW_OUTPUT) !== 0;
+    const shadowOutput = noColorOutput || esmShadowOutput;
+    const compile = shadowOutput ? compileNodePipeline(material._state, material._vertexBody, material._fragmentBody, {
+      _engine: engine,
+      _format: esmShadowOutput ? "rgba16float" : engine.format,
+      _depthStencilFormat: "depth32float",
+      _depthCompare: "less-equal",
+      _msaaSamples: 1,
+      _backFaceCulling: material._graph.backFaceCulling,
+      _noColorOutput: noColorOutput,
+      _esmShadowOutput: esmShadowOutput,
+      _esmShadowDepthCode: esmShadowOutput ? material._esmShadowDepthCode : void 0,
+      _alphaMode: esmShadowOutput ? 0 : void 0
+    }) : material._compile;
+    const meshBGL = compile._meshBGL;
+    let nodeUBO = null;
+    if (compile._nodeUboBinding !== null && compile._nodeUboSize > 0) {
+      nodeUBO = device.createBuffer({ label: "node-ubo", size: compile._nodeUboSize, usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST });
+      writeNodeUBO(engine, nodeUBO, material);
+      material._nodeUBO = nodeUBO;
+    }
+    const packets = [];
+    for (const _mesh of matMeshes) {
+      const meshUboBytes = 96 + 16 * Math.ceil(MAX_LIGHTS / 4);
+      const _meshUBO = device.createBuffer({ label: "node-mesh-ubo", size: meshUboBytes + 15 & -16, usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST });
+      const _meshScratch = new Float32Array((meshUboBytes + 15 & -16) / 4);
+      _meshScratch.set(_mesh.worldMatrix, 0);
+      const recv = _mesh.receiveShadows ? 1 : 0;
+      _meshScratch[16] = recv;
+      if (compile._usesMeshAttributeFlags) {
+        writeAttributeFlags(_mesh, _meshScratch);
+      }
+      writeMeshLightSelection(_mesh, scene.lights, _meshScratch.subarray(4));
+      device.queue.writeBuffer(_meshUBO, 0, _meshScratch);
+      const entries = [{ binding: 0, resource: { buffer: _meshUBO } }];
+      if (nodeUBO) {
+        entries.push({ binding: compile._nodeUboBinding, resource: { buffer: nodeUBO } });
+      }
+      for (const tb of compile._textureBindings) {
+        const slot = material._textureSlots.get(tb._name);
+        const tex = slot == null ? void 0 : slot.current;
+        if (!tex) {
+          throw new Error(
+            `NodeMaterial: texture binding "${tb._name}" not set. Provide it via options.textures or material.inputs["${tb._name}"].texture before the first render.`
+          );
+        }
+        entries.push({ binding: tb._texBinding, resource: tex.view });
+        entries.push({ binding: tb._sampBinding, resource: tex.sampler });
+      }
+      if (compile._morphBindings !== null) {
+        const mt = _mesh.morphTargets ?? getEmptyMorph(engine);
+        entries.push({ binding: compile._morphBindings._textureBinding, resource: mt.texture.createView() });
+        entries.push({ binding: compile._morphBindings._uboBinding, resource: { buffer: mt.weightsBuffer } });
+      }
+      if (compile._envBindings) {
+        material._envHelpers.pushEnvBindGroupEntries(scene, compile._envBindings, entries);
+      }
+      for (let si = 0; si < compile._shadowBindings.length; si++) {
+        const sb = compile._shadowBindings[si];
+        const sg = material._shadowGenerators[si];
+        if (!sg) {
+          throw new Error(`NodeMaterial: material requires shadow generator #${si} but none was supplied to parseNodeMaterialFromSnippet({ shadowGenerators }).`);
+        }
+        entries.push({ binding: sb._texBinding, resource: sg._depthTexture.createView() });
+        entries.push({ binding: sb._sampBinding, resource: sg._depthSampler });
+        entries.push({ binding: sb._uboBinding, resource: { buffer: sg._shadowUBO } });
+      }
+      if (compile._esmShadowParamsBinding !== null) {
+        entries.push({
+          binding: compile._esmShadowParamsBinding,
+          resource: { buffer: material._esmShadowParamsUBO }
+        });
+      }
+      const _meshBG = device.createBindGroup({ label: "node-mesh-bg", layout: meshBGL, entries });
+      packets.push({
+        _mesh,
+        _meshUBO,
+        _meshBG,
+        _meshScratch,
+        _lastWorldVersion: _mesh.worldMatrixVersion,
+        _lastReceivesShadow: recv,
+        _lastLightsCount: scene.lights.length
+      });
+    }
+    const attrNames = material._vertexAttrNames;
+    const updatePacketUBO = (pkt) => {
+      const recv = pkt._mesh.receiveShadows ? 1 : 0;
+      const worldVersion = pkt._mesh.worldMatrixVersion;
+      const worldChanged = worldVersion !== pkt._lastWorldVersion;
+      const recvChanged = recv !== pkt._lastReceivesShadow;
+      const lightsChanged = scene.lights.length !== pkt._lastLightsCount;
+      if (worldChanged || recvChanged || lightsChanged) {
+        pkt._meshScratch.set(pkt._mesh.worldMatrix, 0);
+        pkt._meshScratch[16] = recv;
+        if (compile._usesMeshAttributeFlags) {
+          writeAttributeFlags(pkt._mesh, pkt._meshScratch);
+        }
+        writeMeshLightSelection(pkt._mesh, scene.lights, pkt._meshScratch.subarray(4));
+        device.queue.writeBuffer(pkt._meshUBO, 0, pkt._meshScratch);
+        pkt._lastWorldVersion = worldVersion;
+        pkt._lastReceivesShadow = recv;
+        pkt._lastLightsCount = scene.lights.length;
+      }
+    };
+    const updateNodeUBO = () => {
+      if (nodeUBO && material._uboDirty) {
+        material._uboDirty = false;
+        writeNodeUBO(engine, nodeUBO, material);
+      }
+    };
+    const drawPacket = (pass, pkt) => {
+      const g = pkt._mesh._gpu;
+      for (let i = 0; i < attrNames.length; i++) {
+        const buf = getAttrBuffer(engine, g, attrNames[i]);
+        pass.setVertexBuffer(i, buf);
+      }
+      pass.setIndexBuffer(g.indexBuffer, g.indexFormat);
+      pass.setBindGroup(1, pkt._meshBG);
+      pass.drawIndexed(g.indexCount);
+    };
+    const isTransparent = !noColorOutput && !esmShadowOutput && material._needsAlphaBlending;
+    if (isTransparent) {
+      for (const pkt of packets) {
+        const wm = pkt._mesh.worldMatrix;
+        const cx = ((_b = pkt._mesh.position) == null ? void 0 : _b.x) ?? wm[12];
+        const cy = ((_c = pkt._mesh.position) == null ? void 0 : _c.y) ?? wm[13];
+        const cz = ((_d = pkt._mesh.position) == null ? void 0 : _d.z) ?? wm[14];
+        const sortCenter = [cx, cy, cz];
+        const update = () => {
+          updatePacketUBO(pkt);
+          updateNodeUBO();
+          const m = pkt._mesh.worldMatrix;
+          sortCenter[0] = m[12];
+          sortCenter[1] = m[13];
+          sortCenter[2] = m[14];
+        };
+        const draw = (pass) => {
+          drawPacket(pass, pkt);
+          return 1;
+        };
+        const rTrans = {
+          order: 200,
+          isTransparent: true,
+          mesh: pkt._mesh,
+          _worldCenter: sortCenter,
+          bind() {
+            return { renderable: rTrans, pipeline: compile._pipeline, update, draw };
+          }
+        };
+        renderables.push(rTrans);
+      }
+    } else {
+      const update = () => {
+        for (const pkt of packets) {
+          updatePacketUBO(pkt);
+        }
+        updateNodeUBO();
+      };
+      const draw = (pass) => {
+        let draws = 0;
+        for (const pkt of packets) {
+          drawPacket(pass, pkt);
+          draws++;
+        }
+        return draws;
+      };
+      const rOpaque = {
+        order: 100,
+        isTransparent: false,
+        bind() {
+          return { renderable: rOpaque, pipeline: compile._pipeline, update, draw };
+        }
+      };
+      renderables.push(rOpaque);
+    }
+  }
+  const rebuildSingle = (s, mesh, override) => {
+    return buildNodeMeshRenderables(s, [mesh], override).renderables[0];
+  };
+  return { renderables, rebuildSingle };
+}
+const zeroAttrCache = /* @__PURE__ */ new WeakMap();
+function getZeroAttrBuffer(engine, gpu, name) {
+  let cache = zeroAttrCache.get(gpu);
+  if (!cache) {
+    cache = /* @__PURE__ */ new Map();
+    zeroAttrCache.set(gpu, cache);
+  }
+  const existing = cache.get(name);
+  if (existing) {
+    return existing;
+  }
+  const vertexCount = gpu.positionBuffer.size / 12;
+  const stride = name === "uv" || name === "uv2" ? 8 : name === "normal" ? 12 : name === "tangent" || name === "color" ? 16 : 16;
+  const buf = engine._device.createBuffer({ label: `node-zero-${name}`, size: vertexCount * stride, usage: GPUBufferUsage.VERTEX | GPUBufferUsage.COPY_DST });
+  cache.set(name, buf);
+  return buf;
+}
+function getAttrBuffer(engine, gpu, name) {
+  switch (name) {
+    case "position":
+      return gpu.positionBuffer;
+    case "normal":
+      return gpu.normalBuffer;
+    case "uv":
+      return gpu.uvBuffer;
+    case "uv2":
+      return gpu.uv2Buffer ?? getZeroAttrBuffer(engine, gpu, "uv2");
+    case "tangent":
+      return gpu.tangentBuffer ?? getZeroAttrBuffer(engine, gpu, "tangent");
+    case "color":
+      return gpu.colorBuffer ?? getZeroAttrBuffer(engine, gpu, "color");
+    default:
+      throw new Error(`NodeMaterial: unsupported attribute "${name}"`);
+  }
+}
+function writeAttributeFlags(mesh, scratch) {
+  const gpu = mesh._gpu;
+  scratch[17] = gpu.hasUv === false ? 0 : 1;
+  scratch[18] = gpu.hasTangent ? 1 : 0;
+  scratch[19] = gpu.hasColor ? 1 : 0;
+}
+export {
+  buildNodeMeshRenderables
+};
+//# sourceMappingURL=node-renderable-DlLIdBmd.js.map

package/node-renderable-DlLIdBmd.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"node-renderable-DlLIdBmd.js","sources":["../src/material/node/node-renderable.ts"],"sourcesContent":["/** Node Material — MeshGroupBuilder + Renderable implementation.\n *\n *  Parallel to `standard-renderable.ts`. Each NodeMaterial owns one compile\n *  result (pipeline + BGLs); this builder creates per-mesh GPU resources\n *  (mesh UBO, node UBO, bind groups) and returns a Renderable\n *  that emits draws in the main pass.\n */\n\nimport type { EngineContext } from \"../../engine/engine.js\";\nimport type { SceneContext } from \"../../scene/scene.js\";\nimport type { Mesh } from \"../../mesh/mesh.js\";\nimport type { MeshGPU } from \"../../mesh/mesh.js\";\nimport type { MeshGroupBuildResult, Renderable } from \"../../render/renderable.js\";\nimport type { Material } from \"../material.js\";\nimport type { NodeMaterial } from \"./node-material.js\";\nimport { writeNodeUBO } from \"./node-material.js\";\nimport { compileNodePipeline } from \"./node-pipeline.js\";\nimport { NODE_ESM_SHADOW_OUTPUT, NODE_NO_COLOR_OUTPUT } from \"./node-flags.js\";\nimport { writeMeshLightSelection } from \"../../render/lights-ubo.js\";\nimport { MAX_LIGHTS } from \"../../light/types.js\";\n\n// Per-engine cached no-op morph target: a 1×1 rgba32float texture + a UBO with\n// count=0 + sensible texWidth/rowsPerBand. Meshes without their own morph\n// targets reuse this so materials that contain a MorphTargetsBlock still work\n// (the WGSL loops over `count` and passes through when zero).\nconst emptyMorphByEngine = new WeakMap<EngineContext, { texture: GPUTexture; weightsBuffer: GPUBuffer }>();\nfunction getEmptyMorph(engine: EngineContext): { texture: GPUTexture; weightsBuffer: GPUBuffer } {\n    const cached = emptyMorphByEngine.get(engine);\n    if (cached) {\n        return cached;\n    }\n    const texture = engine._device.createTexture({\n        label: \"node-morph-empty\",\n        size: [1, 1],\n        format: \"rgba32float\",\n        usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST,\n    });\n    engine._device.queue.writeTexture({ texture }, new Float32Array([0, 0, 0, 0]).buffer, { bytesPerRow: 16 }, { width: 1, height: 1 });\n    const ubo = new ArrayBuffer(32);\n    const u32 = new Uint32Array(ubo, 16, 4);\n    u32[0] = 0; // count\n    u32[1] = 1; // texWidth\n    u32[2] = 1; // rowsPerBand\n    const weightsBuffer = engine._device.createBuffer({ label: \"node-morph-empty-ubo\", size: 32, usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST });\n    engine._device.queue.writeBuffer(weightsBuffer, 0, new Uint8Array(ubo));\n    const entry = { texture, weightsBuffer };\n    emptyMorphByEngine.set(engine, entry);\n    return entry;\n}\n\ninterface NodePacket {\n    readonly _mesh: Mesh;\n    readonly _meshUBO: GPUBuffer;\n    readonly _meshBG: GPUBindGroup;\n    readonly _meshScratch: Float32Array;\n    _lastWorldVersion: number;\n    _lastReceivesShadow: number;\n    _lastLightsCount: number;\n}\n\ntype NodeRenderPass = GPURenderPassEncoder | GPURenderBundleEncoder;\n\n/** Build NME renderables for a set of meshes that share a NodeMaterial. */\nexport function buildNodeMeshRenderables(scene: SceneContext, meshes: Mesh[], materialOverride?: Material): MeshGroupBuildResult {\n    const engine = scene.engine;\n    const device = engine._device;\n\n    // All meshes in this group use the same NodeMaterial (scene-core batches by ctor).\n    // We deliberately do NOT re-group by material instance: each renderable loops\n    // packets of the same pipeline. For phase 1 every mesh with an NME material\n    // shares that one material instance.\n    const byMaterial = new Map<NodeMaterial, Mesh[]>();\n    for (const m of meshes) {\n        const mat = (materialOverride ?? m.material) as NodeMaterial;\n        let list = byMaterial.get(mat);\n        if (!list) {\n            list = [];\n            byMaterial.set(mat, list);\n        }\n        list.push(m);\n    }\n\n    const renderables: Renderable[] = [];\n\n    for (const [material, matMeshes] of byMaterial) {\n        const featureFlags = material._renderFeatures?.features ?? 0;\n        const noColorOutput = (featureFlags & NODE_NO_COLOR_OUTPUT) !== 0;\n        const esmShadowOutput = (featureFlags & NODE_ESM_SHADOW_OUTPUT) !== 0;\n        const shadowOutput = noColorOutput || esmShadowOutput;\n        const compile = shadowOutput\n            ? compileNodePipeline(material._state, material._vertexBody, material._fragmentBody, {\n                  _engine: engine,\n                  _format: esmShadowOutput ? \"rgba16float\" : engine.format,\n                  _depthStencilFormat: \"depth32float\",\n                  _depthCompare: \"less-equal\",\n                  _msaaSamples: 1,\n                  _backFaceCulling: material._graph.backFaceCulling,\n                  _noColorOutput: noColorOutput,\n                  _esmShadowOutput: esmShadowOutput,\n                  _esmShadowDepthCode: esmShadowOutput ? material._esmShadowDepthCode : undefined,\n                  _alphaMode: esmShadowOutput ? 0 : undefined,\n              })\n            : material._compile;\n        const meshBGL = compile._meshBGL;\n\n        // Node UBO is per-material (same across all meshes using it).\n        let nodeUBO: GPUBuffer | null = null;\n        if (compile._nodeUboBinding !== null && compile._nodeUboSize > 0) {\n            nodeUBO = device.createBuffer({ label: \"node-ubo\", size: compile._nodeUboSize, usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST });\n            writeNodeUBO(engine, nodeUBO, material);\n            material._nodeUBO = nodeUBO;\n        }\n\n        const packets: NodePacket[] = [];\n        for (const _mesh of matMeshes) {\n            // Mesh UBO layout: world (64B) + receivesShadow (vec4, 16B) + lightCount/indices.\n            const meshUboBytes = 96 + 16 * Math.ceil(MAX_LIGHTS / 4);\n            const _meshUBO = device.createBuffer({ label: \"node-mesh-ubo\", size: (meshUboBytes + 15) & ~15, usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST });\n            const _meshScratch = new Float32Array(((meshUboBytes + 15) & ~15) / 4);\n            _meshScratch.set(_mesh.worldMatrix as unknown as Float32Array, 0);\n            const recv = _mesh.receiveShadows ? 1 : 0;\n            _meshScratch[16] = recv;\n            if (compile._usesMeshAttributeFlags) {\n                writeAttributeFlags(_mesh, _meshScratch);\n            }\n            writeMeshLightSelection(_mesh, scene.lights, _meshScratch.subarray(4));\n            device.queue.writeBuffer(_meshUBO, 0, _meshScratch);\n\n            const entries: GPUBindGroupEntry[] = [{ binding: 0, resource: { buffer: _meshUBO } }];\n            if (nodeUBO) {\n                entries.push({ binding: compile._nodeUboBinding!, resource: { buffer: nodeUBO } });\n            }\n            for (const tb of compile._textureBindings) {\n                const slot = material._textureSlots.get(tb._name);\n                const tex = slot?.current;\n                if (!tex) {\n                    throw new Error(\n                        `NodeMaterial: texture binding \"${tb._name}\" not set. Provide it via options.textures or material.inputs[\"${tb._name}\"].texture before the first render.`\n                    );\n                }\n                entries.push({ binding: tb._texBinding, resource: tex.view });\n                entries.push({ binding: tb._sampBinding, resource: tex.sampler });\n            }\n            if (compile._morphBindings !== null) {\n                const mt = (_mesh as { morphTargets?: { texture: GPUTexture; weightsBuffer: GPUBuffer } | null }).morphTargets ?? getEmptyMorph(engine);\n                entries.push({ binding: compile._morphBindings._textureBinding, resource: mt.texture.createView() });\n                entries.push({ binding: compile._morphBindings._uboBinding, resource: { buffer: mt.weightsBuffer } });\n            }\n            if (compile._envBindings) {\n                material._envHelpers!.pushEnvBindGroupEntries(scene, compile._envBindings, entries);\n            }\n            for (let si = 0; si < compile._shadowBindings.length; si++) {\n                const sb = compile._shadowBindings[si]!;\n                const sg = material._shadowGenerators[si];\n                if (!sg) {\n                    throw new Error(`NodeMaterial: material requires shadow generator #${si} but none was supplied to parseNodeMaterialFromSnippet({ shadowGenerators }).`);\n                }\n                entries.push({ binding: sb._texBinding, resource: sg._depthTexture.createView() });\n                entries.push({ binding: sb._sampBinding, resource: sg._depthSampler });\n                entries.push({ binding: sb._uboBinding, resource: { buffer: sg._shadowUBO } });\n            }\n            if (compile._esmShadowParamsBinding !== null) {\n                entries.push({\n                    binding: compile._esmShadowParamsBinding,\n                    resource: { buffer: material._esmShadowParamsUBO! },\n                });\n            }\n            const _meshBG = device.createBindGroup({ label: \"node-mesh-bg\", layout: meshBGL, entries });\n\n            packets.push({\n                _mesh,\n                _meshUBO,\n                _meshBG,\n                _meshScratch,\n                _lastWorldVersion: _mesh.worldMatrixVersion,\n                _lastReceivesShadow: recv,\n                _lastLightsCount: scene.lights.length,\n            });\n        }\n\n        // Vertex attribute order (matches compile.state — captured on material).\n        const attrNames = material._vertexAttrNames;\n\n        const updatePacketUBO = (pkt: NodePacket): void => {\n            const recv = pkt._mesh.receiveShadows ? 1 : 0;\n            const worldVersion = pkt._mesh.worldMatrixVersion;\n            const worldChanged = worldVersion !== pkt._lastWorldVersion;\n            const recvChanged = recv !== pkt._lastReceivesShadow;\n            const lightsChanged = scene.lights.length !== pkt._lastLightsCount;\n            if (worldChanged || recvChanged || lightsChanged) {\n                pkt._meshScratch.set(pkt._mesh.worldMatrix as unknown as Float32Array, 0);\n                pkt._meshScratch[16] = recv;\n                if (compile._usesMeshAttributeFlags) {\n                    writeAttributeFlags(pkt._mesh, pkt._meshScratch);\n                }\n                writeMeshLightSelection(pkt._mesh, scene.lights, pkt._meshScratch.subarray(4));\n                device.queue.writeBuffer(pkt._meshUBO, 0, pkt._meshScratch as Float32Array<ArrayBuffer>);\n                pkt._lastWorldVersion = worldVersion;\n                pkt._lastReceivesShadow = recv;\n                pkt._lastLightsCount = scene.lights.length;\n            }\n        };\n\n        const updateNodeUBO = (): void => {\n            if (nodeUBO && material._uboDirty) {\n                material._uboDirty = false;\n                writeNodeUBO(engine, nodeUBO, material);\n            }\n        };\n\n        const drawPacket = (pass: NodeRenderPass, pkt: NodePacket): void => {\n            const g = pkt._mesh._gpu;\n            for (let i = 0; i < attrNames.length; i++) {\n                const buf = getAttrBuffer(engine, g, attrNames[i]!);\n                pass.setVertexBuffer(i, buf);\n            }\n            pass.setIndexBuffer(g.indexBuffer, g.indexFormat);\n            pass.setBindGroup(1, pkt._meshBG);\n            pass.drawIndexed(g.indexCount);\n        };\n\n        const isTransparent = !noColorOutput && !esmShadowOutput && material._needsAlphaBlending;\n\n        if (isTransparent) {\n            // Transparent materials: one renderable per mesh so each gets an\n            // independent _worldCenter for back-to-front distance sorting.\n            for (const pkt of packets) {\n                const wm = pkt._mesh.worldMatrix as unknown as ArrayLike<number>;\n                const cx = pkt._mesh.position?.x ?? wm[12]!;\n                const cy = pkt._mesh.position?.y ?? wm[13]!;\n                const cz = pkt._mesh.position?.z ?? wm[14]!;\n                const sortCenter: [number, number, number] = [cx, cy, cz];\n                const update = (): void => {\n                    updatePacketUBO(pkt);\n                    updateNodeUBO();\n                    // Update world center for sorting.\n                    const m = pkt._mesh.worldMatrix as unknown as ArrayLike<number>;\n                    sortCenter[0] = m[12]!;\n                    sortCenter[1] = m[13]!;\n                    sortCenter[2] = m[14]!;\n                };\n                const draw = (pass: NodeRenderPass): number => {\n                    drawPacket(pass, pkt);\n                    return 1;\n                };\n                const rTrans: Renderable = {\n                    order: 200,\n                    isTransparent: true,\n                    mesh: pkt._mesh,\n                    _worldCenter: sortCenter,\n                    bind() {\n                        return { renderable: rTrans, pipeline: compile._pipeline, update, draw };\n                    },\n                };\n                renderables.push(rTrans);\n            }\n        } else {\n            // Opaque: batch all meshes into one renderable for state efficiency.\n            const update = (): void => {\n                for (const pkt of packets) {\n                    updatePacketUBO(pkt);\n                }\n                updateNodeUBO();\n            };\n            const draw = (pass: NodeRenderPass): number => {\n                let draws = 0;\n                for (const pkt of packets) {\n                    drawPacket(pass, pkt);\n                    draws++;\n                }\n                return draws;\n            };\n            const rOpaque: Renderable = {\n                order: 100,\n                isTransparent: false,\n                bind() {\n                    return { renderable: rOpaque, pipeline: compile._pipeline, update, draw };\n                },\n            };\n            renderables.push(rOpaque);\n        }\n    }\n\n    const rebuildSingle = (s: SceneContext, mesh: Mesh, override?: Material): Renderable => {\n        return buildNodeMeshRenderables(s, [mesh], override).renderables[0]!;\n    };\n\n    return { renderables, rebuildSingle };\n}\n\n// Per-gpu-object cached zero buffers for attributes that a NodeMaterial's\n// vertex layout declares but the mesh itself doesn't provide (e.g. vertex\n// color on meshes that don't use VERTEXCOLOR). We allocate one zero buffer\n// lazily per gpu object, sized to its position vertex count × stride.\nconst zeroAttrCache = new WeakMap<object, Map<string, GPUBuffer>>();\nfunction getZeroAttrBuffer(engine: EngineContext, gpu: MeshGPU, name: string): GPUBuffer {\n    let cache = zeroAttrCache.get(gpu as unknown as object);\n    if (!cache) {\n        cache = new Map();\n        zeroAttrCache.set(gpu as unknown as object, cache);\n    }\n    const existing = cache.get(name);\n    if (existing) {\n        return existing;\n    }\n    // position buffer size in bytes / 12 (vec3) = vertex count.\n    const vertexCount = gpu.positionBuffer.size / 12;\n    const stride = name === \"uv\" || name === \"uv2\" ? 8 : name === \"normal\" ? 12 : name === \"tangent\" || name === \"color\" ? 16 : 16;\n    const buf = engine._device.createBuffer({ label: `node-zero-${name}`, size: vertexCount * stride, usage: GPUBufferUsage.VERTEX | GPUBufferUsage.COPY_DST });\n    // Initialize with zeros (buffer starts zeroed when not mappedAtCreation).\n    cache.set(name, buf);\n    return buf;\n}\n\nfunction getAttrBuffer(engine: EngineContext, gpu: MeshGPU, name: string): GPUBuffer {\n    switch (name) {\n        case \"position\":\n            return gpu.positionBuffer;\n        case \"normal\":\n            return gpu.normalBuffer;\n        case \"uv\":\n            return gpu.uvBuffer;\n        case \"uv2\":\n            return gpu.uv2Buffer ?? getZeroAttrBuffer(engine, gpu, \"uv2\");\n        case \"tangent\":\n            return gpu.tangentBuffer ?? getZeroAttrBuffer(engine, gpu, \"tangent\");\n        case \"color\":\n            return gpu.colorBuffer ?? getZeroAttrBuffer(engine, gpu, \"color\");\n        default:\n            throw new Error(`NodeMaterial: unsupported attribute \"${name}\"`);\n    }\n}\n\nfunction writeAttributeFlags(mesh: Mesh, scratch: Float32Array): void {\n    const gpu = mesh._gpu;\n    scratch[17] = gpu.hasUv === false ? 0 : 1;\n    scratch[18] = gpu.hasTangent ? 1 : 0;\n    scratch[19] = gpu.hasColor ? 1 : 0;\n}\n"],"names":[],"mappings":"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"}

package/node-shadow-DKrcqmNg.js

@@ -0,0 +1,122 @@
+import { M as MAX_LIGHTS } from "./index-C8HOR2sB.js";
+const SHADOW_FACTORS_TYPE = `array<f32, ${MAX_LIGHTS}>`;
+const SHADOW_FACTORS_ONE = `${SHADOW_FACTORS_TYPE}(${new Array(MAX_LIGHTS).fill("1.0").join(", ")})`;
+function emitShadow(shadowLights, startBinding, varyings) {
+  const _bindings = [];
+  const wgslDecls = [];
+  const _bglEntries = [];
+  for (const sl of shadowLights) {
+    const suf = `_${sl.lightIndex}`;
+    if (!varyings.some((v) => v._name === `vPosFromLight${suf}`)) {
+      varyings.push({ _name: `vPosFromLight${suf}`, _type: "vec4<f32>" });
+    }
+    if (!varyings.some((v) => v._name === `vDepthMetric${suf}`)) {
+      varyings.push({ _name: `vDepthMetric${suf}`, _type: "f32" });
+    }
+  }
+  const vertLines = [`let _shadowWp4 = meshU.world * vec4<f32>(in.position, 1.0);`];
+  const dispatchLines = [`var _sf = ${SHADOW_FACTORS_ONE};`];
+  let nextBinding = startBinding;
+  for (const sl of shadowLights) {
+    const suf = `_${sl.lightIndex}`;
+    const _lightIndex = sl.lightIndex;
+    const _texBinding = nextBinding++;
+    const _sampBinding = nextBinding++;
+    const _uboBinding = nextBinding++;
+    const _shadowType = sl.shadowType;
+    _bindings.push({ _lightIndex, _texBinding, _sampBinding, _uboBinding, _shadowType });
+    wgslDecls.push(
+      `struct shadowInfo${suf}Uniforms { lightMatrix: mat4x4<f32>, depthValues: vec4<f32>, shadowsInfo: vec4<f32> };`,
+      `@group(1) @binding(${_uboBinding}) var<uniform> shadowInfo${suf}: shadowInfo${suf}Uniforms;`
+    );
+    if (sl.shadowType === "pcf") {
+      wgslDecls.push(
+        `@group(1) @binding(${_texBinding}) var shadowTex${suf}: texture_depth_2d;`,
+        `@group(1) @binding(${_sampBinding}) var shadowComp${suf}: sampler_comparison;`,
+        `fn computeShadowPCF${suf}(posFromLight: vec4<f32>, depthMetric: f32, darkness: f32, mapSz: f32, invMapSz: f32) -> f32 {
+    let clipSpace = posFromLight.xyz / posFromLight.w;
+    let uv = vec2<f32>(0.5 * clipSpace.x + 0.5, 0.5 - 0.5 * clipSpace.y);
+    if (depthMetric < 0.0 || depthMetric > 1.0 || uv.x < 0.0 || uv.x > 1.0 || uv.y < 0.0 || uv.y > 1.0) { return 1.0; }
+    let depthRef = clamp(clipSpace.z, 0.0, 1.0);
+    var tc = uv * mapSz + 0.5;
+    let st = fract(tc);
+    let base = (floor(tc) - 0.5) * invMapSz;
+    let uvw0 = 4.0 - 3.0 * st;
+    let uvw1 = vec2<f32>(7.0);
+    let uvw2 = 1.0 + 3.0 * st;
+    let u = vec3<f32>((3.0 - 2.0 * st.x) / uvw0.x - 2.0, (3.0 + st.x) / uvw1.x, st.x / uvw2.x + 2.0) * invMapSz;
+    let v = vec3<f32>((3.0 - 2.0 * st.y) / uvw0.y - 2.0, (3.0 + st.y) / uvw1.y, st.y / uvw2.y + 2.0) * invMapSz;
+    var sh = 0.0;
+    sh += uvw0.x * uvw0.y * textureSampleCompareLevel(shadowTex${suf}, shadowComp${suf}, base + vec2<f32>(u[0], v[0]), depthRef);
+    sh += uvw1.x * uvw0.y * textureSampleCompareLevel(shadowTex${suf}, shadowComp${suf}, base + vec2<f32>(u[1], v[0]), depthRef);
+    sh += uvw2.x * uvw0.y * textureSampleCompareLevel(shadowTex${suf}, shadowComp${suf}, base + vec2<f32>(u[2], v[0]), depthRef);
+    sh += uvw0.x * uvw1.y * textureSampleCompareLevel(shadowTex${suf}, shadowComp${suf}, base + vec2<f32>(u[0], v[1]), depthRef);
+    sh += uvw1.x * uvw1.y * textureSampleCompareLevel(shadowTex${suf}, shadowComp${suf}, base + vec2<f32>(u[1], v[1]), depthRef);
+    sh += uvw2.x * uvw1.y * textureSampleCompareLevel(shadowTex${suf}, shadowComp${suf}, base + vec2<f32>(u[2], v[1]), depthRef);
+    sh += uvw0.x * uvw2.y * textureSampleCompareLevel(shadowTex${suf}, shadowComp${suf}, base + vec2<f32>(u[0], v[2]), depthRef);
+    sh += uvw1.x * uvw2.y * textureSampleCompareLevel(shadowTex${suf}, shadowComp${suf}, base + vec2<f32>(u[1], v[2]), depthRef);
+    sh += uvw2.x * uvw2.y * textureSampleCompareLevel(shadowTex${suf}, shadowComp${suf}, base + vec2<f32>(u[2], v[2]), depthRef);
+    sh /= 144.0;
+    return mix(darkness, 1.0, sh);
+}`
+      );
+      dispatchLines.push(
+        `_sf[${sl.lightIndex}] = computeShadowPCF${suf}(input.vPosFromLight${suf}, input.vDepthMetric${suf}, shadowInfo${suf}.shadowsInfo.x, shadowInfo${suf}.shadowsInfo.y, shadowInfo${suf}.shadowsInfo.z);`
+      );
+      _bglEntries.push(
+        { binding: _texBinding, visibility: GPUShaderStage.FRAGMENT, texture: { sampleType: "depth", viewDimension: "2d" } },
+        { binding: _sampBinding, visibility: GPUShaderStage.FRAGMENT, sampler: { type: "comparison" } }
+      );
+    } else {
+      wgslDecls.push(
+        `@group(1) @binding(${_texBinding}) var shadowTex${suf}: texture_2d<f32>;`,
+        `@group(1) @binding(${_sampBinding}) var shadowSamp${suf}: sampler;`,
+        `fn computeFallOff${suf}(value: f32, clipSpace: vec2<f32>, frustumEdgeFalloff: f32) -> f32 {
+    let mask = smoothstep(1.0 - frustumEdgeFalloff, 1.00000012, clamp(dot(clipSpace, clipSpace), 0.0, 1.0));
+    return mix(value, 1.0, mask);
+}
+fn computeShadowESM${suf}(posFromLight: vec4<f32>, depthMetric: f32, darkness: f32, depthScale: f32, frustumEdgeFalloff: f32) -> f32 {
+    let clipSpace = posFromLight.xyz / posFromLight.w;
+    let uv = vec2<f32>(0.5 * clipSpace.x + 0.5, 0.5 - 0.5 * clipSpace.y);
+    if (depthMetric < 0.0 || depthMetric > 1.0 || uv.x < 0.0 || uv.x > 1.0 || uv.y < 0.0 || uv.y > 1.0) { return 1.0; }
+    let shadowPixelDepth = clamp(depthMetric, 0.0, 1.0);
+    let shadowMapSample = textureSampleLevel(shadowTex${suf}, shadowSamp${suf}, uv, 0.0).x;
+    let esm = 1.0 - clamp(exp(min(87.0, depthScale * shadowPixelDepth)) * shadowMapSample, 0.0, 1.0 - darkness);
+    return computeFallOff${suf}(esm, clipSpace.xy, frustumEdgeFalloff);
+}`
+      );
+      dispatchLines.push(
+        `_sf[${sl.lightIndex}] = computeShadowESM${suf}(input.vPosFromLight${suf}, input.vDepthMetric${suf}, shadowInfo${suf}.shadowsInfo.x, shadowInfo${suf}.shadowsInfo.z, shadowInfo${suf}.shadowsInfo.w);`
+      );
+      _bglEntries.push(
+        { binding: _texBinding, visibility: GPUShaderStage.FRAGMENT, texture: { sampleType: "float", viewDimension: "2d" } },
+        { binding: _sampBinding, visibility: GPUShaderStage.FRAGMENT, sampler: { type: "filtering" } }
+      );
+    }
+    vertLines.push(
+      `out.vPosFromLight${suf} = shadowInfo${suf}.lightMatrix * _shadowWp4;`,
+      `out.vDepthMetric${suf} = (out.vPosFromLight${suf}.z + shadowInfo${suf}.depthValues.x) / shadowInfo${suf}.depthValues.y;`
+    );
+    _bglEntries.push({
+      binding: _uboBinding,
+      visibility: GPUShaderStage.VERTEX | GPUShaderStage.FRAGMENT,
+      buffer: { type: "uniform", minBindingSize: 96 }
+    });
+  }
+  dispatchLines.push(`for (var _i = 0u; _i < ${MAX_LIGHTS}u; _i++) { _sf[_i] = mix(1.0, _sf[_i], meshU.receivesShadow.x); }`);
+  dispatchLines.push(`return _sf;`);
+  return {
+    _bindings,
+    _wgslDecls: wgslDecls.join("\n"),
+    _fragmentHelper: `fn nme_computeShadowFactors(input: VertexOut) -> ${SHADOW_FACTORS_TYPE} {
+    ${dispatchLines.join("\n    ")}
+}`,
+    _vertexInject: vertLines.join("\n    "),
+    _bglEntries,
+    _bindingCount: shadowLights.length * 3
+  };
+}
+export {
+  emitShadow
+};
+//# sourceMappingURL=node-shadow-DKrcqmNg.js.map

package/node-shadow-DKrcqmNg.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"node-shadow-DKrcqmNg.js","sources":["../src/material/node/node-shadow.ts"],"sourcesContent":["/** Node Material — shadow emission (dynamically imported).\n *\n *  This module is imported ONLY when `parseNodeMaterialFromSnippet` receives\n *  `shadowGenerators`. Scenes without shadows never bundle it, keeping the\n *  shadow WGSL (PCF/ESM helper fns + binding wiring) off the critical path.\n *\n *  Emits three things per shadow light (texture + sampler + shadowInfo UBO)\n *  plus the vertex-stage varying computations and the fragment-stage\n *  `nme_computeShadowFactors(input)` dispatcher consumed by the LightBlock.\n */\n\nimport { MAX_LIGHTS } from \"../../light/types.js\";\nimport type { Varying } from \"../../shader/fragment-types.js\";\n\nconst SHADOW_FACTORS_TYPE = `array<f32, ${MAX_LIGHTS}>`;\nconst SHADOW_FACTORS_ONE = `${SHADOW_FACTORS_TYPE}(${new Array(MAX_LIGHTS).fill(\"1.0\").join(\", \")})`;\n\n/** @internal */\nexport interface ShadowBinding {\n    /** @internal */\n    readonly _lightIndex: number;\n    /** @internal */\n    readonly _texBinding: number;\n    /** @internal */\n    readonly _sampBinding: number;\n    /** @internal */\n    readonly _uboBinding: number;\n    /** @internal */\n    readonly _shadowType: \"esm\" | \"pcf\";\n}\n\nexport interface ShadowEmit {\n    /** @internal One per shadow-casting light (3 binding slots each). */\n    readonly _bindings: readonly ShadowBinding[];\n    /** @internal Module-scope WGSL: struct + binding decls + compute fns. */\n    readonly _wgslDecls: string;\n    /** @internal `nme_computeShadowFactors(input) -> array<f32, MAX_LIGHTS>` called from light blocks. */\n    readonly _fragmentHelper: string;\n    /** @internal Injected into vs_main body: populates vPosFromLight_i + vDepthMetric_i varyings. */\n    readonly _vertexInject: string;\n    /** @internal GPU BGL entries for group 1 (append to meshBglEntries). */\n    readonly _bglEntries: readonly GPUBindGroupLayoutEntry[];\n    /** @internal Total bindings consumed (= shadowLights.length * 3). */\n    readonly _bindingCount: number;\n}\n\n/** Emit shadow WGSL + bindings for a NodeMaterial.\n *  Mutates `varyings` (pushes vPosFromLight_i + vDepthMetric_i per light) so\n *  buildVertexOut picks them up.\n */\nexport function emitShadow(shadowLights: readonly { lightIndex: number; shadowType: \"esm\" | \"pcf\" }[], startBinding: number, varyings: Varying[]): ShadowEmit {\n    const _bindings: ShadowBinding[] = [];\n    const wgslDecls: string[] = [];\n    const _bglEntries: GPUBindGroupLayoutEntry[] = [];\n    for (const sl of shadowLights) {\n        const suf = `_${sl.lightIndex}`;\n        if (!varyings.some((v) => v._name === `vPosFromLight${suf}`)) {\n            varyings.push({ _name: `vPosFromLight${suf}`, _type: \"vec4<f32>\" });\n        }\n        if (!varyings.some((v) => v._name === `vDepthMetric${suf}`)) {\n            varyings.push({ _name: `vDepthMetric${suf}`, _type: \"f32\" });\n        }\n    }\n    const vertLines: string[] = [`let _shadowWp4 = meshU.world * vec4<f32>(in.position, 1.0);`];\n    const dispatchLines: string[] = [`var _sf = ${SHADOW_FACTORS_ONE};`];\n    let nextBinding = startBinding;\n    for (const sl of shadowLights) {\n        const suf = `_${sl.lightIndex}`;\n        const _lightIndex = sl.lightIndex;\n        const _texBinding = nextBinding++;\n        const _sampBinding = nextBinding++;\n        const _uboBinding = nextBinding++;\n        const _shadowType = sl.shadowType;\n        _bindings.push({ _lightIndex, _texBinding, _sampBinding, _uboBinding, _shadowType });\n        wgslDecls.push(\n            `struct shadowInfo${suf}Uniforms { lightMatrix: mat4x4<f32>, depthValues: vec4<f32>, shadowsInfo: vec4<f32> };`,\n            `@group(1) @binding(${_uboBinding}) var<uniform> shadowInfo${suf}: shadowInfo${suf}Uniforms;`\n        );\n        if (sl.shadowType === \"pcf\") {\n            wgslDecls.push(\n                `@group(1) @binding(${_texBinding}) var shadowTex${suf}: texture_depth_2d;`,\n                `@group(1) @binding(${_sampBinding}) var shadowComp${suf}: sampler_comparison;`,\n                `fn computeShadowPCF${suf}(posFromLight: vec4<f32>, depthMetric: f32, darkness: f32, mapSz: f32, invMapSz: f32) -> f32 {\n    let clipSpace = posFromLight.xyz / posFromLight.w;\n    let uv = vec2<f32>(0.5 * clipSpace.x + 0.5, 0.5 - 0.5 * clipSpace.y);\n    if (depthMetric < 0.0 || depthMetric > 1.0 || uv.x < 0.0 || uv.x > 1.0 || uv.y < 0.0 || uv.y > 1.0) { return 1.0; }\n    let depthRef = clamp(clipSpace.z, 0.0, 1.0);\n    var tc = uv * mapSz + 0.5;\n    let st = fract(tc);\n    let base = (floor(tc) - 0.5) * invMapSz;\n    let uvw0 = 4.0 - 3.0 * st;\n    let uvw1 = vec2<f32>(7.0);\n    let uvw2 = 1.0 + 3.0 * st;\n    let u = vec3<f32>((3.0 - 2.0 * st.x) / uvw0.x - 2.0, (3.0 + st.x) / uvw1.x, st.x / uvw2.x + 2.0) * invMapSz;\n    let v = vec3<f32>((3.0 - 2.0 * st.y) / uvw0.y - 2.0, (3.0 + st.y) / uvw1.y, st.y / uvw2.y + 2.0) * invMapSz;\n    var sh = 0.0;\n    sh += uvw0.x * uvw0.y * textureSampleCompareLevel(shadowTex${suf}, shadowComp${suf}, base + vec2<f32>(u[0], v[0]), depthRef);\n    sh += uvw1.x * uvw0.y * textureSampleCompareLevel(shadowTex${suf}, shadowComp${suf}, base + vec2<f32>(u[1], v[0]), depthRef);\n    sh += uvw2.x * uvw0.y * textureSampleCompareLevel(shadowTex${suf}, shadowComp${suf}, base + vec2<f32>(u[2], v[0]), depthRef);\n    sh += uvw0.x * uvw1.y * textureSampleCompareLevel(shadowTex${suf}, shadowComp${suf}, base + vec2<f32>(u[0], v[1]), depthRef);\n    sh += uvw1.x * uvw1.y * textureSampleCompareLevel(shadowTex${suf}, shadowComp${suf}, base + vec2<f32>(u[1], v[1]), depthRef);\n    sh += uvw2.x * uvw1.y * textureSampleCompareLevel(shadowTex${suf}, shadowComp${suf}, base + vec2<f32>(u[2], v[1]), depthRef);\n    sh += uvw0.x * uvw2.y * textureSampleCompareLevel(shadowTex${suf}, shadowComp${suf}, base + vec2<f32>(u[0], v[2]), depthRef);\n    sh += uvw1.x * uvw2.y * textureSampleCompareLevel(shadowTex${suf}, shadowComp${suf}, base + vec2<f32>(u[1], v[2]), depthRef);\n    sh += uvw2.x * uvw2.y * textureSampleCompareLevel(shadowTex${suf}, shadowComp${suf}, base + vec2<f32>(u[2], v[2]), depthRef);\n    sh /= 144.0;\n    return mix(darkness, 1.0, sh);\n}`\n            );\n            dispatchLines.push(\n                `_sf[${sl.lightIndex}] = computeShadowPCF${suf}(input.vPosFromLight${suf}, input.vDepthMetric${suf}, shadowInfo${suf}.shadowsInfo.x, shadowInfo${suf}.shadowsInfo.y, shadowInfo${suf}.shadowsInfo.z);`\n            );\n            _bglEntries.push(\n                { binding: _texBinding, visibility: GPUShaderStage.FRAGMENT, texture: { sampleType: \"depth\", viewDimension: \"2d\" } },\n                { binding: _sampBinding, visibility: GPUShaderStage.FRAGMENT, sampler: { type: \"comparison\" } }\n            );\n        } else {\n            wgslDecls.push(\n                `@group(1) @binding(${_texBinding}) var shadowTex${suf}: texture_2d<f32>;`,\n                `@group(1) @binding(${_sampBinding}) var shadowSamp${suf}: sampler;`,\n                `fn computeFallOff${suf}(value: f32, clipSpace: vec2<f32>, frustumEdgeFalloff: f32) -> f32 {\n    let mask = smoothstep(1.0 - frustumEdgeFalloff, 1.00000012, clamp(dot(clipSpace, clipSpace), 0.0, 1.0));\n    return mix(value, 1.0, mask);\n}\nfn computeShadowESM${suf}(posFromLight: vec4<f32>, depthMetric: f32, darkness: f32, depthScale: f32, frustumEdgeFalloff: f32) -> f32 {\n    let clipSpace = posFromLight.xyz / posFromLight.w;\n    let uv = vec2<f32>(0.5 * clipSpace.x + 0.5, 0.5 - 0.5 * clipSpace.y);\n    if (depthMetric < 0.0 || depthMetric > 1.0 || uv.x < 0.0 || uv.x > 1.0 || uv.y < 0.0 || uv.y > 1.0) { return 1.0; }\n    let shadowPixelDepth = clamp(depthMetric, 0.0, 1.0);\n    let shadowMapSample = textureSampleLevel(shadowTex${suf}, shadowSamp${suf}, uv, 0.0).x;\n    let esm = 1.0 - clamp(exp(min(87.0, depthScale * shadowPixelDepth)) * shadowMapSample, 0.0, 1.0 - darkness);\n    return computeFallOff${suf}(esm, clipSpace.xy, frustumEdgeFalloff);\n}`\n            );\n            dispatchLines.push(\n                `_sf[${sl.lightIndex}] = computeShadowESM${suf}(input.vPosFromLight${suf}, input.vDepthMetric${suf}, shadowInfo${suf}.shadowsInfo.x, shadowInfo${suf}.shadowsInfo.z, shadowInfo${suf}.shadowsInfo.w);`\n            );\n            _bglEntries.push(\n                { binding: _texBinding, visibility: GPUShaderStage.FRAGMENT, texture: { sampleType: \"float\", viewDimension: \"2d\" } },\n                { binding: _sampBinding, visibility: GPUShaderStage.FRAGMENT, sampler: { type: \"filtering\" } }\n            );\n        }\n        vertLines.push(\n            `out.vPosFromLight${suf} = shadowInfo${suf}.lightMatrix * _shadowWp4;`,\n            `out.vDepthMetric${suf} = (out.vPosFromLight${suf}.z + shadowInfo${suf}.depthValues.x) / shadowInfo${suf}.depthValues.y;`\n        );\n        _bglEntries.push({\n            binding: _uboBinding,\n            visibility: GPUShaderStage.VERTEX | GPUShaderStage.FRAGMENT,\n            buffer: { type: \"uniform\", minBindingSize: 96 },\n        });\n    }\n    dispatchLines.push(`for (var _i = 0u; _i < ${MAX_LIGHTS}u; _i++) { _sf[_i] = mix(1.0, _sf[_i], meshU.receivesShadow.x); }`);\n    dispatchLines.push(`return _sf;`);\n    return {\n        _bindings,\n        _wgslDecls: wgslDecls.join(\"\\n\"),\n        _fragmentHelper: `fn nme_computeShadowFactors(input: VertexOut) -> ${SHADOW_FACTORS_TYPE} {\\n    ${dispatchLines.join(\"\\n    \")}\\n}`,\n        _vertexInject: vertLines.join(\"\\n    \"),\n        _bglEntries,\n        _bindingCount: shadowLights.length * 3,\n    };\n}\n"],"names":[],"mappings":"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"}

package/node-snippet-DUMm9qEO.js

@@ -0,0 +1,22 @@
+const DEFAULT_SNIPPET_SERVER = "https://snippet.babylonjs.com";
+async function fetchSnippetSource(snippetId, server = DEFAULT_SNIPPET_SERVER) {
+  const [id, version] = snippetId.split("#");
+  const url = version ? `${server}/${id}/${version}` : `${server}/${id}`;
+  const resp = await fetch(url);
+  if (!resp.ok) {
+    throw new Error(`NodeMaterial: snippet fetch failed (${resp.status}) for ${url}`);
+  }
+  const outer = await resp.json();
+  if (!outer.jsonPayload) {
+    throw new Error(`NodeMaterial: snippet "${snippetId}" has no jsonPayload`);
+  }
+  const inner = JSON.parse(outer.jsonPayload);
+  if (!inner.nodeMaterial) {
+    throw new Error(`NodeMaterial: snippet "${snippetId}" has no nodeMaterial`);
+  }
+  return JSON.parse(inner.nodeMaterial);
+}
+export {
+  fetchSnippetSource
+};
+//# sourceMappingURL=node-snippet-DUMm9qEO.js.map

package/node-snippet-DUMm9qEO.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"node-snippet-DUMm9qEO.js","sources":["../src/material/node/node-snippet.ts"],"sourcesContent":["const DEFAULT_SNIPPET_SERVER = \"https://snippet.babylonjs.com\";\n\nexport async function fetchSnippetSource(snippetId: string, server: string = DEFAULT_SNIPPET_SERVER): Promise<unknown> {\n    const [id, version] = snippetId.split(\"#\");\n    const url = version ? `${server}/${id}/${version}` : `${server}/${id}`;\n    const resp = await fetch(url);\n    if (!resp.ok) {\n        throw new Error(`NodeMaterial: snippet fetch failed (${resp.status}) for ${url}`);\n    }\n    const outer = (await resp.json()) as { jsonPayload?: string };\n    if (!outer.jsonPayload) {\n        throw new Error(`NodeMaterial: snippet \"${snippetId}\" has no jsonPayload`);\n    }\n    const inner = JSON.parse(outer.jsonPayload) as { nodeMaterial?: string };\n    if (!inner.nodeMaterial) {\n        throw new Error(`NodeMaterial: snippet \"${snippetId}\" has no nodeMaterial`);\n    }\n    return JSON.parse(inner.nodeMaterial);\n}\n"],"names":[],"mappings":"AAAA,MAAM,yBAAyB;AAE/B,eAAsB,mBAAmB,WAAmB,SAAiB,wBAA0C;AACnH,QAAM,CAAC,IAAI,OAAO,IAAI,UAAU,MAAM,GAAG;AACzC,QAAM,MAAM,UAAU,GAAG,MAAM,IAAI,EAAE,IAAI,OAAO,KAAK,GAAG,MAAM,IAAI,EAAE;AACpE,QAAM,OAAO,MAAM,MAAM,GAAG;AAC5B,MAAI,CAAC,KAAK,IAAI;AACV,UAAM,IAAI,MAAM,uCAAuC,KAAK,MAAM,SAAS,GAAG,EAAE;AAAA,EACpF;AACA,QAAM,QAAS,MAAM,KAAK,KAAA;AAC1B,MAAI,CAAC,MAAM,aAAa;AACpB,UAAM,IAAI,MAAM,0BAA0B,SAAS,sBAAsB;AAAA,EAC7E;AACA,QAAM,QAAQ,KAAK,MAAM,MAAM,WAAW;AAC1C,MAAI,CAAC,MAAM,cAAc;AACrB,UAAM,IAAI,MAAM,0BAA0B,SAAS,uBAAuB;AAAA,EAC9E;AACA,SAAO,KAAK,MAAM,MAAM,YAAY;AACxC;"}

package/normal-blend-block-BfH_nBoj.js

@@ -0,0 +1,29 @@
+function emitBlend(block, stage, state, ctx) {
+  const stageState = stage === "vertex" ? state.vertex : state.fragment;
+  const memoKey = `_normalBlend_${block.id}`;
+  const existing = stageState.memo.get(memoKey);
+  if (existing) {
+    return existing;
+  }
+  const n0 = ctx.cast(ctx.resolve(block, "normalMap0", stage, state), "vec3f").expr;
+  const n1 = ctx.cast(ctx.resolve(block, "normalMap1", stage, state), "vec3f").expr;
+  const out = `_nb${ctx.temp(state, "normalBlend")}`;
+  stageState.body.push(`let ${out}_stepR = step(0.5, (${n0}).r);`);
+  stageState.body.push(`let ${out}_stepG = step(0.5, (${n0}).g);`);
+  stageState.body.push(
+    `let ${out} = vec3<f32>((1.0 - ${out}_stepR) * (${n0}).r * (${n1}).r * 2.0 + ${out}_stepR * (1.0 - (1.0 - (${n0}).r) * (1.0 - (${n1}).r) * 2.0), (1.0 - ${out}_stepG) * (${n0}).g * (${n1}).g * 2.0 + ${out}_stepG * (1.0 - (1.0 - (${n0}).g) * (1.0 - (${n1}).g) * 2.0), (${n0}).b * (${n1}).b);`
+  );
+  const result = { expr: out, type: "vec3f" };
+  stageState.memo.set(memoKey, result);
+  return result;
+}
+const emitter = {
+  className: "NormalBlendBlock",
+  emit(block, _outputName, stage, state, ctx) {
+    return emitBlend(block, stage, state, ctx);
+  }
+};
+export {
+  emitter
+};
+//# sourceMappingURL=normal-blend-block-BfH_nBoj.js.map

package/normal-blend-block-BfH_nBoj.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"normal-blend-block-BfH_nBoj.js","sources":["../src/material/node/blocks/normal-blend-block.ts"],"sourcesContent":["import type { BlockEmitter, NodeExpr } from \"../node-types.js\";\n\nfunction emitBlend(\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 = `_normalBlend_${block.id}`;\n    const existing = stageState.memo.get(memoKey);\n    if (existing) {\n        return existing;\n    }\n\n    const n0 = ctx.cast(ctx.resolve(block, \"normalMap0\", stage, state), \"vec3f\").expr;\n    const n1 = ctx.cast(ctx.resolve(block, \"normalMap1\", stage, state), \"vec3f\").expr;\n    const out = `_nb${ctx.temp(state, \"normalBlend\")}`;\n    stageState.body.push(`let ${out}_stepR = step(0.5, (${n0}).r);`);\n    stageState.body.push(`let ${out}_stepG = step(0.5, (${n0}).g);`);\n    stageState.body.push(\n        `let ${out} = vec3<f32>((1.0 - ${out}_stepR) * (${n0}).r * (${n1}).r * 2.0 + ${out}_stepR * (1.0 - (1.0 - (${n0}).r) * (1.0 - (${n1}).r) * 2.0), (1.0 - ${out}_stepG) * (${n0}).g * (${n1}).g * 2.0 + ${out}_stepG * (1.0 - (1.0 - (${n0}).g) * (1.0 - (${n1}).g) * 2.0), (${n0}).b * (${n1}).b);`\n    );\n    const result = { expr: out, type: \"vec3f\" } as const;\n    stageState.memo.set(memoKey, result);\n    return result;\n}\n\nexport const emitter: BlockEmitter = {\n    className: \"NormalBlendBlock\",\n    emit(block, _outputName, stage, state, ctx) {\n        return emitBlend(block, stage, state, ctx);\n    },\n};\n"],"names":[],"mappings":"AAEA,SAAS,UACL,OACA,OACA,OACA,KACQ;AACR,QAAM,aAAa,UAAU,WAAW,MAAM,SAAS,MAAM;AAC7D,QAAM,UAAU,gBAAgB,MAAM,EAAE;AACxC,QAAM,WAAW,WAAW,KAAK,IAAI,OAAO;AAC5C,MAAI,UAAU;AACV,WAAO;AAAA,EACX;AAEA,QAAM,KAAK,IAAI,KAAK,IAAI,QAAQ,OAAO,cAAc,OAAO,KAAK,GAAG,OAAO,EAAE;AAC7E,QAAM,KAAK,IAAI,KAAK,IAAI,QAAQ,OAAO,cAAc,OAAO,KAAK,GAAG,OAAO,EAAE;AAC7E,QAAM,MAAM,MAAM,IAAI,KAAK,OAAO,aAAa,CAAC;AAChD,aAAW,KAAK,KAAK,OAAO,GAAG,uBAAuB,EAAE,OAAO;AAC/D,aAAW,KAAK,KAAK,OAAO,GAAG,uBAAuB,EAAE,OAAO;AAC/D,aAAW,KAAK;AAAA,IACZ,OAAO,GAAG,uBAAuB,GAAG,cAAc,EAAE,UAAU,EAAE,eAAe,GAAG,2BAA2B,EAAE,kBAAkB,EAAE,uBAAuB,GAAG,cAAc,EAAE,UAAU,EAAE,eAAe,GAAG,2BAA2B,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,UAAU,EAAE;AAAA,EAAA;AAE/R,QAAM,SAAS,EAAE,MAAM,KAAK,MAAM,QAAA;AAClC,aAAW,KAAK,IAAI,SAAS,MAAM;AACnC,SAAO;AACX;AAEO,MAAM,UAAwB;AAAA,EACjC,WAAW;AAAA,EACX,KAAK,OAAO,aAAa,OAAO,OAAO,KAAK;AACxC,WAAO,UAAU,OAAO,OAAO,OAAO,GAAG;AAAA,EAC7C;AACJ;"}

package/normal-map-fragment-DpsIXrJf.js

@@ -0,0 +1,38 @@
+import { ac as HAS_BUMP_TEXTURE } from "./index-C8HOR2sB.js";
+import { W as WGSL_PERTURB_NORMAL } from "./wgsl-helpers-DyzNzCeE.js";
+const STAGE_FRAGMENT = 2;
+function createNormalMapFragment() {
+  return {
+    _id: "normal-map",
+    _bindings: [
+      { _name: "bT", _type: { _kind: "texture", _textureType: "texture_2d<f32>" }, _visibility: STAGE_FRAGMENT },
+      { _name: "bS", _type: { _kind: "sampler", _samplerType: "sampler" }, _visibility: STAGE_FRAGMENT }
+    ],
+    _helperFunctions: WGSL_PERTURB_NORMAL,
+    _fragmentSlots: {
+      AC: `normalW = perturbNormal(input.vn, input.vp, input.vu, mat.bs);`
+    }
+  };
+}
+const bumpStdExt = {
+  _id: "normal-map",
+  _phase: "mesh",
+  _feature: HAS_BUMP_TEXTURE,
+  _frag: createNormalMapFragment,
+  _bind(mat, entries, b) {
+    const tex = mat.bumpTexture;
+    entries.push({ binding: b++, resource: tex.texture.createView() });
+    entries.push({ binding: b++, resource: tex.sampler });
+    return b;
+  },
+  _textures(mat, out) {
+    if (mat.bumpTexture) {
+      out.push(mat.bumpTexture);
+    }
+  }
+};
+export {
+  bumpStdExt,
+  createNormalMapFragment
+};
+//# sourceMappingURL=normal-map-fragment-DpsIXrJf.js.map

package/normal-map-fragment-DpsIXrJf.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"normal-map-fragment-DpsIXrJf.js","sources":["../src/material/standard/fragments/normal-map-fragment.ts"],"sourcesContent":["/**\n * Normal Map Fragment (Cotangent Frame)\n *\n * Shared cotangent-frame bump mapping for Standard materials.\n * Uses screen-space derivatives to construct the TBN frame without\n * requiring explicit tangent vertex attributes.\n */\n\nimport type { ShaderFragment } from \"../../../shader/fragment-types.js\";\nimport type { StandardMaterialProps } from \"../standard-material.js\";\nimport type { Texture2D } from \"../../../texture/texture-2d.js\";\nimport type { StdExt } from \"../standard-flags.js\";\nimport { HAS_BUMP_TEXTURE } from \"../standard-flags.js\";\nimport { WGSL_PERTURB_NORMAL } from \"../../../shader/wgsl-helpers.js\";\n\nconst STAGE_FRAGMENT = 0x2;\n\n/**\n * Create a bump/normal map fragment for Standard material.\n * @param bumpLevel - The bump level (1.0 = default). bumpScale = 1/bumpLevel.\n */\nexport function createNormalMapFragment(): ShaderFragment {\n    return {\n        _id: \"normal-map\",\n\n        _bindings: [\n            { _name: \"bT\", _type: { _kind: \"texture\", _textureType: \"texture_2d<f32>\" }, _visibility: STAGE_FRAGMENT },\n            { _name: \"bS\", _type: { _kind: \"sampler\", _samplerType: \"sampler\" }, _visibility: STAGE_FRAGMENT },\n        ],\n\n        _helperFunctions: WGSL_PERTURB_NORMAL,\n\n        _fragmentSlots: {\n            AC: `normalW = perturbNormal(input.vn, input.vp, input.vu, mat.bs);`,\n        },\n    };\n}\n\nexport const bumpStdExt: StdExt = {\n    _id: \"normal-map\",\n    _phase: \"mesh\",\n    _feature: HAS_BUMP_TEXTURE,\n    _frag: createNormalMapFragment,\n    _bind(mat: StandardMaterialProps, entries: GPUBindGroupEntry[], b: number): number {\n        const tex = mat.bumpTexture!;\n        entries.push({ binding: b++, resource: tex.texture.createView() });\n        entries.push({ binding: b++, resource: tex.sampler });\n        return b;\n    },\n    _textures(mat: StandardMaterialProps, out: Texture2D[]): void {\n        if (mat.bumpTexture) {\n            out.push(mat.bumpTexture);\n        }\n    },\n};\n"],"names":[],"mappings":";;AAeA,MAAM,iBAAiB;AAMhB,SAAS,0BAA0C;AACtD,SAAO;AAAA,IACH,KAAK;AAAA,IAEL,WAAW;AAAA,MACP,EAAE,OAAO,MAAM,OAAO,EAAE,OAAO,WAAW,cAAc,kBAAA,GAAqB,aAAa,eAAA;AAAA,MAC1F,EAAE,OAAO,MAAM,OAAO,EAAE,OAAO,WAAW,cAAc,aAAa,aAAa,eAAA;AAAA,IAAe;AAAA,IAGrG,kBAAkB;AAAA,IAElB,gBAAgB;AAAA,MACZ,IAAI;AAAA,IAAA;AAAA,EACR;AAER;AAEO,MAAM,aAAqB;AAAA,EAC9B,KAAK;AAAA,EACL,QAAQ;AAAA,EACR,UAAU;AAAA,EACV,OAAO;AAAA,EACP,MAAM,KAA4B,SAA8B,GAAmB;AAC/E,UAAM,MAAM,IAAI;AAChB,YAAQ,KAAK,EAAE,SAAS,KAAK,UAAU,IAAI,QAAQ,WAAA,GAAc;AACjE,YAAQ,KAAK,EAAE,SAAS,KAAK,UAAU,IAAI,SAAS;AACpD,WAAO;AAAA,EACX;AAAA,EACA,UAAU,KAA4B,KAAwB;AAC1D,QAAI,IAAI,aAAa;AACjB,UAAI,KAAK,IAAI,WAAW;AAAA,IAC5B;AAAA,EACJ;AACJ;"}