@babylonjs/lite 0.1.1

package/derivative-block-B8KjtaWs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"derivative-block-B8KjtaWs.js","sources":["../src/material/node/blocks/derivative-block.ts"],"sourcesContent":["import type { BlockEmitter } from \"../node-types.js\";\n\nconst OUTPUT_FN: Record<string, string> = {\n    dx: \"dpdx\",\n    dy: \"dpdy\",\n};\n\nexport const emitter: BlockEmitter = {\n    className: \"DerivativeBlock\",\n    stage: \"fragment\",\n    emit(block, outputName, stage, state, ctx) {\n        const fn = OUTPUT_FN[outputName];\n        if (!fn) {\n            throw new Error(`NodeMaterial: DerivativeBlock output \"${outputName}\" is not supported`);\n        }\n        const input = ctx.resolve(block, \"input\", stage, state);\n        return { expr: `${fn}(${input.expr})`, type: input.type };\n    },\n};\n"],"names":[],"mappings":"AAEA,MAAM,YAAoC;AAAA,EACtC,IAAI;AAAA,EACJ,IAAI;AACR;AAEO,MAAM,UAAwB;AAAA,EACjC,WAAW;AAAA,EACX,OAAO;AAAA,EACP,KAAK,OAAO,YAAY,OAAO,OAAO,KAAK;AACvC,UAAM,KAAK,UAAU,UAAU;AAC/B,QAAI,CAAC,IAAI;AACL,YAAM,IAAI,MAAM,yCAAyC,UAAU,oBAAoB;AAAA,IAC3F;AACA,UAAM,QAAQ,IAAI,QAAQ,OAAO,SAAS,OAAO,KAAK;AACtD,WAAO,EAAE,MAAM,GAAG,EAAE,IAAI,MAAM,IAAI,KAAK,MAAM,MAAM,KAAA;AAAA,EACvD;AACJ;"}

package/desaturate-block-C1RghNSB.js

@@ -0,0 +1,15 @@
+const emitter = {
+  className: "DesaturateBlock",
+  emit(block, _outputName, stage, state, ctx) {
+    const color = ctx.cast(ctx.resolve(block, "color", stage, state), "vec3f").expr;
+    const level = ctx.cast(ctx.resolve(block, "level", stage, state), "f32").expr;
+    const minColor = `min(min((${color}).x, (${color}).y), (${color}).z)`;
+    const maxColor = `max(max((${color}).x, (${color}).y), (${color}).z)`;
+    const merge = `(0.5 * (${minColor} + ${maxColor}))`;
+    return { expr: `mix(${color}, vec3<f32>(${merge}), ${level})`, type: "vec3f" };
+  }
+};
+export {
+  emitter
+};
+//# sourceMappingURL=desaturate-block-C1RghNSB.js.map

package/desaturate-block-C1RghNSB.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"desaturate-block-C1RghNSB.js","sources":["../src/material/node/blocks/desaturate-block.ts"],"sourcesContent":["import type { BlockEmitter } from \"../node-types.js\";\n\nexport const emitter: BlockEmitter = {\n    className: \"DesaturateBlock\",\n    emit(block, _outputName, stage, state, ctx) {\n        const color = ctx.cast(ctx.resolve(block, \"color\", stage, state), \"vec3f\").expr;\n        const level = ctx.cast(ctx.resolve(block, \"level\", stage, state), \"f32\").expr;\n        const minColor = `min(min((${color}).x, (${color}).y), (${color}).z)`;\n        const maxColor = `max(max((${color}).x, (${color}).y), (${color}).z)`;\n        const merge = `(0.5 * (${minColor} + ${maxColor}))`;\n        return { expr: `mix(${color}, vec3<f32>(${merge}), ${level})`, type: \"vec3f\" };\n    },\n};\n"],"names":[],"mappings":"AAEO,MAAM,UAAwB;AAAA,EACjC,WAAW;AAAA,EACX,KAAK,OAAO,aAAa,OAAO,OAAO,KAAK;AACxC,UAAM,QAAQ,IAAI,KAAK,IAAI,QAAQ,OAAO,SAAS,OAAO,KAAK,GAAG,OAAO,EAAE;AAC3E,UAAM,QAAQ,IAAI,KAAK,IAAI,QAAQ,OAAO,SAAS,OAAO,KAAK,GAAG,KAAK,EAAE;AACzE,UAAM,WAAW,YAAY,KAAK,SAAS,KAAK,UAAU,KAAK;AAC/D,UAAM,WAAW,YAAY,KAAK,SAAS,KAAK,UAAU,KAAK;AAC/D,UAAM,QAAQ,WAAW,QAAQ,MAAM,QAAQ;AAC/C,WAAO,EAAE,MAAM,OAAO,KAAK,eAAe,KAAK,MAAM,KAAK,KAAK,MAAM,QAAA;AAAA,EACzE;AACJ;"}

package/discard-block-B2jKjaEL.js

@@ -0,0 +1,21 @@
+const emitter = {
+  className: "DiscardBlock",
+  stage: "fragment",
+  sideEffect: true,
+  emit(block, _outputName, stage, state, ctx) {
+    const memoKey = `_discard_${block.id}_emit`;
+    if (!state.fragment.memo.has(memoKey)) {
+      const valueIn = block.inputs.get("value");
+      const cutoffIn = block.inputs.get("cutoff");
+      const value = (valueIn == null ? void 0 : valueIn.source) ? ctx.cast(ctx.resolve(block, "value", stage, state), "f32") : { expr: "0.0" };
+      const cutoff = (cutoffIn == null ? void 0 : cutoffIn.source) ? ctx.cast(ctx.resolve(block, "cutoff", stage, state), "f32") : { expr: "0.0" };
+      state.fragment.body.push(`if (${value.expr} < ${cutoff.expr}) { discard; }`);
+      state.fragment.memo.set(memoKey, { expr: "0.0", type: "f32" });
+    }
+    return { expr: "0.0", type: "f32" };
+  }
+};
+export {
+  emitter
+};
+//# sourceMappingURL=discard-block-B2jKjaEL.js.map

package/discard-block-B2jKjaEL.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"discard-block-B2jKjaEL.js","sources":["../src/material/node/blocks/discard-block.ts"],"sourcesContent":["/** DiscardBlock — fragment-stage discard.\n *\n *  Inputs: `value` (scalar), `cutoff` (scalar).\n *  Semantics (BJS): if `value < cutoff` then `discard`.\n *\n *  The block has no output expression — it pushes a guarded `discard;` statement\n *  into the fragment body during traversal. Because the pipeline walks from\n *  FragmentOutputBlock back through its inputs, DiscardBlock only executes when\n *  it is reachable from the final output via some consumer. In practice BJS\n *  attaches it to FragmentOutputBlock via a dedicated connection or wires it\n *  upstream of the colour flow; we support the latter shape here — any block\n *  whose output reaches FragmentOutputBlock will cause the discard to be\n *  emitted. To guarantee emission even when not directly in the colour path,\n *  we wire DiscardBlock into the emit loop via the has-side-effects list\n *  maintained by node-emitter.ts.\n */\n\nimport type { BlockEmitter } from \"../node-types.js\";\n\nexport const emitter: BlockEmitter = {\n    className: \"DiscardBlock\",\n    stage: \"fragment\",\n    sideEffect: true,\n    emit(block, _outputName, stage, state, ctx) {\n        const memoKey = `_discard_${block.id}_emit`;\n        if (!state.fragment.memo.has(memoKey)) {\n            const valueIn = block.inputs.get(\"value\");\n            const cutoffIn = block.inputs.get(\"cutoff\");\n            const value = valueIn?.source ? ctx.cast(ctx.resolve(block, \"value\", stage, state), \"f32\") : { expr: \"0.0\", type: \"f32\" as const };\n            const cutoff = cutoffIn?.source ? ctx.cast(ctx.resolve(block, \"cutoff\", stage, state), \"f32\") : { expr: \"0.0\", type: \"f32\" as const };\n            state.fragment.body.push(`if (${value.expr} < ${cutoff.expr}) { discard; }`);\n            state.fragment.memo.set(memoKey, { expr: \"0.0\", type: \"f32\" });\n        }\n        return { expr: \"0.0\", type: \"f32\" };\n    },\n};\n"],"names":[],"mappings":"AAmBO,MAAM,UAAwB;AAAA,EACjC,WAAW;AAAA,EACX,OAAO;AAAA,EACP,YAAY;AAAA,EACZ,KAAK,OAAO,aAAa,OAAO,OAAO,KAAK;AACxC,UAAM,UAAU,YAAY,MAAM,EAAE;AACpC,QAAI,CAAC,MAAM,SAAS,KAAK,IAAI,OAAO,GAAG;AACnC,YAAM,UAAU,MAAM,OAAO,IAAI,OAAO;AACxC,YAAM,WAAW,MAAM,OAAO,IAAI,QAAQ;AAC1C,YAAM,SAAQ,mCAAS,UAAS,IAAI,KAAK,IAAI,QAAQ,OAAO,SAAS,OAAO,KAAK,GAAG,KAAK,IAAI,EAAE,MAAM,MAA4B;AACjI,YAAM,UAAS,qCAAU,UAAS,IAAI,KAAK,IAAI,QAAQ,OAAO,UAAU,OAAO,KAAK,GAAG,KAAK,IAAI,EAAE,MAAM,MAA4B;AACpI,YAAM,SAAS,KAAK,KAAK,OAAO,MAAM,IAAI,MAAM,OAAO,IAAI,gBAAgB;AAC3E,YAAM,SAAS,KAAK,IAAI,SAAS,EAAE,MAAM,OAAO,MAAM,OAAO;AAAA,IACjE;AACA,WAAO,EAAE,MAAM,OAAO,MAAM,MAAA;AAAA,EAChC;AACJ;"}

