@babylonjs/lite 0.2.0 → 1.0.0

package/node-geometry-view-COmWsRXK.js

@@ -0,0 +1,291 @@
+import { B as BU, p as packMat4IntoF32, M as MAX_LIGHTS, bv as findBlockByClassName, bw as emitGraph, x as targetSignatureKey, c as compileNodePipeline, S as SS, a as F32, G as GeometryTextureType, b as writeMeshLightSelection, bx as sanitize, by as bjsTypeToNodeType, bz as extractDefault, bA as floatCount, O as createMaterialView, bB as NODE_GEOMETRY_OUTPUT } from "./index-CLElg2Bo.js";
+import { getAttrBuffer, writeAttributeFlags } from "./node-renderable-B5G8WcdH.js";
+const nodeGeometryGroupBuilder = (async () => {
+  throw new Error("node-geometry view does not support scene group building");
+});
+nodeGeometryGroupBuilder._rebuildSingle = (scene, mesh, materialOverride) => {
+  const view = materialOverride ?? mesh.material;
+  return buildNodeGeometryRenderable(scene, mesh, view);
+};
+nodeGeometryGroupBuilder._materialFamily = "node";
+const ZERO = (wg) => `vec4<f32>(0.0, 0.0, 0.0, ${wg})`;
+function geomWrite(type, inputs, gpRef) {
+  const wg = "1.0";
+  const v = inputs.get(type);
+  const wp = inputs.get(GeometryTextureType.WORLD_POSITION);
+  switch (type) {
+    case GeometryTextureType.WORLD_POSITION:
+      return v ? `vec4<f32>(${v.expr}, ${wg})` : ZERO(wg);
+    case GeometryTextureType.LOCAL_POSITION:
+      return v ? `vec4<f32>(${v.expr}, ${wg})` : ZERO(wg);
+    case GeometryTextureType.WORLD_NORMAL:
+      return v ? `vec4<f32>(normalize(${v.expr}) * 0.5 + vec3<f32>(0.5), ${wg})` : ZERO(wg);
+    case GeometryTextureType.VIEW_NORMAL:
+      return v ? `vec4<f32>(normalize(${v.expr}), ${wg})` : ZERO(wg);
+    case GeometryTextureType.REFLECTIVITY:
+      return v ? `(${v.expr}) * ${wg}` : ZERO(wg);
+    case GeometryTextureType.ALBEDO:
+      return v ? `vec4<f32>(${v.expr}, ${wg})` : ZERO(wg);
+    case GeometryTextureType.IRRADIANCE:
+      return v ? `vec4<f32>(${v.expr}, ${wg})` : ZERO(wg);
+    case GeometryTextureType.SCREENSPACE_DEPTH:
+      return v ? `vec4<f32>(${v.expr}, 0.0, 0.0, ${wg})` : `vec4<f32>(in.position.z, 0.0, 0.0, ${wg})`;
+    case GeometryTextureType.VIEW_DEPTH:
+      if (v) {
+        return `vec4<f32>(${v.expr}, 0.0, 0.0, ${wg})`;
+      }
+      return wp ? `vec4<f32>((scene.view * vec4<f32>(${wp.expr}, 1.0)).z, 0.0, 0.0, ${wg})` : ZERO(wg);
+    case GeometryTextureType.NORMALIZED_VIEW_DEPTH:
+      if (v) {
+        return `vec4<f32>(${v.expr}, 0.0, 0.0, ${wg})`;
+      }
+      if (wp) {
+        gpRef.needsGp = true;
+        return `vec4<f32>(((scene.view * vec4<f32>(${wp.expr}, 1.0)).z - nmeGeom.cameraNearFar.x) / (nmeGeom.cameraNearFar.y - nmeGeom.cameraNearFar.x), 0.0, 0.0, ${wg})`;
+      }
+      return ZERO(wg);
+    case GeometryTextureType.LINEAR_VELOCITY:
+      return v ? `vec4<f32>(${v.expr}, ${wg})` : ZERO(wg);
+  }
+}
+function ensureGeometryResources(view) {
+  const cached = view._geometry;
+  if (cached) {
+    return cached;
+  }
+  const source = view.source;
+  const graph = source._graph;
+  const geomRoot = findBlockByClassName(graph, "GeometryTextureOutputBlock");
+  if (!geomRoot) {
+    throw new Error("NodeMaterial geometry view: graph has no GeometryTextureOutputBlock");
+  }
+  const vertRoot = findBlockByClassName(graph, "VertexOutputBlock");
+  const { vertexWgsl, fragmentWgsl, state } = emitGraph(
+    graph,
+    source._emitters,
+    geomRoot.id,
+    vertRoot ? vertRoot.id : null,
+    [],
+    {
+      hasSkeleton: source._hasSkeleton,
+      hasInstances: source._hasInstances
+    }
+  );
+  if (state.usesMorphTargets || state.usesEnv || state.shadowLights.length > 0) {
+    throw new Error("NodeMaterial geometry view: morph / env / shadow inputs are not supported in the geometry pass");
+  }
+  const inputs = state._geometryInputs ?? /* @__PURE__ */ new Map();
+  const attachments = view._geometryAttachments;
+  const gpRef = { needsGp: false };
+  const structLines = attachments.map((_, i) => `@location(${i}) f${i}: vec4<f32>,`);
+  const struct = `struct FragmentOutput {
+${structLines.join("\n")}
+};`;
+  const writeLines = attachments.map((type, i) => `out.f${i} = ${geomWrite(type, inputs, gpRef)};`);
+  const fsReturn = ["var out: FragmentOutput;", ...writeLines, "return out;"].map((l) => `    ${l}`).join("\n") + "\n";
+  const res = {
+    _vertexWgsl: vertexWgsl,
+    _fragmentWgsl: fragmentWgsl,
+    _geomState: state,
+    _struct: struct,
+    _fsReturn: fsReturn,
+    _needsGpUbo: gpRef.needsGp,
+    _attrNames: state.vertexAttributes.map((a) => a._name),
+    _compileBySig: /* @__PURE__ */ new Map(),
+    _nodeUBO: null,
+    _nodeUBOReady: false
+  };
+  Object.defineProperty(view, "_geometry", { value: res, enumerable: false, configurable: true });
+  return res;
+}
+function ensureGeometryCompile(view, res, engine, sig) {
+  const key = targetSignatureKey(sig);
+  const cached = res._compileBySig.get(key);
+  if (cached) {
+    return cached;
+  }
+  const source = view.source;
+  const colorFormats = sig._colorFormats ?? (sig._colorFormat ? [sig._colorFormat] : []);
+  if (colorFormats.length === 0) {
+    throw new Error("node-geometry: render target has no color attachments");
+  }
+  const cullMode = source._graph.backFaceCulling ? view._reverseCulling ? "front" : "back" : "none";
+  const mrtOutput = {
+    _struct: res._struct,
+    _fsReturnType: " -> FragmentOutput",
+    _fsReturn: res._fsReturn,
+    _cacheKey: `3|mrt:${colorFormats.join()}:${cullMode}`,
+    _needsGpUbo: res._needsGpUbo,
+    _buildGeomUbo: (binding) => ({
+      _wgsl: `struct NmeGeomParams { previousViewProjection: mat4x4<f32>, cameraNearFar: vec4<f32> };
+@group(1) @binding(${binding}) var<uniform> nmeGeom: NmeGeomParams;`,
+      _bglEntry: { binding, visibility: SS.FRAGMENT, buffer: { type: "uniform" } }
+    }),
+    // Geometry MRT renders upright into offscreen targets (the task packs an
+    // un-flipped scene UBO), matching the Standard/PBR geometry renderables.
+    _buildPipeline: (device, a) => device.createRenderPipeline({
+      label: "node-material-geometry",
+      layout: device.createPipelineLayout({ bindGroupLayouts: [a._sceneBGL, a._meshBGL] }),
+      vertex: { module: a._shaderModule, entryPoint: "vs_main", buffers: a._vertexBuffers },
+      fragment: { module: a._shaderModule, entryPoint: "fs_main", targets: colorFormats.map((f) => ({ format: f })) },
+      depthStencil: { format: a._depthFormat, depthCompare: a._depthCompare, depthWriteEnabled: true },
+      multisample: { count: a._msaaSamples },
+      primitive: { topology: "triangle-list", cullMode, frontFace: "ccw" }
+    })
+  };
+  const compile = compileNodePipeline(res._geomState, res._vertexWgsl, res._fragmentWgsl, {
+    _engine: engine,
+    _format: engine.format,
+    _depthStencilFormat: sig._depthStencilFormat,
+    _depthCompare: sig._depthCompare ?? "greater-equal",
+    _msaaSamples: sig._sampleCount,
+    _backFaceCulling: source._graph.backFaceCulling,
+    _alphaMode: 0,
+    _mrtOutput: mrtOutput
+  });
+  res._compileBySig.set(key, compile);
+  return compile;
+}
+function extractNodeUniformDefault(graph, sanitizedName) {
+  for (const block of graph.blocks.values()) {
+    if (block.className !== "InputBlock") {
+      continue;
+    }
+    if (sanitize(block.name || `input${block.id}`) !== sanitizedName) {
+      continue;
+    }
+    const type = bjsTypeToNodeType(block.serialized["type"] ?? 16);
+    if (type === "mat4f") {
+      return null;
+    }
+    const values = new F32(floatCount(type));
+    values.set(extractDefault(block.serialized["value"], type));
+    return values;
+  }
+  return null;
+}
+function ensureGeometryNodeUBO(res, compile, engine, source) {
+  if (res._nodeUBOReady) {
+    return res._nodeUBO;
+  }
+  res._nodeUBOReady = true;
+  if (compile._nodeUboBinding === null || compile._nodeUboSize === 0) {
+    return null;
+  }
+  const scratch = new F32(compile._nodeUboSize / 4);
+  for (const [name, offsetBytes] of compile._nodeUboOffsets) {
+    const live = source._uniformValues.get(name);
+    if (live) {
+      scratch.set(live._values, offsetBytes >> 2);
+      continue;
+    }
+    const def = extractNodeUniformDefault(source._graph, name);
+    if (def) {
+      scratch.set(def, offsetBytes >> 2);
+    }
+  }
+  const ubo = engine._device.createBuffer({ label: "node-geom-ubo", size: compile._nodeUboSize, usage: BU.UNIFORM | BU.COPY_DST });
+  engine._device.queue.writeBuffer(ubo, 0, scratch);
+  res._nodeUBO = ubo;
+  return ubo;
+}
+function buildGeometryBindGroup(engine, source, compile, meshUBO, nodeUBO, view) {
+  var _a;
+  const entries = [{ binding: 0, resource: { buffer: meshUBO } }];
+  if (nodeUBO && compile._nodeUboBinding !== null) {
+    entries.push({ binding: compile._nodeUboBinding, resource: { buffer: nodeUBO } });
+  }
+  for (const tb of compile._textureBindings) {
+    const tex = (_a = source._textureSlots.get(tb._name)) == null ? void 0 : _a.current;
+    if (!tex) {
+      throw new Error(`NodeMaterial geometry view: texture binding "${tb._name}" not set. Provide it via material.inputs["${tb._name}"].texture before the first render.`);
+    }
+    entries.push({ binding: tb._texBinding, resource: tex.view }, { binding: tb._sampBinding, resource: tex.sampler });
+  }
+  if (compile._geometryGpBinding !== null) {
+    if (!view._gpUBO) {
+      throw new Error("NodeMaterial geometry view: NORMALIZED_VIEW_DEPTH requested but no geometry-params UBO was provided by the task.");
+    }
+    entries.push({ binding: compile._geometryGpBinding, resource: { buffer: view._gpUBO } });
+  }
+  return engine._device.createBindGroup({ label: "node-geom-bg", layout: compile._meshBGL, entries });
+}
+function buildNodeGeometryRenderable(scene, mesh, view) {
+  var _a;
+  const engine = scene.surface.engine;
+  const device = engine._device;
+  const source = view.source;
+  const res = ensureGeometryResources(view);
+  const meshUboBytes = 96 + 16 * Math.ceil(MAX_LIGHTS / 4) + 15 & -16;
+  const meshUBO = device.createBuffer({ label: "node-geom-mesh-ubo", size: meshUboBytes, usage: BU.UNIFORM | BU.COPY_DST });
+  const meshScratch = new F32(meshUboBytes / 4);
+  const packMeshWorld = ((_a = engine._makePackMeshWorld) == null ? void 0 : _a.call(engine, scene)) ?? packMat4IntoF32;
+  let needsAttrFlags = false;
+  const writeMesh = () => {
+    packMeshWorld(meshScratch, mesh.worldMatrix, 0, 0);
+    meshScratch[16] = mesh.receiveShadows ? 1 : 0;
+    if (needsAttrFlags) {
+      writeAttributeFlags(mesh, meshScratch);
+    }
+    writeMeshLightSelection(mesh, scene.lights, meshScratch.subarray(4));
+    device.queue.writeBuffer(meshUBO, 0, meshScratch);
+  };
+  let bindGroup = null;
+  let lastWorldVersion = -1;
+  let lastLightsCount = -1;
+  const sortCenter = [mesh.worldMatrix[12], mesh.worldMatrix[13], mesh.worldMatrix[14]];
+  const r = {
+    order: mesh.renderOrder ?? 100,
+    isTransparent: false,
+    mesh,
+    bind(eng, sig) {
+      const compile = ensureGeometryCompile(view, res, eng, sig);
+      needsAttrFlags = compile._usesMeshAttributeFlags;
+      const nodeUBO = ensureGeometryNodeUBO(res, compile, eng, source);
+      bindGroup = buildGeometryBindGroup(eng, source, compile, meshUBO, nodeUBO, view);
+      const update = () => {
+        if (mesh.worldMatrixVersion !== lastWorldVersion || scene.lights.length !== lastLightsCount) {
+          writeMesh();
+          sortCenter[0] = mesh.worldMatrix[12];
+          sortCenter[1] = mesh.worldMatrix[13];
+          sortCenter[2] = mesh.worldMatrix[14];
+          lastWorldVersion = mesh.worldMatrixVersion;
+          lastLightsCount = scene.lights.length;
+        }
+      };
+      const draw = (pass) => {
+        if (mesh.visible === false) {
+          return 0;
+        }
+        const g = mesh._gpu;
+        for (let i = 0; i < res._attrNames.length; i++) {
+          pass.setVertexBuffer(i, getAttrBuffer(engine, g, res._attrNames[i]));
+        }
+        pass.setIndexBuffer(g.indexBuffer, g.indexFormat);
+        pass.setBindGroup(1, bindGroup);
+        pass.drawIndexed(g.indexCount);
+        return 1;
+      };
+      return { renderable: r, pipeline: compile._pipeline, update, draw };
+    }
+  };
+  r._worldCenter = sortCenter;
+  return r;
+}
+function createNodeGeometryMaterialView(source, config) {
+  var _a;
+  if (config.emitColor) {
+    throw new Error("NodeMaterial geometry view: emitColor (real-color target) is not supported — omit targetTexture on the geometry task.");
+  }
+  const baseFeatures = ((_a = source._renderFeatures) == null ? void 0 : _a.features) ?? 0;
+  const view = createMaterialView(source, { features: baseFeatures | NODE_GEOMETRY_OUTPUT });
+  Object.defineProperty(view, "_geometryAttachments", { value: config.attachments, enumerable: false });
+  Object.defineProperty(view, "_gpUBO", { value: config.gpUBO ?? null, enumerable: false });
+  Object.defineProperty(view, "_reverseCulling", { value: config.reverseCulling ?? false, enumerable: false });
+  Object.defineProperty(view, "_buildGroup", { value: nodeGeometryGroupBuilder, enumerable: false });
+  return view;
+}
+export {
+  createNodeGeometryMaterialView
+};
+//# sourceMappingURL=node-geometry-view-COmWsRXK.js.map

