@babylonjs/lite 0.1.1

package/tracking-primitives-wgdBY85t.js

@@ -0,0 +1,82 @@
+import { m as markMaterialUboDirty } from "./index-C8HOR2sB.js";
+function observableColor3(r, g, b, owner) {
+  const arr = [r, g, b];
+  for (let i = 0; i < 3; i++) {
+    let val = arr[i];
+    Object.defineProperty(arr, i, {
+      get() {
+        return val;
+      },
+      set(v) {
+        if (val !== v) {
+          val = v;
+          markMaterialUboDirty(owner);
+        }
+      },
+      configurable: true,
+      enumerable: true
+    });
+  }
+  return arr;
+}
+function observableVec2(x, y, owner) {
+  const arr = [x, y];
+  for (let i = 0; i < 2; i++) {
+    let val = arr[i];
+    Object.defineProperty(arr, i, {
+      get() {
+        return val;
+      },
+      set(v) {
+        if (val !== v) {
+          val = v;
+          markMaterialUboDirty(owner);
+        }
+      },
+      configurable: true,
+      enumerable: true
+    });
+  }
+  return arr;
+}
+function trackScalar(obj, key) {
+  let val = obj[key];
+  Object.defineProperty(obj, key, {
+    get() {
+      return val;
+    },
+    set(v) {
+      if (val !== v) {
+        val = v;
+        markMaterialUboDirty(obj);
+      }
+    },
+    configurable: true,
+    enumerable: true
+  });
+}
+function trackSubProps(parent, sub, keys) {
+  for (const key of keys) {
+    let val = sub[key];
+    Object.defineProperty(sub, key, {
+      get() {
+        return val;
+      },
+      set(v) {
+        if (val !== v) {
+          val = v;
+          markMaterialUboDirty(parent);
+        }
+      },
+      configurable: true,
+      enumerable: true
+    });
+  }
+}
+export {
+  observableVec2 as a,
+  trackSubProps as b,
+  observableColor3 as o,
+  trackScalar as t
+};
+//# sourceMappingURL=tracking-primitives-wgdBY85t.js.map

package/tracking-primitives-wgdBY85t.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tracking-primitives-wgdBY85t.js","sources":["../src/material/tracking/tracking-primitives.ts"],"sourcesContent":["/** Shared tracking primitives for observable material properties. */\n\nimport type { Material } from \"../material.js\";\nimport { markMaterialUboDirty } from \"../material-dirty.js\";\n\nexport function observableColor3(r: number, g: number, b: number, owner: Material): [number, number, number] {\n    const arr = [r, g, b] as [number, number, number];\n    for (let i = 0; i < 3; i++) {\n        let val = arr[i]!;\n        Object.defineProperty(arr, i, {\n            get() {\n                return val;\n            },\n            set(v: number) {\n                if (val !== v) {\n                    val = v;\n                    markMaterialUboDirty(owner);\n                }\n            },\n            configurable: true,\n            enumerable: true,\n        });\n    }\n    return arr;\n}\n\nexport function observableVec2(x: number, y: number, owner: Material): [number, number] {\n    const arr = [x, y] as [number, number];\n    for (let i = 0; i < 2; i++) {\n        let val = arr[i]!;\n        Object.defineProperty(arr, i, {\n            get() {\n                return val;\n            },\n            set(v: number) {\n                if (val !== v) {\n                    val = v;\n                    markMaterialUboDirty(owner);\n                }\n            },\n            configurable: true,\n            enumerable: true,\n        });\n    }\n    return arr;\n}\n\nexport function trackScalar(obj: any, key: string): void {\n    let val = obj[key];\n    Object.defineProperty(obj, key, {\n        get() {\n            return val;\n        },\n        set(v: any) {\n            if (val !== v) {\n                val = v;\n                markMaterialUboDirty(obj as Material);\n            }\n        },\n        configurable: true,\n        enumerable: true,\n    });\n}\n\nexport function trackSubProps(parent: Material, sub: any, keys: string[]): void {\n    for (const key of keys) {\n        let val = sub[key];\n        Object.defineProperty(sub, key, {\n            get() {\n                return val;\n            },\n            set(v: any) {\n                if (val !== v) {\n                    val = v;\n                    markMaterialUboDirty(parent);\n                }\n            },\n            configurable: true,\n            enumerable: true,\n        });\n    }\n}\n"],"names":[],"mappings":";AAKO,SAAS,iBAAiB,GAAW,GAAW,GAAW,OAA2C;AACzG,QAAM,MAAM,CAAC,GAAG,GAAG,CAAC;AACpB,WAAS,IAAI,GAAG,IAAI,GAAG,KAAK;AACxB,QAAI,MAAM,IAAI,CAAC;AACf,WAAO,eAAe,KAAK,GAAG;AAAA,MAC1B,MAAM;AACF,eAAO;AAAA,MACX;AAAA,MACA,IAAI,GAAW;AACX,YAAI,QAAQ,GAAG;AACX,gBAAM;AACN,+BAAqB,KAAK;AAAA,QAC9B;AAAA,MACJ;AAAA,MACA,cAAc;AAAA,MACd,YAAY;AAAA,IAAA,CACf;AAAA,EACL;AACA,SAAO;AACX;AAEO,SAAS,eAAe,GAAW,GAAW,OAAmC;AACpF,QAAM,MAAM,CAAC,GAAG,CAAC;AACjB,WAAS,IAAI,GAAG,IAAI,GAAG,KAAK;AACxB,QAAI,MAAM,IAAI,CAAC;AACf,WAAO,eAAe,KAAK,GAAG;AAAA,MAC1B,MAAM;AACF,eAAO;AAAA,MACX;AAAA,MACA,IAAI,GAAW;AACX,YAAI,QAAQ,GAAG;AACX,gBAAM;AACN,+BAAqB,KAAK;AAAA,QAC9B;AAAA,MACJ;AAAA,MACA,cAAc;AAAA,MACd,YAAY;AAAA,IAAA,CACf;AAAA,EACL;AACA,SAAO;AACX;AAEO,SAAS,YAAY,KAAU,KAAmB;AACrD,MAAI,MAAM,IAAI,GAAG;AACjB,SAAO,eAAe,KAAK,KAAK;AAAA,IAC5B,MAAM;AACF,aAAO;AAAA,IACX;AAAA,IACA,IAAI,GAAQ;AACR,UAAI,QAAQ,GAAG;AACX,cAAM;AACN,6BAAqB,GAAe;AAAA,MACxC;AAAA,IACJ;AAAA,IACA,cAAc;AAAA,IACd,YAAY;AAAA,EAAA,CACf;AACL;AAEO,SAAS,cAAc,QAAkB,KAAU,MAAsB;AAC5E,aAAW,OAAO,MAAM;AACpB,QAAI,MAAM,IAAI,GAAG;AACjB,WAAO,eAAe,KAAK,KAAK;AAAA,MAC5B,MAAM;AACF,eAAO;AAAA,MACX;AAAA,MACA,IAAI,GAAQ;AACR,YAAI,QAAQ,GAAG;AACX,gBAAM;AACN,+BAAqB,MAAM;AAAA,QAC/B;AAAA,MACJ;AAAA,MACA,cAAc;AAAA,MACd,YAAY;AAAA,IAAA,CACf;AAAA,EACL;AACJ;"}

package/transform-block-DbRph9JI.js

@@ -0,0 +1,32 @@
+import { f as formatFloat } from "./_math-factory-C-QqW-Wi.js";
+const emitter = {
+  className: "TransformBlock",
+  stage: "vertex",
+  emit(block, _outputName, stage, state, ctx) {
+    const vector = ctx.resolve(block, "vector", stage, state);
+    const transform = ctx.resolve(block, "transform", stage, state);
+    const wRaw = block.serialized.complementW;
+    const zRaw = block.serialized.complementZ;
+    const cw = formatFloat(typeof wRaw === "number" ? wRaw : 1);
+    const cz = formatFloat(typeof zRaw === "number" ? zRaw : 0);
+    let vec4;
+    switch (vector.type) {
+      case "vec4f":
+        vec4 = vector.expr;
+        break;
+      case "vec3f":
+        vec4 = `vec4<f32>(${vector.expr}, ${cw})`;
+        break;
+      case "vec2f":
+        vec4 = `vec4<f32>(${vector.expr}, ${cz}, ${cw})`;
+        break;
+      default:
+        vec4 = `vec4<f32>(${ctx.cast(vector, "vec3f").expr}, ${cw})`;
+    }
+    return { expr: `(${transform.expr} * ${vec4})`, type: "vec4f" };
+  }
+};
+export {
+  emitter
+};
+//# sourceMappingURL=transform-block-DbRph9JI.js.map