package/distance-block-3NkgFZ3f.js

@@ -0,0 +1,16 @@
+import { w as widerType } from "./_math-factory-C-QqW-Wi.js";
+const emitter = {
+  className: "DistanceBlock",
+  emit(block, _outputName, stage, state, ctx) {
+    const left = ctx.resolve(block, "left", stage, state);
+    const right = ctx.resolve(block, "right", stage, state);
+    const type = widerType(left.type, right.type);
+    const lc = ctx.cast(left, type).expr;
+    const rc = ctx.cast(right, type).expr;
+    return { expr: `length(${lc} - ${rc})`, type: "f32" };
+  }
+};
+export {
+  emitter
+};
+//# sourceMappingURL=distance-block-3NkgFZ3f.js.map

package/distance-block-3NkgFZ3f.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"distance-block-3NkgFZ3f.js","sources":["../src/material/node/blocks/distance-block.ts"],"sourcesContent":["import type { BlockEmitter } from \"../node-types.js\";\nimport { widerType } from \"./_math-factory.js\";\n\nexport const emitter: BlockEmitter = {\n    className: \"DistanceBlock\",\n    emit(block, _outputName, stage, state, ctx) {\n        const left = ctx.resolve(block, \"left\", stage, state);\n        const right = ctx.resolve(block, \"right\", stage, state);\n        const type = widerType(left.type, right.type);\n        const lc = ctx.cast(left, type).expr;\n        const rc = ctx.cast(right, type).expr;\n        return { expr: `length(${lc} - ${rc})`, type: \"f32\" };\n    },\n};\n"],"names":[],"mappings":";AAGO,MAAM,UAAwB;AAAA,EACjC,WAAW;AAAA,EACX,KAAK,OAAO,aAAa,OAAO,OAAO,KAAK;AACxC,UAAM,OAAO,IAAI,QAAQ,OAAO,QAAQ,OAAO,KAAK;AACpD,UAAM,QAAQ,IAAI,QAAQ,OAAO,SAAS,OAAO,KAAK;AACtD,UAAM,OAAO,UAAU,KAAK,MAAM,MAAM,IAAI;AAC5C,UAAM,KAAK,IAAI,KAAK,MAAM,IAAI,EAAE;AAChC,UAAM,KAAK,IAAI,KAAK,OAAO,IAAI,EAAE;AACjC,WAAO,EAAE,MAAM,UAAU,EAAE,MAAM,EAAE,KAAK,MAAM,MAAA;AAAA,EAClD;AACJ;"}

package/divide-block-ZyepIg_-.js

@@ -0,0 +1,6 @@
+import { b as binaryEmitter } from "./_math-factory-C-QqW-Wi.js";
+const emitter = binaryEmitter("DivideBlock", (l, r) => `${l} / ${r}`);
+export {
+  emitter
+};
+//# sourceMappingURL=divide-block-ZyepIg_-.js.map

package/divide-block-ZyepIg_-.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"divide-block-ZyepIg_-.js","sources":["../src/material/node/blocks/divide-block.ts"],"sourcesContent":["import { binaryEmitter } from \"./_math-factory.js\";\n\nexport const emitter = binaryEmitter(\"DivideBlock\", (l, r) => `${l} / ${r}`);\n"],"names":[],"mappings":";AAEO,MAAM,UAAU,cAAc,eAAe,CAAC,GAAG,MAAM,GAAG,CAAC,MAAM,CAAC,EAAE;"}

package/dot-block-VlfAC6cD.js

@@ -0,0 +1,16 @@
+import { w as widerType } from "./_math-factory-C-QqW-Wi.js";
+const emitter = {
+  className: "DotBlock",
+  emit(block, _outputName, stage, state, ctx) {
+    const l = ctx.resolve(block, "left", stage, state);
+    const r = ctx.resolve(block, "right", stage, state);
+    const t = widerType(l.type, r.type);
+    const lc = ctx.cast(l, t).expr;
+    const rc = ctx.cast(r, t).expr;
+    return { expr: `dot(${lc}, ${rc})`, type: "f32" };
+  }
+};
+export {
+  emitter
+};
+//# sourceMappingURL=dot-block-VlfAC6cD.js.map

package/dot-block-VlfAC6cD.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dot-block-VlfAC6cD.js","sources":["../src/material/node/blocks/dot-block.ts"],"sourcesContent":["import type { BlockEmitter } from \"../node-types.js\";\nimport { widerType } from \"./_math-factory.js\";\n\nexport const emitter: BlockEmitter = {\n    className: \"DotBlock\",\n    emit(block, _outputName, stage, state, ctx) {\n        const l = ctx.resolve(block, \"left\", stage, state);\n        const r = ctx.resolve(block, \"right\", stage, state);\n        const t = widerType(l.type, r.type);\n        const lc = ctx.cast(l, t).expr;\n        const rc = ctx.cast(r, t).expr;\n        return { expr: `dot(${lc}, ${rc})`, type: \"f32\" };\n    },\n};\n"],"names":[],"mappings":";AAGO,MAAM,UAAwB;AAAA,EACjC,WAAW;AAAA,EACX,KAAK,OAAO,aAAa,OAAO,OAAO,KAAK;AACxC,UAAM,IAAI,IAAI,QAAQ,OAAO,QAAQ,OAAO,KAAK;AACjD,UAAM,IAAI,IAAI,QAAQ,OAAO,SAAS,OAAO,KAAK;AAClD,UAAM,IAAI,UAAU,EAAE,MAAM,EAAE,IAAI;AAClC,UAAM,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE;AAC1B,UAAM,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE;AAC1B,WAAO,EAAE,MAAM,OAAO,EAAE,KAAK,EAAE,KAAK,MAAM,MAAA;AAAA,EAC9C;AACJ;"}

package/elbow-block-NEOiIxzO.js

@@ -0,0 +1,10 @@
+const emitter = {
+  className: "ElbowBlock",
+  emit(block, _outputName, stage, state, ctx) {
+    return ctx.resolve(block, "input", stage, state);
+  }
+};
+export {
+  emitter
+};
+//# sourceMappingURL=elbow-block-NEOiIxzO.js.map