package/node-geometry-view-COmWsRXK.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"node-geometry-view-COmWsRXK.js","sources":["../src/material/node/node-geometry-renderable.ts","../src/material/node/node-geometry-view.ts"],"sourcesContent":["/** Node Material geometry-MRT renderable factory.\n *\n *  Builds a {@link Renderable} that draws a single mesh through a\n *  {@link createNodeGeometryMaterialView} into the geometry renderer task's\n *  multi-attachment render target. Parallel to\n *  `standard-geometry-renderable.ts` / `pbr-geometry-renderable.ts` but for the\n *  NodeMaterial family.\n *\n *  The geometry shader is produced by **re-walking** the parsed graph from the\n *  `GeometryTextureOutputBlock` terminal (instead of `FragmentOutputBlock`).\n *  That second `emitGraph` pass fills `state._geometryInputs` with the WGSL\n *  expression for every connected geometry input; this module turns those into\n *  the per-attachment `FragmentOutput` writes (falling back to the engine\n *  default for unconnected attachments) and feeds them to\n *  {@link compileNodePipeline} via its `_mrtOutput` option.\n *\n *  This module is imported only by {@link createNodeGeometryMaterialView}, which\n *  the geometry renderer task dynamic-imports — node scenes that never use the\n *  geometry renderer pay zero bytes for it.\n */\n\nimport { F32 } from \"../../engine/typed-arrays.js\";\nimport { BU, SS } from \"../../engine/gpu-flags.js\";\nimport type { EngineContext } from \"../../engine/engine.js\";\nimport type { RenderTargetSignature } from \"../../engine/render-target.js\";\nimport { targetSignatureKey } from \"../../engine/render-target.js\";\nimport type { Mesh } from \"../../mesh/mesh.js\";\nimport type { MeshGroupBuilder, Renderable } from \"../../render/renderable.js\";\nimport { writeMeshLightSelection } from \"../../render/lights-ubo.js\";\nimport { MAX_LIGHTS } from \"../../light/types.js\";\nimport { packMat4IntoF32 } from \"../../math/pack-mat4-into-f32.js\";\nimport type { SceneContext } from \"../../scene/scene-core.js\";\nimport type { Material } from \"../material.js\";\nimport { GeometryTextureType } from \"../../frame-graph/geometry-types.js\";\nimport type { NodeExpr, NodeBuildState, NodeGraph } from \"./node-types.js\";\nimport { emitGraph } from \"./node-emitter.js\";\nimport { findBlockByClassName } from \"./node-parser.js\";\nimport { compileNodePipeline, type NodeCompileResult, type MrtOutputOpts } from \"./node-pipeline.js\";\nimport type { NodeMaterial } from \"./node-material.js\";\nimport { sanitize, bjsTypeToNodeType, floatCount, extractDefault } from \"./node-material.js\";\nimport { getAttrBuffer, writeAttributeFlags } from \"./node-renderable.js\";\nimport type { NodeGeometryMaterialView } from \"./node-geometry-view.js\";\n\n/** Singleton {@link MeshGroupBuilder} that node geometry views point at via their\n *  overridden `_buildGroup`. The async builder body is unreachable — geometry\n *  views are dispatched per-mesh via the geometry renderer task which calls\n *  `_rebuildSingle` directly. */\nexport const nodeGeometryGroupBuilder: MeshGroupBuilder = (async () => {\n    throw new Error(\"node-geometry view does not support scene group building\");\n}) as MeshGroupBuilder;\nnodeGeometryGroupBuilder._rebuildSingle = (scene: SceneContext, mesh: Mesh, materialOverride?: Material): Renderable => {\n    const view = (materialOverride ?? mesh.material) as NodeGeometryMaterialView;\n    return buildNodeGeometryRenderable(scene, mesh, view);\n};\nnodeGeometryGroupBuilder._materialFamily = \"node\";\n\n/** Shared per-view geometry resources, computed once and cached on the view. */\ninterface NodeGeometryViewResources {\n    readonly _vertexWgsl: string;\n    readonly _fragmentWgsl: string;\n    readonly _geomState: NodeBuildState;\n    readonly _struct: string;\n    /** Fully-assembled fs_main return body (`var out…; return out;`), indented\n     *  one level with a trailing newline — ready to splice straight into the\n     *  node pipeline's `fs_main` (no WGSL assembly leaks into node-pipeline.ts). */\n    readonly _fsReturn: string;\n    readonly _needsGpUbo: boolean;\n    readonly _attrNames: readonly string[];\n    /** Per-target-signature compile (pipeline + BGL). */\n    readonly _compileBySig: Map<string, NodeCompileResult>;\n    /** Shared node UBO (one per material, format-independent). Allocated on first compile. */\n    _nodeUBO: GPUBuffer | null;\n    _nodeUBOReady: boolean;\n}\n\nconst ZERO = (wg: string): string => `vec4<f32>(0.0, 0.0, 0.0, ${wg})`;\n\n/** Build the per-attachment WGSL write for one geometry texture type, reading a\n *  connected graph input when present and falling back to the engine default. */\nfunction geomWrite(type: GeometryTextureType, inputs: Map<GeometryTextureType, NodeExpr>, gpRef: { needsGp: boolean }): string {\n    const wg = \"1.0\"; // opaque node materials: writeGeometryInfo gate is always 1.\n    const v = inputs.get(type);\n    const wp = inputs.get(GeometryTextureType.WORLD_POSITION);\n    switch (type) {\n        case GeometryTextureType.WORLD_POSITION:\n            return v ? `vec4<f32>(${v.expr}, ${wg})` : ZERO(wg);\n        case GeometryTextureType.LOCAL_POSITION:\n            return v ? `vec4<f32>(${v.expr}, ${wg})` : ZERO(wg);\n        case GeometryTextureType.WORLD_NORMAL:\n            return v ? `vec4<f32>(normalize(${v.expr}) * 0.5 + vec3<f32>(0.5), ${wg})` : ZERO(wg);\n        case GeometryTextureType.VIEW_NORMAL:\n            return v ? `vec4<f32>(normalize(${v.expr}), ${wg})` : ZERO(wg);\n        case GeometryTextureType.REFLECTIVITY:\n            // Stored as vec4 — vec4(rgb, a) * writeGeometryInfo.\n            return v ? `(${v.expr}) * ${wg}` : ZERO(wg);\n        case GeometryTextureType.ALBEDO:\n            return v ? `vec4<f32>(${v.expr}, ${wg})` : ZERO(wg);\n        case GeometryTextureType.IRRADIANCE:\n            return v ? `vec4<f32>(${v.expr}, ${wg})` : ZERO(wg);\n        case GeometryTextureType.SCREENSPACE_DEPTH:\n            return v ? `vec4<f32>(${v.expr}, 0.0, 0.0, ${wg})` : `vec4<f32>(in.position.z, 0.0, 0.0, ${wg})`;\n        case GeometryTextureType.VIEW_DEPTH:\n            if (v) {\n                return `vec4<f32>(${v.expr}, 0.0, 0.0, ${wg})`;\n            }\n            return wp ? `vec4<f32>((scene.view * vec4<f32>(${wp.expr}, 1.0)).z, 0.0, 0.0, ${wg})` : ZERO(wg);\n        case GeometryTextureType.NORMALIZED_VIEW_DEPTH:\n            if (v) {\n                return `vec4<f32>(${v.expr}, 0.0, 0.0, ${wg})`;\n            }\n            if (wp) {\n                gpRef.needsGp = true;\n                return `vec4<f32>(((scene.view * vec4<f32>(${wp.expr}, 1.0)).z - nmeGeom.cameraNearFar.x) / (nmeGeom.cameraNearFar.y - nmeGeom.cameraNearFar.x), 0.0, 0.0, ${wg})`;\n            }\n            return ZERO(wg);\n        case GeometryTextureType.LINEAR_VELOCITY:\n            // Stored as vec3 — node materials do not compute velocity, default 0.\n            return v ? `vec4<f32>(${v.expr}, ${wg})` : ZERO(wg);\n    }\n}\n\n/** Re-emit the graph from the GeometryTextureOutputBlock terminal and build the\n *  shared geometry resources (WGSL bodies + FragmentOutput struct + writes). */\nfunction ensureGeometryResources(view: NodeGeometryMaterialView): NodeGeometryViewResources {\n    const cached = view._geometry as NodeGeometryViewResources | undefined;\n    if (cached) {\n        return cached;\n    }\n    const source = view.source as NodeMaterial;\n    const graph = source._graph;\n    const geomRoot = findBlockByClassName(graph, \"GeometryTextureOutputBlock\");\n    if (!geomRoot) {\n        throw new Error(\"NodeMaterial geometry view: graph has no GeometryTextureOutputBlock\");\n    }\n    const vertRoot = findBlockByClassName(graph, \"VertexOutputBlock\");\n    const { vertexWgsl, fragmentWgsl, state } = emitGraph(\n        graph,\n        source._emitters as Map<string, import(\"./node-types.js\").BlockEmitter>,\n        geomRoot.id,\n        vertRoot ? vertRoot.id : null,\n        [],\n        {\n            hasSkeleton: source._hasSkeleton,\n            hasInstances: source._hasInstances,\n        }\n    );\n    if (state.usesMorphTargets || state.usesEnv || state.shadowLights.length > 0) {\n        throw new Error(\"NodeMaterial geometry view: morph / env / shadow inputs are not supported in the geometry pass\");\n    }\n\n    const inputs = state._geometryInputs ?? new Map<GeometryTextureType, NodeExpr>();\n    const attachments = view._geometryAttachments;\n    const gpRef = { needsGp: false };\n    const structLines = attachments.map((_, i) => `@location(${i}) f${i}: vec4<f32>,`);\n    const struct = `struct FragmentOutput {\\n${structLines.join(\"\\n\")}\\n};`;\n    const writeLines = attachments.map((type, i) => `out.f${i} = ${geomWrite(type, inputs, gpRef)};`);\n    // Pre-indent the full return body here (one level + trailing newline) so the\n    // node pipeline just splices the string — no geometry WGSL assembly in the\n    // always-loaded compileNodePipeline.\n    const fsReturn = [\"var out: FragmentOutput;\", ...writeLines, \"return out;\"].map((l) => `    ${l}`).join(\"\\n\") + \"\\n\";\n\n    const res: NodeGeometryViewResources = {\n        _vertexWgsl: vertexWgsl,\n        _fragmentWgsl: fragmentWgsl,\n        _geomState: state,\n        _struct: struct,\n        _fsReturn: fsReturn,\n        _needsGpUbo: gpRef.needsGp,\n        _attrNames: state.vertexAttributes.map((a) => a._name),\n        _compileBySig: new Map(),\n        _nodeUBO: null,\n        _nodeUBOReady: false,\n    };\n    Object.defineProperty(view, \"_geometry\", { value: res, enumerable: false, configurable: true });\n    return res;\n}\n\n/** Compile (or fetch cached) the geometry MRT pipeline for a target signature. */\nfunction ensureGeometryCompile(view: NodeGeometryMaterialView, res: NodeGeometryViewResources, engine: EngineContext, sig: RenderTargetSignature): NodeCompileResult {\n    const key = targetSignatureKey(sig);\n    const cached = res._compileBySig.get(key);\n    if (cached) {\n        return cached;\n    }\n    const source = view.source as NodeMaterial;\n    const colorFormats = (sig as RenderTargetSignature & { _colorFormats?: readonly GPUTextureFormat[] })._colorFormats ?? (sig._colorFormat ? [sig._colorFormat] : []);\n    if (colorFormats.length === 0) {\n        throw new Error(\"node-geometry: render target has no color attachments\");\n    }\n    const cullMode: GPUCullMode = source._graph.backFaceCulling ? (view._reverseCulling ? \"front\" : \"back\") : \"none\";\n    // All geometry-specific WGSL object-literals + the MRT pipeline descriptor\n    // live here (lazy module). compileNodePipeline only splices strings + calls\n    // these callbacks, so non-geometry node scenes bundle none of it.\n    const mrtOutput: MrtOutputOpts = {\n        _struct: res._struct,\n        _fsReturnType: \" -> FragmentOutput\",\n        _fsReturn: res._fsReturn,\n        _cacheKey: `3|mrt:${colorFormats.join()}:${cullMode}`,\n        _needsGpUbo: res._needsGpUbo,\n        _buildGeomUbo: (binding) => ({\n            _wgsl: `struct NmeGeomParams { previousViewProjection: mat4x4<f32>, cameraNearFar: vec4<f32> };\\n@group(1) @binding(${binding}) var<uniform> nmeGeom: NmeGeomParams;`,\n            _bglEntry: { binding, visibility: SS.FRAGMENT, buffer: { type: \"uniform\" } },\n        }),\n        // Geometry MRT renders upright into offscreen targets (the task packs an\n        // un-flipped scene UBO), matching the Standard/PBR geometry renderables.\n        _buildPipeline: (device, a) =>\n            device.createRenderPipeline({\n                label: \"node-material-geometry\",\n                layout: device.createPipelineLayout({ bindGroupLayouts: [a._sceneBGL, a._meshBGL] }),\n                vertex: { module: a._shaderModule, entryPoint: \"vs_main\", buffers: a._vertexBuffers },\n                fragment: { module: a._shaderModule, entryPoint: \"fs_main\", targets: colorFormats.map((f) => ({ format: f })) },\n                depthStencil: { format: a._depthFormat, depthCompare: a._depthCompare, depthWriteEnabled: true },\n                multisample: { count: a._msaaSamples },\n                primitive: { topology: \"triangle-list\", cullMode, frontFace: \"ccw\" },\n            }),\n    };\n    const compile = compileNodePipeline(res._geomState, res._vertexWgsl, res._fragmentWgsl, {\n        _engine: engine,\n        _format: engine.format,\n        _depthStencilFormat: sig._depthStencilFormat,\n        _depthCompare: sig._depthCompare ?? \"greater-equal\",\n        _msaaSamples: sig._sampleCount,\n        _backFaceCulling: source._graph.backFaceCulling,\n        _alphaMode: 0,\n        _mrtOutput: mrtOutput,\n    });\n    res._compileBySig.set(key, compile);\n    return compile;\n}\n\n/** Resolve the default uniform value (as a Float32Array) for the InputBlock\n *  whose sanitized name matches `sanitizedName`. Used by {@link ensureGeometryNodeUBO}\n *  for uniforms that only appear in the geometry re-emit — e.g. a constant\n *  reflectivity colour referenced solely by the GeometryTextureOutputBlock\n *  terminal and therefore absent from the colour pass's `_uniformValues`.\n *  Returns null when no matching scalar/vector uniform InputBlock exists. Lives\n *  here (not in the always-loaded `node-material.ts`) so non-geometry node\n *  scenes pay zero bytes for it; the tiny helpers it calls (`sanitize`,\n *  `bjsTypeToNodeType`, `floatCount`, `extractDefault`) are already retained by\n *  the always-loaded UBO writer and merely re-exported. */\nfunction extractNodeUniformDefault(graph: NodeGraph, sanitizedName: string): Float32Array | null {\n    for (const block of graph.blocks.values()) {\n        if (block.className !== \"InputBlock\") {\n            continue;\n        }\n        if (sanitize(block.name || `input${block.id}`) !== sanitizedName) {\n            continue;\n        }\n        const type = bjsTypeToNodeType((block.serialized[\"type\"] as number | undefined) ?? 0x10);\n        if (type === \"mat4f\") {\n            return null;\n        }\n        const values = new F32(floatCount(type));\n        values.set(extractDefault(block.serialized[\"value\"], type));\n        return values;\n    }\n    return null;\n}\n\n/** Build / refresh the shared geometry node UBO (constants + live uniform overlays). */\nfunction ensureGeometryNodeUBO(res: NodeGeometryViewResources, compile: NodeCompileResult, engine: EngineContext, source: NodeMaterial): GPUBuffer | null {\n    if (res._nodeUBOReady) {\n        return res._nodeUBO;\n    }\n    res._nodeUBOReady = true;\n    if (compile._nodeUboBinding === null || compile._nodeUboSize === 0) {\n        return null;\n    }\n    const scratch = new F32(compile._nodeUboSize / 4);\n    for (const [name, offsetBytes] of compile._nodeUboOffsets) {\n        const live = source._uniformValues.get(name);\n        if (live) {\n            scratch.set(live._values, offsetBytes >> 2);\n            continue;\n        }\n        const def = extractNodeUniformDefault(source._graph, name);\n        if (def) {\n            scratch.set(def, offsetBytes >> 2);\n        }\n    }\n    const ubo = engine._device.createBuffer({ label: \"node-geom-ubo\", size: compile._nodeUboSize, usage: BU.UNIFORM | BU.COPY_DST });\n    engine._device.queue.writeBuffer(ubo, 0, scratch);\n    res._nodeUBO = ubo;\n    return ubo;\n}\n\nfunction buildGeometryBindGroup(\n    engine: EngineContext,\n    source: NodeMaterial,\n    compile: NodeCompileResult,\n    meshUBO: GPUBuffer,\n    nodeUBO: GPUBuffer | null,\n    view: NodeGeometryMaterialView\n): GPUBindGroup {\n    const entries: GPUBindGroupEntry[] = [{ binding: 0, resource: { buffer: meshUBO } }];\n    if (nodeUBO && compile._nodeUboBinding !== null) {\n        entries.push({ binding: compile._nodeUboBinding, resource: { buffer: nodeUBO } });\n    }\n    for (const tb of compile._textureBindings) {\n        const tex = source._textureSlots.get(tb._name)?.current;\n        if (!tex) {\n            throw new Error(`NodeMaterial geometry view: texture binding \"${tb._name}\" not set. Provide it via material.inputs[\"${tb._name}\"].texture before the first render.`);\n        }\n        entries.push({ binding: tb._texBinding, resource: tex.view }, { binding: tb._sampBinding, resource: tex.sampler });\n    }\n    if (compile._geometryGpBinding !== null) {\n        if (!view._gpUBO) {\n            throw new Error(\"NodeMaterial geometry view: NORMALIZED_VIEW_DEPTH requested but no geometry-params UBO was provided by the task.\");\n        }\n        entries.push({ binding: compile._geometryGpBinding, resource: { buffer: view._gpUBO } });\n    }\n    return engine._device.createBindGroup({ label: \"node-geom-bg\", layout: compile._meshBGL, entries });\n}\n\n/** Build a {@link Renderable} for one mesh drawn through a NodeMaterial geometry view. */\nexport function buildNodeGeometryRenderable(scene: SceneContext, mesh: Mesh, view: NodeGeometryMaterialView): Renderable {\n    const engine = scene.surface.engine;\n    const device = engine._device;\n    const source = view.source as NodeMaterial;\n    const res = ensureGeometryResources(view);\n\n    // Per-mesh UBO: world (64B) + receivesShadow (vec4) + light count/indices.\n    const meshUboBytes = (96 + 16 * Math.ceil(MAX_LIGHTS / 4) + 15) & ~15;\n    const meshUBO = device.createBuffer({ label: \"node-geom-mesh-ubo\", size: meshUboBytes, usage: BU.UNIFORM | BU.COPY_DST });\n    const meshScratch = new F32(meshUboBytes / 4);\n    const packMeshWorld = engine._makePackMeshWorld?.(scene) ?? packMat4IntoF32;\n\n    let needsAttrFlags = false;\n    const writeMesh = (): void => {\n        packMeshWorld(meshScratch, mesh.worldMatrix, 0, 0);\n        meshScratch[16] = mesh.receiveShadows ? 1 : 0;\n        if (needsAttrFlags) {\n            writeAttributeFlags(mesh, meshScratch);\n        }\n        writeMeshLightSelection(mesh, scene.lights, meshScratch.subarray(4));\n        device.queue.writeBuffer(meshUBO, 0, meshScratch as Float32Array<ArrayBuffer>);\n    };\n\n    let bindGroup: GPUBindGroup | null = null;\n    let lastWorldVersion = -1;\n    let lastLightsCount = -1;\n\n    const sortCenter: [number, number, number] = [mesh.worldMatrix[12]!, mesh.worldMatrix[13]!, mesh.worldMatrix[14]!];\n\n    const r: Renderable = {\n        order: mesh.renderOrder ?? 100,\n        isTransparent: false,\n        mesh,\n        bind(eng: EngineContext, sig: RenderTargetSignature) {\n            const compile = ensureGeometryCompile(view, res, eng as EngineContext, sig);\n            needsAttrFlags = compile._usesMeshAttributeFlags;\n            const nodeUBO = ensureGeometryNodeUBO(res, compile, eng as EngineContext, source);\n            bindGroup = buildGeometryBindGroup(eng as EngineContext, source, compile, meshUBO, nodeUBO, view);\n\n            const update = (): void => {\n                if (mesh.worldMatrixVersion !== lastWorldVersion || scene.lights.length !== lastLightsCount) {\n                    writeMesh();\n                    sortCenter[0] = mesh.worldMatrix[12]!;\n                    sortCenter[1] = mesh.worldMatrix[13]!;\n                    sortCenter[2] = mesh.worldMatrix[14]!;\n                    lastWorldVersion = mesh.worldMatrixVersion;\n                    lastLightsCount = scene.lights.length;\n                }\n            };\n            const draw = (pass: GPURenderPassEncoder | GPURenderBundleEncoder): number => {\n                if (mesh.visible === false) {\n                    return 0;\n                }\n                const g = mesh._gpu;\n                for (let i = 0; i < res._attrNames.length; i++) {\n                    pass.setVertexBuffer(i, getAttrBuffer(engine, g, res._attrNames[i]!));\n                }\n                pass.setIndexBuffer(g.indexBuffer, g.indexFormat);\n                pass.setBindGroup(1, bindGroup!);\n                pass.drawIndexed(g.indexCount);\n                return 1;\n            };\n            return { renderable: r, pipeline: compile._pipeline, update, draw };\n        },\n    };\n    r._worldCenter = sortCenter;\n    return r;\n}\n","/** NodeMaterial view helper that targets geometry-rendering MRT output.\n *\n *  The geometry renderer task wraps each NodeMaterial caster in a\n *  `NodeGeometryMaterialView`. The view carries the per-task attachment list,\n *  optional `gp` UBO (camera near/far, shared across the task's materials), and\n *  reverse-culling flag, and shadows {@link Material._buildGroup} with\n *  {@link nodeGeometryGroupBuilder} so the geometry renderer task materialises a\n *  {@link Renderable} through the node geometry renderable infrastructure — no\n *  view-aware branching needed in core render-task.\n *\n *  The geometry-output WGSL itself is produced by re-walking the parsed graph\n *  from the `GeometryTextureOutputBlock` terminal in\n *  `./node-geometry-renderable.ts`. Mirrors `material/standard/geometry-view.ts`\n *  and `material/node/esm-shadow-view.ts`. */\n\nimport { createMaterialView } from \"../material-view.js\";\nimport type { MaterialView } from \"../material.js\";\nimport type { GeometryTextureType } from \"../../frame-graph/geometry-types.js\";\nimport { NODE_GEOMETRY_OUTPUT } from \"./node-flags.js\";\nimport type { NodeMaterial } from \"./node-material.js\";\nimport { nodeGeometryGroupBuilder } from \"./node-geometry-renderable.js\";\n\n/** Per-task ordered attachment list driving the geometry template. The array\n *  index is the MRT color-attachment slot used in `@location(i)`. */\nexport type NodeGeometryAttachments = readonly GeometryTextureType[];\n\n/** Per-(task, material) NodeMaterial geometry view configuration. */\nexport interface NodeGeometryViewConfig {\n    /** Ordered MRT attachment list — index = `@location(i)`. */\n    readonly attachments: NodeGeometryAttachments;\n    /** When true the task additionally wants the real (lit) material color at\n     *  `@location(N)`. NodeMaterial geometry views do not implement the extra\n     *  color attachment (the realColor impostor is dropped); passing `true`\n     *  throws so callers don't silently mismatch the render-pass attachments. */\n    readonly emitColor: boolean;\n    /** Per-task camera-near-far UBO. Required when {@link attachments} contains\n     *  `NORMALIZED_VIEW_DEPTH` (and the input is left unconnected). */\n    readonly gpUBO?: GPUBuffer | null;\n    /** Flip culling direction. */\n    readonly reverseCulling?: boolean;\n}\n\n/** NodeMaterial view that emits geometry textures instead of shaded colour. */\nexport interface NodeGeometryMaterialView extends MaterialView {\n    /** @internal Ordered MRT attachment list — index = `@location(i)`. */\n    readonly _geometryAttachments: NodeGeometryAttachments;\n    /** @internal Optional per-task geometry-params UBO. */\n    readonly _gpUBO: GPUBuffer | null;\n    /** @internal */\n    readonly _reverseCulling: boolean;\n    /** @internal Shared per-view resources cache populated lazily by the renderable factory. */\n    _geometry?: unknown;\n}\n\n/** Wrap a NodeMaterial as a geometry-output view.\n *  - Sets the `NODE_GEOMETRY_OUTPUT` feature bit.\n *  - Shadows `_buildGroup` with {@link nodeGeometryGroupBuilder} so the natural\n *    `material._buildGroup._rebuildSingle` dispatch builds a geometry-MRT\n *    renderable for this view. */\nexport function createNodeGeometryMaterialView(source: NodeMaterial, config: NodeGeometryViewConfig): NodeGeometryMaterialView {\n    if (config.emitColor) {\n        throw new Error(\"NodeMaterial geometry view: emitColor (real-color target) is not supported — omit targetTexture on the geometry task.\");\n    }\n    const baseFeatures = source._renderFeatures?.features ?? 0;\n    const view = createMaterialView(source, { features: baseFeatures | NODE_GEOMETRY_OUTPUT }) as NodeGeometryMaterialView;\n    Object.defineProperty(view, \"_geometryAttachments\", { value: config.attachments, enumerable: false });\n    Object.defineProperty(view, \"_gpUBO\", { value: config.gpUBO ?? null, enumerable: false });\n    Object.defineProperty(view, \"_reverseCulling\", { value: config.reverseCulling ?? false, enumerable: false });\n    Object.defineProperty(view, \"_buildGroup\", { value: nodeGeometryGroupBuilder, enumerable: false });\n    return view;\n}\n"],"names":[],"mappings":"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"}