package/transform-block-DbRph9JI.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"transform-block-DbRph9JI.js","sources":["../src/material/node/blocks/transform-block.ts"],"sourcesContent":["/** TransformBlock — matrix * vector.\n *\n *  BJS serializes `complementW` (default 1.0 for positions, 0.0 for directions)\n *  and `complementZ` for 2D-vector → 3D promotion. We honour both.\n */\n\nimport type { BlockEmitter } from \"../node-types.js\";\nimport { formatFloat } from \"./_math-factory.js\";\n\nexport const emitter: BlockEmitter = {\n    className: \"TransformBlock\",\n    stage: \"vertex\",\n    emit(block, _outputName, stage, state, ctx) {\n        const vector = ctx.resolve(block, \"vector\", stage, state);\n        const transform = ctx.resolve(block, \"transform\", stage, state);\n        const wRaw = block.serialized.complementW;\n        const zRaw = block.serialized.complementZ;\n        const cw = formatFloat(typeof wRaw === \"number\" ? wRaw : 1);\n        const cz = formatFloat(typeof zRaw === \"number\" ? zRaw : 0);\n\n        let vec4: string;\n        switch (vector.type) {\n            case \"vec4f\":\n                vec4 = vector.expr;\n                break;\n            case \"vec3f\":\n                vec4 = `vec4<f32>(${vector.expr}, ${cw})`;\n                break;\n            case \"vec2f\":\n                vec4 = `vec4<f32>(${vector.expr}, ${cz}, ${cw})`;\n                break;\n            default:\n                vec4 = `vec4<f32>(${ctx.cast(vector, \"vec3f\").expr}, ${cw})`;\n        }\n        return { expr: `(${transform.expr} * ${vec4})`, type: \"vec4f\" };\n    },\n};\n"],"names":[],"mappings":";AASO,MAAM,UAAwB;AAAA,EACjC,WAAW;AAAA,EACX,OAAO;AAAA,EACP,KAAK,OAAO,aAAa,OAAO,OAAO,KAAK;AACxC,UAAM,SAAS,IAAI,QAAQ,OAAO,UAAU,OAAO,KAAK;AACxD,UAAM,YAAY,IAAI,QAAQ,OAAO,aAAa,OAAO,KAAK;AAC9D,UAAM,OAAO,MAAM,WAAW;AAC9B,UAAM,OAAO,MAAM,WAAW;AAC9B,UAAM,KAAK,YAAY,OAAO,SAAS,WAAW,OAAO,CAAC;AAC1D,UAAM,KAAK,YAAY,OAAO,SAAS,WAAW,OAAO,CAAC;AAE1D,QAAI;AACJ,YAAQ,OAAO,MAAA;AAAA,MACX,KAAK;AACD,eAAO,OAAO;AACd;AAAA,MACJ,KAAK;AACD,eAAO,aAAa,OAAO,IAAI,KAAK,EAAE;AACtC;AAAA,MACJ,KAAK;AACD,eAAO,aAAa,OAAO,IAAI,KAAK,EAAE,KAAK,EAAE;AAC7C;AAAA,MACJ;AACI,eAAO,aAAa,IAAI,KAAK,QAAQ,OAAO,EAAE,IAAI,KAAK,EAAE;AAAA,IAAA;AAEjE,WAAO,EAAE,MAAM,IAAI,UAAU,IAAI,MAAM,IAAI,KAAK,MAAM,QAAA;AAAA,EAC1D;AACJ;"}

package/trigonometry-block-BYQcTHiD.js

@@ -0,0 +1,36 @@
+const OP = {
+  0: "cos",
+  1: "sin",
+  2: "abs",
+  3: "exp",
+  4: "exp2",
+  5: "round",
+  6: "floor",
+  7: "ceil",
+  8: "sqrt",
+  9: "log",
+  10: "tan",
+  11: "atan",
+  12: "acos",
+  13: "asin",
+  14: "fract",
+  15: "sign",
+  16: "radians",
+  17: "degrees"
+};
+const emitter = {
+  className: "TrigonometryBlock",
+  emit(block, _outputName, stage, state, ctx) {
+    const input = ctx.resolve(block, "input", stage, state);
+    const opIdx = block.serialized.operation;
+    const fn = typeof opIdx === "number" ? OP[opIdx] : void 0;
+    if (!fn) {
+      throw new Error(`NodeMaterial: unknown TrigonometryBlock operation ${String(opIdx)}`);
+    }
+    return { expr: `${fn}(${input.expr})`, type: input.type };
+  }
+};
+export {
+  emitter
+};
+//# sourceMappingURL=trigonometry-block-BYQcTHiD.js.map

package/trigonometry-block-BYQcTHiD.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"trigonometry-block-BYQcTHiD.js","sources":["../src/material/node/blocks/trigonometry-block.ts"],"sourcesContent":["import type { BlockEmitter } from \"../node-types.js\";\n\n// Matches BJS `TrigonometryBlockOperations` enum.\nconst OP: Record<number, string> = {\n    0: \"cos\",\n    1: \"sin\",\n    2: \"abs\",\n    3: \"exp\",\n    4: \"exp2\",\n    5: \"round\",\n    6: \"floor\",\n    7: \"ceil\",\n    8: \"sqrt\",\n    9: \"log\",\n    10: \"tan\",\n    11: \"atan\",\n    12: \"acos\",\n    13: \"asin\",\n    14: \"fract\",\n    15: \"sign\",\n    16: \"radians\",\n    17: \"degrees\",\n};\n\nexport const emitter: BlockEmitter = {\n    className: \"TrigonometryBlock\",\n    emit(block, _outputName, stage, state, ctx) {\n        const input = ctx.resolve(block, \"input\", stage, state);\n        const opIdx = block.serialized.operation;\n        const fn = typeof opIdx === \"number\" ? OP[opIdx] : undefined;\n        if (!fn) {\n            throw new Error(`NodeMaterial: unknown TrigonometryBlock operation ${String(opIdx)}`);\n        }\n        return { expr: `${fn}(${input.expr})`, type: input.type };\n    },\n};\n"],"names":[],"mappings":"AAGA,MAAM,KAA6B;AAAA,EAC/B,GAAG;AAAA,EACH,GAAG;AAAA,EACH,GAAG;AAAA,EACH,GAAG;AAAA,EACH,GAAG;AAAA,EACH,GAAG;AAAA,EACH,GAAG;AAAA,EACH,GAAG;AAAA,EACH,GAAG;AAAA,EACH,GAAG;AAAA,EACH,IAAI;AAAA,EACJ,IAAI;AAAA,EACJ,IAAI;AAAA,EACJ,IAAI;AAAA,EACJ,IAAI;AAAA,EACJ,IAAI;AAAA,EACJ,IAAI;AAAA,EACJ,IAAI;AACR;AAEO,MAAM,UAAwB;AAAA,EACjC,WAAW;AAAA,EACX,KAAK,OAAO,aAAa,OAAO,OAAO,KAAK;AACxC,UAAM,QAAQ,IAAI,QAAQ,OAAO,SAAS,OAAO,KAAK;AACtD,UAAM,QAAQ,MAAM,WAAW;AAC/B,UAAM,KAAK,OAAO,UAAU,WAAW,GAAG,KAAK,IAAI;AACnD,QAAI,CAAC,IAAI;AACL,YAAM,IAAI,MAAM,qDAAqD,OAAO,KAAK,CAAC,EAAE;AAAA,IACxF;AACA,WAAO,EAAE,MAAM,GAAG,EAAE,IAAI,MAAM,IAAI,KAAK,MAAM,MAAM,KAAA;AAAA,EACvD;AACJ;"}

package/triplanar-block-BZHkD9hX.js