package/elbow-block-NEOiIxzO.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"elbow-block-NEOiIxzO.js","sources":["../src/material/node/blocks/elbow-block.ts"],"sourcesContent":["import type { BlockEmitter } from \"../node-types.js\";\n\nexport const emitter: BlockEmitter = {\n    className: \"ElbowBlock\",\n    emit(block, _outputName, stage, state, ctx) {\n        return ctx.resolve(block, \"input\", stage, state);\n    },\n};\n"],"names":[],"mappings":"AAEO,MAAM,UAAwB;AAAA,EACjC,WAAW;AAAA,EACX,KAAK,OAAO,aAAa,OAAO,OAAO,KAAK;AACxC,WAAO,IAAI,QAAQ,OAAO,SAAS,OAAO,KAAK;AAAA,EACnD;AACJ;"}

package/emissive-fragment-BnNvbBCw.js

@@ -0,0 +1,39 @@
+import { aK as PBR_HAS_EMISSIVE_COLOR, aL as PBR_HAS_EMISSIVE } from "./index-C8HOR2sB.js";
+function createEmissiveColorFragment(hasEmissiveTexture) {
+  return {
+    _id: "emissive-color",
+    _uboFields: [
+      { _name: "emissiveColor", _type: "vec3<f32>" },
+      { _name: "_emissiveColorPad", _type: "f32" }
+    ],
+    _fragmentSlots: {
+      AT: hasEmissiveTexture ? `let emissive = material.emissiveColor * textureSample(emissiveTexture, emissiveSampler, input.uv).rgb;` : `let emissive = material.emissiveColor;`
+    }
+  };
+}
+function writeEmissiveUBO(data, material, offsets) {
+  if (!material.emissiveColor || !offsets.has("emissiveColor")) {
+    return;
+  }
+  const off = offsets.get("emissiveColor") / 4;
+  data[off] = material.emissiveColor[0];
+  data[off + 1] = material.emissiveColor[1];
+  data[off + 2] = material.emissiveColor[2];
+}
+const pbrExt = {
+  id: "emissive-color",
+  phase: "fragment",
+  frag(ctx) {
+    if (!(ctx._features & PBR_HAS_EMISSIVE_COLOR)) {
+      return null;
+    }
+    return createEmissiveColorFragment((ctx._features & PBR_HAS_EMISSIVE) !== 0);
+  },
+  writeUbo: writeEmissiveUBO
+};
+export {
+  createEmissiveColorFragment,
+  pbrExt,
+  writeEmissiveUBO
+};
+//# sourceMappingURL=emissive-fragment-BnNvbBCw.js.map

package/emissive-fragment-BnNvbBCw.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"emissive-fragment-BnNvbBCw.js","sources":["../src/material/pbr/fragments/emissive-fragment.ts"],"sourcesContent":["/**\n * Emissive Color Fragment\n *\n * Adds an emissiveColor vec3 uniform to MeshUniforms and uses it\n * in the fragment shader's emissive computation.\n *\n * Zero bytes in bundles for scenes that don't use emissive color.\n */\n\nimport type { ShaderFragment } from \"../../../shader/fragment-types.js\";\nimport type { PbrMaterialProps } from \"../pbr-material.js\";\nimport type { PbrExt } from \"../pbr-flags.js\";\nimport { PBR_HAS_EMISSIVE_COLOR, PBR_HAS_EMISSIVE } from \"../pbr-flag-bits.js\";\n\n/**\n * Create an emissive-color fragment.\n * @param hasEmissiveTexture - Whether the material also has an emissive texture.\n */\nexport function createEmissiveColorFragment(hasEmissiveTexture: boolean): ShaderFragment {\n    return {\n        _id: \"emissive-color\",\n\n        _uboFields: [\n            { _name: \"emissiveColor\", _type: \"vec3<f32>\" },\n            { _name: \"_emissiveColorPad\", _type: \"f32\" },\n        ],\n\n        _fragmentSlots: {\n            AT: hasEmissiveTexture\n                ? `let emissive = material.emissiveColor * textureSample(emissiveTexture, emissiveSampler, input.uv).rgb;`\n                : `let emissive = material.emissiveColor;`,\n        },\n    };\n}\n\n/** Write the emissive-color material-UBO slice. */\nexport function writeEmissiveUBO(data: Float32Array, material: PbrMaterialProps, offsets: ReadonlyMap<string, number>): void {\n    if (!material.emissiveColor || !offsets.has(\"emissiveColor\")) {\n        return;\n    }\n    const off = offsets.get(\"emissiveColor\")! / 4;\n    data[off] = material.emissiveColor[0]!;\n    data[off + 1] = material.emissiveColor[1]!;\n    data[off + 2] = material.emissiveColor[2]!;\n}\n\nexport const pbrExt: PbrExt = {\n    id: \"emissive-color\",\n    phase: \"fragment\",\n    frag(ctx) {\n        if (!(ctx._features & PBR_HAS_EMISSIVE_COLOR)) {\n            return null;\n        }\n        return createEmissiveColorFragment((ctx._features & PBR_HAS_EMISSIVE) !== 0);\n    },\n    writeUbo: writeEmissiveUBO as PbrExt[\"writeUbo\"],\n};\n"],"names":[],"mappings":";AAkBO,SAAS,4BAA4B,oBAA6C;AACrF,SAAO;AAAA,IACH,KAAK;AAAA,IAEL,YAAY;AAAA,MACR,EAAE,OAAO,iBAAiB,OAAO,YAAA;AAAA,MACjC,EAAE,OAAO,qBAAqB,OAAO,MAAA;AAAA,IAAM;AAAA,IAG/C,gBAAgB;AAAA,MACZ,IAAI,qBACE,2GACA;AAAA,IAAA;AAAA,EACV;AAER;AAGO,SAAS,iBAAiB,MAAoB,UAA4B,SAA4C;AACzH,MAAI,CAAC,SAAS,iBAAiB,CAAC,QAAQ,IAAI,eAAe,GAAG;AAC1D;AAAA,EACJ;AACA,QAAM,MAAM,QAAQ,IAAI,eAAe,IAAK;AAC5C,OAAK,GAAG,IAAI,SAAS,cAAc,CAAC;AACpC,OAAK,MAAM,CAAC,IAAI,SAAS,cAAc,CAAC;AACxC,OAAK,MAAM,CAAC,IAAI,SAAS,cAAc,CAAC;AAC5C;AAEO,MAAM,SAAiB;AAAA,EAC1B,IAAI;AAAA,EACJ,OAAO;AAAA,EACP,KAAK,KAAK;AACN,QAAI,EAAE,IAAI,YAAY,yBAAyB;AAC3C,aAAO;AAAA,IACX;AACA,WAAO,6BAA6B,IAAI,YAAY,sBAAsB,CAAC;AAAA,EAC/E;AAAA,EACA,UAAU;AACd;"}

package/esm-shadow-view-DGKdF1NI.js

@@ -0,0 +1,18 @@
+import { Q as createMaterialView, U as PBR2_ESM_SHADOW_OUTPUT, V as PBR_HAS_ALPHA_BLEND } from "./index-C8HOR2sB.js";
+const PBR_ESM_SHADOW_DEPTH_CODE = `let depthMetricSM = (input.clipPos.z + shadowParams.depthValues.x) / shadowParams.depthValues.y + shadowParams.biasAndScale.x;
+let depthSM = clamp(exp(-min(87.0, shadowParams.biasAndScale.z * depthMetricSM)), 0.0, 1.0);
+return vec4<f32>(depthSM, 1.0, 1.0, 1.0);`;
+function createPbrEsmShadowMaterialView(source, shadowParamsUBO) {
+  const features = source._renderFeatures ?? { features: 0, features2: 0 };
+  const view = createMaterialView(source, {
+    features: features.features & ~PBR_HAS_ALPHA_BLEND,
+    features2: (features.features2 ?? 0) | PBR2_ESM_SHADOW_OUTPUT
+  });
+  Object.defineProperty(view, "_esmShadowParamsUBO", { value: shadowParamsUBO, enumerable: false });
+  Object.defineProperty(view, "_esmShadowDepthCode", { value: PBR_ESM_SHADOW_DEPTH_CODE, enumerable: false });
+  return view;
+}
+export {
+  createPbrEsmShadowMaterialView
+};
+//# sourceMappingURL=esm-shadow-view-DGKdF1NI.js.map

