@babylonjs/lite 0.1.1 → 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-Dhrw8fDQ.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-Bb23EOMb.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-Dhrw8fDQ.js.map
+//# sourceMappingURL=node-registry-extra-compat-dWrv7gpS.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"node-registry-extra-compat-Dhrw8fDQ.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-CsAHvIZo.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-BlJpXVYv.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-CsAHvIZo.js.map
+//# sourceMappingURL=node-registry-extra-math-Bn854sX9.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"node-registry-extra-math-CsAHvIZo.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-DlLIdBmd.js → node-renderable-B5G8WcdH.js}

@@ -1,4 +1,4 @@
-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";
+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;
-  const engine = scene.engine;
+  var _a, _b, _c, _d, _e, _f, _g, _h;
+  const engine = scene.surface.engine;
   const device = engine._device;
   const byMaterial = /* @__PURE__ */ new Map();
   for (const m of meshes) {
@@ -53,21 +53,28 @@ function buildNodeMeshRenderables(scene, meshes, materialOverride) {
       _noColorOutput: noColorOutput,
       _esmShadowOutput: esmShadowOutput,
       _esmShadowDepthCode: esmShadowOutput ? material._esmShadowDepthCode : void 0,
-      _alphaMode: esmShadowOutput ? 0 : void 0
+      _alphaMode: esmShadowOutput ? 0 : void 0,
+      // The shared fragment body still references env IBL/BRDF samplers
+      // (e.g. nmeBrdfLUT) even in the no-color shadow-depth variant, so we
+      // must emit the env decls + BGL entries here too; otherwise WGSL fails
+      // to resolve those identifiers. _envEmitter is undefined for non-env
+      // materials (state.usesEnv === false), leaving them unaffected.
+      _envEmitter: (_b = material._envHelpers) == null ? void 0 : _b.emitEnv
     }) : 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 });
+      nodeUBO = device.createBuffer({ label: "node-ubo", size: compile._nodeUboSize, usage: BU.UNIFORM | BU.COPY_DST });
       writeNodeUBO(engine, nodeUBO, material);
       material._nodeUBO = nodeUBO;
     }
+    const _packMeshWorld = ((_c = engine._makePackMeshWorld) == null ? void 0 : _c.call(engine, scene)) ?? packMat4IntoF32;
     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 _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;
       if (compile._usesMeshAttributeFlags) {
@@ -133,7 +140,7 @@ function buildNodeMeshRenderables(scene, meshes, materialOverride) {
       const recvChanged = recv !== pkt._lastReceivesShadow;
       const lightsChanged = scene.lights.length !== pkt._lastLightsCount;
       if (worldChanged || recvChanged || lightsChanged) {
-        pkt._meshScratch.set(pkt._mesh.worldMatrix, 0);
+        _packMeshWorld(pkt._meshScratch, pkt._mesh.worldMatrix, 0, 0);
         pkt._meshScratch[16] = recv;
         if (compile._usesMeshAttributeFlags) {
           writeAttributeFlags(pkt._mesh, pkt._meshScratch);
@@ -165,11 +172,11 @@ function buildNodeMeshRenderables(scene, meshes, materialOverride) {
     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 cx = ((_d = pkt._mesh.position) == null ? void 0 : _d.x) ?? wm[12];
+        const cy = ((_e = pkt._mesh.position) == null ? void 0 : _e.y) ?? wm[13];
+        const cz = ((_f = pkt._mesh.position) == null ? void 0 : _f.z) ?? wm[14];
         const sortCenter = [cx, cy, cz];
-        const update = () => {
+        const _baseUpdate = () => {
           updatePacketUBO(pkt);
           updateNodeUBO();
           const m = pkt._mesh.worldMatrix;
@@ -177,6 +184,10 @@ function buildNodeMeshRenderables(scene, meshes, materialOverride) {
           sortCenter[1] = m[13];
           sortCenter[2] = m[14];
         };
+        const _invalidate = () => {
+          pkt._lastWorldVersion = -1;
+        };
+        const update = ((_g = engine._wrapRenderableForFO) == null ? void 0 : _g.call(engine, _baseUpdate, scene, _invalidate)) ?? _baseUpdate;
         const draw = (pass) => {
           drawPacket(pass, pkt);
           return 1;
@@ -193,12 +204,18 @@ function buildNodeMeshRenderables(scene, meshes, materialOverride) {
         renderables.push(rTrans);
       }
     } else {
-      const update = () => {
+      const _baseUpdate = () => {
         for (const pkt of packets) {
           updatePacketUBO(pkt);
         }
         updateNodeUBO();
       };
+      const _invalidate = () => {
+        for (const pkt of packets) {
+          pkt._lastWorldVersion = -1;
+        }
+      };
+      const update = ((_h = engine._wrapRenderableForFO) == null ? void 0 : _h.call(engine, _baseUpdate, scene, _invalidate)) ?? _baseUpdate;
       const draw = (pass) => {
         let draws = 0;
         for (const pkt of packets) {
@@ -235,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;
 }
@@ -264,6 +281,8 @@ function writeAttributeFlags(mesh, scratch) {
   scratch[19] = gpu.hasColor ? 1 : 0;
 }
 export {
-  buildNodeMeshRenderables
+  buildNodeMeshRenderables,
+  getAttrBuffer,
+  writeAttributeFlags
 };
-//# sourceMappingURL=node-renderable-DlLIdBmd.js.map
+//# sourceMappingURL=node-renderable-B5G8WcdH.js.map