@@ -0,0 +1,148 @@
+const OUTPUT = {
+  rgba: { swizzle: "", type: "vec4f" },
+  rgb: { swizzle: ".xyz", type: "vec3f" },
+  r: { swizzle: ".x", type: "f32" },
+  g: { swizzle: ".y", type: "f32" },
+  b: { swizzle: ".z", type: "f32" },
+  a: { swizzle: ".w", type: "f32" }
+};
+function sanitize(name) {
+  return name.replace(/[^A-Za-z0-9_]/g, "_");
+}
+function formatFloat(value) {
+  if (Number.isInteger(value)) {
+    return `${value}.0`;
+  }
+  return `${value}`;
+}
+function textureTransform(block) {
+  const tex = block.serialized["texture"];
+  const num = (name, fallback) => {
+    const value = tex == null ? void 0 : tex[name];
+    return typeof value === "number" ? value : fallback;
+  };
+  return {
+    level: num("level", 1),
+    uAng: num("uAng", 0),
+    vAng: num("vAng", 0),
+    wAng: num("wAng", 0),
+    uOffset: num("uOffset", 0),
+    vOffset: num("vOffset", 0),
+    uScale: num("uScale", 1),
+    vScale: num("vScale", 1)
+  };
+}
+function bindingName(block, inputName, ctx, fallback) {
+  const input = block.inputs.get(inputName);
+  if (input == null ? void 0 : input.source) {
+    const producer = ctx.graph.blocks.get(input.source.blockId);
+    return sanitize((producer == null ? void 0 : producer.name) || fallback);
+  }
+  return sanitize(fallback);
+}
+function ensureBinding(state, name) {
+  if (!state.textures.find((t) => t.name === name)) {
+    state.textures.push({ name, kind: "texture2d", texture: null });
+  }
+}
+function applyColorSpace(expr, outputName, convertToLinear, convertToGamma) {
+  if (!convertToLinear && !convertToGamma) {
+    return expr;
+  }
+  const power = convertToLinear ? "2.2" : "0.45454545";
+  if (outputName === "rgba") {
+    return `vec4<f32>(pow(max(${expr}.xyz, vec3<f32>(0.0)), vec3<f32>(${power})), ${expr}.w)`;
+  }
+  if (outputName === "rgb") {
+    return `pow(max(${expr}.xyz, vec3<f32>(0.0)), vec3<f32>(${power}))`;
+  }
+  if (outputName === "r" || outputName === "g" || outputName === "b") {
+    return `pow(max(${expr}${OUTPUT[outputName].swizzle}, 0.0), ${power})`;
+  }
+  return expr;
+}
+function emitTriPlanarSample(block, stage, state, ctx) {
+  var _a;
+  if (stage !== "fragment") {
+    throw new Error("TriPlanarBlock: texture projection is supported only in the fragment stage");
+  }
+  const stageState = state.fragment;
+  const memoKey = `_triplanar_${block.id}_sample`;
+  const memo = stageState.memo.get(memoKey);
+  if (memo) {
+    return memo;
+  }
+  const baseName = sanitize(block.name || `triPlanar${block.id}`);
+  const texX = bindingName(block, "source", ctx, baseName);
+  const texY = bindingName(block, "sourceY", ctx, texX);
+  const texZ = bindingName(block, "sourceZ", ctx, texX);
+  ensureBinding(state, texX);
+  ensureBinding(state, texY);
+  ensureBinding(state, texZ);
+  const position = ctx.cast(ctx.resolve(block, "position", stage, state), "vec3f");
+  const normal = ctx.cast(ctx.resolve(block, "normal", stage, state), "vec3f");
+  const sharpnessInput = ((_a = block.inputs.get("sharpness")) == null ? void 0 : _a.source) ? ctx.cast(ctx.resolve(block, "sharpness", stage, state), "f32").expr : "1.0";
+  const transform = textureTransform(block);
+  const temp = ctx.temp(state, "tri");
+  const n = `_n${temp}`;
+  const uvx = `_uvx${temp}`;
+  const uvy = `_uvy${temp}`;
+  const uvz = `_uvz${temp}`;
+  const x = `_x${temp}`;
+  const y = `_y${temp}`;
+  const z = `_z${temp}`;
+  const w = `_w${temp}`;
+  const sample = `_sample${temp}`;
+  stageState.body.push(`let ${n} = ${normal.expr};`);
+  stageState.body.push(`var ${uvx} = (${position.expr}).yz;`);
+  stageState.body.push(`var ${uvy} = (${position.expr}).zx;`);
+  stageState.body.push(`var ${uvz} = (${position.expr}).xy;`);
+  if (block.serialized["projectAsCube"] === true) {
+    stageState.body.push(`${uvx} = (${uvx}).yx;`);
+    stageState.body.push(`if (${n}.x >= 0.0) { ${uvx}.x = -${uvx}.x; }`);
+    stageState.body.push(`if (${n}.y < 0.0) { ${uvy}.y = -${uvy}.y; }`);
+    stageState.body.push(`if (${n}.z < 0.0) { ${uvz}.x = -${uvz}.x; }`);
+  }
+  stageState.body.push(`let _cU${temp} = cos(${formatFloat(transform.uAng)});`);
+  stageState.body.push(`let _sU${temp} = sin(${formatFloat(transform.uAng)});`);
+  stageState.body.push(`${uvx} = mat2x2<f32>(_cU${temp}, -_sU${temp}, _sU${temp}, _cU${temp}) * ${uvx};`);
+  stageState.body.push(`let _cV${temp} = cos(${formatFloat(transform.vAng)});`);
+  stageState.body.push(`let _sV${temp} = sin(${formatFloat(transform.vAng)});`);
+  stageState.body.push(`${uvy} = mat2x2<f32>(_cV${temp}, _sV${temp}, -_sV${temp}, _cV${temp}) * ${uvy};`);
+  stageState.body.push(`let _cW${temp} = cos(${formatFloat(transform.wAng)});`);
+  stageState.body.push(`let _sW${temp} = sin(${formatFloat(transform.wAng)});`);
+  stageState.body.push(`${uvz} = mat2x2<f32>(_cW${temp}, -_sW${temp}, _sW${temp}, _cW${temp}) * ${uvz};`);
+  stageState.body.push(`let _scale${temp} = vec2<f32>(${formatFloat(transform.uScale)}, ${formatFloat(transform.vScale)});`);
+  stageState.body.push(`let _offset${temp} = vec2<f32>(${formatFloat(transform.uOffset)}, ${formatFloat(transform.vOffset)});`);
+  stageState.body.push(`${uvx} = ${uvx} * _scale${temp} + _offset${temp};`);
+  stageState.body.push(`${uvy} = ${uvy} * _scale${temp} + _offset${temp};`);
+  stageState.body.push(`${uvz} = ${uvz} * _scale${temp} + _offset${temp};`);
+  stageState.body.push(`let ${x} = textureSample(nodeTex_${texX}, nodeSamp_${texX}, ${uvx});`);
+  stageState.body.push(`let ${y} = textureSample(nodeTex_${texY}, nodeSamp_${texY}, ${uvy});`);
+  stageState.body.push(`let ${z} = textureSample(nodeTex_${texZ}, nodeSamp_${texZ}, ${uvz});`);
+  stageState.body.push(`let ${w} = pow(abs(${n}), vec3<f32>(${sharpnessInput}));`);
+  stageState.body.push(
+    `let ${sample} = ((${x} * ${w}.x + ${y} * ${w}.y + ${z} * ${w}.z) / (${w}.x + ${w}.y + ${w}.z)) * ${formatFloat(block.serialized["disableLevelMultiplication"] === true ? 1 : transform.level)};`
+  );
+  const result = { expr: sample, type: "vec4f" };
+  stageState.memo.set(memoKey, result);
+  return result;
+}
+const emitter = {
+  className: "TriPlanarBlock",
+  emit(block, outputName, stage, state, ctx) {
+    if (outputName === "level") {
+      const transform = textureTransform(block);
+      return { expr: formatFloat(transform.level), type: "f32" };
+    }
+    const sample = emitTriPlanarSample(block, stage, state, ctx);
+    const out = OUTPUT[outputName] ?? OUTPUT.rgba;
+    const serialized = block.serialized;
+    const converted = applyColorSpace(sample.expr, outputName, serialized.convertToLinearSpace === true, serialized.convertToGammaSpace === true);
+    return { expr: converted === sample.expr ? `${sample.expr}${out.swizzle}` : converted, type: out.type };
+  }
+};
+export {
+  emitter
+};
+//# sourceMappingURL=triplanar-block-BZHkD9hX.js.map