package/esm-shadow-view-DGKdF1NI.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"esm-shadow-view-DGKdF1NI.js","sources":["../src/material/pbr/esm-shadow-view.ts"],"sourcesContent":["/** PBR material view helper that writes ESM shadow color. */\n\nimport { createMaterialView } from \"../material-view.js\";\nimport type { MaterialView } from \"../material.js\";\nimport { PBR_HAS_ALPHA_BLEND, PBR2_ESM_SHADOW_OUTPUT } from \"./pbr-flags.js\";\nimport type { PbrMaterialProps } from \"./pbr-material.js\";\n\nexport interface PbrEsmShadowMaterialView extends MaterialView {\n    /** @internal */\n    readonly _esmShadowParamsUBO: GPUBuffer;\n    /** @internal */\n    readonly _esmShadowDepthCode: string;\n}\n\nconst PBR_ESM_SHADOW_DEPTH_CODE = `let depthMetricSM = (input.clipPos.z + shadowParams.depthValues.x) / shadowParams.depthValues.y + shadowParams.biasAndScale.x;\nlet depthSM = clamp(exp(-min(87.0, shadowParams.biasAndScale.z * depthMetricSM)), 0.0, 1.0);\nreturn vec4<f32>(depthSM, 1.0, 1.0, 1.0);`;\n\nexport function createPbrEsmShadowMaterialView(source: PbrMaterialProps, shadowParamsUBO: GPUBuffer): PbrEsmShadowMaterialView {\n    const features = source._renderFeatures ?? { features: 0, features2: 0 };\n    const view = createMaterialView(source, {\n        features: features.features & ~PBR_HAS_ALPHA_BLEND,\n        features2: (features.features2 ?? 0) | PBR2_ESM_SHADOW_OUTPUT,\n    }) as PbrEsmShadowMaterialView;\n    Object.defineProperty(view, \"_esmShadowParamsUBO\", { value: shadowParamsUBO, enumerable: false });\n    Object.defineProperty(view, \"_esmShadowDepthCode\", { value: PBR_ESM_SHADOW_DEPTH_CODE, enumerable: false });\n    return view;\n}\n"],"names":[],"mappings":";AAcA,MAAM,4BAA4B;AAAA;AAAA;AAI3B,SAAS,+BAA+B,QAA0B,iBAAsD;AAC3H,QAAM,WAAW,OAAO,mBAAmB,EAAE,UAAU,GAAG,WAAW,EAAA;AACrE,QAAM,OAAO,mBAAmB,QAAQ;AAAA,IACpC,UAAU,SAAS,WAAW,CAAC;AAAA,IAC/B,YAAY,SAAS,aAAa,KAAK;AAAA,EAAA,CAC1C;AACD,SAAO,eAAe,MAAM,uBAAuB,EAAE,OAAO,iBAAiB,YAAY,OAAO;AAChG,SAAO,eAAe,MAAM,uBAAuB,EAAE,OAAO,2BAA2B,YAAY,OAAO;AAC1G,SAAO;AACX;"}

package/esm-shadow-view-DN9HIaM4.js

@@ -0,0 +1,15 @@
+import { Q as createMaterialView, N as NODE_ESM_SHADOW_OUTPUT } from "./index-C8HOR2sB.js";
+const NODE_ESM_SHADOW_DEPTH_CODE = `let depthMetricSM = (in.position.z + nmeShadowParams.depthValues.x) / nmeShadowParams.depthValues.y + nmeShadowParams.biasAndScale.x;
+let depthSM = clamp(exp(-min(87.0, nmeShadowParams.biasAndScale.z * depthMetricSM)), 0.0, 1.0);
+return vec4<f32>(depthSM, 1.0, 1.0, 1.0);`;
+function createNodeEsmShadowMaterialView(source, shadowParamsUBO) {
+  const features = source._renderFeatures ?? { features: 0 };
+  const view = createMaterialView(source, { features: features.features | NODE_ESM_SHADOW_OUTPUT });
+  Object.defineProperty(view, "_esmShadowParamsUBO", { value: shadowParamsUBO, enumerable: false });
+  Object.defineProperty(view, "_esmShadowDepthCode", { value: NODE_ESM_SHADOW_DEPTH_CODE, enumerable: false });
+  return view;
+}
+export {
+  createNodeEsmShadowMaterialView
+};
+//# sourceMappingURL=esm-shadow-view-DN9HIaM4.js.map

package/esm-shadow-view-DN9HIaM4.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"esm-shadow-view-DN9HIaM4.js","sources":["../src/material/node/esm-shadow-view.ts"],"sourcesContent":["/** NodeMaterial view helper that writes ESM shadow color. */\n\nimport { createMaterialView } from \"../material-view.js\";\nimport type { MaterialView } from \"../material.js\";\nimport { NODE_ESM_SHADOW_OUTPUT } from \"./node-flags.js\";\nimport type { NodeMaterial } from \"./node-material.js\";\n\nexport interface NodeEsmShadowMaterialView extends MaterialView {\n    /** @internal */\n    readonly _esmShadowParamsUBO: GPUBuffer;\n    /** @internal */\n    readonly _esmShadowDepthCode: string;\n}\n\nconst NODE_ESM_SHADOW_DEPTH_CODE = `let depthMetricSM = (in.position.z + nmeShadowParams.depthValues.x) / nmeShadowParams.depthValues.y + nmeShadowParams.biasAndScale.x;\nlet depthSM = clamp(exp(-min(87.0, nmeShadowParams.biasAndScale.z * depthMetricSM)), 0.0, 1.0);\nreturn vec4<f32>(depthSM, 1.0, 1.0, 1.0);`;\n\nexport function createNodeEsmShadowMaterialView(source: NodeMaterial, shadowParamsUBO: GPUBuffer): NodeEsmShadowMaterialView {\n    const features = source._renderFeatures ?? { features: 0 };\n    const view = createMaterialView(source, { features: features.features | NODE_ESM_SHADOW_OUTPUT }) as NodeEsmShadowMaterialView;\n    Object.defineProperty(view, \"_esmShadowParamsUBO\", { value: shadowParamsUBO, enumerable: false });\n    Object.defineProperty(view, \"_esmShadowDepthCode\", { value: NODE_ESM_SHADOW_DEPTH_CODE, enumerable: false });\n    return view;\n}\n"],"names":[],"mappings":";AAcA,MAAM,6BAA6B;AAAA;AAAA;AAI5B,SAAS,gCAAgC,QAAsB,iBAAuD;AACzH,QAAM,WAAW,OAAO,mBAAmB,EAAE,UAAU,EAAA;AACvD,QAAM,OAAO,mBAAmB,QAAQ,EAAE,UAAU,SAAS,WAAW,wBAAwB;AAChG,SAAO,eAAe,MAAM,uBAAuB,EAAE,OAAO,iBAAiB,YAAY,OAAO;AAChG,SAAO,eAAe,MAAM,uBAAuB,EAAE,OAAO,4BAA4B,YAAY,OAAO;AAC3G,SAAO;AACX;"}

package/esm-shadow-view-Dk9NFtLq.js

@@ -0,0 +1,15 @@
+import { Q as createMaterialView, R as ESM_SHADOW_OUTPUT, S as MATERIAL_ALPHA_BLEND } from "./index-C8HOR2sB.js";
+const STANDARD_ESM_SHADOW_DEPTH_CODE = `let depthMetricSM = (input.clipPos.z + shadowParams.depthValues.x) / shadowParams.depthValues.y + shadowParams.biasAndScale.x;
+let depthSM = clamp(exp(-min(87.0, shadowParams.biasAndScale.z * depthMetricSM)), 0.0, 1.0);
+return vec4<f32>(depthSM, 1.0, 1.0, 1.0);`;
+function createStandardEsmShadowMaterialView(source, shadowParamsUBO) {
+  const features = source._renderFeatures ?? { features: 0 };
+  const view = createMaterialView(source, { features: features.features & ~MATERIAL_ALPHA_BLEND | ESM_SHADOW_OUTPUT });
+  Object.defineProperty(view, "_esmShadowParamsUBO", { value: shadowParamsUBO, enumerable: false });
+  Object.defineProperty(view, "_esmShadowDepthCode", { value: STANDARD_ESM_SHADOW_DEPTH_CODE, enumerable: false });
+  return view;
+}
+export {
+  createStandardEsmShadowMaterialView
+};
+//# sourceMappingURL=esm-shadow-view-Dk9NFtLq.js.map

