@babylonjs/lite 1.1.0 → 1.3.0

package/{node-registry-extra-compat-CDLeBR1P.js.map → node-registry-extra-compat-SwS962Ax.js.map}

@@ -1 +1 @@
-{"version":3,"file":"node-registry-extra-compat-CDLeBR1P.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-SwS962Ax.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-BA8_l4lB.js → node-registry-extra-math-Bsj4UAE5.js}

@@ -27,7 +27,7 @@ function blockLoader(key) {
     case "ConditionalBlock":
       return () => import("./conditional-block-Cd2pbejI.js");
     case "CurveBlock":
-      return () => import("./curve-block-Ditr4R7V.js");
+      return () => import("./curve-block-CeLMJE2N.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-BA8_l4lB.js.map
+//# sourceMappingURL=node-registry-extra-math-Bsj4UAE5.js.map

package/{node-registry-extra-math-BA8_l4lB.js.map → node-registry-extra-math-Bsj4UAE5.js.map}

@@ -1 +1 @@
-{"version":3,"file":"node-registry-extra-math-BA8_l4lB.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-Bsj4UAE5.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-EwLLnaL1.js → node-renderable-BOIc3hM1.js}

@@ -1,4 +1,4 @@
-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-BgY3QEzL.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-C2sM8ERH.js";
 const emptyMorphByEngine = /* @__PURE__ */ new WeakMap();
 function getEmptyMorph(engine) {
   const cached = emptyMorphByEngine.get(engine);
@@ -285,4 +285,4 @@ export {
   getAttrBuffer,
   writeAttributeFlags
 };
-//# sourceMappingURL=node-renderable-EwLLnaL1.js.map
+//# sourceMappingURL=node-renderable-BOIc3hM1.js.map

package/{node-renderable-EwLLnaL1.js.map → node-renderable-BOIc3hM1.js.map}

@@ -1 +1 @@
-{"version":3,"file":"node-renderable-EwLLnaL1.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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"}
+{"version":3,"file":"node-renderable-BOIc3hM1.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-CeTmT6g4.js → node-shadow-DE--Q2V1.js}

@@ -1,4 +1,4 @@
-import { M as MAX_LIGHTS, S as SS } from "./index-BgY3QEzL.js";
+import { M as MAX_LIGHTS, S as SS } from "./index-C2sM8ERH.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) {
@@ -119,4 +119,4 @@ fn computeShadowESM${suf}(posFromLight: vec4<f32>, depthMetric: f32, darkness: f
 export {
   emitShadow
 };
-//# sourceMappingURL=node-shadow-CeTmT6g4.js.map
+//# sourceMappingURL=node-shadow-DE--Q2V1.js.map

package/{node-shadow-CeTmT6g4.js.map → node-shadow-DE--Q2V1.js.map}

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

package/{normal-map-fragment-BHImLyM-.js → normal-map-fragment-Cjm-v9uq.js}

@@ -1,5 +1,4 @@
-import { ae as HAS_BUMP_TEXTURE } from "./index-BgY3QEzL.js";
-import { W as WGSL_PERTURB_NORMAL } from "./wgsl-helpers-D8sl1VVA.js";
+import { ac as HAS_BUMP_TEXTURE, ad as WGSL_PERTURB_NORMAL } from "./index-C2sM8ERH.js";
 const STAGE_FRAGMENT = 2;
 function createNormalMapFragment() {
   return {
@@ -35,4 +34,4 @@ export {
   bumpStdExt,
   createNormalMapFragment
 };
-//# sourceMappingURL=normal-map-fragment-BHImLyM-.js.map
+//# sourceMappingURL=normal-map-fragment-Cjm-v9uq.js.map

package/{normal-map-fragment-BHImLyM-.js.map → normal-map-fragment-Cjm-v9uq.js.map}

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@babylonjs/lite",
-  "version": "1.1.0",
+  "version": "1.3.0",
   "description": "A lightweight, tree-shakable, WebGPU-first rendering library derived from Babylon.js.",
   "license": "Apache-2.0",
   "homepage": "https://doc.babylonjs.com/lite/",
@@ -20,7 +20,7 @@
   },
   "sideEffects": false,
   "babylonLiteRelease": {
-    "azureBuildId": "54961",
-    "sourceVersion": "fbf5a62071dc7fce7c0a00f3a16080f3f5932a91"
+    "azureBuildId": "55036",
+    "sourceVersion": "a9cfda1b0940e1234b6a29773dada678607c7412"
   }
 }

package/{parse-camera-5IGdctAS.js → parse-camera-uQ8oKgeH.js}

@@ -1,4 +1,4 @@
-import { x as createFreeCamera } from "./index-BgY3QEzL.js";
+import { t as createFreeCamera } from "./index-C2sM8ERH.js";
 function parseBabylonCamera(cd) {
   var _a, _b;
   const p = cd.position;
@@ -20,4 +20,4 @@ function parseBabylonCamera(cd) {
 export {
   parseBabylonCamera
 };
-//# sourceMappingURL=parse-camera-5IGdctAS.js.map
+//# sourceMappingURL=parse-camera-uQ8oKgeH.js.map

package/{parse-camera-5IGdctAS.js.map → parse-camera-uQ8oKgeH.js.map}

@@ -1 +1 @@
-{"version":3,"file":"parse-camera-5IGdctAS.js","sources":["../src/loader-babylon/parse-camera.ts"],"sourcesContent":["/** Parse a FreeCamera from .babylon camera data. Dynamically imported by load-babylon.ts. */\nimport { createFreeCamera } from \"../camera/free-camera.js\";\nimport type { FreeCamera } from \"../camera/free-camera.js\";\n\nexport function parseBabylonCamera(cd: { position: number[]; rotation?: number[]; fov?: number; minZ?: number; maxZ?: number }): FreeCamera {\n    const p = cd.position;\n    const pitch = cd.rotation?.[0] ?? 0;\n    const yaw = cd.rotation?.[1] ?? 0;\n    const cp = Math.cos(pitch);\n    const cam = createFreeCamera({ x: p[0]!, y: p[1]!, z: p[2]! }, { x: p[0]! + cp * Math.sin(yaw), y: p[1]! - Math.sin(pitch), z: p[2]! + cp * Math.cos(yaw) });\n    if (cd.fov != null) {\n        cam.fov = cd.fov;\n    }\n    if (cd.minZ != null) {\n        cam.nearPlane = cd.minZ;\n    }\n    if (cd.maxZ != null) {\n        cam.farPlane = cd.maxZ;\n    }\n    return cam;\n}\n"],"names":[],"mappings":";AAIO,SAAS,mBAAmB,IAAyG;;AACxI,QAAM,IAAI,GAAG;AACb,QAAM,UAAQ,QAAG,aAAH,mBAAc,OAAM;AAClC,QAAM,QAAM,QAAG,aAAH,mBAAc,OAAM;AAChC,QAAM,KAAK,KAAK,IAAI,KAAK;AACzB,QAAM,MAAM,iBAAiB,EAAE,GAAG,EAAE,CAAC,GAAI,GAAG,EAAE,CAAC,GAAI,GAAG,EAAE,CAAC,EAAA,GAAM,EAAE,GAAG,EAAE,CAAC,IAAK,KAAK,KAAK,IAAI,GAAG,GAAG,GAAG,EAAE,CAAC,IAAK,KAAK,IAAI,KAAK,GAAG,GAAG,EAAE,CAAC,IAAK,KAAK,KAAK,IAAI,GAAG,GAAG;AAC3J,MAAI,GAAG,OAAO,MAAM;AAChB,QAAI,MAAM,GAAG;AAAA,EACjB;AACA,MAAI,GAAG,QAAQ,MAAM;AACjB,QAAI,YAAY,GAAG;AAAA,EACvB;AACA,MAAI,GAAG,QAAQ,MAAM;AACjB,QAAI,WAAW,GAAG;AAAA,EACtB;AACA,SAAO;AACX;"}
+{"version":3,"file":"parse-camera-uQ8oKgeH.js","sources":["../src/loader-babylon/parse-camera.ts"],"sourcesContent":["/** Parse a FreeCamera from .babylon camera data. Dynamically imported by load-babylon.ts. */\nimport { createFreeCamera } from \"../camera/free-camera.js\";\nimport type { FreeCamera } from \"../camera/free-camera.js\";\n\nexport function parseBabylonCamera(cd: { position: number[]; rotation?: number[]; fov?: number; minZ?: number; maxZ?: number }): FreeCamera {\n    const p = cd.position;\n    const pitch = cd.rotation?.[0] ?? 0;\n    const yaw = cd.rotation?.[1] ?? 0;\n    const cp = Math.cos(pitch);\n    const cam = createFreeCamera({ x: p[0]!, y: p[1]!, z: p[2]! }, { x: p[0]! + cp * Math.sin(yaw), y: p[1]! - Math.sin(pitch), z: p[2]! + cp * Math.cos(yaw) });\n    if (cd.fov != null) {\n        cam.fov = cd.fov;\n    }\n    if (cd.minZ != null) {\n        cam.nearPlane = cd.minZ;\n    }\n    if (cd.maxZ != null) {\n        cam.farPlane = cd.maxZ;\n    }\n    return cam;\n}\n"],"names":[],"mappings":";AAIO,SAAS,mBAAmB,IAAyG;;AACxI,QAAM,IAAI,GAAG;AACb,QAAM,UAAQ,QAAG,aAAH,mBAAc,OAAM;AAClC,QAAM,QAAM,QAAG,aAAH,mBAAc,OAAM;AAChC,QAAM,KAAK,KAAK,IAAI,KAAK;AACzB,QAAM,MAAM,iBAAiB,EAAE,GAAG,EAAE,CAAC,GAAI,GAAG,EAAE,CAAC,GAAI,GAAG,EAAE,CAAC,EAAA,GAAM,EAAE,GAAG,EAAE,CAAC,IAAK,KAAK,KAAK,IAAI,GAAG,GAAG,GAAG,EAAE,CAAC,IAAK,KAAK,IAAI,KAAK,GAAG,GAAG,EAAE,CAAC,IAAK,KAAK,KAAK,IAAI,GAAG,GAAG;AAC3J,MAAI,GAAG,OAAO,MAAM;AAChB,QAAI,MAAM,GAAG;AAAA,EACjB;AACA,MAAI,GAAG,QAAQ,MAAM;AACjB,QAAI,YAAY,GAAG;AAAA,EACvB;AACA,MAAI,GAAG,QAAQ,MAAM;AACjB,QAAI,WAAW,GAAG;AAAA,EACtB;AACA,SAAO;AACX;"}

package/{pbr-fog-wgsl-BqdCid6r.js → pbr-fog-wgsl-B5LrMToX.js}

@@ -1,8 +1,8 @@
-import { a as WGSL_FOG } from "./wgsl-helpers-D8sl1VVA.js";
+import { bl as WGSL_FOG } from "./index-C2sM8ERH.js";
 const PBR_FOG_HELPER = WGSL_FOG;
 const PBR_FOG_BLOCK = `if(scene.vFogInfos.x>0.0){var fogFactor=calcFogFactor((scene.view*vec4<f32>(input.worldPos,1.0)).xyz);fogFactor=pow(fogFactor,2.2);color=mix(pow(scene.vFogColor.rgb,vec3<f32>(2.2)),color,fogFactor);}`;
 export {
   PBR_FOG_BLOCK,
   PBR_FOG_HELPER
 };
-//# sourceMappingURL=pbr-fog-wgsl-BqdCid6r.js.map
+//# sourceMappingURL=pbr-fog-wgsl-B5LrMToX.js.map

package/{pbr-fog-wgsl-BqdCid6r.js.map → pbr-fog-wgsl-B5LrMToX.js.map}

@@ -1 +1 @@
-{"version":3,"file":"pbr-fog-wgsl-BqdCid6r.js","sources":["../src/material/pbr/pbr-fog-wgsl.ts"],"sourcesContent":["/**\n * PBR fog receiver WGSL — the `calcFogFactor` helper plus the fog blend block.\n *\n * Dynamically imported by `pbr-renderable` ONLY when `scene.fog` is set, then threaded into the\n * PBR template as plain strings (the same pattern the ACES tonemap uses). This keeps every byte of\n * fog WGSL out of the bundles of PBR scenes that don't use fog — a static `import` of the helper\n * into `pbr-template` would defeat tree-shaking and inflate every PBR scene (see GUIDANCE §4c′).\n *\n * Parity notes (matches Babylon.js `pbr.fragment` exactly):\n *  - Fog is mixed into the LINEAR HDR colour BEFORE the tonemap / image-processing chain\n *    (BJS runs `fogFragment` before `pbrBlockImageProcessing`).\n *  - The fog FACTOR is linearised: `fog = toLinearSpace(fog)` = `pow(fog, 2.2)` (default approx sRGB).\n *  - The fog COLOUR is linearised too: BJS binds `vFogColor` with `linearSpace = true` for PBR\n *    (`BindFogParameters`), whereas the Standard material binds it raw. Lite stores one raw\n *    `vFogColor` in the scene UBO (correct for Standard, which has no trailing gamma), so the PBR\n *    path linearises it here with `pow(.., 2.2)`; after Lite's trailing gamma encode the fully\n *    fogged result returns to the authored fog colour (matching the background), exactly like BJS.\n *  - The runtime `vFogInfos.x > 0.0` guard lets `fogMode` toggle none/linear/exp/exp2 at runtime.\n */\n\nimport { WGSL_FOG } from \"../../shader/wgsl-helpers.js\";\n\n/** `calcFogFactor` + `E_FOG` helper WGSL (reads `scene.vFogInfos`). */\nexport const PBR_FOG_HELPER = WGSL_FOG;\n\n/** Fog blend, emitted just before the PBR tonemap block (operates on the linear HDR `color`). */\nexport const PBR_FOG_BLOCK = `if(scene.vFogInfos.x>0.0){var fogFactor=calcFogFactor((scene.view*vec4<f32>(input.worldPos,1.0)).xyz);fogFactor=pow(fogFactor,2.2);color=mix(pow(scene.vFogColor.rgb,vec3<f32>(2.2)),color,fogFactor);}`;\n"],"names":[],"mappings":";AAuBO,MAAM,iBAAiB;AAGvB,MAAM,gBAAgB;"}
+{"version":3,"file":"pbr-fog-wgsl-B5LrMToX.js","sources":["../src/material/pbr/pbr-fog-wgsl.ts"],"sourcesContent":["/**\n * PBR fog receiver WGSL — the `calcFogFactor` helper plus the fog blend block.\n *\n * Dynamically imported by `pbr-renderable` ONLY when `scene.fog` is set, then threaded into the\n * PBR template as plain strings (the same pattern the ACES tonemap uses). This keeps every byte of\n * fog WGSL out of the bundles of PBR scenes that don't use fog — a static `import` of the helper\n * into `pbr-template` would defeat tree-shaking and inflate every PBR scene (see GUIDANCE §4c′).\n *\n * Parity notes (matches Babylon.js `pbr.fragment` exactly):\n *  - Fog is mixed into the LINEAR HDR colour BEFORE the tonemap / image-processing chain\n *    (BJS runs `fogFragment` before `pbrBlockImageProcessing`).\n *  - The fog FACTOR is linearised: `fog = toLinearSpace(fog)` = `pow(fog, 2.2)` (default approx sRGB).\n *  - The fog COLOUR is linearised too: BJS binds `vFogColor` with `linearSpace = true` for PBR\n *    (`BindFogParameters`), whereas the Standard material binds it raw. Lite stores one raw\n *    `vFogColor` in the scene UBO (correct for Standard, which has no trailing gamma), so the PBR\n *    path linearises it here with `pow(.., 2.2)`; after Lite's trailing gamma encode the fully\n *    fogged result returns to the authored fog colour (matching the background), exactly like BJS.\n *  - The runtime `vFogInfos.x > 0.0` guard lets `fogMode` toggle none/linear/exp/exp2 at runtime.\n */\n\nimport { WGSL_FOG } from \"../../shader/wgsl-helpers.js\";\n\n/** `calcFogFactor` + `E_FOG` helper WGSL (reads `scene.vFogInfos`). */\nexport const PBR_FOG_HELPER = WGSL_FOG;\n\n/** Fog blend, emitted just before the PBR tonemap block (operates on the linear HDR `color`). */\nexport const PBR_FOG_BLOCK = `if(scene.vFogInfos.x>0.0){var fogFactor=calcFogFactor((scene.view*vec4<f32>(input.worldPos,1.0)).xyz);fogFactor=pow(fogFactor,2.2);color=mix(pow(scene.vFogColor.rgb,vec3<f32>(2.2)),color,fogFactor);}`;\n"],"names":[],"mappings":";AAuBO,MAAM,iBAAiB;AAGvB,MAAM,gBAAgB;"}

package/{pbr-geometry-view-Dthf9Aut.js → pbr-geometry-view-BI52zgUI.js}

@@ -1,5 +1,5 @@
-import { c5 as _registerPbrExt, c6 as PBR2_GEOMETRY_OUTPUT, G as GeometryTextureType, W as PBR_HAS_ALPHA_BLEND, c7 as PBR_HAS_ENV, c8 as _computePbrMaterialFeatures, b as writeMeshLightSelection, aw as _computeMeshFeatures, a as F32, p as packMat4IntoF32, ay as createUniformBuffer, c9 as collectPbrBoundTextures, aA as acquireTexture, aB as releaseTexture, A as getSceneBindGroupLayout, y as targetSignatureKey, bN as REVERSE_DEPTH_COMPARE, ca as PBR_HAS_NORMAL_MAP, cb as MSH_HAS_TANGENTS, aP as PBR2_HAS_UV2, cc as MSH_HAS_UV2, cd as MSH_HAS_VERTEX_COLOR, aG as MSH_HAS_THIN_INSTANCES, aE as MSH_HAS_INSTANCE_COLOR, ce as PBR_HAS_DOUBLE_SIDED, P as createMaterialView } from "./index-BgY3QEzL.js";
-import { c as createPbrMeshBindGroup, _ as _writeMaterialData } from "./pbr-renderable-CuKWalEM.js";
+import { cc as _registerPbrExt, cd as PBR2_GEOMETRY_OUTPUT, G as GeometryTextureType, R as PBR_HAS_ALPHA_BLEND, ce as PBR_HAS_ENV, cf as _computePbrMaterialFeatures, b as writeMeshLightSelection, aw as _computeMeshFeatures, a as F32, p as packMat4IntoF32, az as createUniformBuffer, cg as createPbrMeshBindGroup, ch as collectPbrBoundTextures, aD as acquireTexture, aE as releaseTexture, y as getSceneBindGroupLayout, v as targetSignatureKey, ci as REVERSE_DEPTH_COMPARE, cj as PBR_HAS_NORMAL_MAP, ck as MSH_HAS_TANGENTS, a_ as PBR2_HAS_UV2, cl as MSH_HAS_UV2, cm as MSH_HAS_VERTEX_COLOR, aK as MSH_HAS_THIN_INSTANCES, aI as MSH_HAS_INSTANCE_COLOR, cn as PBR_HAS_DOUBLE_SIDED, L as createMaterialView } from "./index-C2sM8ERH.js";
+import { _writeMaterialData } from "./pbr-renderable-B0elfRlX.js";
 const STAGE_FRAGMENT = 2;
 const STAGE_VERTEX = 1;
 function needsGpUbo(attachments) {
@@ -267,7 +267,6 @@ function buildPbrGeometryRenderable(scene, mesh, view) {
   };
   const update = ((_b = engine._wrapRenderableForFO) == null ? void 0 : _b.call(engine, _baseUpdate, scene, _invalidate)) ?? _baseUpdate;
   const draw = (pass) => {
-    var _a2, _b2, _c, _d, _e, _f;
     if (mesh.visible === false) {
       return 0;
     }
@@ -277,18 +276,17 @@ function buildPbrGeometryRenderable(scene, mesh, view) {
       pass.setBindGroup(2, shadowBindGroup);
     }
     let slot = 0;
-    const vb = gpu._vbLayout;
-    pass.setVertexBuffer(slot++, gpu.positionBuffer, (_a2 = vb == null ? void 0 : vb._p) == null ? void 0 : _a2._offset);
-    pass.setVertexBuffer(slot++, gpu.normalBuffer, (_b2 = vb == null ? void 0 : vb._n) == null ? void 0 : _b2._offset);
+    pass.setVertexBuffer(slot++, gpu.positionBuffer);
+    pass.setVertexBuffer(slot++, gpu.normalBuffer);
     if (hasNormalMap && gpu.tangentBuffer) {
-      pass.setVertexBuffer(slot++, gpu.tangentBuffer, (_c = vb == null ? void 0 : vb._t) == null ? void 0 : _c._offset);
+      pass.setVertexBuffer(slot++, gpu.tangentBuffer);
     }
-    pass.setVertexBuffer(slot++, gpu.uvBuffer, (_d = vb == null ? void 0 : vb._u) == null ? void 0 : _d._offset);
+    pass.setVertexBuffer(slot++, gpu.uvBuffer);
     if (hasUV2 && gpu.uv2Buffer) {
-      pass.setVertexBuffer(slot++, gpu.uv2Buffer, (_e = vb == null ? void 0 : vb._u2) == null ? void 0 : _e._offset);
+      pass.setVertexBuffer(slot++, gpu.uv2Buffer);
     }
     if (hasVertexColor && gpu.colorBuffer) {
-      pass.setVertexBuffer(slot++, gpu.colorBuffer, (_f = vb == null ? void 0 : vb._c) == null ? void 0 : _f._offset);
+      pass.setVertexBuffer(slot++, gpu.colorBuffer);
     }
     const skin = mesh.skeleton ?? mesh.vat;
     if (skin) {
@@ -488,4 +486,4 @@ export {
   _setActivePbrGeometryAttachments,
   createPbrGeometryMaterialView
 };
-//# sourceMappingURL=pbr-geometry-view-Dthf9Aut.js.map
+//# sourceMappingURL=pbr-geometry-view-BI52zgUI.js.map

package/pbr-geometry-view-BI52zgUI.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pbr-geometry-view-BI52zgUI.js","sources":["../src/material/pbr/pbr-geometry-output-shader.ts","../src/material/pbr/pbr-geometry-renderable.ts","../src/material/pbr/pbr-geometry-view.ts"],"sourcesContent":["/** PBR geometry-output shader composer.\n *\n *  Builds the WGSL for a {@link createPbrGeometryMaterialView}-wrapped PBR\n *  material that targets the geometry-renderer MRT pass.\n *\n *  Design — *zero bundle impact* on PBR scenes that never load the\n *  geometry-renderer task:\n *\n *  1. Reuse the per-scene {@link composePbr} captured on the scene context.\n *     The composer already wires every PBR feature (IBL, shadows, lights,\n *     clearcoat, sheen, iridescence, anisotropy, subsurface, alpha-test,\n *     emissive, tonemap, …); none of it needs re-implementing for the\n *     real-colour attachment.\n *  2. Register a PBR extension that, only when `PBR2_GEOMETRY_OUTPUT` is on,\n *     contributes a small `geometry-params` ShaderFragment carrying the\n *     `gp` UBO + per-attachment varyings (vCurrentClip / vPreviousClip /\n *     vLocalPos). Off otherwise — no impact on regular PBR composes.\n *  3. Post-process the composed fragment WGSL: change the entry signature\n *     to return a `FragmentOutput` MRT struct, inject the struct\n *     declaration, and replace the alpha-block `return …` with code that\n *     writes each requested geometry attachment from the in-scope PBR\n *     intermediates (`N`, `surfaceAlbedo`, `colorF0`, `roughness`,\n *     `microSurface`, `finalIrradiance`, `input.worldPos`, …).\n *\n *  The lighting / tonemap / gamma pipeline still runs in full, producing\n *  the lit `color` written to the optional real-colour attachment. */\n\nimport type { ComposedShader, ShaderFragment, Varying } from \"../../shader/fragment-types.js\";\nimport { GeometryTextureType } from \"../../frame-graph/geometry-types.js\";\nimport { PBR_HAS_ALPHA_BLEND, PBR_HAS_ENV, PBR2_GEOMETRY_OUTPUT, _registerPbrExt, type _PbrBindCtx, type _PbrFragCtx, type PbrExt } from \"./pbr-flags.js\";\nimport type { createPbrComposer, PbrLightMode } from \"./pbr-compose.js\";\nimport type { MeshVbLayout } from \"../../mesh/mesh.js\";\n\nconst STAGE_FRAGMENT = 0x2;\nconst STAGE_VERTEX = 0x1;\n\n// ─── PBR extension contributing the geometry-params fragment ──────────\n\nfunction needsGpUbo(attachments: readonly GeometryTextureType[]): boolean {\n    for (const t of attachments) {\n        if (t === GeometryTextureType.NORMALIZED_VIEW_DEPTH || t === GeometryTextureType.LINEAR_VELOCITY) {\n            return true;\n        }\n    }\n    return false;\n}\n\nfunction needsVelocity(attachments: readonly GeometryTextureType[]): boolean {\n    return attachments.includes(GeometryTextureType.LINEAR_VELOCITY);\n}\n\nfunction needsLocalPos(attachments: readonly GeometryTextureType[]): boolean {\n    return attachments.includes(GeometryTextureType.LOCAL_POSITION);\n}\n\n/** ShaderFragment contributing the `gp` UBO + (optionally) velocity / local-pos varyings.\n *  PBR-specific: world-position varying is `out.worldPos`. */\nfunction createPbrGeometryParamsFragment(needsParamsUbo: boolean, needsVelocityVaryings: boolean, needsLocalPosVarying: boolean): ShaderFragment {\n    const bindings = needsParamsUbo ? [{ _name: \"gp\", _type: { _kind: \"uniform-buffer\" as const }, _visibility: STAGE_FRAGMENT | STAGE_VERTEX }] : [];\n    const helpers = needsParamsUbo ? `struct gpUniforms { previousViewProjection: mat4x4<f32>, cameraNearFar: vec4<f32>, };` : \"\";\n    const varyings: Varying[] = [];\n    if (needsVelocityVaryings) {\n        varyings.push({ _name: \"vCurrentClip\", _type: \"vec4<f32>\" }, { _name: \"vPreviousClip\", _type: \"vec4<f32>\" });\n    }\n    if (needsLocalPosVarying) {\n        varyings.push({ _name: \"vLocalPos\", _type: \"vec3<f32>\" });\n    }\n    const vbParts: string[] = [];\n    if (needsVelocityVaryings) {\n        vbParts.push(`out.vCurrentClip = scene.viewProjection * vec4<f32>(out.worldPos, 1.0);`);\n        vbParts.push(`out.vPreviousClip = gp.previousViewProjection * vec4<f32>(out.worldPos, 1.0);`);\n    }\n    if (needsLocalPosVarying) {\n        vbParts.push(`out.vLocalPos = position;`);\n    }\n    const slots: ShaderFragment[\"_vertexSlots\"] = vbParts.length > 0 ? { VB: vbParts.join(\"\\n\") } : {};\n    return {\n        _id: \"pbr-geometry-params\",\n        _bindings: bindings,\n        _helperFunctions: helpers,\n        _vertexHelperFunctions: helpers,\n        _varyings: varyings,\n        _vertexSlots: slots,\n    };\n}\n\n/** PBR extension that wires the geometry-params fragment + gp UBO bind entry.\n *  Off-path for any scene that doesn't request `PBR2_GEOMETRY_OUTPUT`. */\nlet _pbrGeomExtRegistered = false;\n\n/** @internal Registers (idempotent) the PBR extension that wires up the\n *  geometry-output `gp` UBO and varyings. Called by the geometry view at\n *  first use so non-geometry PBR scenes pay zero bytes. */\nexport function _ensurePbrGeometryExt(getAttachments: () => readonly GeometryTextureType[] | undefined): void {\n    if (_pbrGeomExtRegistered) {\n        return;\n    }\n    _pbrGeomExtRegistered = true;\n    const ext: PbrExt = {\n        id: \"pbr-geometry-params\",\n        // Fragment-phase so bind entry is appended after all other PBR exts.\n        phase: \"fragment\",\n        frag(ctx: _PbrFragCtx): ShaderFragment | null {\n            if ((ctx._features2 & PBR2_GEOMETRY_OUTPUT) === 0) {\n                return null;\n            }\n            const att = getAttachments() ?? [];\n            const wantsGp = needsGpUbo(att);\n            const wantsVelocity = needsVelocity(att);\n            const wantsLocalPos = needsLocalPos(att);\n            if (!wantsGp && !wantsVelocity && !wantsLocalPos) {\n                return null;\n            }\n            return createPbrGeometryParamsFragment(wantsGp, wantsVelocity, wantsLocalPos);\n        },\n        bind(ctx: _PbrBindCtx, entries: GPUBindGroupEntry[], b: number): number {\n            if ((ctx._features2 & PBR2_GEOMETRY_OUTPUT) === 0) {\n                return b;\n            }\n            const view = ctx._material as { _gpUBO?: GPUBuffer | null };\n            if (view._gpUBO) {\n                entries.push({ binding: b++, resource: { buffer: view._gpUBO } });\n            }\n            return b;\n        },\n    };\n    _registerPbrExt(ext);\n}\n\n// ─── Per-attachment WGSL expressions ──────────────────────────────────\n\n/** Per-attachment WGSL output expression. Symbols are resolved against the\n *  in-scope PBR fragment vars at the BC slot location (after tonemap +\n *  gamma + contrast; same scope as the alpha-block).\n *  @internal */\nfunction attachmentExpr(type: GeometryTextureType, wg: string, hasIbl: boolean): string {\n    switch (type) {\n        case GeometryTextureType.IRRADIANCE:\n            // BJS PREPASS_IRRADIANCE (pbrBlockPrePass.fx): `finalDiffuse + finalIrradiance`\n            // — direct-light diffuse plus the IBL diffuse contribution (already multiplied\n            // by surfaceAlbedo / occlusion), NOT the raw SH irradiance. Lite's equivalents\n            // are `directDiffuse` (direct) and `finalIrradiance` (= environmentIrradiance *\n            // surfaceAlbedo * occlusion, ibl-fragment.ts). Both are pre-tonemap, matching BJS.\n            return hasIbl ? `vec4<f32>(directDiffuse + finalIrradiance, ${wg})` : `vec4<f32>(directDiffuse, ${wg})`;\n        case GeometryTextureType.WORLD_POSITION:\n            return `vec4<f32>(input.worldPos, ${wg})`;\n        case GeometryTextureType.LOCAL_POSITION:\n            return `vec4<f32>(input.vLocalPos, ${wg})`;\n        case GeometryTextureType.REFLECTIVITY:\n            // BJS PREPASS_REFLECTIVITY (pbrBlockPrePass.fx): `vec4(specularEnvironmentR0, microSurface)`\n            // — LINEAR F0 reflectance (no gamma) in RGB, microSurface (= 1 - roughness) in A,\n            // the whole vec4 masked by writeGeometryInfo. Lite's `colorF0` is the F0 reflectance.\n            return `vec4<f32>(colorF0, 1.0 - roughness) * ${wg}`;\n        case GeometryTextureType.VIEW_DEPTH:\n            return `vec4<f32>((scene.view * vec4<f32>(input.worldPos, 1.0)).z, 0.0, 0.0, ${wg})`;\n        case GeometryTextureType.NORMALIZED_VIEW_DEPTH:\n            return `vec4<f32>(((scene.view * vec4<f32>(input.worldPos, 1.0)).z - gp.cameraNearFar.x) / (gp.cameraNearFar.y - gp.cameraNearFar.x), 0.0, 0.0, ${wg})`;\n        case GeometryTextureType.SCREENSPACE_DEPTH:\n            return `vec4<f32>(input.clipPos.z, 0.0, 0.0, ${wg})`;\n        case GeometryTextureType.VIEW_NORMAL:\n            return `vec4<f32>(normalize((scene.view * vec4<f32>(N, 0.0)).xyz), ${wg})`;\n        case GeometryTextureType.WORLD_NORMAL:\n            return `vec4<f32>(N * 0.5 + vec3<f32>(0.5), ${wg})`;\n        case GeometryTextureType.ALBEDO:\n            // BJS uses `surfaceAlbedo` for PBR (post diffuse / metallic split).\n            return `vec4<f32>(surfaceAlbedo, ${wg})`;\n        case GeometryTextureType.LINEAR_VELOCITY: {\n            const cur = `(input.vCurrentClip.xy / input.vCurrentClip.w)`;\n            const prev = `(input.vPreviousClip.xy / input.vPreviousClip.w)`;\n            return `vec4<f32>(0.5 * (${prev} - ${cur}), 0.0, ${wg})`;\n        }\n    }\n}\n\n// ─── Composer entry ────────────────────────────────────────────────────\n\n/** Compose a PBR geometry-output shader by reusing the per-scene composer\n *  and post-patching the resulting WGSL into MRT form. */\nexport function composePbrGeometryShader(\n    composePbr: ReturnType<typeof createPbrComposer>,\n    features: number,\n    features2: number,\n    meshFeatures: number,\n    sceneFeatures: number,\n    lightMode: PbrLightMode,\n    singleLightType: string,\n    esmShadowDepthCode: string,\n    vbStrides: MeshVbLayout | undefined,\n    vbKey: string,\n    attachments: readonly GeometryTextureType[],\n    emitColor: boolean\n): ComposedShader {\n    // Strip PBR_HAS_ALPHA_BLEND: the template's alpha-blend branch returns\n    // `finalAlpha = saturate(alpha + luminanceOverAlpha²)` which we don't need\n    // — we drive blending per attachment via the geometry pipeline state and\n    // gate writes via the `writeGeometryInfo` mask. Stripping yields the\n    // simple `return vec4<f32>(color,alpha*material.materialAlpha);` alpha\n    // block which is easier to pattern-match for the replacement.\n    const geomFeatures = features & ~PBR_HAS_ALPHA_BLEND;\n    // Tag the cache key with PBR2_GEOMETRY_OUTPUT so the geometry composed\n    // shader doesn't collide with the regular non-geometry one in composePbr's\n    // internal cache.\n    const geomFeatures2 = features2 | PBR2_GEOMETRY_OUTPUT;\n\n    const base = composePbr(\n        geomFeatures,\n        geomFeatures2,\n        meshFeatures,\n        sceneFeatures,\n        lightMode,\n        singleLightType,\n        esmShadowDepthCode,\n        vbStrides,\n        `${vbKey}:geom:${attachments.join(\",\")}:${emitColor ? \"c\" : \"\"}`\n    );\n\n    const hasIbl = (sceneFeatures & PBR_HAS_ENV) !== 0;\n\n    // ── Post-process the fragment WGSL ────────────────────────────────────\n\n    // 1) Swap the entry signature.\n    const fragmentSignatureFrom = \"-> @location(0) vec4<f32>\";\n    const fragmentSignatureTo = \"-> FragmentOutput\";\n    if (!base._fragmentWGSL.includes(fragmentSignatureFrom)) {\n        throw new Error(\"composePbrGeometryShader: PBR fragment signature mismatch — _noColorOutput/_esmShadowOutput should be off\");\n    }\n    let frag = base._fragmentWGSL.replace(fragmentSignatureFrom, fragmentSignatureTo);\n\n    // 2) Inject FragmentOutput struct before `@fragment fn main`. When\n    //    `emitColor` is true, append an extra slot at @location(N) for the\n    //    real lit colour (matches BJS `targetTexture`).\n    const colorSlot = attachments.length;\n    const extraColorLine = emitColor ? `\\n@location(${colorSlot}) color: vec4<f32>,` : \"\";\n    const outputStruct = `struct FragmentOutput {\n${attachments.map((_, i) => `@location(${i}) f${i}: vec4<f32>,`).join(\"\\n\")}${extraColorLine}\n};\n`;\n    frag = frag.replace(\"@fragment fn main\", `${outputStruct}@fragment fn main`);\n\n    // 3) Replace the alpha-block return with MRT writes. With ALPHA_BLEND\n    //    stripped, the template emits the simpler return form.\n    const wg = `select(0.0, 1.0, alpha > 0.4)`;\n    const writes = attachments.map((type, i) => `out.f${i} = ${attachmentExpr(type, wg, hasIbl)};`).join(\"\\n\");\n    const extraColorWrite = emitColor ? `\\nout.color = vec4<f32>(color, alpha * material.materialAlpha);` : \"\";\n    const replacement = `var out: FragmentOutput;\n${writes}${extraColorWrite}\nreturn out;`;\n    const returnPattern = \"return vec4<f32>(color,alpha*material.materialAlpha);\";\n    if (!frag.includes(returnPattern)) {\n        throw new Error(\"composePbrGeometryShader: alpha-block return statement not found — template changed?\");\n    }\n    frag = frag.replace(returnPattern, replacement);\n\n    return { ...base, _fragmentWGSL: frag };\n}\n","/** PBR geometry-MRT renderable factory.\n *\n *  Builds a {@link Renderable} that draws a single mesh through a\n *  {@link createPbrGeometryMaterialView} into the geometry renderer task's\n *  multi-attachment render target. Mirrors the regular PBR per-mesh\n *  rebuildSingle closure (mesh UBO, material UBO, mesh bind group with env +\n *  shadows, draw closure) but swaps the single-target pipeline for a\n *  multi-color-attachment one built from the geometry-output shader.\n *\n *  Per-(view, mesh-feature-variant) shared state — composed shader, mesh\n *  BGL, pipeline cache — is cached on `view._geometry` keyed by the\n *  shader-relevant mesh-feature bits + (features, features2, sceneFeatures,\n *  lightMode, singleLightType). Per-mesh state (UBOs, bind group, sort\n *  centre) lives in the closure returned by {@link buildPbrGeometryRenderable}.\n *\n *  This module is imported only by {@link createPbrGeometryMaterialView} —\n *  PBR scenes that don't use the geometry renderer task pay zero bytes for\n *  it. */\n\nimport { F32 } from \"../../engine/typed-arrays.js\";\nimport type { EngineContext } from \"../../engine/engine.js\";\nimport type { RenderTargetSignature } 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 type { SceneContext } from \"../../scene/scene-core.js\";\nimport { createUniformBuffer } from \"../../resource/gpu-buffers.js\";\nimport { acquireTexture, releaseTexture } from \"../../resource/gpu-pool.js\";\nimport type { ComposedShader } from \"../../shader/fragment-types.js\";\nimport { targetSignatureKey, REVERSE_DEPTH_COMPARE } from \"../../engine/render-target.js\";\nimport { packMat4IntoF32 } from \"../../math/pack-mat4-into-f32.js\";\nimport { _computeMeshFeatures, MSH_HAS_INSTANCE_COLOR, MSH_HAS_THIN_INSTANCES, MSH_HAS_TANGENTS, MSH_HAS_UV2, MSH_HAS_VERTEX_COLOR } from \"../mesh-features.js\";\nimport type { Material } from \"../material.js\";\nimport { getSceneBindGroupLayout } from \"../../render/scene-helpers.js\";\n\nimport type { PbrMaterialProps } from \"./pbr-material.js\";\nimport { collectPbrBoundTextures } from \"./pbr-material.js\";\nimport { _computePbrMaterialFeatures } from \"./pbr-material.js\";\nimport { PBR_HAS_ALPHA_BLEND, PBR_HAS_DOUBLE_SIDED, PBR_HAS_NORMAL_MAP, PBR2_HAS_UV2 } from \"./pbr-flags.js\";\nimport { createPbrMeshBindGroup } from \"./pbr-pipeline.js\";\nimport type { _PbrGeometryContext } from \"./pbr-renderable.js\";\nimport { _writeMaterialData } from \"./pbr-renderable.js\";\nimport type { PbrGeometryMaterialView } from \"./pbr-geometry-view.js\";\nimport { composePbrGeometryShader, _ensurePbrGeometryExt } from \"./pbr-geometry-output-shader.js\";\nimport { _setActivePbrGeometryAttachments } from \"./pbr-geometry-view.js\";\n\n/** Singleton {@link MeshGroupBuilder} that geometry views point at via their\n *  overridden `_buildGroup`. The async builder body is unreachable —\n *  geometry views are dispatched per-mesh via `_rebuildSingle` directly. */\nexport const pbrGeometryGroupBuilder: MeshGroupBuilder = (async () => {\n    throw new Error(\"pbr-geometry view does not support scene group building\");\n}) as MeshGroupBuilder;\npbrGeometryGroupBuilder._rebuildSingle = (scene: SceneContext, mesh: Mesh, materialOverride?: Material): Renderable => {\n    const view = (materialOverride ?? mesh.material) as PbrGeometryMaterialView;\n    return buildPbrGeometryRenderable(scene, mesh, view);\n};\npbrGeometryGroupBuilder._materialFamily = \"pbr\";\n\ninterface PbrGeometryViewResources {\n    _composed: ComposedShader;\n    _features: number;\n    _features2: number;\n    _meshFeatures: number;\n    _sceneFeatures: number;\n    _meshBGL: GPUBindGroupLayout;\n    _shadowBGL: GPUBindGroupLayout | null;\n    _pipelineLayout: GPUPipelineLayout;\n    _vertModule: GPUShaderModule;\n    _fragModule: GPUShaderModule;\n    _pipelines: Map<string, GPURenderPipeline>;\n    _alphaBlend: boolean;\n}\n\nfunction _variantKey(meshFeatures: number, lightMode: number, singleLightType: string): string {\n    return `${meshFeatures}:${lightMode}:${singleLightType}`;\n}\n\n/** Build a {@link Renderable} for one mesh drawn through a PBR geometry view. */\nexport function buildPbrGeometryRenderable(scene: SceneContext, mesh: Mesh, view: PbrGeometryMaterialView): Renderable {\n    const engine = scene.surface.engine;\n    const device = engine._device;\n\n    const ctx = (scene as SceneContext & { _pbrGeomContext?: _PbrGeometryContext })._pbrGeomContext;\n    if (!ctx) {\n        throw new Error(\"buildPbrGeometryRenderable: scene has no PBR context. Ensure regular PBR meshes have been built before recording the geometry task.\");\n    }\n\n    const source = view.source as PbrMaterialProps;\n    if (!source._renderFeatures) {\n        source._renderFeatures = _computePbrMaterialFeatures(source);\n    }\n\n    // Light selection mirrors regular PBR rebuildSingle, gated by the same\n    // shadow rules so the geometry-pass real-color attachment receives the\n    // same lighting as the regular PBR pass would have produced.\n    const lr = writeMeshLightSelection(mesh, scene.lights);\n    const lightCount = lr > 0 ? 1 : -lr;\n    const hasSomeShadows = ctx._shadowLights.length > 0;\n    const receiveShadows = mesh.receiveShadows && hasSomeShadows;\n    const lightMode: 0 | 1 | 2 = lightCount === 0 ? 0 : lightCount === 1 && !receiveShadows ? 1 : 2;\n    const singleLightType = lightMode === 1 ? _getPackedSingleLightType(scene.lights, lr - 1) : \"\";\n    const meshFeatures = _computeMeshFeatures(mesh, receiveShadows);\n\n    const variantKey = _variantKey(meshFeatures, lightMode, singleLightType);\n    const res = _ensureViewResources(view, engine, ctx, meshFeatures, lightMode, singleLightType, variantKey);\n\n    const features = res._features;\n    const features2 = res._features2;\n    const composed = res._composed;\n\n    // ── Mesh UBO ───────────────────────────────────────────────────────\n    const meshUboData = new F32(composed._meshUboSpec._totalBytes / 4);\n    const _packMeshWorld = engine._makePackMeshWorld?.(scene) ?? packMat4IntoF32;\n    _packMeshWorld(meshUboData, mesh.worldMatrix, 0, 0);\n    writeMeshLightSelection(mesh, scene.lights, meshUboData);\n    const meshUBO = createUniformBuffer(engine, meshUboData);\n\n    // ── Material UBO ───────────────────────────────────────────────────\n    const materialSpec = composed._materialUboSpec!;\n    const matInitData = new F32(materialSpec._totalBytes / 4);\n    // Use the per-scene writer captured on the geometry context.\n    _writePbrMaterialData(matInitData, source, materialSpec);\n    const materialUBO = createUniformBuffer(engine, matInitData);\n\n    // ── Mesh bind group (group 1). Pass the VIEW as the \"material\" so the\n    //    PBR geometry ext can read `view._gpUBO`. The view inherits all\n    //    source fields via its prototype chain, so other ext bind callbacks\n    //    that look at source.* still resolve correctly.\n    //\n    //    Bind during a scope where `_activeAttachments` is set so that any\n    //    composePbr cache miss inside `createPbrMeshBindGroup` (none expected\n    //    here, but defensive) sees the right attachments.\n    const prev = _setActivePbrGeometryAttachments(view._geometryAttachments);\n    let materialBindGroupStatic: GPUBindGroup;\n    try {\n        materialBindGroupStatic = createPbrMeshBindGroup(engine, _wrapBindings(res), composed, meshUBO, materialUBO, view as unknown as PbrMaterialProps, ctx._envTextures, mesh);\n    } finally {\n        _setActivePbrGeometryAttachments(prev);\n    }\n\n    // ── Shadow bind group (group 2) ────────────────────────────────────\n    let shadowBindGroup: GPUBindGroup | null = null;\n    if (receiveShadows && res._shadowBGL) {\n        const entries: GPUBindGroupEntry[] = [];\n        let b = 0;\n        for (const sl of ctx._shadowLights) {\n            const sg = sl.gen;\n            entries.push({ binding: b++, resource: sg._depthTexture.createView() });\n            entries.push({ binding: b++, resource: sg._depthSampler });\n            entries.push({ binding: b++, resource: { buffer: sg._shadowUBO } });\n        }\n        shadowBindGroup = device.createBindGroup({ layout: res._shadowBGL, entries });\n    }\n\n    // ── Texture acquire/release lifecycle ──────────────────────────────\n    const boundTextures = collectPbrBoundTextures(source);\n    for (const t of boundTextures) {\n        acquireTexture(t);\n    }\n    const prevDisposables = scene._meshDisposables.get(mesh) ?? [];\n    scene._meshDisposables.set(mesh, [\n        ...prevDisposables,\n        () => {\n            meshUBO.destroy();\n            materialUBO.destroy();\n        },\n        () => {\n            for (const t of boundTextures) {\n                releaseTexture(t);\n            }\n        },\n    ]);\n\n    const hasNormalMap = (features & PBR_HAS_NORMAL_MAP) !== 0 && (meshFeatures & MSH_HAS_TANGENTS) !== 0;\n    const hasUV2 = (features2 & PBR2_HAS_UV2) !== 0 && (meshFeatures & MSH_HAS_UV2) !== 0;\n    const hasVertexColor = (meshFeatures & MSH_HAS_VERTEX_COLOR) !== 0;\n    const hasTI = (meshFeatures & MSH_HAS_THIN_INSTANCES) !== 0;\n    const hasTIColor = (meshFeatures & MSH_HAS_INSTANCE_COLOR) !== 0;\n    const syncThinInstanceBuffers = ctx._syncThinInstanceBuffers;\n    const isAlphaBlend = res._alphaBlend;\n    const sortCenter = [mesh.worldMatrix[12]!, mesh.worldMatrix[13]!, mesh.worldMatrix[14]!] as [number, number, number];\n\n    let _lastWorldVersion = mesh.worldMatrixVersion;\n    let _lastLightsCount = scene.lights.length;\n    let _lastUboVersion = source._uboVersion;\n    const matScratch = new F32(materialSpec._totalBytes / 4);\n\n    const _baseUpdate = (): void => {\n        if (mesh.worldMatrixVersion !== _lastWorldVersion || scene.lights.length !== _lastLightsCount) {\n            sortCenter[0] = mesh.worldMatrix[12]!;\n            sortCenter[1] = mesh.worldMatrix[13]!;\n            sortCenter[2] = mesh.worldMatrix[14]!;\n            _packMeshWorld(meshUboData, mesh.worldMatrix, 0, 0);\n            writeMeshLightSelection(mesh, scene.lights, meshUboData);\n            device.queue.writeBuffer(meshUBO, 0, meshUboData as Float32Array<ArrayBuffer>);\n            _lastWorldVersion = mesh.worldMatrixVersion;\n            _lastLightsCount = scene.lights.length;\n        }\n        if (source._uboVersion !== _lastUboVersion) {\n            _lastUboVersion = source._uboVersion;\n            matScratch.fill(0);\n            _writePbrMaterialData(matScratch, source, materialSpec);\n            device.queue.writeBuffer(materialUBO, 0, matScratch.buffer, 0, matScratch.byteLength);\n        }\n    };\n    const _invalidate = (): void => {\n        _lastWorldVersion = -1;\n    };\n    const update = engine._wrapRenderableForFO?.(_baseUpdate, scene, _invalidate) ?? _baseUpdate;\n\n    const draw = (pass: GPURenderPassEncoder | GPURenderBundleEncoder): number => {\n        if (mesh.visible === false) {\n            return 0;\n        }\n        const gpu = mesh._gpu;\n        pass.setBindGroup(1, materialBindGroupStatic);\n        if (shadowBindGroup) {\n            pass.setBindGroup(2, shadowBindGroup);\n        }\n        let slot = 0;\n        // Bind every attribute at offset 0 — the per-attribute byte offset is baked into the\n        // pipeline vertex layout (see pbr-template). A non-zero setVertexBuffer bind offset\n        // corrupts vertex fetch on some AMD/Dawn paths; this mirrors the color pass and BJS.\n        pass.setVertexBuffer(slot++, gpu.positionBuffer);\n        pass.setVertexBuffer(slot++, gpu.normalBuffer);\n        if (hasNormalMap && gpu.tangentBuffer) {\n            pass.setVertexBuffer(slot++, gpu.tangentBuffer);\n        }\n        pass.setVertexBuffer(slot++, gpu.uvBuffer);\n        if (hasUV2 && gpu.uv2Buffer) {\n            pass.setVertexBuffer(slot++, gpu.uv2Buffer);\n        }\n        if (hasVertexColor && gpu.colorBuffer) {\n            pass.setVertexBuffer(slot++, gpu.colorBuffer);\n        }\n        // Skinning vertex buffers: live skeleton OR baked VAT (same field names, mutually exclusive).\n        // Mirrors the main PBR renderable — without the VAT branch, VAT-animated thin instances leave the\n        // pipeline's joint/weight vertex slots unbound (invalid command buffer, black frame).\n        const skin = mesh.skeleton ?? mesh.vat;\n        if (skin) {\n            pass.setVertexBuffer(slot++, skin.jointsBuffer);\n            pass.setVertexBuffer(slot++, skin.weightsBuffer);\n            if (skin.joints1Buffer && skin.weights1Buffer) {\n                pass.setVertexBuffer(slot++, skin.joints1Buffer);\n                pass.setVertexBuffer(slot++, skin.weights1Buffer);\n            }\n        }\n        const ti = hasTI ? mesh.thinInstances : null;\n        if (ti && syncThinInstanceBuffers) {\n            slot = syncThinInstanceBuffers(engine, ti, pass, slot, hasTIColor);\n        }\n        pass.setIndexBuffer(gpu.indexBuffer, gpu.indexFormat);\n        if (ti && ti.count > 0) {\n            pass.drawIndexed(gpu.indexCount, ti.count);\n        } else {\n            pass.drawIndexed(gpu.indexCount);\n        }\n        return 1;\n    };\n\n    const r: Renderable = {\n        order: mesh.renderOrder ?? (isAlphaBlend ? 200 : 100),\n        isTransparent: isAlphaBlend,\n        mesh,\n        bind(eng: EngineContext, sig: RenderTargetSignature) {\n            return {\n                renderable: r,\n                pipeline: _getOrCreateGeometryPipeline(eng as EngineContext, sig, view, res),\n                update,\n                draw,\n            };\n        },\n    };\n    r._worldCenter = sortCenter;\n    return r;\n}\n\n// ─── Shared per-view resources ─────────────────────────────────────────\n\nfunction _ensureViewResources(\n    view: PbrGeometryMaterialView,\n    engine: EngineContext,\n    ctx: _PbrGeometryContext,\n    meshFeatures: number,\n    lightMode: 0 | 1 | 2,\n    singleLightType: string,\n    variantKey: string\n): PbrGeometryViewResources {\n    let cache = view._geometry as Map<string, PbrGeometryViewResources> | undefined;\n    if (!cache) {\n        cache = new Map();\n        Object.defineProperty(view, \"_geometry\", { value: cache, enumerable: false, configurable: true });\n    }\n    const cached = cache.get(variantKey);\n    if (cached) {\n        return cached;\n    }\n    // Ensure the PBR geometry ext is registered (idempotent) before composePbr is called.\n    _ensurePbrGeometryExt(() => view._geometryAttachments);\n\n    const features = view._renderFeatures.features;\n    const features2 = view._renderFeatures.features2 ?? 0;\n    const sceneFeatures = ctx._sceneFeatures;\n    const source = view.source as PbrMaterialProps;\n    const vbLayout = (source as unknown as { _vbLayout?: import(\"../../mesh/mesh.js\").MeshVbLayout })._vbLayout;\n    const vbKey = \"\";\n\n    // Compose with the active-attachment scope set so the registered ext\n    // sees the right list when contributing the geometry-params fragment.\n    const prev = _setActivePbrGeometryAttachments(view._geometryAttachments);\n    let composed: ComposedShader;\n    try {\n        composed = composePbrGeometryShader(\n            ctx._composePbr,\n            features,\n            features2,\n            meshFeatures,\n            sceneFeatures,\n            lightMode,\n            singleLightType,\n            \"\",\n            vbLayout,\n            vbKey,\n            view._geometryAttachments,\n            view._emitColor\n        );\n    } finally {\n        _setActivePbrGeometryAttachments(prev);\n    }\n\n    const device = engine._device;\n    const meshBGL = device.createBindGroupLayout(composed._meshBGLDescriptor);\n    const shadowBGL = composed._shadowBGLDescriptor ? device.createBindGroupLayout(composed._shadowBGLDescriptor) : null;\n    const sceneBGL = (engine as unknown as { _getSceneBGL: () => GPUBindGroupLayout })._getSceneBGL?.() ?? _getSceneBindGroupLayoutLocal(engine, composed);\n    const bgls: GPUBindGroupLayout[] = shadowBGL ? [sceneBGL, meshBGL, shadowBGL] : [sceneBGL, meshBGL];\n    const pipelineLayout = device.createPipelineLayout({ bindGroupLayouts: bgls });\n    const vertModule = device.createShaderModule({ code: composed._vertexWGSL });\n    const fragModule = device.createShaderModule({ code: composed._fragmentWGSL });\n\n    // The view's features have PBR_HAS_ALPHA_BLEND already stripped. Detect\n    // alpha-blend from the SOURCE so transparent meshes get the right blend\n    // pipeline state below.\n    const sourceFeatures = source._renderFeatures?.features ?? 0;\n    const alphaBlend = (sourceFeatures & PBR_HAS_ALPHA_BLEND) !== 0;\n\n    const res: PbrGeometryViewResources = {\n        _composed: composed,\n        _features: features,\n        _features2: features2,\n        _meshFeatures: meshFeatures,\n        _sceneFeatures: sceneFeatures,\n        _meshBGL: meshBGL,\n        _shadowBGL: shadowBGL,\n        _pipelineLayout: pipelineLayout,\n        _vertModule: vertModule,\n        _fragModule: fragModule,\n        _pipelines: new Map(),\n        _alphaBlend: alphaBlend,\n    };\n    cache.set(variantKey, res);\n    return res;\n}\n\n/** Adapter so `createPbrMeshBindGroup` (which takes `_PbrShaderBindings`) can\n *  consume our view resources. Only the fields it touches matter. */\nfunction _wrapBindings(res: PbrGeometryViewResources): Parameters<typeof createPbrMeshBindGroup>[1] {\n    return {\n        _features: res._features,\n        _features2: res._features2,\n        _meshFeatures: res._meshFeatures,\n        _meshBGL: res._meshBGL,\n        _shadowBGL: res._shadowBGL,\n        _composed: res._composed,\n        _pipelines: res._pipelines,\n    } as Parameters<typeof createPbrMeshBindGroup>[1];\n}\n\n/** Local fallback used when the engine does not expose a centralised scene BGL\n *  cache helper. Matches the layout produced by `getSceneBindGroupLayout`. */\nfunction _getSceneBindGroupLayoutLocal(engine: EngineContext, _composed: ComposedShader): GPUBindGroupLayout {\n    return getSceneBindGroupLayout(engine);\n}\n\nfunction _getOrCreateGeometryPipeline(engine: EngineContext, sig: RenderTargetSignature, view: PbrGeometryMaterialView, res: PbrGeometryViewResources): GPURenderPipeline {\n    const key = targetSignatureKey(sig);\n    const cached = res._pipelines.get(key);\n    if (cached) {\n        return cached;\n    }\n    const device = engine._device;\n    const formats = (sig as RenderTargetSignature & { _colorFormats?: readonly GPUTextureFormat[] })._colorFormats ?? (sig._colorFormat ? [sig._colorFormat] : []);\n    if (formats.length === 0) {\n        throw new Error(\"pbr-geometry: render target has no color attachments\");\n    }\n    const alphaBlend = res._alphaBlend;\n    const blendState: GPUBlendState | undefined = alphaBlend\n        ? {\n              color: { srcFactor: \"src-alpha\", dstFactor: \"one-minus-src-alpha\", operation: \"add\" },\n              alpha: { srcFactor: \"src-alpha\", dstFactor: \"one-minus-src-alpha\", operation: \"add\" },\n          }\n        : undefined;\n    const colorTargets: GPUColorTargetState[] = formats.map((fmt) => (blendState ? { format: fmt, blend: blendState } : { format: fmt }));\n    const sourceFeatures = (view.source as PbrMaterialProps)._renderFeatures?.features ?? 0;\n    const hasDoubleSided = (sourceFeatures & PBR_HAS_DOUBLE_SIDED) !== 0;\n    const cullMode = hasDoubleSided ? \"none\" : view._reverseCulling ? \"front\" : \"back\";\n    const pipeline = device.createRenderPipeline({\n        layout: res._pipelineLayout,\n        vertex: { module: res._vertModule, entryPoint: \"main\", buffers: res._composed._vertexBufferLayouts },\n        fragment: { module: res._fragModule, entryPoint: \"main\", targets: colorTargets },\n        depthStencil: sig._depthStencilFormat\n            ? {\n                  format: sig._depthStencilFormat,\n                  depthCompare: sig._depthCompare ?? REVERSE_DEPTH_COMPARE,\n                  // Disable depth-write for alpha-blended meshes so background\n                  // depth survives partially-transparent pixels. Matches the\n                  // Standard geometry-renderable behaviour.\n                  depthWriteEnabled: !alphaBlend,\n              }\n            : undefined,\n        multisample: { count: sig._sampleCount },\n        primitive: { topology: \"triangle-list\", cullMode, frontFace: \"ccw\" },\n    });\n    res._pipelines.set(key, pipeline);\n    return pipeline;\n}\n\n// ─── Helpers cribbed from pbr-renderable (no static cycle) ─────────────\n\nfunction _getPackedSingleLightType(lights: SceneContext[\"lights\"], packedIndex: number): \"hemispheric\" | \"directional\" | \"spot\" | \"point\" {\n    let packed = 0;\n    for (const light of lights) {\n        if (!light._writeLightUbo) {\n            continue;\n        }\n        if (packed === packedIndex) {\n            const t = light.lightType;\n            return t === \"hemispheric\" || t === \"directional\" || t === \"spot\" ? t : \"point\";\n        }\n        packed++;\n    }\n    return \"point\";\n}\n\n/** Writes material UBO via the helper exported from pbr-renderable. */\nfunction _writePbrMaterialData(data: Float32Array, mat: PbrMaterialProps, spec: import(\"../../shader/fragment-types.js\").UboSpec): void {\n    _writeMaterialData(data, mat, spec);\n}\n","/** PBR material view helper that targets geometry-rendering MRT output.\n *\n *  The geometry renderer task wraps each PBR caster material in a\n *  `PbrGeometryMaterialView`. The view carries the per-task attachment\n *  list, target-texture intent, optional `gp` UBO (shared across the task's\n *  materials), and reverse-culling flag. The view also shadows\n *  {@link Material._buildGroup} with {@link pbrGeometryGroupBuilder} so that\n *  the geometry renderer task materialises a {@link Renderable} through the\n *  PBR geometry renderable infrastructure — no view-aware branching needed\n *  in core render-task.\n *\n *  The geometry-output WGSL itself is produced by post-processing the regular\n *  per-scene composed PBR shader (reused via the `_pbrGeomContext` stash) in\n *  `./pbr-geometry-output-shader.ts`. */\n\nimport { createMaterialView } from \"../material-view.js\";\nimport type { MaterialView } from \"../material.js\";\nimport type { GeometryTextureType } from \"../../frame-graph/geometry-types.js\";\nimport { PBR_HAS_ALPHA_BLEND, PBR2_GEOMETRY_OUTPUT } from \"./pbr-flags.js\";\nimport type { PbrMaterialProps } from \"./pbr-material.js\";\nimport { pbrGeometryGroupBuilder } from \"./pbr-geometry-renderable.js\";\nimport { _ensurePbrGeometryExt } from \"./pbr-geometry-output-shader.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 PbrGeometryAttachments = readonly GeometryTextureType[];\n\n/** Per-(task, material) PBR geometry view configuration. All fields are owned\n *  by the geometry renderer task; the view captures them so per-mesh renderables\n *  pick up the same pipeline state and bindings. */\nexport interface PbrGeometryViewConfig {\n    /** Ordered MRT attachment list — index = `@location(i)`. */\n    readonly attachments: PbrGeometryAttachments;\n    /** When true, the composed fragment emits the real (lit) material color\n     *  at `@location(N)` (N = attachments.length). The target texture is\n     *  added to the pipeline color-target list at the same slot. */\n    readonly emitColor: boolean;\n    /** Per-task previous-VP + camera-near-far UBO. Required when\n     *  {@link attachments} contains `NORMALIZED_VIEW_DEPTH` or\n     *  `LINEAR_VELOCITY`; ignored otherwise. */\n    readonly gpUBO?: GPUBuffer | null;\n    /** Flip culling direction. */\n    readonly reverseCulling?: boolean;\n}\n\n/** PBR material view that emits geometry textures instead of shaded colour. */\nexport interface PbrGeometryMaterialView extends MaterialView {\n    /** @internal Ordered MRT attachment list — index = `@location(i)`. */\n    readonly _geometryAttachments: PbrGeometryAttachments;\n    /** @internal Geometry pipeline carries an extra `@location(N)` color attachment. */\n    readonly _emitColor: boolean;\n    /** @internal Optional per-task geometry-params UBO shared with the composer's\n     *  `geometry-params` fragment. */\n    readonly _gpUBO: GPUBuffer | null;\n    /** @internal */\n    readonly _reverseCulling: boolean;\n    /** @internal Shared per-view resources cache populated lazily by the renderable\n     *  factory. Opaque to callers. */\n    _geometry?: unknown;\n}\n\n// Snapshot of the currently-building view's attachments so the registered\n// PBR geometry extension can read them from `frag(ctx)`. The extension is\n// invoked synchronously during composePbr inside `buildPbrGeometryRenderable`;\n// the snapshot is set right before that call and cleared after.\nlet _activeAttachments: readonly GeometryTextureType[] | undefined;\n\n/** @internal Used by the geometry renderable to scope attachment access for\n *  the PBR ext during a composePbr call. Returns the previous value so the\n *  caller can restore it (avoids global leakage in nested scenarios). */\nexport function _setActivePbrGeometryAttachments(att: readonly GeometryTextureType[] | undefined): readonly GeometryTextureType[] | undefined {\n    const prev = _activeAttachments;\n    _activeAttachments = att;\n    return prev;\n}\n\n/** Wrap a PBR material as a geometry-output view.\n *  - Sets the `PBR2_GEOMETRY_OUTPUT` features2 bit.\n *  - Clears `PBR_HAS_ALPHA_BLEND`: the geometry pipeline drives blending per\n *    attachment via the pipeline color-target state, not via the PBR\n *    fragment's source-over color output.\n *  - Shadows `_buildGroup` with {@link pbrGeometryGroupBuilder} so the\n *    natural `material._buildGroup._rebuildSingle` dispatch in\n *    `resolvePendingMeshes` builds a geometry-MRT renderable for this view.\n *  - Registers the PBR geometry extension (idempotent) so subsequent\n *    composePbr calls pick up the `gp` UBO + geometry varyings when\n *    `PBR2_GEOMETRY_OUTPUT` is set. */\nexport function createPbrGeometryMaterialView(source: PbrMaterialProps, config: PbrGeometryViewConfig): PbrGeometryMaterialView {\n    _ensurePbrGeometryExt(() => _activeAttachments);\n    const baseFeatures = source._renderFeatures?.features ?? 0;\n    const baseFeatures2 = source._renderFeatures?.features2 ?? 0;\n    const view = createMaterialView(source, {\n        features: baseFeatures & ~PBR_HAS_ALPHA_BLEND,\n        features2: baseFeatures2 | PBR2_GEOMETRY_OUTPUT,\n    }) as PbrGeometryMaterialView;\n    Object.defineProperty(view, \"_geometryAttachments\", { value: config.attachments, enumerable: false });\n    Object.defineProperty(view, \"_emitColor\", { value: config.emitColor, 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: pbrGeometryGroupBuilder, enumerable: false });\n    return view;\n}\n"],"names":[],"mappings":"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"}

package/{pbr-metallic-roughness-block-g7wjzwN_.js → pbr-metallic-roughness-block-C7s1jL4q.js}

@@ -1,4 +1,4 @@
-import { M as MAX_LIGHTS } from "./index-BgY3QEzL.js";
+import { M as MAX_LIGHTS } from "./index-C2sM8ERH.js";
 const HELPER_KEY_PREFIX = "nme_pbr_mr";
 const SHADOW_FACTORS_ONE = `array<f32, ${MAX_LIGHTS}>(${new Array(MAX_LIGHTS).fill("1.0").join(", ")})`;
 function resolveOptional(block, inputName, fallback, target, stage, state, ctx) {
@@ -101,4 +101,4 @@ const emitter = {
 export {
   emitter
 };
-//# sourceMappingURL=pbr-metallic-roughness-block-g7wjzwN_.js.map
+//# sourceMappingURL=pbr-metallic-roughness-block-C7s1jL4q.js.map