package/triplanar-block-BZHkD9hX.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"triplanar-block-BZHkD9hX.js","sources":["../src/material/node/blocks/triplanar-block.ts"],"sourcesContent":["/** TriPlanarBlock — texture projection from position/normal.\n *\n * Implements the Babylon.js WGSL math for the common texture-source path:\n *   uvx = position.yz, uvy = position.zx, uvz = position.xy\n *   optional cube-facing flips\n *   sample X/Y/Z projections\n *   blend by pow(abs(normal), sharpness)\n *\n * Texture transform/level defaults are identity/1.0 unless serialized on the\n * block's embedded texture. Runtime ImageSource texture transforms are not part\n * of Lite's NME binding ABI today, so Scene 81 uses default transforms.\n */\n\nimport type { BlockEmitter, NodeBlock, NodeBuildState, NodeEmitContext, NodeExpr, NodeValueType, Stage } from \"../node-types.js\";\n\nconst OUTPUT: Record<string, { swizzle: string; type: NodeValueType }> = {\n    rgba: { swizzle: \"\", type: \"vec4f\" },\n    rgb: { swizzle: \".xyz\", type: \"vec3f\" },\n    r: { swizzle: \".x\", type: \"f32\" },\n    g: { swizzle: \".y\", type: \"f32\" },\n    b: { swizzle: \".z\", type: \"f32\" },\n    a: { swizzle: \".w\", type: \"f32\" },\n};\n\ninterface TextureTransform {\n    readonly level: number;\n    readonly uAng: number;\n    readonly vAng: number;\n    readonly wAng: number;\n    readonly uOffset: number;\n    readonly vOffset: number;\n    readonly uScale: number;\n    readonly vScale: number;\n}\n\nfunction sanitize(name: string): string {\n    return name.replace(/[^A-Za-z0-9_]/g, \"_\");\n}\n\nfunction formatFloat(value: number): string {\n    if (Number.isInteger(value)) {\n        return `${value}.0`;\n    }\n    return `${value}`;\n}\n\nfunction textureTransform(block: NodeBlock): TextureTransform {\n    const tex = block.serialized[\"texture\"] as Record<string, unknown> | null | undefined;\n    const num = (name: string, fallback: number): number => {\n        const value = tex?.[name];\n        return typeof value === \"number\" ? value : fallback;\n    };\n    return {\n        level: num(\"level\", 1),\n        uAng: num(\"uAng\", 0),\n        vAng: num(\"vAng\", 0),\n        wAng: num(\"wAng\", 0),\n        uOffset: num(\"uOffset\", 0),\n        vOffset: num(\"vOffset\", 0),\n        uScale: num(\"uScale\", 1),\n        vScale: num(\"vScale\", 1),\n    };\n}\n\nfunction bindingName(block: NodeBlock, inputName: string, ctx: NodeEmitContext, fallback: string): string {\n    const input = block.inputs.get(inputName);\n    if (input?.source) {\n        const producer = ctx.graph.blocks.get(input.source.blockId);\n        return sanitize(producer?.name || fallback);\n    }\n    return sanitize(fallback);\n}\n\nfunction ensureBinding(state: NodeBuildState, name: string): void {\n    if (!state.textures.find((t) => t.name === name)) {\n        state.textures.push({ name, kind: \"texture2d\", texture: null });\n    }\n}\n\nfunction applyColorSpace(expr: string, outputName: string, convertToLinear: boolean, convertToGamma: boolean): string {\n    if (!convertToLinear && !convertToGamma) {\n        return expr;\n    }\n    const power = convertToLinear ? \"2.2\" : \"0.45454545\";\n    if (outputName === \"rgba\") {\n        return `vec4<f32>(pow(max(${expr}.xyz, vec3<f32>(0.0)), vec3<f32>(${power})), ${expr}.w)`;\n    }\n    if (outputName === \"rgb\") {\n        return `pow(max(${expr}.xyz, vec3<f32>(0.0)), vec3<f32>(${power}))`;\n    }\n    if (outputName === \"r\" || outputName === \"g\" || outputName === \"b\") {\n        return `pow(max(${expr}${OUTPUT[outputName]!.swizzle}, 0.0), ${power})`;\n    }\n    return expr;\n}\n\nfunction emitTriPlanarSample(block: NodeBlock, stage: Stage, state: NodeBuildState, ctx: NodeEmitContext): NodeExpr {\n    if (stage !== \"fragment\") {\n        throw new Error(\"TriPlanarBlock: texture projection is supported only in the fragment stage\");\n    }\n\n    const stageState = state.fragment;\n    const memoKey = `_triplanar_${block.id}_sample`;\n    const memo = stageState.memo.get(memoKey);\n    if (memo) {\n        return memo;\n    }\n\n    const baseName = sanitize(block.name || `triPlanar${block.id}`);\n    const texX = bindingName(block, \"source\", ctx, baseName);\n    const texY = bindingName(block, \"sourceY\", ctx, texX);\n    const texZ = bindingName(block, \"sourceZ\", ctx, texX);\n    ensureBinding(state, texX);\n    ensureBinding(state, texY);\n    ensureBinding(state, texZ);\n\n    const position = ctx.cast(ctx.resolve(block, \"position\", stage, state), \"vec3f\");\n    const normal = ctx.cast(ctx.resolve(block, \"normal\", stage, state), \"vec3f\");\n    const sharpnessInput = block.inputs.get(\"sharpness\")?.source ? ctx.cast(ctx.resolve(block, \"sharpness\", stage, state), \"f32\").expr : \"1.0\";\n    const transform = textureTransform(block);\n\n    const temp = ctx.temp(state, \"tri\");\n    const n = `_n${temp}`;\n    const uvx = `_uvx${temp}`;\n    const uvy = `_uvy${temp}`;\n    const uvz = `_uvz${temp}`;\n    const x = `_x${temp}`;\n    const y = `_y${temp}`;\n    const z = `_z${temp}`;\n    const w = `_w${temp}`;\n    const sample = `_sample${temp}`;\n\n    stageState.body.push(`let ${n} = ${normal.expr};`);\n    stageState.body.push(`var ${uvx} = (${position.expr}).yz;`);\n    stageState.body.push(`var ${uvy} = (${position.expr}).zx;`);\n    stageState.body.push(`var ${uvz} = (${position.expr}).xy;`);\n    if (block.serialized[\"projectAsCube\"] === true) {\n        stageState.body.push(`${uvx} = (${uvx}).yx;`);\n        stageState.body.push(`if (${n}.x >= 0.0) { ${uvx}.x = -${uvx}.x; }`);\n        stageState.body.push(`if (${n}.y < 0.0) { ${uvy}.y = -${uvy}.y; }`);\n        stageState.body.push(`if (${n}.z < 0.0) { ${uvz}.x = -${uvz}.x; }`);\n    }\n    stageState.body.push(`let _cU${temp} = cos(${formatFloat(transform.uAng)});`);\n    stageState.body.push(`let _sU${temp} = sin(${formatFloat(transform.uAng)});`);\n    stageState.body.push(`${uvx} = mat2x2<f32>(_cU${temp}, -_sU${temp}, _sU${temp}, _cU${temp}) * ${uvx};`);\n    stageState.body.push(`let _cV${temp} = cos(${formatFloat(transform.vAng)});`);\n    stageState.body.push(`let _sV${temp} = sin(${formatFloat(transform.vAng)});`);\n    stageState.body.push(`${uvy} = mat2x2<f32>(_cV${temp}, _sV${temp}, -_sV${temp}, _cV${temp}) * ${uvy};`);\n    stageState.body.push(`let _cW${temp} = cos(${formatFloat(transform.wAng)});`);\n    stageState.body.push(`let _sW${temp} = sin(${formatFloat(transform.wAng)});`);\n    stageState.body.push(`${uvz} = mat2x2<f32>(_cW${temp}, -_sW${temp}, _sW${temp}, _cW${temp}) * ${uvz};`);\n    stageState.body.push(`let _scale${temp} = vec2<f32>(${formatFloat(transform.uScale)}, ${formatFloat(transform.vScale)});`);\n    stageState.body.push(`let _offset${temp} = vec2<f32>(${formatFloat(transform.uOffset)}, ${formatFloat(transform.vOffset)});`);\n    stageState.body.push(`${uvx} = ${uvx} * _scale${temp} + _offset${temp};`);\n    stageState.body.push(`${uvy} = ${uvy} * _scale${temp} + _offset${temp};`);\n    stageState.body.push(`${uvz} = ${uvz} * _scale${temp} + _offset${temp};`);\n    stageState.body.push(`let ${x} = textureSample(nodeTex_${texX}, nodeSamp_${texX}, ${uvx});`);\n    stageState.body.push(`let ${y} = textureSample(nodeTex_${texY}, nodeSamp_${texY}, ${uvy});`);\n    stageState.body.push(`let ${z} = textureSample(nodeTex_${texZ}, nodeSamp_${texZ}, ${uvz});`);\n    stageState.body.push(`let ${w} = pow(abs(${n}), vec3<f32>(${sharpnessInput}));`);\n    stageState.body.push(\n        `let ${sample} = ((${x} * ${w}.x + ${y} * ${w}.y + ${z} * ${w}.z) / (${w}.x + ${w}.y + ${w}.z)) * ${formatFloat(block.serialized[\"disableLevelMultiplication\"] === true ? 1 : transform.level)};`\n    );\n\n    const result = { expr: sample, type: \"vec4f\" } as const;\n    stageState.memo.set(memoKey, result);\n    return result;\n}\n\nexport const emitter: BlockEmitter = {\n    className: \"TriPlanarBlock\",\n    emit(block, outputName, stage, state, ctx) {\n        if (outputName === \"level\") {\n            const transform = textureTransform(block);\n            return { expr: formatFloat(transform.level), type: \"f32\" };\n        }\n        const sample = emitTriPlanarSample(block, stage, state, ctx);\n        const out = OUTPUT[outputName] ?? OUTPUT.rgba!;\n        const serialized = block.serialized as { convertToLinearSpace?: boolean; convertToGammaSpace?: boolean };\n        const converted = applyColorSpace(sample.expr, outputName, serialized.convertToLinearSpace === true, serialized.convertToGammaSpace === true);\n        return { expr: converted === sample.expr ? `${sample.expr}${out.swizzle}` : converted, type: out.type };\n    },\n};\n"],"names":[],"mappings":"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"}

package/twirl-block-78WtdiBd.js