package/esm-shadow-view-Dk9NFtLq.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"esm-shadow-view-Dk9NFtLq.js","sources":["../src/material/standard/esm-shadow-view.ts"],"sourcesContent":["/** Standard material view helper that writes ESM shadow color. */\n\nimport { createMaterialView } from \"../material-view.js\";\nimport type { MaterialView } from \"../material.js\";\nimport { ESM_SHADOW_OUTPUT, MATERIAL_ALPHA_BLEND } from \"./standard-flags.js\";\nimport type { StandardMaterialProps } from \"./standard-material.js\";\n\nexport interface StandardEsmShadowMaterialView extends MaterialView {\n    /** @internal */\n    readonly _esmShadowParamsUBO: GPUBuffer;\n    /** @internal */\n    readonly _esmShadowDepthCode: string;\n}\n\nconst STANDARD_ESM_SHADOW_DEPTH_CODE = `let depthMetricSM = (input.clipPos.z + shadowParams.depthValues.x) / shadowParams.depthValues.y + shadowParams.biasAndScale.x;\nlet depthSM = clamp(exp(-min(87.0, shadowParams.biasAndScale.z * depthMetricSM)), 0.0, 1.0);\nreturn vec4<f32>(depthSM, 1.0, 1.0, 1.0);`;\n\nexport function createStandardEsmShadowMaterialView(source: StandardMaterialProps, shadowParamsUBO: GPUBuffer): StandardEsmShadowMaterialView {\n    const features = source._renderFeatures ?? { features: 0 };\n    const view = createMaterialView(source, { features: (features.features & ~MATERIAL_ALPHA_BLEND) | ESM_SHADOW_OUTPUT }) as StandardEsmShadowMaterialView;\n    Object.defineProperty(view, \"_esmShadowParamsUBO\", { value: shadowParamsUBO, enumerable: false });\n    Object.defineProperty(view, \"_esmShadowDepthCode\", { value: STANDARD_ESM_SHADOW_DEPTH_CODE, enumerable: false });\n    return view;\n}\n"],"names":[],"mappings":";AAcA,MAAM,iCAAiC;AAAA;AAAA;AAIhC,SAAS,oCAAoC,QAA+B,iBAA2D;AAC1I,QAAM,WAAW,OAAO,mBAAmB,EAAE,UAAU,EAAA;AACvD,QAAM,OAAO,mBAAmB,QAAQ,EAAE,UAAW,SAAS,WAAW,CAAC,uBAAwB,mBAAmB;AACrH,SAAO,eAAe,MAAM,uBAAuB,EAAE,OAAO,iBAAiB,YAAY,OAAO;AAChG,SAAO,eAAe,MAAM,uBAAuB,EAAE,OAAO,gCAAgC,YAAY,OAAO;AAC/G,SAAO;AACX;"}

package/fog-block-DJ9hEolm.js

@@ -0,0 +1,41 @@
+const FOG_HELPER_KEY = "nme_fog";
+const FOG_HELPER_WGSL = `
+fn nme_fogFactor(worldPos: vec3<f32>, cameraPos: vec3<f32>, fogParams: vec4<f32>) -> f32 {
+    let dist = distance(worldPos, cameraPos);
+    let mode = fogParams.x;
+    let density = fogParams.y;
+    let fstart = fogParams.z;
+    let fend = fogParams.w;
+    // mode: 1=EXP, 2=EXP2, 3=LINEAR
+    if (mode < 1.5) {
+        return clamp(exp(-dist * density), 0.0, 1.0);
+    }
+    if (mode < 2.5) {
+        let d = dist * density;
+        return clamp(exp(-d * d), 0.0, 1.0);
+    }
+    return clamp((fend - dist) / (fend - fstart), 0.0, 1.0);
+}
+`;
+const emitter = {
+  className: "FogBlock",
+  stage: "fragment",
+  emit(block, _outputName, stage, state, ctx) {
+    state.fragment.helpers.set(FOG_HELPER_KEY, FOG_HELPER_WGSL);
+    const wp = ctx.cast(ctx.resolve(block, "worldPosition", stage, state), "vec3f").expr;
+    const input = ctx.resolve(block, "input", stage, state);
+    const fogColor = ctx.cast(ctx.resolve(block, "fogColor", stage, state), "vec3f").expr;
+    const inType = input.type === "vec4f" ? "vec4f" : "vec3f";
+    const inVec3 = ctx.cast(input, "vec3f").expr;
+    const factor = `nme_fogFactor(${wp}, _NME_CAMERA_POS_, _NME_FOG_PARAMS_)`;
+    const mixed = `mix(${fogColor}, ${inVec3}, ${factor})`;
+    if (inType === "vec4f") {
+      return { expr: `vec4<f32>(${mixed}, (${input.expr}).w)`, type: "vec4f" };
+    }
+    return { expr: mixed, type: "vec3f" };
+  }
+};
+export {
+  emitter
+};
+//# sourceMappingURL=fog-block-DJ9hEolm.js.map

package/fog-block-DJ9hEolm.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fog-block-DJ9hEolm.js","sources":["../src/material/node/blocks/fog-block.ts"],"sourcesContent":["/** FogBlock — standard Babylon fog blend.\n *\n *  Inputs: worldPosition, view (optional), input (color to blend), fogColor.\n *  Outputs: output (vec3 or vec4 matching `input`).\n *\n *  Scene-provided sentinels: `_NME_FOG_PARAMS_` (vec4: mode, density, start, end)\n *  and `_NME_CAMERA_POS_`. The pipeline builder wires these to the scene UBOs.\n */\n\nimport type { BlockEmitter } from \"../node-types.js\";\n\nconst FOG_HELPER_KEY = \"nme_fog\";\nconst FOG_HELPER_WGSL = `\nfn nme_fogFactor(worldPos: vec3<f32>, cameraPos: vec3<f32>, fogParams: vec4<f32>) -> f32 {\n    let dist = distance(worldPos, cameraPos);\n    let mode = fogParams.x;\n    let density = fogParams.y;\n    let fstart = fogParams.z;\n    let fend = fogParams.w;\n    // mode: 1=EXP, 2=EXP2, 3=LINEAR\n    if (mode < 1.5) {\n        return clamp(exp(-dist * density), 0.0, 1.0);\n    }\n    if (mode < 2.5) {\n        let d = dist * density;\n        return clamp(exp(-d * d), 0.0, 1.0);\n    }\n    return clamp((fend - dist) / (fend - fstart), 0.0, 1.0);\n}\n`;\n\nexport const emitter: BlockEmitter = {\n    className: \"FogBlock\",\n    stage: \"fragment\",\n    emit(block, _outputName, stage, state, ctx) {\n        state.fragment.helpers.set(FOG_HELPER_KEY, FOG_HELPER_WGSL);\n        const wp = ctx.cast(ctx.resolve(block, \"worldPosition\", stage, state), \"vec3f\").expr;\n        const input = ctx.resolve(block, \"input\", stage, state);\n        const fogColor = ctx.cast(ctx.resolve(block, \"fogColor\", stage, state), \"vec3f\").expr;\n        const inType = input.type === \"vec4f\" ? \"vec4f\" : \"vec3f\";\n        const inVec3 = ctx.cast(input, \"vec3f\").expr;\n        const factor = `nme_fogFactor(${wp}, _NME_CAMERA_POS_, _NME_FOG_PARAMS_)`;\n        const mixed = `mix(${fogColor}, ${inVec3}, ${factor})`;\n        if (inType === \"vec4f\") {\n            return { expr: `vec4<f32>(${mixed}, (${input.expr}).w)`, type: \"vec4f\" };\n        }\n        return { expr: mixed, type: \"vec3f\" };\n    },\n};\n"],"names":[],"mappings":"AAWA,MAAM,iBAAiB;AACvB,MAAM,kBAAkB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAmBjB,MAAM,UAAwB;AAAA,EACjC,WAAW;AAAA,EACX,OAAO;AAAA,EACP,KAAK,OAAO,aAAa,OAAO,OAAO,KAAK;AACxC,UAAM,SAAS,QAAQ,IAAI,gBAAgB,eAAe;AAC1D,UAAM,KAAK,IAAI,KAAK,IAAI,QAAQ,OAAO,iBAAiB,OAAO,KAAK,GAAG,OAAO,EAAE;AAChF,UAAM,QAAQ,IAAI,QAAQ,OAAO,SAAS,OAAO,KAAK;AACtD,UAAM,WAAW,IAAI,KAAK,IAAI,QAAQ,OAAO,YAAY,OAAO,KAAK,GAAG,OAAO,EAAE;AACjF,UAAM,SAAS,MAAM,SAAS,UAAU,UAAU;AAClD,UAAM,SAAS,IAAI,KAAK,OAAO,OAAO,EAAE;AACxC,UAAM,SAAS,iBAAiB,EAAE;AAClC,UAAM,QAAQ,OAAO,QAAQ,KAAK,MAAM,KAAK,MAAM;AACnD,QAAI,WAAW,SAAS;AACpB,aAAO,EAAE,MAAM,aAAa,KAAK,MAAM,MAAM,IAAI,QAAQ,MAAM,QAAA;AAAA,IACnE;AACA,WAAO,EAAE,MAAM,OAAO,MAAM,QAAA;AAAA,EAChC;AACJ;"}