package/{node-registry-extra-compat-Ch7ApZHF.js → node-registry-extra-compat-dWrv7gpS.js}

@@ -19,7 +19,7 @@ function blockLoader(key) {
     case "IridescenceBlock":
       return () => import("./iridescence-block-B0pRFoOU.js");
     case "LoopBlock":
-      return () => import("./loop-block-BFkLFYGm.js");
+      return () => import("./loop-block-qTg8vb99.js");
     case "StorageReadBlock":
       return () => import("./storage-read-block-BdzhJfln.js");
     case "StorageWriteBlock":
@@ -38,4 +38,4 @@ async function loadExtraEmitter(key) {
 export {
   loadExtraEmitter
 };
-//# sourceMappingURL=node-registry-extra-compat-Ch7ApZHF.js.map
+//# sourceMappingURL=node-registry-extra-compat-dWrv7gpS.js.map

package/{node-registry-extra-compat-Ch7ApZHF.js.map → node-registry-extra-compat-dWrv7gpS.js.map}

@@ -1 +1 @@
-{"version":3,"file":"node-registry-extra-compat-Ch7ApZHF.js","sources":["../src/material/node/node-registry-extra-compat.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 \"ElbowBlock\":\n            return () => import(\"./blocks/elbow-block.js\");\n        case \"NodeMaterialTeleportInBlock\":\n            return () => import(\"./blocks/teleport-in-block.js\");\n        case \"NodeMaterialTeleportOutBlock\":\n            return () => import(\"./blocks/teleport-out-block.js\");\n        case \"NodeMaterialDebugBlock\":\n            return () => import(\"./blocks/debug-block.js\");\n        case \"MeshAttributeExistsBlock\":\n            return () => import(\"./blocks/mesh-attribute-exists-block.js\");\n        case \"ClipPlanesBlock\":\n            return () => import(\"./blocks/clip-planes-block.js\");\n        case \"ReflectionTextureBaseBlock\":\n            return () => import(\"./blocks/reflection-texture-base-block.js\");\n        case \"ImageProcessingBlock\":\n            return () => import(\"./blocks/image-processing-block.js\");\n        case \"IridescenceBlock\":\n            return () => import(\"./blocks/iridescence-block.js\");\n        case \"LoopBlock\":\n            return () => import(\"./blocks/loop-block.js\");\n        case \"StorageReadBlock\":\n            return () => import(\"./blocks/storage-read-block.js\");\n        case \"StorageWriteBlock\":\n            return () => import(\"./blocks/storage-write-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 compatibility 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,2BAAyB;AAAA,IACjD,KAAK;AACD,aAAO,MAAM,OAAO,iCAA+B;AAAA,IACvD,KAAK;AACD,aAAO,MAAM,OAAO,kCAAgC;AAAA,IACxD,KAAK;AACD,aAAO,MAAM,OAAO,2BAAyB;AAAA,IACjD,KAAK;AACD,aAAO,MAAM,OAAO,2CAAyC;AAAA,IACjE,KAAK;AACD,aAAO,MAAM,OAAO,iCAA+B;AAAA,IACvD,KAAK;AACD,aAAO,MAAM,OAAO,6CAA2C;AAAA,IACnE,KAAK;AACD,aAAO,MAAM,OAAO,sCAAoC;AAAA,IAC5D,KAAK;AACD,aAAO,MAAM,OAAO,iCAA+B;AAAA,IACvD,KAAK;AACD,aAAO,MAAM,OAAO,0BAAwB;AAAA,IAChD,KAAK;AACD,aAAO,MAAM,OAAO,kCAAgC;AAAA,IACxD,KAAK;AACD,aAAO,MAAM,OAAO,mCAAiC;AAAA,IACzD;AACI,aAAO;AAAA,EAAA;AAEnB;AAEA,eAAsB,iBAAiB,KAAoC;AACvE,QAAM,SAAS,YAAY,GAAG;AAC9B,MAAI,CAAC,QAAQ;AACT,UAAM,IAAI,MAAM,0EAA0E,GAAG,GAAG;AAAA,EACpG;AACA,UAAQ,MAAM,UAAU;AAC5B;"}
+{"version":3,"file":"node-registry-extra-compat-dWrv7gpS.js","sources":["../src/material/node/node-registry-extra-compat.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 \"ElbowBlock\":\n            return () => import(\"./blocks/elbow-block.js\");\n        case \"NodeMaterialTeleportInBlock\":\n            return () => import(\"./blocks/teleport-in-block.js\");\n        case \"NodeMaterialTeleportOutBlock\":\n            return () => import(\"./blocks/teleport-out-block.js\");\n        case \"NodeMaterialDebugBlock\":\n            return () => import(\"./blocks/debug-block.js\");\n        case \"MeshAttributeExistsBlock\":\n            return () => import(\"./blocks/mesh-attribute-exists-block.js\");\n        case \"ClipPlanesBlock\":\n            return () => import(\"./blocks/clip-planes-block.js\");\n        case \"ReflectionTextureBaseBlock\":\n            return () => import(\"./blocks/reflection-texture-base-block.js\");\n        case \"ImageProcessingBlock\":\n            return () => import(\"./blocks/image-processing-block.js\");\n        case \"IridescenceBlock\":\n            return () => import(\"./blocks/iridescence-block.js\");\n        case \"LoopBlock\":\n            return () => import(\"./blocks/loop-block.js\");\n        case \"StorageReadBlock\":\n            return () => import(\"./blocks/storage-read-block.js\");\n        case \"StorageWriteBlock\":\n            return () => import(\"./blocks/storage-write-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 compatibility 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,2BAAyB;AAAA,IACjD,KAAK;AACD,aAAO,MAAM,OAAO,iCAA+B;AAAA,IACvD,KAAK;AACD,aAAO,MAAM,OAAO,kCAAgC;AAAA,IACxD,KAAK;AACD,aAAO,MAAM,OAAO,2BAAyB;AAAA,IACjD,KAAK;AACD,aAAO,MAAM,OAAO,2CAAyC;AAAA,IACjE,KAAK;AACD,aAAO,MAAM,OAAO,iCAA+B;AAAA,IACvD,KAAK;AACD,aAAO,MAAM,OAAO,6CAA2C;AAAA,IACnE,KAAK;AACD,aAAO,MAAM,OAAO,sCAAoC;AAAA,IAC5D,KAAK;AACD,aAAO,MAAM,OAAO,iCAA+B;AAAA,IACvD,KAAK;AACD,aAAO,MAAM,OAAO,0BAAwB;AAAA,IAChD,KAAK;AACD,aAAO,MAAM,OAAO,kCAAgC;AAAA,IACxD,KAAK;AACD,aAAO,MAAM,OAAO,mCAAiC;AAAA,IACzD;AACI,aAAO;AAAA,EAAA;AAEnB;AAEA,eAAsB,iBAAiB,KAAoC;AACvE,QAAM,SAAS,YAAY,GAAG;AAC9B,MAAI,CAAC,QAAQ;AACT,UAAM,IAAI,MAAM,0EAA0E,GAAG,GAAG;AAAA,EACpG;AACA,UAAQ,MAAM,UAAU;AAC5B;"}

package/{node-registry-extra-math-6ezzTkPj.js → node-registry-extra-math-Bn854sX9.js}

@@ -27,7 +27,7 @@ function blockLoader(key) {
     case "ConditionalBlock":
       return () => import("./conditional-block-Cd2pbejI.js");
     case "CurveBlock":
-      return () => import("./curve-block-Dh_xdUj-.js");
+      return () => import("./curve-block-21rT0JjG.js");
     case "WaveBlock":
       return () => import("./wave-block-CY_mk1ec.js");
     case "RandomNumberBlock":
@@ -46,4 +46,4 @@ async function loadExtraEmitter(key) {
 export {
   loadExtraEmitter
 };
-//# sourceMappingURL=node-registry-extra-math-6ezzTkPj.js.map
+//# sourceMappingURL=node-registry-extra-math-Bn854sX9.js.map

package/{node-registry-extra-math-6ezzTkPj.js.map → node-registry-extra-math-Bn854sX9.js.map}

@@ -1 +1 @@
-{"version":3,"file":"node-registry-extra-math-6ezzTkPj.js","sources":["../src/material/node/node-registry-extra-math.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 \"DivideBlock\":\n            return () => import(\"./blocks/divide-block.js\");\n        case \"ModBlock\":\n            return () => import(\"./blocks/mod-block.js\");\n        case \"ReciprocalBlock\":\n            return () => import(\"./blocks/reciprocal-block.js\");\n        case \"LengthBlock\":\n            return () => import(\"./blocks/length-block.js\");\n        case \"DistanceBlock\":\n            return () => import(\"./blocks/distance-block.js\");\n        case \"CrossBlock\":\n            return () => import(\"./blocks/cross-block.js\");\n        case \"ReflectBlock\":\n            return () => import(\"./blocks/reflect-block.js\");\n        case \"RefractBlock\":\n            return () => import(\"./blocks/refract-block.js\");\n        case \"ArcTan2Block\":\n            return () => import(\"./blocks/arc-tan2-block.js\");\n        case \"FresnelBlock\":\n            return () => import(\"./blocks/fresnel-block.js\");\n        case \"OppositeBlock\":\n            return () => import(\"./blocks/opposite-block.js\");\n        case \"NLerpBlock\":\n            return () => import(\"./blocks/nlerp-block.js\");\n        case \"ConditionalBlock\":\n            return () => import(\"./blocks/conditional-block.js\");\n        case \"CurveBlock\":\n            return () => import(\"./blocks/curve-block.js\");\n        case \"WaveBlock\":\n            return () => import(\"./blocks/wave-block.js\");\n        case \"RandomNumberBlock\":\n            return () => import(\"./blocks/random-number-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 math 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,yBAAuB;AAAA,IAC/C,KAAK;AACD,aAAO,MAAM,OAAO,gCAA8B;AAAA,IACtD,KAAK;AACD,aAAO,MAAM,OAAO,4BAA0B;AAAA,IAClD,KAAK;AACD,aAAO,MAAM,OAAO,8BAA4B;AAAA,IACpD,KAAK;AACD,aAAO,MAAM,OAAO,2BAAyB;AAAA,IACjD,KAAK;AACD,aAAO,MAAM,OAAO,6BAA2B;AAAA,IACnD,KAAK;AACD,aAAO,MAAM,OAAO,6BAA2B;AAAA,IACnD,KAAK;AACD,aAAO,MAAM,OAAO,8BAA4B;AAAA,IACpD,KAAK;AACD,aAAO,MAAM,OAAO,6BAA2B;AAAA,IACnD,KAAK;AACD,aAAO,MAAM,OAAO,8BAA4B;AAAA,IACpD,KAAK;AACD,aAAO,MAAM,OAAO,2BAAyB;AAAA,IACjD,KAAK;AACD,aAAO,MAAM,OAAO,iCAA+B;AAAA,IACvD,KAAK;AACD,aAAO,MAAM,OAAO,2BAAyB;AAAA,IACjD,KAAK;AACD,aAAO,MAAM,OAAO,0BAAwB;AAAA,IAChD,KAAK;AACD,aAAO,MAAM,OAAO,mCAAiC;AAAA,IACzD;AACI,aAAO;AAAA,EAAA;AAEnB;AAEA,eAAsB,iBAAiB,KAAoC;AACvE,QAAM,SAAS,YAAY,GAAG;AAC9B,MAAI,CAAC,QAAQ;AACT,UAAM,IAAI,MAAM,iEAAiE,GAAG,GAAG;AAAA,EAC3F;AACA,UAAQ,MAAM,UAAU;AAC5B;"}
+{"version":3,"file":"node-registry-extra-math-Bn854sX9.js","sources":["../src/material/node/node-registry-extra-math.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 \"DivideBlock\":\n            return () => import(\"./blocks/divide-block.js\");\n        case \"ModBlock\":\n            return () => import(\"./blocks/mod-block.js\");\n        case \"ReciprocalBlock\":\n            return () => import(\"./blocks/reciprocal-block.js\");\n        case \"LengthBlock\":\n            return () => import(\"./blocks/length-block.js\");\n        case \"DistanceBlock\":\n            return () => import(\"./blocks/distance-block.js\");\n        case \"CrossBlock\":\n            return () => import(\"./blocks/cross-block.js\");\n        case \"ReflectBlock\":\n            return () => import(\"./blocks/reflect-block.js\");\n        case \"RefractBlock\":\n            return () => import(\"./blocks/refract-block.js\");\n        case \"ArcTan2Block\":\n            return () => import(\"./blocks/arc-tan2-block.js\");\n        case \"FresnelBlock\":\n            return () => import(\"./blocks/fresnel-block.js\");\n        case \"OppositeBlock\":\n            return () => import(\"./blocks/opposite-block.js\");\n        case \"NLerpBlock\":\n            return () => import(\"./blocks/nlerp-block.js\");\n        case \"ConditionalBlock\":\n            return () => import(\"./blocks/conditional-block.js\");\n        case \"CurveBlock\":\n            return () => import(\"./blocks/curve-block.js\");\n        case \"WaveBlock\":\n            return () => import(\"./blocks/wave-block.js\");\n        case \"RandomNumberBlock\":\n            return () => import(\"./blocks/random-number-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 math 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,yBAAuB;AAAA,IAC/C,KAAK;AACD,aAAO,MAAM,OAAO,gCAA8B;AAAA,IACtD,KAAK;AACD,aAAO,MAAM,OAAO,4BAA0B;AAAA,IAClD,KAAK;AACD,aAAO,MAAM,OAAO,8BAA4B;AAAA,IACpD,KAAK;AACD,aAAO,MAAM,OAAO,2BAAyB;AAAA,IACjD,KAAK;AACD,aAAO,MAAM,OAAO,6BAA2B;AAAA,IACnD,KAAK;AACD,aAAO,MAAM,OAAO,6BAA2B;AAAA,IACnD,KAAK;AACD,aAAO,MAAM,OAAO,8BAA4B;AAAA,IACpD,KAAK;AACD,aAAO,MAAM,OAAO,6BAA2B;AAAA,IACnD,KAAK;AACD,aAAO,MAAM,OAAO,8BAA4B;AAAA,IACpD,KAAK;AACD,aAAO,MAAM,OAAO,2BAAyB;AAAA,IACjD,KAAK;AACD,aAAO,MAAM,OAAO,iCAA+B;AAAA,IACvD,KAAK;AACD,aAAO,MAAM,OAAO,2BAAyB;AAAA,IACjD,KAAK;AACD,aAAO,MAAM,OAAO,0BAAwB;AAAA,IAChD,KAAK;AACD,aAAO,MAAM,OAAO,mCAAiC;AAAA,IACzD;AACI,aAAO;AAAA,EAAA;AAEnB;AAEA,eAAsB,iBAAiB,KAAoC;AACvE,QAAM,SAAS,YAAY,GAAG;AAC9B,MAAI,CAAC,QAAQ;AACT,UAAM,IAAI,MAAM,iEAAiE,GAAG,GAAG;AAAA,EAC3F;AACA,UAAQ,MAAM,UAAU;AAC5B;"}

package/{node-renderable-CS0CmsSp.js → node-renderable-B5G8WcdH.js}

@@ -1,4 +1,4 @@
-import { c as compileNodePipeline, w as writeNodeUBO, p as packMat4IntoF32, a as writeMeshLightSelection, N as NODE_ESM_SHADOW_OUTPUT, b as NODE_NO_COLOR_OUTPUT, M as MAX_LIGHTS } from "./index-B7Qhw0xL.js";
+import { c as compileNodePipeline, B as BU, w as writeNodeUBO, p as packMat4IntoF32, a as F32, b as writeMeshLightSelection, N as NODE_ESM_SHADOW_OUTPUT, d as NODE_NO_COLOR_OUTPUT, M as MAX_LIGHTS, T as TU, U as U32, e as U8 } from "./index-CLElg2Bo.js";
 const emptyMorphByEngine = /* @__PURE__ */ new WeakMap();
 function getEmptyMorph(engine) {
   const cached = emptyMorphByEngine.get(engine);
@@ -9,23 +9,23 @@ function getEmptyMorph(engine) {
     label: "node-morph-empty",
     size: [1, 1],
     format: "rgba32float",
-    usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST
+    usage: TU.TEXTURE_BINDING | TU.COPY_DST
   });
-  engine._device.queue.writeTexture({ texture }, new Float32Array([0, 0, 0, 0]).buffer, { bytesPerRow: 16 }, { width: 1, height: 1 });
+  engine._device.queue.writeTexture({ texture }, new F32([0, 0, 0, 0]).buffer, { bytesPerRow: 16 }, { width: 1, height: 1 });
   const ubo = new ArrayBuffer(32);
-  const u32 = new Uint32Array(ubo, 16, 4);
+  const u32 = new U32(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 weightsBuffer = engine._device.createBuffer({ label: "node-morph-empty-ubo", size: 32, usage: BU.UNIFORM | BU.COPY_DST });
+  engine._device.queue.writeBuffer(weightsBuffer, 0, new U8(ubo));
   const entry = { texture, weightsBuffer };
   emptyMorphByEngine.set(engine, entry);
   return entry;
 }
 function buildNodeMeshRenderables(scene, meshes, materialOverride) {
   var _a, _b, _c, _d, _e, _f, _g, _h;
-  const engine = scene.engine;
+  const engine = scene.surface.engine;
   const device = engine._device;
   const byMaterial = /* @__PURE__ */ new Map();
   for (const m of meshes) {
@@ -64,7 +64,7 @@ function buildNodeMeshRenderables(scene, meshes, materialOverride) {
     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 });
+      nodeUBO = device.createBuffer({ label: "node-ubo", size: compile._nodeUboSize, usage: BU.UNIFORM | BU.COPY_DST });
       writeNodeUBO(engine, nodeUBO, material);
       material._nodeUBO = nodeUBO;
     }
@@ -72,8 +72,8 @@ function buildNodeMeshRenderables(scene, meshes, materialOverride) {
     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);
+      const _meshUBO = device.createBuffer({ label: "node-mesh-ubo", size: meshUboBytes + 15 & -16, usage: BU.UNIFORM | BU.COPY_DST });
+      const _meshScratch = new F32((meshUboBytes + 15 & -16) / 4);
       _packMeshWorld(_meshScratch, _mesh.worldMatrix, 0, 0);
       const recv = _mesh.receiveShadows ? 1 : 0;
       _meshScratch[16] = recv;
@@ -252,7 +252,7 @@ function getZeroAttrBuffer(engine, gpu, name) {
   }
   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 });
+  const buf = engine._device.createBuffer({ label: `node-zero-${name}`, size: vertexCount * stride, usage: BU.VERTEX | BU.COPY_DST });
   cache.set(name, buf);
   return buf;
 }
@@ -281,6 +281,8 @@ function writeAttributeFlags(mesh, scratch) {
   scratch[19] = gpu.hasColor ? 1 : 0;
 }
 export {
-  buildNodeMeshRenderables
+  buildNodeMeshRenderables,
+  getAttrBuffer,
+  writeAttributeFlags
 };
-//# sourceMappingURL=node-renderable-CS0CmsSp.js.map
+//# sourceMappingURL=node-renderable-B5G8WcdH.js.map

package/node-renderable-B5G8WcdH.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"node-renderable-B5G8WcdH.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 { F32, U32, U8 } from \"../../engine/typed-arrays.js\";\nimport { TU, BU } from \"../../engine/gpu-flags.js\";\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\";\nimport { packMat4IntoF32 } from \"../../math/pack-mat4-into-f32.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: TU.TEXTURE_BINDING | TU.COPY_DST,\n    });\n    engine._device.queue.writeTexture({ texture }, new F32([0, 0, 0, 0]).buffer, { bytesPerRow: 16 }, { width: 1, height: 1 });\n    const ubo = new ArrayBuffer(32);\n    const u32 = new U32(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: BU.UNIFORM | BU.COPY_DST });\n    engine._device.queue.writeBuffer(weightsBuffer, 0, new U8(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.surface.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                  // The shared fragment body still references env IBL/BRDF samplers\n                  // (e.g. nmeBrdfLUT) even in the no-color shadow-depth variant, so we\n                  // must emit the env decls + BGL entries here too; otherwise WGSL fails\n                  // to resolve those identifiers. _envEmitter is undefined for non-env\n                  // materials (state.usesEnv === false), leaving them unaffected.\n                  _envEmitter: material._envHelpers?.emitEnv,\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: BU.UNIFORM | BU.COPY_DST });\n            writeNodeUBO(engine, nodeUBO, material);\n            material._nodeUBO = nodeUBO;\n        }\n\n        const _packMeshWorld = engine._makePackMeshWorld?.(scene as SceneContext) ?? packMat4IntoF32;\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: BU.UNIFORM | BU.COPY_DST });\n            const _meshScratch = new F32(((meshUboBytes + 15) & ~15) / 4);\n            _packMeshWorld(_meshScratch, _mesh.worldMatrix, 0, 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                _packMeshWorld(pkt._meshScratch, pkt._mesh.worldMatrix, 0, 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 _baseUpdate = (): 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 _invalidate = (): void => {\n                    pkt._lastWorldVersion = -1;\n                };\n                const update = engine._wrapRenderableForFO?.(_baseUpdate, scene as SceneContext, _invalidate) ?? _baseUpdate;\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 _baseUpdate = (): void => {\n                for (const pkt of packets) {\n                    updatePacketUBO(pkt);\n                }\n                updateNodeUBO();\n            };\n            const _invalidate = (): void => {\n                for (const pkt of packets) {\n                    pkt._lastWorldVersion = -1;\n                }\n            };\n            const update = engine._wrapRenderableForFO?.(_baseUpdate, scene as SceneContext, _invalidate) ?? _baseUpdate;\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: BU.VERTEX | BU.COPY_DST });\n    // Initialize with zeros (buffer starts zeroed when not mappedAtCreation).\n    cache.set(name, buf);\n    return buf;\n}\n\nexport function 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\nexport function 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-CpnrdvtJ.js → node-shadow-CVIUlNf0.js}

@@ -1,4 +1,4 @@
-import { M as MAX_LIGHTS } from "./index-B7Qhw0xL.js";
+import { M as MAX_LIGHTS, S as SS } from "./index-CLElg2Bo.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) {
@@ -64,8 +64,8 @@ function emitShadow(shadowLights, startBinding, varyings) {
         `_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" } }
+        { binding: _texBinding, visibility: SS.FRAGMENT, texture: { sampleType: "depth", viewDimension: "2d" } },
+        { binding: _sampBinding, visibility: SS.FRAGMENT, sampler: { type: "comparison" } }
       );
     } else {
       wgslDecls.push(
@@ -89,8 +89,8 @@ fn computeShadowESM${suf}(posFromLight: vec4<f32>, depthMetric: f32, darkness: f
         `_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" } }
+        { binding: _texBinding, visibility: SS.FRAGMENT, texture: { sampleType: "float", viewDimension: "2d" } },
+        { binding: _sampBinding, visibility: SS.FRAGMENT, sampler: { type: "filtering" } }
       );
     }
     vertLines.push(
@@ -99,7 +99,7 @@ fn computeShadowESM${suf}(posFromLight: vec4<f32>, depthMetric: f32, darkness: f
     );
     _bglEntries.push({
       binding: _uboBinding,
-      visibility: GPUShaderStage.VERTEX | GPUShaderStage.FRAGMENT,
+      visibility: SS.VERTEX | SS.FRAGMENT,
       buffer: { type: "uniform", minBindingSize: 96 }
     });
   }
@@ -119,4 +119,4 @@ fn computeShadowESM${suf}(posFromLight: vec4<f32>, depthMetric: f32, darkness: f
 export {
   emitShadow
 };
-//# sourceMappingURL=node-shadow-CpnrdvtJ.js.map
+//# sourceMappingURL=node-shadow-CVIUlNf0.js.map