@@ -0,0 +1,39 @@
+const OUTPUTS = {
+  output: { swizzle: "", type: "vec2f" },
+  x: { swizzle: ".x", type: "f32" },
+  y: { swizzle: ".y", type: "f32" }
+};
+function defaultVec2(expr) {
+  return { expr, type: "vec2f" };
+}
+function defaultF32(expr) {
+  return { expr, type: "f32" };
+}
+const emitter = {
+  className: "TwirlBlock",
+  stage: "fragment",
+  emit(block, outputName, stage, state, ctx) {
+    var _a, _b, _c;
+    const input = ctx.cast(ctx.resolve(block, "input", stage, state), "vec2f");
+    const strength = ctx.cast(((_a = block.inputs.get("strength")) == null ? void 0 : _a.source) ? ctx.resolve(block, "strength", stage, state) : defaultF32("1.0"), "f32");
+    const center = ctx.cast(((_b = block.inputs.get("center")) == null ? void 0 : _b.source) ? ctx.resolve(block, "center", stage, state) : defaultVec2("vec2<f32>(0.5, 0.5)"), "vec2f");
+    const offset = ctx.cast(((_c = block.inputs.get("offset")) == null ? void 0 : _c.source) ? ctx.resolve(block, "offset", stage, state) : defaultVec2("vec2<f32>(0.0, 0.0)"), "vec2f");
+    const delta = ctx.temp(state, "twirlDelta");
+    const angle = ctx.temp(state, "twirlAngle");
+    const result = ctx.temp(state, "twirl");
+    state.fragment.body.push(`let ${delta} = ${input.expr} - ${center.expr};`);
+    state.fragment.body.push(`let ${angle} = ${strength.expr} * length(${delta});`);
+    state.fragment.body.push(
+      `let ${result} = vec2<f32>(cos(${angle}) * ${delta}.x - sin(${angle}) * ${delta}.y, sin(${angle}) * ${delta}.x + cos(${angle}) * ${delta}.y) + ${center.expr} + ${offset.expr};`
+    );
+    const out = OUTPUTS[outputName];
+    if (!out) {
+      throw new Error(`NodeMaterial: TwirlBlock has no output "${outputName}"`);
+    }
+    return { expr: `${result}${out.swizzle}`, type: out.type };
+  }
+};
+export {
+  emitter
+};
+//# sourceMappingURL=twirl-block-78WtdiBd.js.map

package/twirl-block-78WtdiBd.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"twirl-block-78WtdiBd.js","sources":["../src/material/node/blocks/twirl-block.ts"],"sourcesContent":["/** TwirlBlock — rotates a vec2 around a center by strength * distance, then adds offset. */\n\nimport type { BlockEmitter, NodeValueType } from \"../node-types.js\";\n\nconst OUTPUTS: Record<string, { readonly swizzle: string; readonly type: NodeValueType }> = {\n    output: { swizzle: \"\", type: \"vec2f\" },\n    x: { swizzle: \".x\", type: \"f32\" },\n    y: { swizzle: \".y\", type: \"f32\" },\n};\n\nfunction defaultVec2(expr: string): { readonly expr: string; readonly type: \"vec2f\" } {\n    return { expr, type: \"vec2f\" };\n}\n\nfunction defaultF32(expr: string): { readonly expr: string; readonly type: \"f32\" } {\n    return { expr, type: \"f32\" };\n}\n\nexport const emitter: BlockEmitter = {\n    className: \"TwirlBlock\",\n    stage: \"fragment\",\n    emit(block, outputName, stage, state, ctx) {\n        const input = ctx.cast(ctx.resolve(block, \"input\", stage, state), \"vec2f\");\n        const strength = ctx.cast(block.inputs.get(\"strength\")?.source ? ctx.resolve(block, \"strength\", stage, state) : defaultF32(\"1.0\"), \"f32\");\n        const center = ctx.cast(block.inputs.get(\"center\")?.source ? ctx.resolve(block, \"center\", stage, state) : defaultVec2(\"vec2<f32>(0.5, 0.5)\"), \"vec2f\");\n        const offset = ctx.cast(block.inputs.get(\"offset\")?.source ? ctx.resolve(block, \"offset\", stage, state) : defaultVec2(\"vec2<f32>(0.0, 0.0)\"), \"vec2f\");\n        const delta = ctx.temp(state, \"twirlDelta\");\n        const angle = ctx.temp(state, \"twirlAngle\");\n        const result = ctx.temp(state, \"twirl\");\n        state.fragment.body.push(`let ${delta} = ${input.expr} - ${center.expr};`);\n        state.fragment.body.push(`let ${angle} = ${strength.expr} * length(${delta});`);\n        state.fragment.body.push(\n            `let ${result} = vec2<f32>(cos(${angle}) * ${delta}.x - sin(${angle}) * ${delta}.y, sin(${angle}) * ${delta}.x + cos(${angle}) * ${delta}.y) + ${center.expr} + ${offset.expr};`\n        );\n        const out = OUTPUTS[outputName];\n        if (!out) {\n            throw new Error(`NodeMaterial: TwirlBlock has no output \"${outputName}\"`);\n        }\n        return { expr: `${result}${out.swizzle}`, type: out.type };\n    },\n};\n"],"names":[],"mappings":"AAIA,MAAM,UAAsF;AAAA,EACxF,QAAQ,EAAE,SAAS,IAAI,MAAM,QAAA;AAAA,EAC7B,GAAG,EAAE,SAAS,MAAM,MAAM,MAAA;AAAA,EAC1B,GAAG,EAAE,SAAS,MAAM,MAAM,MAAA;AAC9B;AAEA,SAAS,YAAY,MAAiE;AAClF,SAAO,EAAE,MAAM,MAAM,QAAA;AACzB;AAEA,SAAS,WAAW,MAA+D;AAC/E,SAAO,EAAE,MAAM,MAAM,MAAA;AACzB;AAEO,MAAM,UAAwB;AAAA,EACjC,WAAW;AAAA,EACX,OAAO;AAAA,EACP,KAAK,OAAO,YAAY,OAAO,OAAO,KAAK;AAjB/C;AAkBQ,UAAM,QAAQ,IAAI,KAAK,IAAI,QAAQ,OAAO,SAAS,OAAO,KAAK,GAAG,OAAO;AACzE,UAAM,WAAW,IAAI,OAAK,WAAM,OAAO,IAAI,UAAU,MAA3B,mBAA8B,UAAS,IAAI,QAAQ,OAAO,YAAY,OAAO,KAAK,IAAI,WAAW,KAAK,GAAG,KAAK;AACxI,UAAM,SAAS,IAAI,OAAK,WAAM,OAAO,IAAI,QAAQ,MAAzB,mBAA4B,UAAS,IAAI,QAAQ,OAAO,UAAU,OAAO,KAAK,IAAI,YAAY,qBAAqB,GAAG,OAAO;AACrJ,UAAM,SAAS,IAAI,OAAK,WAAM,OAAO,IAAI,QAAQ,MAAzB,mBAA4B,UAAS,IAAI,QAAQ,OAAO,UAAU,OAAO,KAAK,IAAI,YAAY,qBAAqB,GAAG,OAAO;AACrJ,UAAM,QAAQ,IAAI,KAAK,OAAO,YAAY;AAC1C,UAAM,QAAQ,IAAI,KAAK,OAAO,YAAY;AAC1C,UAAM,SAAS,IAAI,KAAK,OAAO,OAAO;AACtC,UAAM,SAAS,KAAK,KAAK,OAAO,KAAK,MAAM,MAAM,IAAI,MAAM,OAAO,IAAI,GAAG;AACzE,UAAM,SAAS,KAAK,KAAK,OAAO,KAAK,MAAM,SAAS,IAAI,aAAa,KAAK,IAAI;AAC9E,UAAM,SAAS,KAAK;AAAA,MAChB,OAAO,MAAM,oBAAoB,KAAK,OAAO,KAAK,YAAY,KAAK,OAAO,KAAK,WAAW,KAAK,OAAO,KAAK,YAAY,KAAK,OAAO,KAAK,SAAS,OAAO,IAAI,MAAM,OAAO,IAAI;AAAA,IAAA;AAEjL,UAAM,MAAM,QAAQ,UAAU;AAC9B,QAAI,CAAC,KAAK;AACN,YAAM,IAAI,MAAM,2CAA2C,UAAU,GAAG;AAAA,IAC5E;AACA,WAAO,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,OAAO,IAAI,MAAM,IAAI,KAAA;AAAA,EACxD;AACJ;"}

package/unlit-fragment-BIlhJpz6.js

@@ -0,0 +1,43 @@
+import { aM as PBR2_HAS_UNLIT } from "./index-C8HOR2sB.js";
+function createUnlitFragment(hasIbl) {
+  const assign = `color = baseColor * material.unlitColor;`;
+  return {
+    _id: "unlit",
+    _dependencies: hasIbl ? ["ibl"] : void 0,
+    _uboFields: [
+      { _name: "unlitColor", _type: "vec3<f32>" },
+      { _name: "_unlitColorPad", _type: "f32" }
+    ],
+    _fragmentSlots: hasIbl ? { AI: assign } : { NI: assign }
+  };
+}
+function writeUnlitUBO(data, material, offsets) {
+  if (!material.unlit || !offsets.has("unlitColor")) {
+    return;
+  }
+  const off = offsets.get("unlitColor") / 4;
+  const tint = material.unlitColor ?? [1, 1, 1];
+  data[off] = tint[0];
+  data[off + 1] = tint[1];
+  data[off + 2] = tint[2];
+}
+const pbrExt = {
+  id: "unlit",
+  phase: "fragment",
+  detect(mat) {
+    return mat.unlit ? { f: 0, f2: PBR2_HAS_UNLIT } : { f: 0, f2: 0 };
+  },
+  frag(ctx) {
+    if (!(ctx._features2 & PBR2_HAS_UNLIT)) {
+      return null;
+    }
+    return createUnlitFragment(ctx._hasIbl);
+  },
+  writeUbo: writeUnlitUBO
+};
+export {
+  createUnlitFragment,
+  pbrExt,
+  writeUnlitUBO
+};
+//# sourceMappingURL=unlit-fragment-BIlhJpz6.js.map