package/frag-coord-block-DzXfFgfV.js

@@ -0,0 +1,25 @@
+const OUTPUTS = {
+  xyzw: { swizzle: "", type: "vec4f" },
+  xyz: { swizzle: ".xyz", type: "vec3f" },
+  xy: { swizzle: ".xy", type: "vec2f" },
+  x: { swizzle: ".x", type: "f32" },
+  y: { swizzle: ".y", type: "f32" },
+  z: { swizzle: ".z", type: "f32" },
+  w: { swizzle: ".w", type: "f32" }
+};
+const emitter = {
+  className: "FragCoordBlock",
+  stage: "fragment",
+  emit(_block, outputName, _stage, state) {
+    state.usesScreenSize = true;
+    const out = OUTPUTS[outputName];
+    if (!out) {
+      throw new Error(`NodeMaterial: FragCoordBlock has no output "${outputName}"`);
+    }
+    return { expr: `vec4<f32>(_NME_FRAG_COORD_.x, _NME_SCREEN_SIZE_.y - _NME_FRAG_COORD_.y, 1.0 - _NME_FRAG_COORD_.z, _NME_FRAG_COORD_.w)${out.swizzle}`, type: out.type };
+  }
+};
+export {
+  emitter
+};
+//# sourceMappingURL=frag-coord-block-DzXfFgfV.js.map

package/frag-coord-block-DzXfFgfV.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"frag-coord-block-DzXfFgfV.js","sources":["../src/material/node/blocks/frag-coord-block.ts"],"sourcesContent":["/** FragCoordBlock — exposes fragment pixel coordinates (`fragmentInputs.position` in BJS WGSL). */\n\nimport type { BlockEmitter, NodeValueType } from \"../node-types.js\";\n\nconst OUTPUTS: Record<string, { readonly swizzle: string; readonly type: NodeValueType }> = {\n    xyzw: { swizzle: \"\", type: \"vec4f\" },\n    xyz: { swizzle: \".xyz\", type: \"vec3f\" },\n    xy: { swizzle: \".xy\", type: \"vec2f\" },\n    x: { swizzle: \".x\", type: \"f32\" },\n    y: { swizzle: \".y\", type: \"f32\" },\n    z: { swizzle: \".z\", type: \"f32\" },\n    w: { swizzle: \".w\", type: \"f32\" },\n};\n\nexport const emitter: BlockEmitter = {\n    className: \"FragCoordBlock\",\n    stage: \"fragment\",\n    emit(_block, outputName, _stage, state) {\n        // Babylon.js keeps NME FragCoord aligned with the historical WebGL\n        // gl_FragCoord convention (bottom-left origin). WebGPU's fragment\n        // position is top-left origin, so flip only the y component here.\n        state.usesScreenSize = true;\n        const out = OUTPUTS[outputName];\n        if (!out) {\n            throw new Error(`NodeMaterial: FragCoordBlock has no output \"${outputName}\"`);\n        }\n        return { expr: `vec4<f32>(_NME_FRAG_COORD_.x, _NME_SCREEN_SIZE_.y - _NME_FRAG_COORD_.y, 1.0 - _NME_FRAG_COORD_.z, _NME_FRAG_COORD_.w)${out.swizzle}`, type: out.type };\n    },\n};\n"],"names":[],"mappings":"AAIA,MAAM,UAAsF;AAAA,EACxF,MAAM,EAAE,SAAS,IAAI,MAAM,QAAA;AAAA,EAC3B,KAAK,EAAE,SAAS,QAAQ,MAAM,QAAA;AAAA,EAC9B,IAAI,EAAE,SAAS,OAAO,MAAM,QAAA;AAAA,EAC5B,GAAG,EAAE,SAAS,MAAM,MAAM,MAAA;AAAA,EAC1B,GAAG,EAAE,SAAS,MAAM,MAAM,MAAA;AAAA,EAC1B,GAAG,EAAE,SAAS,MAAM,MAAM,MAAA;AAAA,EAC1B,GAAG,EAAE,SAAS,MAAM,MAAM,MAAA;AAC9B;AAEO,MAAM,UAAwB;AAAA,EACjC,WAAW;AAAA,EACX,OAAO;AAAA,EACP,KAAK,QAAQ,YAAY,QAAQ,OAAO;AAIpC,UAAM,iBAAiB;AACvB,UAAM,MAAM,QAAQ,UAAU;AAC9B,QAAI,CAAC,KAAK;AACN,YAAM,IAAI,MAAM,+CAA+C,UAAU,GAAG;AAAA,IAChF;AACA,WAAO,EAAE,MAAM,wHAAwH,IAAI,OAAO,IAAI,MAAM,IAAI,KAAA;AAAA,EACpK;AACJ;"}

package/frag-depth-block-UQbeKP2D.js

@@ -0,0 +1,34 @@
+const emitter = {
+  className: "FragDepthBlock",
+  stage: "fragment",
+  sideEffect: true,
+  emit(block, _outputName, stage, state, ctx) {
+    var _a, _b;
+    const memoKey = `${block.id}|fragDepth`;
+    const existing = state.fragment.memo.get(memoKey);
+    if (existing) {
+      return existing;
+    }
+    state.usesFragDepth = true;
+    const depthConn = block.inputs.get("depth");
+    if (depthConn == null ? void 0 : depthConn.source) {
+      const depth = ctx.cast(ctx.resolve(block, "depth", stage, state), "f32");
+      state.fragment.body.push(`_NME_FRAG_DEPTH_ = 1.0 - (${depth.expr});`);
+    } else if (((_a = block.inputs.get("worldPos")) == null ? void 0 : _a.source) && ((_b = block.inputs.get("viewProjection")) == null ? void 0 : _b.source)) {
+      const worldPos = ctx.cast(ctx.resolve(block, "worldPos", stage, state), "vec4f");
+      const viewProjection = ctx.cast(ctx.resolve(block, "viewProjection", stage, state), "mat4f");
+      const p = ctx.temp(state, "fragDepthP");
+      state.fragment.body.push(`let ${p} = ${viewProjection.expr} * ${worldPos.expr};`);
+      state.fragment.body.push(`_NME_FRAG_DEPTH_ = ${p}.z / ${p}.w;`);
+    } else {
+      throw new Error("NodeMaterial: FragDepthBlock requires `depth` or both `worldPos` and `viewProjection` inputs");
+    }
+    const result = { expr: "_NME_FRAG_DEPTH_", type: "f32" };
+    state.fragment.memo.set(memoKey, result);
+    return result;
+  }
+};
+export {
+  emitter
+};
+//# sourceMappingURL=frag-depth-block-UQbeKP2D.js.map