package/unlit-fragment-BIlhJpz6.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"unlit-fragment-BIlhJpz6.js","sources":["../src/material/pbr/fragments/unlit-fragment.ts"],"sourcesContent":["/**\n * Unlit Fragment (KHR_materials_unlit).\n *\n * Replaces the lit-color computation with `baseColor * unlitColor` right\n * before the tonemap/gamma/contrast chain runs.  Depends on the IBL fragment\n * when present so our AI injection runs *after* IBL's, overwriting the IBL\n * color contribution.  The subsequent tonemap/gamma/contrast stages still\n * apply, matching BJS's unlit output under `createDefaultEnvironment`.\n *\n * Zero bytes in bundles for scenes that don't use unlit materials.\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 { PBR2_HAS_UNLIT } from \"../pbr-flag-bits.js\";\n\nexport function createUnlitFragment(hasIbl: boolean): ShaderFragment {\n    const assign = `color = baseColor * material.unlitColor;`;\n    return {\n        _id: \"unlit\",\n        _dependencies: hasIbl ? [\"ibl\"] : undefined,\n        _uboFields: [\n            { _name: \"unlitColor\", _type: \"vec3<f32>\" },\n            { _name: \"_unlitColorPad\", _type: \"f32\" },\n        ],\n        _fragmentSlots: hasIbl ? { AI: assign } : { NI: assign },\n    };\n}\n\n/** Write the unlit material-UBO slice. */\nexport function writeUnlitUBO(data: Float32Array, material: PbrMaterialProps, offsets: ReadonlyMap<string, number>): void {\n    if (!material.unlit || !offsets.has(\"unlitColor\")) {\n        return;\n    }\n    const off = offsets.get(\"unlitColor\")! / 4;\n    const tint = material.unlitColor ?? [1, 1, 1];\n    data[off] = tint[0]!;\n    data[off + 1] = tint[1]!;\n    data[off + 2] = tint[2]!;\n}\n\nexport const pbrExt: PbrExt = {\n    id: \"unlit\",\n    phase: \"fragment\",\n    detect(mat) {\n        return (mat as PbrMaterialProps).unlit ? { f: 0, f2: PBR2_HAS_UNLIT } : { f: 0, f2: 0 };\n    },\n    frag(ctx) {\n        if (!(ctx._features2 & PBR2_HAS_UNLIT)) {\n            return null;\n        }\n        return createUnlitFragment(ctx._hasIbl);\n    },\n    writeUbo: writeUnlitUBO as PbrExt[\"writeUbo\"],\n};\n"],"names":[],"mappings":";AAiBO,SAAS,oBAAoB,QAAiC;AACjE,QAAM,SAAS;AACf,SAAO;AAAA,IACH,KAAK;AAAA,IACL,eAAe,SAAS,CAAC,KAAK,IAAI;AAAA,IAClC,YAAY;AAAA,MACR,EAAE,OAAO,cAAc,OAAO,YAAA;AAAA,MAC9B,EAAE,OAAO,kBAAkB,OAAO,MAAA;AAAA,IAAM;AAAA,IAE5C,gBAAgB,SAAS,EAAE,IAAI,WAAW,EAAE,IAAI,OAAA;AAAA,EAAO;AAE/D;AAGO,SAAS,cAAc,MAAoB,UAA4B,SAA4C;AACtH,MAAI,CAAC,SAAS,SAAS,CAAC,QAAQ,IAAI,YAAY,GAAG;AAC/C;AAAA,EACJ;AACA,QAAM,MAAM,QAAQ,IAAI,YAAY,IAAK;AACzC,QAAM,OAAO,SAAS,cAAc,CAAC,GAAG,GAAG,CAAC;AAC5C,OAAK,GAAG,IAAI,KAAK,CAAC;AAClB,OAAK,MAAM,CAAC,IAAI,KAAK,CAAC;AACtB,OAAK,MAAM,CAAC,IAAI,KAAK,CAAC;AAC1B;AAEO,MAAM,SAAiB;AAAA,EAC1B,IAAI;AAAA,EACJ,OAAO;AAAA,EACP,OAAO,KAAK;AACR,WAAQ,IAAyB,QAAQ,EAAE,GAAG,GAAG,IAAI,eAAA,IAAmB,EAAE,GAAG,GAAG,IAAI,EAAA;AAAA,EACxF;AAAA,EACA,KAAK,KAAK;AACN,QAAI,EAAE,IAAI,aAAa,iBAAiB;AACpC,aAAO;AAAA,IACX;AACA,WAAO,oBAAoB,IAAI,OAAO;AAAA,EAC1C;AAAA,EACA,UAAU;AACd;"}

package/uv-transform-fragment-hYujGpZg.js

@@ -0,0 +1,47 @@
+function writeOne(data, offsets, texName, tex) {
+  const mOff = offsets.get(`${texName}UVm`);
+  const tOff = offsets.get(`${texName}UVt`);
+  if (mOff === void 0 || tOff === void 0) {
+    return;
+  }
+  const mi = mOff / 4;
+  const ti = tOff / 4;
+  const sx = (tex == null ? void 0 : tex.uScale) ?? 1;
+  const sy = (tex == null ? void 0 : tex.vScale) ?? 1;
+  const ang = (tex == null ? void 0 : tex.uAng) ?? 0;
+  const ox = (tex == null ? void 0 : tex.uOffset) ?? 0;
+  const oy = (tex == null ? void 0 : tex.vOffset) ?? 0;
+  if (ang === 0) {
+    data[mi] = sx;
+    data[mi + 1] = 0;
+    data[mi + 2] = 0;
+    data[mi + 3] = sy;
+  } else {
+    const c = Math.cos(ang);
+    const s = Math.sin(ang);
+    data[mi] = c * sx;
+    data[mi + 1] = -s * sy;
+    data[mi + 2] = s * sx;
+    data[mi + 3] = c * sy;
+  }
+  data[ti] = ox;
+  data[ti + 1] = oy;
+  data[ti + 2] = 0;
+  data[ti + 3] = 0;
+}
+const pbrExt = {
+  id: "uv-transform",
+  phase: "fragment",
+  writeUbo(data, material, offsets) {
+    const m = material;
+    writeOne(data, offsets, "baseColor", m.baseColorTexture);
+    writeOne(data, offsets, "normal", m.normalTexture);
+    writeOne(data, offsets, "orm", m.ormTexture);
+    writeOne(data, offsets, "emissive", m.emissiveTexture);
+    writeOne(data, offsets, "specGloss", m.specGlossTexture);
+  }
+};
+export {
+  pbrExt
+};
+//# sourceMappingURL=uv-transform-fragment-hYujGpZg.js.map

package/uv-transform-fragment-hYujGpZg.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"uv-transform-fragment-hYujGpZg.js","sources":["../src/material/pbr/fragments/uv-transform-fragment.ts"],"sourcesContent":["/** UV-transform PbrExt. Registered lazily only when a scene actually has a\n *  material with PBR2_HAS_UV_TRANSFORM set, so non-UV-transform bundles pay\n *  zero bytes. Template-only ext — contributes no fragment or bindings, just\n *  a material-UBO slice. */\n\nimport type { Texture2D } from \"../../../texture/texture-2d.js\";\nimport type { PbrMaterialProps } from \"../pbr-material.js\";\nimport type { PbrExt } from \"../pbr-flags.js\";\n\nfunction writeOne(data: Float32Array, offsets: ReadonlyMap<string, number>, texName: string, tex: Texture2D | null | undefined): void {\n    const mOff = offsets.get(`${texName}UVm`);\n    const tOff = offsets.get(`${texName}UVt`);\n    if (mOff === undefined || tOff === undefined) {\n        return;\n    }\n    const mi = mOff / 4;\n    const ti = tOff / 4;\n    const sx = tex?.uScale ?? 1;\n    const sy = tex?.vScale ?? 1;\n    const ang = tex?.uAng ?? 0;\n    const ox = tex?.uOffset ?? 0;\n    const oy = tex?.vOffset ?? 0;\n    if (ang === 0) {\n        data[mi] = sx;\n        data[mi + 1] = 0;\n        data[mi + 2] = 0;\n        data[mi + 3] = sy;\n    } else {\n        const c = Math.cos(ang);\n        const s = Math.sin(ang);\n        data[mi] = c * sx;\n        data[mi + 1] = -s * sy;\n        data[mi + 2] = s * sx;\n        data[mi + 3] = c * sy;\n    }\n    data[ti] = ox;\n    data[ti + 1] = oy;\n    data[ti + 2] = 0;\n    data[ti + 3] = 0;\n}\n\nexport const pbrExt: PbrExt = {\n    id: \"uv-transform\",\n    phase: \"fragment\",\n    writeUbo(data: Float32Array, material: unknown, offsets: ReadonlyMap<string, number>): void {\n        const m = material as PbrMaterialProps;\n        writeOne(data, offsets, \"baseColor\", m.baseColorTexture);\n        writeOne(data, offsets, \"normal\", m.normalTexture);\n        writeOne(data, offsets, \"orm\", m.ormTexture);\n        writeOne(data, offsets, \"emissive\", m.emissiveTexture);\n        writeOne(data, offsets, \"specGloss\", m.specGlossTexture);\n    },\n};\n"],"names":[],"mappings":"AASA,SAAS,SAAS,MAAoB,SAAsC,SAAiB,KAAyC;AAClI,QAAM,OAAO,QAAQ,IAAI,GAAG,OAAO,KAAK;AACxC,QAAM,OAAO,QAAQ,IAAI,GAAG,OAAO,KAAK;AACxC,MAAI,SAAS,UAAa,SAAS,QAAW;AAC1C;AAAA,EACJ;AACA,QAAM,KAAK,OAAO;AAClB,QAAM,KAAK,OAAO;AAClB,QAAM,MAAK,2BAAK,WAAU;AAC1B,QAAM,MAAK,2BAAK,WAAU;AAC1B,QAAM,OAAM,2BAAK,SAAQ;AACzB,QAAM,MAAK,2BAAK,YAAW;AAC3B,QAAM,MAAK,2BAAK,YAAW;AAC3B,MAAI,QAAQ,GAAG;AACX,SAAK,EAAE,IAAI;AACX,SAAK,KAAK,CAAC,IAAI;AACf,SAAK,KAAK,CAAC,IAAI;AACf,SAAK,KAAK,CAAC,IAAI;AAAA,EACnB,OAAO;AACH,UAAM,IAAI,KAAK,IAAI,GAAG;AACtB,UAAM,IAAI,KAAK,IAAI,GAAG;AACtB,SAAK,EAAE,IAAI,IAAI;AACf,SAAK,KAAK,CAAC,IAAI,CAAC,IAAI;AACpB,SAAK,KAAK,CAAC,IAAI,IAAI;AACnB,SAAK,KAAK,CAAC,IAAI,IAAI;AAAA,EACvB;AACA,OAAK,EAAE,IAAI;AACX,OAAK,KAAK,CAAC,IAAI;AACf,OAAK,KAAK,CAAC,IAAI;AACf,OAAK,KAAK,CAAC,IAAI;AACnB;AAEO,MAAM,SAAiB;AAAA,EAC1B,IAAI;AAAA,EACJ,OAAO;AAAA,EACP,SAAS,MAAoB,UAAmB,SAA4C;AACxF,UAAM,IAAI;AACV,aAAS,MAAM,SAAS,aAAa,EAAE,gBAAgB;AACvD,aAAS,MAAM,SAAS,UAAU,EAAE,aAAa;AACjD,aAAS,MAAM,SAAS,OAAO,EAAE,UAAU;AAC3C,aAAS,MAAM,SAAS,YAAY,EAAE,eAAe;AACrD,aAAS,MAAM,SAAS,aAAa,EAAE,gBAAgB;AAAA,EAC3D;AACJ;"}

package/vector-merger-CrW-ONB0.js

@@ -0,0 +1,43 @@
+function tryResolve(block, inputName, stage, state, ctx) {
+  const input = block.inputs.get(inputName);
+  if (!input || !input.source) {
+    return null;
+  }
+  return ctx.resolve(block, inputName, stage, state);
+}
+function tryResolveAny(block, inputNames, stage, state, ctx) {
+  for (const inputName of inputNames) {
+    const resolved = tryResolve(block, inputName, stage, state, ctx);
+    if (resolved) {
+      return resolved;
+    }
+  }
+  return null;
+}
+const emitter = {
+  className: "VectorMergerBlock",
+  emit(block, outputName, stage, state, ctx) {
+    const xyzIn = tryResolveAny(block, ["xyzIn", "xyz"], stage, state, ctx);
+    const xyIn = tryResolveAny(block, ["xyIn", "xy"], stage, state, ctx);
+    const zwIn = tryResolveAny(block, ["zwIn", "zw"], stage, state, ctx);
+    const x = tryResolve(block, "x", stage, state, ctx);
+    const y = tryResolve(block, "y", stage, state, ctx);
+    const z = tryResolve(block, "z", stage, state, ctx);
+    const w = tryResolve(block, "w", stage, state, ctx);
+    const sx = x ? ctx.cast(x, "f32").expr : xyIn ? `(${xyIn.expr}).x` : xyzIn ? `(${xyzIn.expr}).x` : "0.0";
+    const sy = y ? ctx.cast(y, "f32").expr : xyIn ? `(${xyIn.expr}).y` : xyzIn ? `(${xyzIn.expr}).y` : "0.0";
+    const sz = z ? ctx.cast(z, "f32").expr : zwIn ? `(${zwIn.expr}).x` : xyzIn ? `(${xyzIn.expr}).z` : "0.0";
+    const sw = w ? ctx.cast(w, "f32").expr : zwIn ? `(${zwIn.expr}).y` : "0.0";
+    if (outputName === "xy") {
+      return { expr: `vec2<f32>(${sx}, ${sy})`, type: "vec2f" };
+    }
+    if (outputName === "xyz") {
+      return { expr: `vec3<f32>(${sx}, ${sy}, ${sz})`, type: "vec3f" };
+    }
+    return { expr: `vec4<f32>(${sx}, ${sy}, ${sz}, ${sw})`, type: "vec4f" };
+  }
+};
+export {
+  emitter
+};
+//# sourceMappingURL=vector-merger-CrW-ONB0.js.map

package/vector-merger-CrW-ONB0.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"vector-merger-CrW-ONB0.js","sources":["../src/material/node/blocks/vector-merger.ts"],"sourcesContent":["/** VectorMergerBlock emitter.\n *\n *  Combines up to 4 scalar/vector inputs into a vector output. BJS input names:\n *  `xyIn`, `zwIn`, `xyzIn`, `x`, `y`, `z`, `w`. Outputs: `xyzw`, `xyz`, `xy`.\n *  Unconnected inputs default to 0.\n */\n\nimport type { BlockEmitter, NodeExpr, NodeEmitContext, NodeBuildState, NodeBlock, Stage } from \"../node-types.js\";\n\nfunction tryResolve(block: NodeBlock, inputName: string, stage: Stage, state: NodeBuildState, ctx: NodeEmitContext): NodeExpr | null {\n    const input = block.inputs.get(inputName);\n    if (!input || !input.source) {\n        return null;\n    }\n    return ctx.resolve(block, inputName, stage, state);\n}\n\nfunction tryResolveAny(block: NodeBlock, inputNames: string[], stage: Stage, state: NodeBuildState, ctx: NodeEmitContext): NodeExpr | null {\n    for (const inputName of inputNames) {\n        const resolved = tryResolve(block, inputName, stage, state, ctx);\n        if (resolved) {\n            return resolved;\n        }\n    }\n    return null;\n}\n\nexport const emitter: BlockEmitter = {\n    className: \"VectorMergerBlock\",\n    emit(block, outputName, stage, state, ctx) {\n        // Resolve optional inputs. Prefer bundle (xyzIn/xyIn/zwIn) over scalar (x/y/z/w).\n        const xyzIn = tryResolveAny(block, [\"xyzIn\", \"xyz\"], stage, state, ctx);\n        const xyIn = tryResolveAny(block, [\"xyIn\", \"xy\"], stage, state, ctx);\n        const zwIn = tryResolveAny(block, [\"zwIn\", \"zw\"], stage, state, ctx);\n        const x = tryResolve(block, \"x\", stage, state, ctx);\n        const y = tryResolve(block, \"y\", stage, state, ctx);\n        const z = tryResolve(block, \"z\", stage, state, ctx);\n        const w = tryResolve(block, \"w\", stage, state, ctx);\n\n        const sx = x ? ctx.cast(x, \"f32\").expr : xyIn ? `(${xyIn.expr}).x` : xyzIn ? `(${xyzIn.expr}).x` : \"0.0\";\n        const sy = y ? ctx.cast(y, \"f32\").expr : xyIn ? `(${xyIn.expr}).y` : xyzIn ? `(${xyzIn.expr}).y` : \"0.0\";\n        const sz = z ? ctx.cast(z, \"f32\").expr : zwIn ? `(${zwIn.expr}).x` : xyzIn ? `(${xyzIn.expr}).z` : \"0.0\";\n        const sw = w ? ctx.cast(w, \"f32\").expr : zwIn ? `(${zwIn.expr}).y` : \"0.0\";\n\n        if (outputName === \"xy\") {\n            return { expr: `vec2<f32>(${sx}, ${sy})`, type: \"vec2f\" };\n        }\n        if (outputName === \"xyz\") {\n            return { expr: `vec3<f32>(${sx}, ${sy}, ${sz})`, type: \"vec3f\" };\n        }\n        // Default to xyzw.\n        return { expr: `vec4<f32>(${sx}, ${sy}, ${sz}, ${sw})`, type: \"vec4f\" };\n    },\n};\n"],"names":[],"mappings":"AASA,SAAS,WAAW,OAAkB,WAAmB,OAAc,OAAuB,KAAuC;AACjI,QAAM,QAAQ,MAAM,OAAO,IAAI,SAAS;AACxC,MAAI,CAAC,SAAS,CAAC,MAAM,QAAQ;AACzB,WAAO;AAAA,EACX;AACA,SAAO,IAAI,QAAQ,OAAO,WAAW,OAAO,KAAK;AACrD;AAEA,SAAS,cAAc,OAAkB,YAAsB,OAAc,OAAuB,KAAuC;AACvI,aAAW,aAAa,YAAY;AAChC,UAAM,WAAW,WAAW,OAAO,WAAW,OAAO,OAAO,GAAG;AAC/D,QAAI,UAAU;AACV,aAAO;AAAA,IACX;AAAA,EACJ;AACA,SAAO;AACX;AAEO,MAAM,UAAwB;AAAA,EACjC,WAAW;AAAA,EACX,KAAK,OAAO,YAAY,OAAO,OAAO,KAAK;AAEvC,UAAM,QAAQ,cAAc,OAAO,CAAC,SAAS,KAAK,GAAG,OAAO,OAAO,GAAG;AACtE,UAAM,OAAO,cAAc,OAAO,CAAC,QAAQ,IAAI,GAAG,OAAO,OAAO,GAAG;AACnE,UAAM,OAAO,cAAc,OAAO,CAAC,QAAQ,IAAI,GAAG,OAAO,OAAO,GAAG;AACnE,UAAM,IAAI,WAAW,OAAO,KAAK,OAAO,OAAO,GAAG;AAClD,UAAM,IAAI,WAAW,OAAO,KAAK,OAAO,OAAO,GAAG;AAClD,UAAM,IAAI,WAAW,OAAO,KAAK,OAAO,OAAO,GAAG;AAClD,UAAM,IAAI,WAAW,OAAO,KAAK,OAAO,OAAO,GAAG;AAElD,UAAM,KAAK,IAAI,IAAI,KAAK,GAAG,KAAK,EAAE,OAAO,OAAO,IAAI,KAAK,IAAI,QAAQ,QAAQ,IAAI,MAAM,IAAI,QAAQ;AACnG,UAAM,KAAK,IAAI,IAAI,KAAK,GAAG,KAAK,EAAE,OAAO,OAAO,IAAI,KAAK,IAAI,QAAQ,QAAQ,IAAI,MAAM,IAAI,QAAQ;AACnG,UAAM,KAAK,IAAI,IAAI,KAAK,GAAG,KAAK,EAAE,OAAO,OAAO,IAAI,KAAK,IAAI,QAAQ,QAAQ,IAAI,MAAM,IAAI,QAAQ;AACnG,UAAM,KAAK,IAAI,IAAI,KAAK,GAAG,KAAK,EAAE,OAAO,OAAO,IAAI,KAAK,IAAI,QAAQ;AAErE,QAAI,eAAe,MAAM;AACrB,aAAO,EAAE,MAAM,aAAa,EAAE,KAAK,EAAE,KAAK,MAAM,QAAA;AAAA,IACpD;AACA,QAAI,eAAe,OAAO;AACtB,aAAO,EAAE,MAAM,aAAa,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,MAAM,QAAA;AAAA,IAC3D;AAEA,WAAO,EAAE,MAAM,aAAa,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,MAAM,QAAA;AAAA,EAClE;AACJ;"}