package/frag-depth-block-UQbeKP2D.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"frag-depth-block-UQbeKP2D.js","sources":["../src/material/node/blocks/frag-depth-block.ts"],"sourcesContent":["/** FragDepthBlock — writes `@builtin(frag_depth)` from a depth scalar or worldPos/viewProjection pair. */\n\nimport type { BlockEmitter } from \"../node-types.js\";\n\nexport const emitter: BlockEmitter = {\n    className: \"FragDepthBlock\",\n    stage: \"fragment\",\n    sideEffect: true,\n    emit(block, _outputName, stage, state, ctx) {\n        const memoKey = `${block.id}|fragDepth`;\n        const existing = state.fragment.memo.get(memoKey);\n        if (existing) {\n            return existing;\n        }\n        state.usesFragDepth = true;\n        const depthConn = block.inputs.get(\"depth\");\n        if (depthConn?.source) {\n            const depth = ctx.cast(ctx.resolve(block, \"depth\", stage, state), \"f32\");\n            state.fragment.body.push(`_NME_FRAG_DEPTH_ = 1.0 - (${depth.expr});`);\n        } else if (block.inputs.get(\"worldPos\")?.source && block.inputs.get(\"viewProjection\")?.source) {\n            const worldPos = ctx.cast(ctx.resolve(block, \"worldPos\", stage, state), \"vec4f\");\n            const viewProjection = ctx.cast(ctx.resolve(block, \"viewProjection\", stage, state), \"mat4f\");\n            const p = ctx.temp(state, \"fragDepthP\");\n            state.fragment.body.push(`let ${p} = ${viewProjection.expr} * ${worldPos.expr};`);\n            state.fragment.body.push(`_NME_FRAG_DEPTH_ = ${p}.z / ${p}.w;`);\n        } else {\n            throw new Error(\"NodeMaterial: FragDepthBlock requires `depth` or both `worldPos` and `viewProjection` inputs\");\n        }\n        const result = { expr: \"_NME_FRAG_DEPTH_\", type: \"f32\" as const };\n        state.fragment.memo.set(memoKey, result);\n        return result;\n    },\n};\n"],"names":[],"mappings":"AAIO,MAAM,UAAwB;AAAA,EACjC,WAAW;AAAA,EACX,OAAO;AAAA,EACP,YAAY;AAAA,EACZ,KAAK,OAAO,aAAa,OAAO,OAAO,KAAK;AAJzC;AAKC,UAAM,UAAU,GAAG,MAAM,EAAE;AAC3B,UAAM,WAAW,MAAM,SAAS,KAAK,IAAI,OAAO;AAChD,QAAI,UAAU;AACV,aAAO;AAAA,IACX;AACA,UAAM,gBAAgB;AACtB,UAAM,YAAY,MAAM,OAAO,IAAI,OAAO;AAC1C,QAAI,uCAAW,QAAQ;AACnB,YAAM,QAAQ,IAAI,KAAK,IAAI,QAAQ,OAAO,SAAS,OAAO,KAAK,GAAG,KAAK;AACvE,YAAM,SAAS,KAAK,KAAK,6BAA6B,MAAM,IAAI,IAAI;AAAA,IACxE,aAAW,WAAM,OAAO,IAAI,UAAU,MAA3B,mBAA8B,aAAU,WAAM,OAAO,IAAI,gBAAgB,MAAjC,mBAAoC,SAAQ;AAC3F,YAAM,WAAW,IAAI,KAAK,IAAI,QAAQ,OAAO,YAAY,OAAO,KAAK,GAAG,OAAO;AAC/E,YAAM,iBAAiB,IAAI,KAAK,IAAI,QAAQ,OAAO,kBAAkB,OAAO,KAAK,GAAG,OAAO;AAC3F,YAAM,IAAI,IAAI,KAAK,OAAO,YAAY;AACtC,YAAM,SAAS,KAAK,KAAK,OAAO,CAAC,MAAM,eAAe,IAAI,MAAM,SAAS,IAAI,GAAG;AAChF,YAAM,SAAS,KAAK,KAAK,sBAAsB,CAAC,QAAQ,CAAC,KAAK;AAAA,IAClE,OAAO;AACH,YAAM,IAAI,MAAM,8FAA8F;AAAA,IAClH;AACA,UAAM,SAAS,EAAE,MAAM,oBAAoB,MAAM,MAAA;AACjD,UAAM,SAAS,KAAK,IAAI,SAAS,MAAM;AACvC,WAAO;AAAA,EACX;AACJ;"}

package/fragment-output-BOphkIeh.js

@@ -0,0 +1,26 @@
+const emitter = {
+  className: "FragmentOutputBlock",
+  stage: "fragment",
+  emit(block, _outputName, stage, state, ctx) {
+    const rgbaConn = block.inputs.get("rgba");
+    let finalVec4;
+    if (rgbaConn && rgbaConn.source) {
+      const v = ctx.resolve(block, "rgba", stage, state);
+      finalVec4 = ctx.cast(v, "vec4f");
+    } else {
+      const rgbConn = block.inputs.get("rgb");
+      const aConn = block.inputs.get("a");
+      const rgb = rgbConn && rgbConn.source ? ctx.cast(ctx.resolve(block, "rgb", stage, state), "vec3f") : { expr: "vec3<f32>(0.0, 0.0, 0.0)" };
+      const a = aConn && aConn.source ? ctx.cast(ctx.resolve(block, "a", stage, state), "f32") : { expr: "1.0" };
+      finalVec4 = { expr: `vec4<f32>(${rgb.expr}, ${a.expr})`, type: "vec4f" };
+    }
+    const t = ctx.temp(state, "frag");
+    state.fragment.body.push(`let ${t} = ${finalVec4.expr};`);
+    state.fragment.body.push(`_NME_FRAG_OUTPUT_ = ${t};`);
+    return { expr: t, type: "vec4f" };
+  }
+};
+export {
+  emitter
+};
+//# sourceMappingURL=fragment-output-BOphkIeh.js.map