package/vector-splitter-BoJuHrAU.js

@@ -0,0 +1,34 @@
+const COMPONENT = {
+  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: "VectorSplitterBlock",
+  emit(block, outputName, stage, state, ctx) {
+    var _a;
+    let source = null;
+    for (const key of ["xyzw", "xyz", "xy"]) {
+      if ((_a = block.inputs.get(key)) == null ? void 0 : _a.source) {
+        source = ctx.resolve(block, key, stage, state);
+        break;
+      }
+    }
+    if (!source) {
+      throw new Error(`NodeMaterial: VectorSplitterBlock (id=${block.id}) has no connected input`);
+    }
+    const c = COMPONENT[outputName];
+    if (!c) {
+      throw new Error(`NodeMaterial: VectorSplitterBlock has no output "${outputName}"`);
+    }
+    return { expr: `(${source.expr})${c.swizzle}`, type: c.type };
+  }
+};
+export {
+  emitter
+};
+//# sourceMappingURL=vector-splitter-BoJuHrAU.js.map

package/vector-splitter-BoJuHrAU.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"vector-splitter-BoJuHrAU.js","sources":["../src/material/node/blocks/vector-splitter.ts"],"sourcesContent":["/** VectorSplitterBlock — splits a vector into sub-vectors / components. */\n\nimport type { BlockEmitter, NodeExpr, NodeValueType } from \"../node-types.js\";\n\nconst COMPONENT: Record<string, { swizzle: string; 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: \"VectorSplitterBlock\",\n    emit(block, outputName, stage, state, ctx) {\n        // Pick the widest connected input: xyzw > xyz > xy\n        let source: NodeExpr | null = null;\n        for (const key of [\"xyzw\", \"xyz\", \"xy\"] as const) {\n            if (block.inputs.get(key)?.source) {\n                source = ctx.resolve(block, key, stage, state);\n                break;\n            }\n        }\n        if (!source) {\n            throw new Error(`NodeMaterial: VectorSplitterBlock (id=${block.id}) has no connected input`);\n        }\n        const c = COMPONENT[outputName];\n        if (!c) {\n            throw new Error(`NodeMaterial: VectorSplitterBlock has no output \"${outputName}\"`);\n        }\n        return { expr: `(${source.expr})${c.swizzle}`, type: c.type };\n    },\n};\n"],"names":[],"mappings":"AAIA,MAAM,YAAsE;AAAA,EACxE,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,KAAK,OAAO,YAAY,OAAO,OAAO,KAAK;AAZ/C;AAcQ,QAAI,SAA0B;AAC9B,eAAW,OAAO,CAAC,QAAQ,OAAO,IAAI,GAAY;AAC9C,WAAI,WAAM,OAAO,IAAI,GAAG,MAApB,mBAAuB,QAAQ;AAC/B,iBAAS,IAAI,QAAQ,OAAO,KAAK,OAAO,KAAK;AAC7C;AAAA,MACJ;AAAA,IACJ;AACA,QAAI,CAAC,QAAQ;AACT,YAAM,IAAI,MAAM,yCAAyC,MAAM,EAAE,0BAA0B;AAAA,IAC/F;AACA,UAAM,IAAI,UAAU,UAAU;AAC9B,QAAI,CAAC,GAAG;AACJ,YAAM,IAAI,MAAM,oDAAoD,UAAU,GAAG;AAAA,IACrF;AACA,WAAO,EAAE,MAAM,IAAI,OAAO,IAAI,IAAI,EAAE,OAAO,IAAI,MAAM,EAAE,KAAA;AAAA,EAC3D;AACJ;"}

package/vertex-output-Cvft64y0.js

@@ -0,0 +1,14 @@
+const emitter = {
+  className: "VertexOutputBlock",
+  stage: "vertex",
+  emit(block, _outputName, _stage, state, ctx) {
+    const vector = ctx.resolve(block, "vector", "vertex", state);
+    const pos = ctx.cast(vector, "vec4f").expr;
+    state.vertex.body.push(`_NME_VTX_OUTPUT_ = ${pos};`);
+    return { expr: pos, type: "vec4f" };
+  }
+};
+export {
+  emitter
+};
+//# sourceMappingURL=vertex-output-Cvft64y0.js.map

package/vertex-output-Cvft64y0.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"vertex-output-Cvft64y0.js","sources":["../src/material/node/blocks/vertex-output.ts"],"sourcesContent":["/** VertexOutputBlock — terminal block for the vertex stage.\n *\n *  Writes the final clip-space position to the sentinel `_NME_VTX_OUTPUT_`,\n *  which the pipeline builder wraps with the vertex entry-point boilerplate.\n */\n\nimport type { BlockEmitter } from \"../node-types.js\";\n\nexport const emitter: BlockEmitter = {\n    className: \"VertexOutputBlock\",\n    stage: \"vertex\",\n    emit(block, _outputName, _stage, state, ctx) {\n        const vector = ctx.resolve(block, \"vector\", \"vertex\", state);\n        const pos = ctx.cast(vector, \"vec4f\").expr;\n        state.vertex.body.push(`_NME_VTX_OUTPUT_ = ${pos};`);\n        return { expr: pos, type: \"vec4f\" };\n    },\n};\n"],"names":[],"mappings":"AAQO,MAAM,UAAwB;AAAA,EACjC,WAAW;AAAA,EACX,OAAO;AAAA,EACP,KAAK,OAAO,aAAa,QAAQ,OAAO,KAAK;AACzC,UAAM,SAAS,IAAI,QAAQ,OAAO,UAAU,UAAU,KAAK;AAC3D,UAAM,MAAM,IAAI,KAAK,QAAQ,OAAO,EAAE;AACtC,UAAM,OAAO,KAAK,KAAK,sBAAsB,GAAG,GAAG;AACnD,WAAO,EAAE,MAAM,KAAK,MAAM,QAAA;AAAA,EAC9B;AACJ;"}