package/fragment-output-BOphkIeh.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fragment-output-BOphkIeh.js","sources":["../src/material/node/blocks/fragment-output.ts"],"sourcesContent":["/** FragmentOutputBlock emitter.\n *\n *  The fragment root. Reads the `rgba` (or `rgb` + `a`) input, casts to vec4,\n *  and writes it to the fragment main body via an SSA temp so the pipeline\n *  scaffold can emit `return finalColor;`.\n */\n\nimport type { BlockEmitter } from \"../node-types.js\";\n\nexport const emitter: BlockEmitter = {\n    className: \"FragmentOutputBlock\",\n    stage: \"fragment\",\n    emit(block, _outputName, stage, state, ctx) {\n        // rgba takes precedence; otherwise combine rgb + a.\n        const rgbaConn = block.inputs.get(\"rgba\");\n        let finalVec4;\n        if (rgbaConn && rgbaConn.source) {\n            const v = ctx.resolve(block, \"rgba\", stage, state);\n            finalVec4 = ctx.cast(v, \"vec4f\");\n        } else {\n            const rgbConn = block.inputs.get(\"rgb\");\n            const aConn = block.inputs.get(\"a\");\n            const rgb = rgbConn && rgbConn.source ? ctx.cast(ctx.resolve(block, \"rgb\", stage, state), \"vec3f\") : { expr: \"vec3<f32>(0.0, 0.0, 0.0)\", type: \"vec3f\" as const };\n            const a = aConn && aConn.source ? ctx.cast(ctx.resolve(block, \"a\", stage, state), \"f32\") : { expr: \"1.0\", type: \"f32\" as const };\n            finalVec4 = { expr: `vec4<f32>(${rgb.expr}, ${a.expr})`, type: \"vec4f\" as const };\n        }\n        const t = ctx.temp(state, \"frag\");\n        state.fragment.body.push(`let ${t} = ${finalVec4.expr};`);\n        state.fragment.body.push(`_NME_FRAG_OUTPUT_ = ${t};`);\n        return { expr: t, type: \"vec4f\" };\n    },\n};\n"],"names":[],"mappings":"AASO,MAAM,UAAwB;AAAA,EACjC,WAAW;AAAA,EACX,OAAO;AAAA,EACP,KAAK,OAAO,aAAa,OAAO,OAAO,KAAK;AAExC,UAAM,WAAW,MAAM,OAAO,IAAI,MAAM;AACxC,QAAI;AACJ,QAAI,YAAY,SAAS,QAAQ;AAC7B,YAAM,IAAI,IAAI,QAAQ,OAAO,QAAQ,OAAO,KAAK;AACjD,kBAAY,IAAI,KAAK,GAAG,OAAO;AAAA,IACnC,OAAO;AACH,YAAM,UAAU,MAAM,OAAO,IAAI,KAAK;AACtC,YAAM,QAAQ,MAAM,OAAO,IAAI,GAAG;AAClC,YAAM,MAAM,WAAW,QAAQ,SAAS,IAAI,KAAK,IAAI,QAAQ,OAAO,OAAO,OAAO,KAAK,GAAG,OAAO,IAAI,EAAE,MAAM,2BAAmD;AAChK,YAAM,IAAI,SAAS,MAAM,SAAS,IAAI,KAAK,IAAI,QAAQ,OAAO,KAAK,OAAO,KAAK,GAAG,KAAK,IAAI,EAAE,MAAM,MAA4B;AAC/H,kBAAY,EAAE,MAAM,aAAa,IAAI,IAAI,KAAK,EAAE,IAAI,KAAK,MAAM,QAAA;AAAA,IACnE;AACA,UAAM,IAAI,IAAI,KAAK,OAAO,MAAM;AAChC,UAAM,SAAS,KAAK,KAAK,OAAO,CAAC,MAAM,UAAU,IAAI,GAAG;AACxD,UAAM,SAAS,KAAK,KAAK,uBAAuB,CAAC,GAAG;AACpD,WAAO,EAAE,MAAM,GAAG,MAAM,QAAA;AAAA,EAC5B;AACJ;"}

package/fresnel-block-DefHWeO-.js

@@ -0,0 +1,20 @@
+const HELPER = `fn nme_computeFresnelTerm(viewDirection: vec3<f32>, worldNormal: vec3<f32>, bias: f32, power: f32) -> f32 {
+    let fresnelTerm = pow(bias + abs(dot(viewDirection, worldNormal)), power);
+    return clamp(fresnelTerm, 0.0, 1.0);
+}`;
+const emitter = {
+  className: "FresnelBlock",
+  emit(block, _outputName, stage, state, ctx) {
+    const worldNormal = ctx.cast(ctx.resolve(block, "worldNormal", stage, state), "vec3f").expr;
+    const viewDirection = ctx.cast(ctx.resolve(block, "viewDirection", stage, state), "vec3f").expr;
+    const bias = ctx.cast(ctx.resolve(block, "bias", stage, state), "f32").expr;
+    const power = ctx.cast(ctx.resolve(block, "power", stage, state), "f32").expr;
+    const stageState = stage === "vertex" ? state.vertex : state.fragment;
+    stageState.helpers.set("nme_computeFresnelTerm", HELPER);
+    return { expr: `nme_computeFresnelTerm(${viewDirection}, ${worldNormal}, ${bias}, ${power})`, type: "f32" };
+  }
+};
+export {
+  emitter
+};
+//# sourceMappingURL=fresnel-block-DefHWeO-.js.map

package/fresnel-block-DefHWeO-.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fresnel-block-DefHWeO-.js","sources":["../src/material/node/blocks/fresnel-block.ts"],"sourcesContent":["import type { BlockEmitter } from \"../node-types.js\";\n\nconst HELPER = `fn nme_computeFresnelTerm(viewDirection: vec3<f32>, worldNormal: vec3<f32>, bias: f32, power: f32) -> f32 {\n    let fresnelTerm = pow(bias + abs(dot(viewDirection, worldNormal)), power);\n    return clamp(fresnelTerm, 0.0, 1.0);\n}`;\n\nexport const emitter: BlockEmitter = {\n    className: \"FresnelBlock\",\n    emit(block, _outputName, stage, state, ctx) {\n        const worldNormal = ctx.cast(ctx.resolve(block, \"worldNormal\", stage, state), \"vec3f\").expr;\n        const viewDirection = ctx.cast(ctx.resolve(block, \"viewDirection\", stage, state), \"vec3f\").expr;\n        const bias = ctx.cast(ctx.resolve(block, \"bias\", stage, state), \"f32\").expr;\n        const power = ctx.cast(ctx.resolve(block, \"power\", stage, state), \"f32\").expr;\n        const stageState = stage === \"vertex\" ? state.vertex : state.fragment;\n        stageState.helpers.set(\"nme_computeFresnelTerm\", HELPER);\n        return { expr: `nme_computeFresnelTerm(${viewDirection}, ${worldNormal}, ${bias}, ${power})`, type: \"f32\" };\n    },\n};\n"],"names":[],"mappings":"AAEA,MAAM,SAAS;AAAA;AAAA;AAAA;AAKR,MAAM,UAAwB;AAAA,EACjC,WAAW;AAAA,EACX,KAAK,OAAO,aAAa,OAAO,OAAO,KAAK;AACxC,UAAM,cAAc,IAAI,KAAK,IAAI,QAAQ,OAAO,eAAe,OAAO,KAAK,GAAG,OAAO,EAAE;AACvF,UAAM,gBAAgB,IAAI,KAAK,IAAI,QAAQ,OAAO,iBAAiB,OAAO,KAAK,GAAG,OAAO,EAAE;AAC3F,UAAM,OAAO,IAAI,KAAK,IAAI,QAAQ,OAAO,QAAQ,OAAO,KAAK,GAAG,KAAK,EAAE;AACvE,UAAM,QAAQ,IAAI,KAAK,IAAI,QAAQ,OAAO,SAAS,OAAO,KAAK,GAAG,KAAK,EAAE;AACzE,UAAM,aAAa,UAAU,WAAW,MAAM,SAAS,MAAM;AAC7D,eAAW,QAAQ,IAAI,0BAA0B,MAAM;AACvD,WAAO,EAAE,MAAM,0BAA0B,aAAa,KAAK,WAAW,KAAK,IAAI,KAAK,KAAK,KAAK,MAAM,MAAA;AAAA,EACxG;AACJ;"}

package/front-facing-0d6aiyrv.js

@@ -0,0 +1,11 @@
+const emitter = {
+  className: "FrontFacingBlock",
+  stage: "fragment",
+  emit(_block, _outputName, _stage, _state, _ctx) {
+    return { expr: "select(0.0, 1.0, _NME_FRONT_FACING_)", type: "f32" };
+  }
+};
+export {
+  emitter
+};
+//# sourceMappingURL=front-facing-0d6aiyrv.js.map

package/front-facing-0d6aiyrv.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"front-facing-0d6aiyrv.js","sources":["../src/material/node/blocks/front-facing.ts"],"sourcesContent":["/** FrontFacingBlock — 1.0 if the fragment is front-facing, else 0.0. */\n\nimport type { BlockEmitter } from \"../node-types.js\";\n\nexport const emitter: BlockEmitter = {\n    className: \"FrontFacingBlock\",\n    stage: \"fragment\",\n    emit(_block, _outputName, _stage, _state, _ctx) {\n        // WGSL: `select(0.0, 1.0, frontFacing)` where `frontFacing` is a @builtin(front_facing) bool.\n        // The pipeline builder wires this builtin into the fragment entry-point.\n        return { expr: \"select(0.0, 1.0, _NME_FRONT_FACING_)\", type: \"f32\" };\n    },\n};\n"],"names":[],"mappings":"AAIO,MAAM,UAAwB;AAAA,EACjC,WAAW;AAAA,EACX,OAAO;AAAA,EACP,KAAK,QAAQ,aAAa,QAAQ,QAAQ,MAAM;AAG5C,WAAO,EAAE,MAAM,wCAAwC,MAAM,MAAA;AAAA,EACjE;AACJ;"}