@babylonjs/lite 0.1.1

package/matrix-blocks-acWn_V6g.js

@@ -0,0 +1,51 @@
+const SPLIT_OUTPUT = {
+  row0: { expr: (input) => `(${input})[0]`, type: "vec4f" },
+  row1: { expr: (input) => `(${input})[1]`, type: "vec4f" },
+  row2: { expr: (input) => `(${input})[2]`, type: "vec4f" },
+  row3: { expr: (input) => `(${input})[3]`, type: "vec4f" },
+  col0: { expr: (input) => `vec4<f32>((${input})[0][0], (${input})[1][0], (${input})[2][0], (${input})[3][0])`, type: "vec4f" },
+  col1: { expr: (input) => `vec4<f32>((${input})[0][1], (${input})[1][1], (${input})[2][1], (${input})[3][1])`, type: "vec4f" },
+  col2: { expr: (input) => `vec4<f32>((${input})[0][2], (${input})[1][2], (${input})[2][2], (${input})[3][2])`, type: "vec4f" },
+  col3: { expr: (input) => `vec4<f32>((${input})[0][3], (${input})[1][3], (${input})[2][3], (${input})[3][3])`, type: "vec4f" }
+};
+function optionalVec4(block, inputName, fallback, stage, state, ctx) {
+  const input = block.inputs.get(inputName);
+  if (!(input == null ? void 0 : input.source)) {
+    return fallback;
+  }
+  return ctx.cast(ctx.resolve(block, inputName, stage, state), "vec4f").expr;
+}
+function emitMatrixBuilder(block, stage, state, ctx) {
+  const row0 = optionalVec4(block, "row0", "vec4<f32>(1.0, 0.0, 0.0, 0.0)", stage, state, ctx);
+  const row1 = optionalVec4(block, "row1", "vec4<f32>(0.0, 1.0, 0.0, 0.0)", stage, state, ctx);
+  const row2 = optionalVec4(block, "row2", "vec4<f32>(0.0, 0.0, 1.0, 0.0)", stage, state, ctx);
+  const row3 = optionalVec4(block, "row3", "vec4<f32>(0.0, 0.0, 0.0, 1.0)", stage, state, ctx);
+  return { expr: `mat4x4<f32>(${row0}, ${row1}, ${row2}, ${row3})`, type: "mat4f" };
+}
+const emitter = {
+  className: "MatrixBlocks",
+  emit(block, outputName, stage, state, ctx) {
+    if (block.className === "MatrixBuilder") {
+      return emitMatrixBuilder(block, stage, state, ctx);
+    }
+    const input = ctx.cast(ctx.resolve(block, "input", stage, state), "mat4f");
+    if (block.className === "MatrixTransposeBlock") {
+      return { expr: `transpose(${input.expr})`, type: "mat4f" };
+    }
+    if (block.className === "MatrixDeterminantBlock") {
+      return { expr: `determinant(${input.expr})`, type: "f32" };
+    }
+    if (block.className === "MatrixSplitterBlock") {
+      const output = SPLIT_OUTPUT[outputName];
+      if (!output) {
+        throw new Error(`NodeMaterial: MatrixSplitterBlock has no output "${outputName}"`);
+      }
+      return { expr: output.expr(input.expr), type: output.type };
+    }
+    throw new Error(`NodeMaterial: unsupported matrix block "${block.className}"`);
+  }
+};
+export {
+  emitter
+};
+//# sourceMappingURL=matrix-blocks-acWn_V6g.js.map

package/matrix-blocks-acWn_V6g.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"matrix-blocks-acWn_V6g.js","sources":["../src/material/node/blocks/matrix-blocks.ts"],"sourcesContent":["/** Matrix operation emitters.\n *\n * Supports MatrixBuilder, MatrixSplitterBlock, MatrixTransposeBlock, and\n * MatrixDeterminantBlock. Babylon.js' WGSL MatrixBuilder path emits\n * `mat4x4f(row0, row1, row2, row3)`; WGSL matrix constructors take column\n * vectors, so Lite follows that exact constructor ordering.\n */\n\nimport type { BlockEmitter, NodeBlock, NodeBuildState, NodeEmitContext, NodeExpr, NodeValueType, Stage } from \"../node-types.js\";\n\nconst SPLIT_OUTPUT: Record<string, { readonly expr: (input: string) => string; readonly type: NodeValueType }> = {\n    row0: { expr: (input) => `(${input})[0]`, type: \"vec4f\" },\n    row1: { expr: (input) => `(${input})[1]`, type: \"vec4f\" },\n    row2: { expr: (input) => `(${input})[2]`, type: \"vec4f\" },\n    row3: { expr: (input) => `(${input})[3]`, type: \"vec4f\" },\n    col0: { expr: (input) => `vec4<f32>((${input})[0][0], (${input})[1][0], (${input})[2][0], (${input})[3][0])`, type: \"vec4f\" },\n    col1: { expr: (input) => `vec4<f32>((${input})[0][1], (${input})[1][1], (${input})[2][1], (${input})[3][1])`, type: \"vec4f\" },\n    col2: { expr: (input) => `vec4<f32>((${input})[0][2], (${input})[1][2], (${input})[2][2], (${input})[3][2])`, type: \"vec4f\" },\n    col3: { expr: (input) => `vec4<f32>((${input})[0][3], (${input})[1][3], (${input})[2][3], (${input})[3][3])`, type: \"vec4f\" },\n};\n\nfunction optionalVec4(block: NodeBlock, inputName: string, fallback: string, stage: Stage, state: NodeBuildState, ctx: NodeEmitContext): string {\n    const input = block.inputs.get(inputName);\n    if (!input?.source) {\n        return fallback;\n    }\n    return ctx.cast(ctx.resolve(block, inputName, stage, state), \"vec4f\").expr;\n}\n\nfunction emitMatrixBuilder(block: NodeBlock, stage: Stage, state: NodeBuildState, ctx: NodeEmitContext): NodeExpr {\n    const row0 = optionalVec4(block, \"row0\", \"vec4<f32>(1.0, 0.0, 0.0, 0.0)\", stage, state, ctx);\n    const row1 = optionalVec4(block, \"row1\", \"vec4<f32>(0.0, 1.0, 0.0, 0.0)\", stage, state, ctx);\n    const row2 = optionalVec4(block, \"row2\", \"vec4<f32>(0.0, 0.0, 1.0, 0.0)\", stage, state, ctx);\n    const row3 = optionalVec4(block, \"row3\", \"vec4<f32>(0.0, 0.0, 0.0, 1.0)\", stage, state, ctx);\n    return { expr: `mat4x4<f32>(${row0}, ${row1}, ${row2}, ${row3})`, type: \"mat4f\" };\n}\n\nexport const emitter: BlockEmitter = {\n    className: \"MatrixBlocks\",\n    emit(block, outputName, stage, state, ctx) {\n        if (block.className === \"MatrixBuilder\") {\n            return emitMatrixBuilder(block, stage, state, ctx);\n        }\n        const input = ctx.cast(ctx.resolve(block, \"input\", stage, state), \"mat4f\");\n        if (block.className === \"MatrixTransposeBlock\") {\n            return { expr: `transpose(${input.expr})`, type: \"mat4f\" };\n        }\n        if (block.className === \"MatrixDeterminantBlock\") {\n            return { expr: `determinant(${input.expr})`, type: \"f32\" };\n        }\n        if (block.className === \"MatrixSplitterBlock\") {\n            const output = SPLIT_OUTPUT[outputName];\n            if (!output) {\n                throw new Error(`NodeMaterial: MatrixSplitterBlock has no output \"${outputName}\"`);\n            }\n            return { expr: output.expr(input.expr), type: output.type };\n        }\n        throw new Error(`NodeMaterial: unsupported matrix block \"${block.className}\"`);\n    },\n};\n"],"names":[],"mappings":"AAUA,MAAM,eAA2G;AAAA,EAC7G,MAAM,EAAE,MAAM,CAAC,UAAU,IAAI,KAAK,QAAQ,MAAM,QAAA;AAAA,EAChD,MAAM,EAAE,MAAM,CAAC,UAAU,IAAI,KAAK,QAAQ,MAAM,QAAA;AAAA,EAChD,MAAM,EAAE,MAAM,CAAC,UAAU,IAAI,KAAK,QAAQ,MAAM,QAAA;AAAA,EAChD,MAAM,EAAE,MAAM,CAAC,UAAU,IAAI,KAAK,QAAQ,MAAM,QAAA;AAAA,EAChD,MAAM,EAAE,MAAM,CAAC,UAAU,cAAc,KAAK,aAAa,KAAK,aAAa,KAAK,aAAa,KAAK,YAAY,MAAM,QAAA;AAAA,EACpH,MAAM,EAAE,MAAM,CAAC,UAAU,cAAc,KAAK,aAAa,KAAK,aAAa,KAAK,aAAa,KAAK,YAAY,MAAM,QAAA;AAAA,EACpH,MAAM,EAAE,MAAM,CAAC,UAAU,cAAc,KAAK,aAAa,KAAK,aAAa,KAAK,aAAa,KAAK,YAAY,MAAM,QAAA;AAAA,EACpH,MAAM,EAAE,MAAM,CAAC,UAAU,cAAc,KAAK,aAAa,KAAK,aAAa,KAAK,aAAa,KAAK,YAAY,MAAM,QAAA;AACxH;AAEA,SAAS,aAAa,OAAkB,WAAmB,UAAkB,OAAc,OAAuB,KAA8B;AAC5I,QAAM,QAAQ,MAAM,OAAO,IAAI,SAAS;AACxC,MAAI,EAAC,+BAAO,SAAQ;AAChB,WAAO;AAAA,EACX;AACA,SAAO,IAAI,KAAK,IAAI,QAAQ,OAAO,WAAW,OAAO,KAAK,GAAG,OAAO,EAAE;AAC1E;AAEA,SAAS,kBAAkB,OAAkB,OAAc,OAAuB,KAAgC;AAC9G,QAAM,OAAO,aAAa,OAAO,QAAQ,iCAAiC,OAAO,OAAO,GAAG;AAC3F,QAAM,OAAO,aAAa,OAAO,QAAQ,iCAAiC,OAAO,OAAO,GAAG;AAC3F,QAAM,OAAO,aAAa,OAAO,QAAQ,iCAAiC,OAAO,OAAO,GAAG;AAC3F,QAAM,OAAO,aAAa,OAAO,QAAQ,iCAAiC,OAAO,OAAO,GAAG;AAC3F,SAAO,EAAE,MAAM,eAAe,IAAI,KAAK,IAAI,KAAK,IAAI,KAAK,IAAI,KAAK,MAAM,QAAA;AAC5E;AAEO,MAAM,UAAwB;AAAA,EACjC,WAAW;AAAA,EACX,KAAK,OAAO,YAAY,OAAO,OAAO,KAAK;AACvC,QAAI,MAAM,cAAc,iBAAiB;AACrC,aAAO,kBAAkB,OAAO,OAAO,OAAO,GAAG;AAAA,IACrD;AACA,UAAM,QAAQ,IAAI,KAAK,IAAI,QAAQ,OAAO,SAAS,OAAO,KAAK,GAAG,OAAO;AACzE,QAAI,MAAM,cAAc,wBAAwB;AAC5C,aAAO,EAAE,MAAM,aAAa,MAAM,IAAI,KAAK,MAAM,QAAA;AAAA,IACrD;AACA,QAAI,MAAM,cAAc,0BAA0B;AAC9C,aAAO,EAAE,MAAM,eAAe,MAAM,IAAI,KAAK,MAAM,MAAA;AAAA,IACvD;AACA,QAAI,MAAM,cAAc,uBAAuB;AAC3C,YAAM,SAAS,aAAa,UAAU;AACtC,UAAI,CAAC,QAAQ;AACT,cAAM,IAAI,MAAM,oDAAoD,UAAU,GAAG;AAAA,MACrF;AACA,aAAO,EAAE,MAAM,OAAO,KAAK,MAAM,IAAI,GAAG,MAAM,OAAO,KAAA;AAAA,IACzD;AACA,UAAM,IAAI,MAAM,2CAA2C,MAAM,SAAS,GAAG;AAAA,EACjF;AACJ;"}

package/max-block-CjFgljZ7.js

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

package/max-block-CjFgljZ7.js.map

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

package/mesh-attribute-exists-block-BfK8UiSL.js

@@ -0,0 +1,44 @@
+function attributeFlag(attributeType) {
+  switch (attributeType) {
+    case 1:
+      return "1.0";
+    case 2:
+      return "meshU.receivesShadow.z";
+    case 3:
+      return "meshU.receivesShadow.w";
+    case 4:
+      return "meshU.receivesShadow.y";
+    case 5:
+      return "0.0";
+    case 6:
+    // UV3
+    case 7:
+    // UV4
+    case 8:
+    // UV5
+    case 9:
+      return "0.0";
+    default:
+      return null;
+  }
+}
+const emitter = {
+  className: "MeshAttributeExistsBlock",
+  emit(block, _outputName, stage, state, ctx) {
+    state.usesMeshAttributeExists = true;
+    const input = ctx.resolve(block, "input", stage, state);
+    const flag = attributeFlag(block.serialized["attributeType"] ?? 0);
+    if (flag === null) {
+      return input;
+    }
+    const fallback = ctx.cast(ctx.resolve(block, "fallback", stage, state), input.type);
+    const expr = ctx.temp(state, "attr");
+    const s = stage === "vertex" ? state.vertex : state.fragment;
+    s.body.push(`let ${expr} = select(${fallback.expr}, ${input.expr}, ${flag} > 0.5);`);
+    return { expr, type: input.type };
+  }
+};
+export {
+  emitter
+};
+//# sourceMappingURL=mesh-attribute-exists-block-BfK8UiSL.js.map

package/mesh-attribute-exists-block-BfK8UiSL.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mesh-attribute-exists-block-BfK8UiSL.js","sources":["../src/material/node/blocks/mesh-attribute-exists-block.ts"],"sourcesContent":["/** MeshAttributeExistsBlock — per-mesh attribute branch.\n *\n * Babylon.js emits preprocessor branches based on the mesh attribute defines\n * (`UV1`, `TANGENT`, `VERTEXCOLOR_NME`, ...). Babylon Lite batches meshes that\n * share the same NME pipeline, so the equivalent decision is a per-mesh uniform\n * flag written beside the world matrix. Missing attributes still bind zero\n * buffers to satisfy the pipeline layout, but this block selects the serialized\n * fallback value when the real mesh attribute is absent.\n */\n\nimport type { BlockEmitter, NodeExpr } from \"../node-types.js\";\n\nfunction attributeFlag(attributeType: number): string | null {\n    switch (attributeType) {\n        case 1: // Normal\n            return \"1.0\";\n        case 2: // Tangent\n            return \"meshU.receivesShadow.z\";\n        case 3: // VertexColor\n            return \"meshU.receivesShadow.w\";\n        case 4: // UV1\n            return \"meshU.receivesShadow.y\";\n        case 5: // UV2\n            return \"0.0\";\n        case 6: // UV3\n        case 7: // UV4\n        case 8: // UV5\n        case 9: // UV6\n            return \"0.0\";\n        default:\n            return null;\n    }\n}\n\nexport const emitter: BlockEmitter = {\n    className: \"MeshAttributeExistsBlock\",\n    emit(block, _outputName, stage, state, ctx) {\n        state.usesMeshAttributeExists = true;\n        const input = ctx.resolve(block, \"input\", stage, state);\n        const flag = attributeFlag((block.serialized[\"attributeType\"] as number | undefined) ?? 0);\n        if (flag === null) {\n            return input;\n        }\n        const fallback = ctx.cast(ctx.resolve(block, \"fallback\", stage, state), input.type);\n        const expr = ctx.temp(state, \"attr\");\n        const s = stage === \"vertex\" ? state.vertex : state.fragment;\n        s.body.push(`let ${expr} = select(${fallback.expr}, ${input.expr}, ${flag} > 0.5);`);\n        return { expr, type: input.type } as NodeExpr;\n    },\n};\n"],"names":[],"mappings":"AAYA,SAAS,cAAc,eAAsC;AACzD,UAAQ,eAAA;AAAA,IACJ,KAAK;AACD,aAAO;AAAA,IACX,KAAK;AACD,aAAO;AAAA,IACX,KAAK;AACD,aAAO;AAAA,IACX,KAAK;AACD,aAAO;AAAA,IACX,KAAK;AACD,aAAO;AAAA,IACX,KAAK;AAAA;AAAA,IACL,KAAK;AAAA;AAAA,IACL,KAAK;AAAA;AAAA,IACL,KAAK;AACD,aAAO;AAAA,IACX;AACI,aAAO;AAAA,EAAA;AAEnB;AAEO,MAAM,UAAwB;AAAA,EACjC,WAAW;AAAA,EACX,KAAK,OAAO,aAAa,OAAO,OAAO,KAAK;AACxC,UAAM,0BAA0B;AAChC,UAAM,QAAQ,IAAI,QAAQ,OAAO,SAAS,OAAO,KAAK;AACtD,UAAM,OAAO,cAAe,MAAM,WAAW,eAAe,KAA4B,CAAC;AACzF,QAAI,SAAS,MAAM;AACf,aAAO;AAAA,IACX;AACA,UAAM,WAAW,IAAI,KAAK,IAAI,QAAQ,OAAO,YAAY,OAAO,KAAK,GAAG,MAAM,IAAI;AAClF,UAAM,OAAO,IAAI,KAAK,OAAO,MAAM;AACnC,UAAM,IAAI,UAAU,WAAW,MAAM,SAAS,MAAM;AACpD,MAAE,KAAK,KAAK,OAAO,IAAI,aAAa,SAAS,IAAI,KAAK,MAAM,IAAI,KAAK,IAAI,UAAU;AACnF,WAAO,EAAE,MAAM,MAAM,MAAM,KAAA;AAAA,EAC/B;AACJ;"}

package/mesh-features-BLENkYVt.js

@@ -0,0 +1,341 @@
+import { aV as computeUboLayout, aW as SCENE_UBO_WGSL } from "./index-C8HOR2sB.js";
+const STAGE_VERTEX = 1;
+const STAGE_FRAGMENT = 2;
+function topoSort(fragments) {
+  const byId = /* @__PURE__ */ new Map();
+  for (const f of fragments) {
+    if (byId.has(f._id)) {
+      throw Error();
+    }
+    byId.set(f._id, f);
+  }
+  const inDeg = /* @__PURE__ */ new Map();
+  const deps = /* @__PURE__ */ new Map();
+  for (const f of fragments) {
+    if (!inDeg.has(f._id)) {
+      inDeg.set(f._id, 0);
+    }
+    for (const d of f._dependencies ?? []) {
+      if (!byId.has(d)) {
+        throw Error();
+      }
+      inDeg.set(f._id, (inDeg.get(f._id) ?? 0) + 1);
+      let arr = deps.get(d);
+      if (!arr) {
+        arr = [];
+        deps.set(d, arr);
+      }
+      arr.push(f._id);
+    }
+  }
+  const q = [];
+  for (const [id, d] of inDeg) {
+    if (d === 0) {
+      q.push(id);
+    }
+  }
+  q.sort();
+  const out = [];
+  let qi = 0;
+  while (qi < q.length) {
+    const id = q[qi++];
+    out.push(byId.get(id));
+    for (const d of deps.get(id) ?? []) {
+      const nd = (inDeg.get(d) ?? 1) - 1;
+      inDeg.set(d, nd);
+      if (nd === 0) {
+        let i = qi;
+        while (i < q.length && q[i] < d) {
+          i++;
+        }
+        q.splice(i, 0, d);
+      }
+    }
+  }
+  if (out.length !== fragments.length) {
+    throw Error();
+  }
+  return out;
+}
+function dedup(base, extra) {
+  const seen = /* @__PURE__ */ new Set();
+  const all = [];
+  for (const v of base) {
+    if (!seen.has(v._name)) {
+      seen.add(v._name);
+      all.push(v);
+    }
+  }
+  for (const v of extra) {
+    if (!seen.has(v._name)) {
+      seen.add(v._name);
+      all.push(v);
+    }
+  }
+  return all;
+}
+function bglEntry(binding, decl) {
+  const e = { binding, visibility: decl._visibility };
+  switch (decl._type._kind) {
+    case "uniform-buffer":
+      e.buffer = { type: "uniform" };
+      break;
+    case "texture": {
+      const def = decl._type._textureType === "texture_depth_2d" ? "depth" : decl._type._textureType === "texture_2d<u32>" ? "uint" : "float";
+      e.texture = { sampleType: decl._type._sampleType ?? def, viewDimension: decl._type._textureType.includes("cube") ? "cube" : "2d" };
+      break;
+    }
+    case "sampler":
+      e.sampler = {
+        type: decl._type._samplerType === "sampler_comparison" ? "comparison" : decl._type._samplerType === "sampler_non_filtering" ? "non-filtering" : "filtering"
+      };
+      break;
+    case "storage-texture":
+      e.storageTexture = { access: decl._type._access, format: decl._type._format };
+      break;
+  }
+  return e;
+}
+function declWGSL(g, b, d) {
+  switch (d._type._kind) {
+    case "uniform-buffer":
+      return `@group(${g})@binding(${b}) var<uniform> ${d._name}:${d._name}Uniforms;`;
+    case "texture":
+      return `@group(${g})@binding(${b}) var ${d._name}:${d._type._textureType};`;
+    case "sampler":
+      return `@group(${g})@binding(${b}) var ${d._name}:${d._type._samplerType === "sampler_non_filtering" ? "sampler" : d._type._samplerType};`;
+    case "storage-texture":
+      return `@group(${g})@binding(${b}) var ${d._name}:texture_storage_2d<${d._type._format},${d._type._access}>;`;
+  }
+}
+const SLOT_RE = /\/\*([A-Z_0-9]+)\*\//g;
+function injectSlots(tpl, sorted, key) {
+  return tpl.replace(SLOT_RE, (_, slot) => {
+    const parts = [];
+    for (const f of sorted) {
+      const s = f[key];
+      if (s == null ? void 0 : s[slot]) {
+        parts.push(s[slot]);
+      }
+    }
+    return parts.join("\n");
+  });
+}
+function composeShader(template, fragments) {
+  var _a;
+  const sorted = topoSort(fragments);
+  const fragAttrs = [];
+  const fragVaryings = [];
+  const helpers = [];
+  const vHelpers = [];
+  const vBuiltins = [];
+  for (const f of sorted) {
+    if (f._vertexAttributes) {
+      fragAttrs.push(...f._vertexAttributes);
+    }
+    if (f._varyings) {
+      fragVaryings.push(...f._varyings);
+    }
+    if (f._helperFunctions) {
+      helpers.push(f._helperFunctions);
+    }
+    if (f._vertexHelperFunctions) {
+      vHelpers.push(f._vertexHelperFunctions);
+    }
+    for (const b of f._vertexBuiltins ?? []) {
+      vBuiltins.push(`@builtin(${b._builtin}) ${b._name}:${b._type},`);
+    }
+  }
+  const allAttrs = dedup(template._baseVertexAttributes, fragAttrs);
+  const inputLines = [];
+  const _vertexBufferLayouts = [];
+  const groups = /* @__PURE__ */ new Map();
+  const firstOfGroup = /* @__PURE__ */ new Map();
+  for (let i = 0; i < allAttrs.length; i++) {
+    const a = allAttrs[i];
+    inputLines.push(`@location(${i}) ${a._name}:${a._type},`);
+    if (a._bufferGroup) {
+      if (!groups.has(a._bufferGroup)) {
+        groups.set(a._bufferGroup, []);
+        firstOfGroup.set(a._bufferGroup, a);
+      }
+      groups.get(a._bufferGroup).push({ loc: i, off: a._offset ?? 0, fmt: a._gpuFormat });
+    } else {
+      _vertexBufferLayouts.push({
+        arrayStride: a._arrayStride,
+        stepMode: a._stepMode ?? "vertex",
+        attributes: [{ shaderLocation: i, offset: a._offset ?? 0, format: a._gpuFormat }]
+      });
+    }
+  }
+  for (const [grp, attrs] of groups) {
+    const f = firstOfGroup.get(grp);
+    _vertexBufferLayouts.push({
+      arrayStride: f._arrayStride,
+      stepMode: f._stepMode ?? "vertex",
+      attributes: attrs.map((a) => ({ shaderLocation: a.loc, offset: a.off, format: a.fmt }))
+    });
+  }
+  let nextLoc = allAttrs.length;
+  for (const f of sorted) {
+    if (f._pipelineVertexBuffers) {
+      const r = f._pipelineVertexBuffers(nextLoc);
+      _vertexBufferLayouts.push(...r._buffers);
+      nextLoc = r._nextLoc;
+    }
+  }
+  const allVary = dedup(template._baseVaryings, fragVaryings);
+  const varyBody = `@builtin(position) clipPos:vec4f,
+` + allVary.map((v, i) => `@location(${i}) ${v._name}:${v._type},`).join("\n");
+  const hasMaterialUbo = !!(template._baseMaterialUboFields && template._baseMaterialUboFields.length > 0);
+  const meshFields = [...template._baseMeshUboFields];
+  const materialFields = hasMaterialUbo ? [...template._baseMaterialUboFields] : [];
+  for (const f of sorted) {
+    if ((_a = f._uboFields) == null ? void 0 : _a.length) {
+      (hasMaterialUbo ? materialFields : meshFields).push(...f._uboFields);
+    }
+  }
+  const _meshUboSpec = computeUboLayout(meshFields);
+  const _materialUboSpec = hasMaterialUbo ? computeUboLayout(materialFields) : void 0;
+  const meshBGL = [{ binding: 0, visibility: STAGE_VERTEX | STAGE_FRAGMENT, buffer: { type: "uniform" } }];
+  if (hasMaterialUbo) {
+    meshBGL.push({ binding: 1, visibility: STAGE_FRAGMENT, buffer: { type: "uniform" } });
+  }
+  const shadowBGL = [];
+  const vDecls = [];
+  const fDecls = [];
+  let mb = hasMaterialUbo ? 2 : 1, sb = 0;
+  function addBinding(d, _isVertex) {
+    const isShadow = d._group === "shadow";
+    const b = isShadow ? sb++ : mb++;
+    const g = isShadow ? 2 : 1;
+    (isShadow ? shadowBGL : meshBGL).push(bglEntry(b, d));
+    const w = declWGSL(g, b, d);
+    if (d._visibility & STAGE_VERTEX) {
+      vDecls.push(w);
+    }
+    if (d._visibility & STAGE_FRAGMENT) {
+      fDecls.push(w);
+    }
+  }
+  for (const d of template._baseVertexBindings ?? []) {
+    addBinding(d);
+  }
+  for (const f of sorted) {
+    for (const d of f._vertexBindings ?? []) {
+      addBinding(d);
+    }
+  }
+  for (const d of template._baseBindings ?? []) {
+    addBinding(d);
+  }
+  for (const f of sorted) {
+    for (const d of (f._bindings ?? []).filter((b) => (b._group ?? "mesh") === "mesh")) {
+      addBinding(d);
+    }
+  }
+  for (const f of sorted) {
+    for (const d of (f._bindings ?? []).filter((b) => b._group === "shadow")) {
+      addBinding(d);
+    }
+  }
+  const _fragmentKey = sorted.map((f) => f._id).join("|");
+  const vParams = (vBuiltins.length ? vBuiltins.join("\n") + "\n" : "") + inputLines.join("\n");
+  const meshStruct = `struct MeshUniforms{
+${_meshUboSpec._structBody}
+}`;
+  const materialStruct = _materialUboSpec ? `
+struct MaterialUniforms{
+${_materialUboSpec._structBody}
+}
+@group(1)@binding(1) var<uniform> material:MaterialUniforms;` : "";
+  let _vertexWGSL = template._vertexTemplate;
+  _vertexWGSL = _vertexWGSL.replace("/*SU*/", SCENE_UBO_WGSL);
+  _vertexWGSL = _vertexWGSL.replace("/*MU*/", meshStruct);
+  _vertexWGSL = _vertexWGSL.replace("/*VI*/", `struct VertexInput{
+${inputLines.join("\n")}
+}`);
+  _vertexWGSL = _vertexWGSL.replace("/*VO*/", `struct VertexOutput{
+${varyBody}
+}`);
+  _vertexWGSL = _vertexWGSL.replace("/*VD*/", vDecls.join("\n"));
+  _vertexWGSL = _vertexWGSL.replace("/*VP*/", vParams);
+  _vertexWGSL = _vertexWGSL.replace("/*VH*/", vHelpers.join("\n"));
+  _vertexWGSL = injectSlots(_vertexWGSL, sorted, "_vertexSlots");
+  let _fragmentWGSL = template._fragmentTemplate;
+  _fragmentWGSL = _fragmentWGSL.replace("/*SU*/", SCENE_UBO_WGSL);
+  _fragmentWGSL = _fragmentWGSL.replace("/*MU*/", meshStruct + materialStruct);
+  _fragmentWGSL = _fragmentWGSL.replace("/*FI*/", `struct FragmentInput{
+${varyBody}
+}`);
+  _fragmentWGSL = _fragmentWGSL.replace("/*HF*/", helpers.join("\n"));
+  _fragmentWGSL = _fragmentWGSL.replace("/*FB*/", fDecls.join("\n"));
+  _fragmentWGSL = injectSlots(_fragmentWGSL, sorted, "_fragmentSlots");
+  const _meshBGLDescriptor = { entries: meshBGL };
+  const _shadowBGLDescriptor = shadowBGL.length ? { entries: shadowBGL } : null;
+  return {
+    _vertexWGSL,
+    _fragmentWGSL,
+    _meshBGLDescriptor,
+    _shadowBGLDescriptor,
+    _vertexBufferLayouts,
+    _meshUboSpec,
+    _materialUboSpec,
+    _fragmentKey
+  };
+}
+const MSH_HAS_TANGENTS = 1 << 0;
+const MSH_HAS_SKELETON = 1 << 1;
+const MSH_HAS_SKELETON_8 = 1 << 2;
+const MSH_HAS_MORPH_TARGETS = 1 << 3;
+const MSH_HAS_THIN_INSTANCES = 1 << 4;
+const MSH_HAS_INSTANCE_COLOR = 1 << 5;
+const MSH_HAS_VERTEX_COLOR = 1 << 6;
+const MSH_HAS_UV2 = 1 << 7;
+const MSH_RECEIVE_SHADOWS = 1 << 8;
+function _computeMeshFeatures(mesh, receiveShadows = false) {
+  const gpu = mesh._gpu;
+  let features = 0;
+  if (gpu.tangentBuffer) {
+    features |= MSH_HAS_TANGENTS;
+  }
+  if (mesh.skeleton) {
+    features |= MSH_HAS_SKELETON;
+    if (mesh.skeleton.joints1Buffer) {
+      features |= MSH_HAS_SKELETON_8;
+    }
+  }
+  if (mesh.morphTargets) {
+    features |= MSH_HAS_MORPH_TARGETS;
+  }
+  if (mesh.thinInstances) {
+    features |= MSH_HAS_THIN_INSTANCES;
+    if (mesh.thinInstances.colors) {
+      features |= MSH_HAS_INSTANCE_COLOR;
+    }
+  }
+  if (gpu.colorBuffer) {
+    features |= MSH_HAS_VERTEX_COLOR;
+  }
+  if (gpu.uv2Buffer) {
+    features |= MSH_HAS_UV2;
+  }
+  if (receiveShadows) {
+    features |= MSH_RECEIVE_SHADOWS;
+  }
+  return features;
+}
+export {
+  MSH_HAS_SKELETON as M,
+  _computeMeshFeatures as _,
+  MSH_HAS_SKELETON_8 as a,
+  MSH_HAS_MORPH_TARGETS as b,
+  MSH_HAS_UV2 as c,
+  MSH_HAS_TANGENTS as d,
+  composeShader as e,
+  MSH_RECEIVE_SHADOWS as f,
+  MSH_HAS_THIN_INSTANCES as g,
+  MSH_HAS_VERTEX_COLOR as h,
+  MSH_HAS_INSTANCE_COLOR as i
+};
+//# sourceMappingURL=mesh-features-BLENkYVt.js.map

package/mesh-features-BLENkYVt.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mesh-features-BLENkYVt.js","sources":["../src/shader/shader-composer.ts","../src/material/mesh-features.ts"],"sourcesContent":["/**\n * Shader Composer — assembles ShaderFragment[] + ShaderTemplate into\n * final WGSL source + GPU layout descriptors. Pure function, no global state.\n * All shader text comes from template + fragment modules.\n */\nimport type { BindingDecl, ComposedShader, FragmentSlot, ShaderFragment, ShaderTemplate, VertexAttribute, VertexSlot, Varying } from \"./fragment-types.js\";\nimport { computeUboLayout } from \"./ubo-layout.js\";\nimport { SCENE_UBO_WGSL } from \"./scene-uniforms.js\";\n\nconst STAGE_VERTEX = 0x1;\nconst STAGE_FRAGMENT = 0x2;\n\nfunction topoSort(fragments: readonly ShaderFragment[]): ShaderFragment[] {\n    const byId = new Map<string, ShaderFragment>();\n    for (const f of fragments) {\n        if (byId.has(f._id)) {\n            throw Error();\n        }\n        byId.set(f._id, f);\n    }\n    const inDeg = new Map<string, number>();\n    const deps = new Map<string, string[]>();\n    for (const f of fragments) {\n        if (!inDeg.has(f._id)) {\n            inDeg.set(f._id, 0);\n        }\n        for (const d of f._dependencies ?? []) {\n            if (!byId.has(d)) {\n                throw Error();\n            }\n            inDeg.set(f._id, (inDeg.get(f._id) ?? 0) + 1);\n            let arr = deps.get(d);\n            if (!arr) {\n                arr = [];\n                deps.set(d, arr);\n            }\n            arr.push(f._id);\n        }\n    }\n    const q: string[] = [];\n    for (const [id, d] of inDeg) {\n        if (d === 0) {\n            q.push(id);\n        }\n    }\n    q.sort();\n    const out: ShaderFragment[] = [];\n    let qi = 0;\n    while (qi < q.length) {\n        const id = q[qi++]!;\n        out.push(byId.get(id)!);\n        for (const d of deps.get(id) ?? []) {\n            const nd = (inDeg.get(d) ?? 1) - 1;\n            inDeg.set(d, nd);\n            if (nd === 0) {\n                let i = qi;\n                while (i < q.length && q[i]! < d) {\n                    i++;\n                }\n                q.splice(i, 0, d);\n            }\n        }\n    }\n    if (out.length !== fragments.length) {\n        throw Error();\n    }\n    return out;\n}\n\nfunction dedup<T extends { _name: string }>(base: readonly T[], extra: readonly T[]): T[] {\n    const seen = new Set<string>();\n    const all: T[] = [];\n    for (const v of base) {\n        if (!seen.has(v._name)) {\n            seen.add(v._name);\n            all.push(v);\n        }\n    }\n    for (const v of extra) {\n        if (!seen.has(v._name)) {\n            seen.add(v._name);\n            all.push(v);\n        }\n    }\n    return all;\n}\n\nfunction bglEntry(binding: number, decl: BindingDecl): GPUBindGroupLayoutEntry {\n    const e: GPUBindGroupLayoutEntry = { binding, visibility: decl._visibility };\n    switch (decl._type._kind) {\n        case \"uniform-buffer\":\n            e.buffer = { type: \"uniform\" };\n            break;\n        case \"texture\": {\n            const def = decl._type._textureType === \"texture_depth_2d\" ? \"depth\" : decl._type._textureType === \"texture_2d<u32>\" ? \"uint\" : \"float\";\n            e.texture = { sampleType: (decl._type._sampleType ?? def) as GPUTextureSampleType, viewDimension: decl._type._textureType.includes(\"cube\") ? \"cube\" : \"2d\" };\n            break;\n        }\n        case \"sampler\":\n            e.sampler = {\n                type: decl._type._samplerType === \"sampler_comparison\" ? \"comparison\" : decl._type._samplerType === \"sampler_non_filtering\" ? \"non-filtering\" : \"filtering\",\n            };\n            break;\n        case \"storage-texture\":\n            e.storageTexture = { access: decl._type._access as GPUStorageTextureAccess, format: decl._type._format as GPUTextureFormat };\n            break;\n    }\n    return e;\n}\n\nfunction declWGSL(g: number, b: number, d: BindingDecl): string {\n    switch (d._type._kind) {\n        case \"uniform-buffer\":\n            return `@group(${g})@binding(${b}) var<uniform> ${d._name}:${d._name}Uniforms;`;\n        case \"texture\":\n            return `@group(${g})@binding(${b}) var ${d._name}:${d._type._textureType};`;\n        case \"sampler\":\n            return `@group(${g})@binding(${b}) var ${d._name}:${d._type._samplerType === \"sampler_non_filtering\" ? \"sampler\" : d._type._samplerType};`;\n        case \"storage-texture\":\n            return `@group(${g})@binding(${b}) var ${d._name}:texture_storage_2d<${d._type._format},${d._type._access}>;`;\n    }\n}\n\nconst SLOT_RE = /\\/\\*([A-Z_0-9]+)\\*\\//g;\nfunction injectSlots(tpl: string, sorted: readonly ShaderFragment[], key: \"_fragmentSlots\" | \"_vertexSlots\"): string {\n    return tpl.replace(SLOT_RE, (_, slot: string) => {\n        const parts: string[] = [];\n        for (const f of sorted) {\n            const s = f[key] as Partial<Record<FragmentSlot | VertexSlot, string>> | undefined;\n            if (s?.[slot as FragmentSlot | VertexSlot]) {\n                parts.push(s[slot as FragmentSlot | VertexSlot]!);\n            }\n        }\n        return parts.join(\"\\n\");\n    });\n}\n\nexport function composeShader(template: ShaderTemplate, fragments: readonly ShaderFragment[]): ComposedShader {\n    const sorted = topoSort(fragments);\n\n    // Collect fragment data\n    const fragAttrs: VertexAttribute[] = [];\n    const fragVaryings: Varying[] = [];\n    const helpers: string[] = [];\n    const vHelpers: string[] = [];\n    const vBuiltins: string[] = [];\n    for (const f of sorted) {\n        if (f._vertexAttributes) {\n            fragAttrs.push(...f._vertexAttributes);\n        }\n        if (f._varyings) {\n            fragVaryings.push(...f._varyings);\n        }\n        if (f._helperFunctions) {\n            helpers.push(f._helperFunctions);\n        }\n        if (f._vertexHelperFunctions) {\n            vHelpers.push(f._vertexHelperFunctions);\n        }\n        for (const b of f._vertexBuiltins ?? []) {\n            vBuiltins.push(`@builtin(${b._builtin}) ${b._name}:${b._type},`);\n        }\n    }\n\n    // Vertex attributes + layouts\n    const allAttrs = dedup(template._baseVertexAttributes, fragAttrs);\n    const inputLines: string[] = [];\n    const _vertexBufferLayouts: GPUVertexBufferLayout[] = [];\n    const groups = new Map<string, { loc: number; off: number; fmt: GPUVertexFormat }[]>();\n    const firstOfGroup = new Map<string, VertexAttribute>();\n    for (let i = 0; i < allAttrs.length; i++) {\n        const a = allAttrs[i]!;\n        inputLines.push(`@location(${i}) ${a._name}:${a._type},`);\n        if (a._bufferGroup) {\n            if (!groups.has(a._bufferGroup)) {\n                groups.set(a._bufferGroup, []);\n                firstOfGroup.set(a._bufferGroup, a);\n            }\n            groups.get(a._bufferGroup)!.push({ loc: i, off: a._offset ?? 0, fmt: a._gpuFormat });\n        } else {\n            _vertexBufferLayouts.push({\n                arrayStride: a._arrayStride,\n                stepMode: a._stepMode ?? \"vertex\",\n                attributes: [{ shaderLocation: i, offset: a._offset ?? 0, format: a._gpuFormat }],\n            });\n        }\n    }\n    for (const [grp, attrs] of groups) {\n        const f = firstOfGroup.get(grp)!;\n        _vertexBufferLayouts.push({\n            arrayStride: f._arrayStride,\n            stepMode: f._stepMode ?? \"vertex\",\n            attributes: attrs.map((a) => ({ shaderLocation: a.loc, offset: a.off, format: a.fmt })),\n        });\n    }\n    let nextLoc = allAttrs.length;\n    for (const f of sorted) {\n        if (f._pipelineVertexBuffers) {\n            const r = f._pipelineVertexBuffers(nextLoc);\n            _vertexBufferLayouts.push(...r._buffers);\n            nextLoc = r._nextLoc;\n        }\n    }\n\n    // Varyings\n    const allVary = dedup(template._baseVaryings, fragVaryings);\n    const varyBody = `@builtin(position) clipPos:vec4f,\\n` + allVary.map((v, i) => `@location(${i}) ${v._name}:${v._type},`).join(\"\\n\");\n\n    // UBO layouts\n    const hasMaterialUbo = !!(template._baseMaterialUboFields && template._baseMaterialUboFields.length > 0);\n    const meshFields = [...template._baseMeshUboFields];\n    const materialFields = hasMaterialUbo ? [...template._baseMaterialUboFields] : [];\n    for (const f of sorted) {\n        if (f._uboFields?.length) {\n            (hasMaterialUbo ? materialFields : meshFields).push(...f._uboFields);\n        }\n    }\n    const _meshUboSpec = computeUboLayout(meshFields);\n    const _materialUboSpec = hasMaterialUbo ? computeUboLayout(materialFields) : undefined;\n\n    // Bindings\n    const meshBGL: GPUBindGroupLayoutEntry[] = [{ binding: 0, visibility: STAGE_VERTEX | STAGE_FRAGMENT, buffer: { type: \"uniform\" } }];\n    if (hasMaterialUbo) {\n        meshBGL.push({ binding: 1, visibility: STAGE_FRAGMENT, buffer: { type: \"uniform\" } });\n    }\n    const shadowBGL: GPUBindGroupLayoutEntry[] = [];\n    const vDecls: string[] = [];\n    const fDecls: string[] = [];\n    let mb = hasMaterialUbo ? 2 : 1,\n        sb = 0;\n\n    function addBinding(d: BindingDecl, _isVertex: boolean) {\n        const isShadow = d._group === \"shadow\";\n        const b = isShadow ? sb++ : mb++;\n        const g = isShadow ? 2 : 1;\n        (isShadow ? shadowBGL : meshBGL).push(bglEntry(b, d));\n        const w = declWGSL(g, b, d);\n        if (d._visibility & STAGE_VERTEX) {\n            vDecls.push(w);\n        }\n        if (d._visibility & STAGE_FRAGMENT) {\n            fDecls.push(w);\n        }\n    }\n\n    for (const d of template._baseVertexBindings ?? []) {\n        addBinding(d, true);\n    }\n    for (const f of sorted) {\n        for (const d of f._vertexBindings ?? []) {\n            addBinding(d, true);\n        }\n    }\n    for (const d of template._baseBindings ?? []) {\n        addBinding(d, false);\n    }\n    for (const f of sorted) {\n        for (const d of (f._bindings ?? []).filter((b) => (b._group ?? \"mesh\") === \"mesh\")) {\n            addBinding(d, false);\n        }\n    }\n    for (const f of sorted) {\n        for (const d of (f._bindings ?? []).filter((b) => b._group === \"shadow\")) {\n            addBinding(d, false);\n        }\n    }\n\n    const _fragmentKey = sorted.map((f) => f._id).join(\"|\");\n    const vParams = (vBuiltins.length ? vBuiltins.join(\"\\n\") + \"\\n\" : \"\") + inputLines.join(\"\\n\");\n    const meshStruct = `struct MeshUniforms{\\n${_meshUboSpec._structBody}\\n}`;\n    const materialStruct = _materialUboSpec ? `\\nstruct MaterialUniforms{\\n${_materialUboSpec._structBody}\\n}\\n@group(1)@binding(1) var<uniform> material:MaterialUniforms;` : \"\";\n\n    let _vertexWGSL = template._vertexTemplate;\n    _vertexWGSL = _vertexWGSL.replace(\"/*SU*/\", SCENE_UBO_WGSL);\n    _vertexWGSL = _vertexWGSL.replace(\"/*MU*/\", meshStruct);\n    _vertexWGSL = _vertexWGSL.replace(\"/*VI*/\", `struct VertexInput{\\n${inputLines.join(\"\\n\")}\\n}`);\n    _vertexWGSL = _vertexWGSL.replace(\"/*VO*/\", `struct VertexOutput{\\n${varyBody}\\n}`);\n    _vertexWGSL = _vertexWGSL.replace(\"/*VD*/\", vDecls.join(\"\\n\"));\n    _vertexWGSL = _vertexWGSL.replace(\"/*VP*/\", vParams);\n    _vertexWGSL = _vertexWGSL.replace(\"/*VH*/\", vHelpers.join(\"\\n\"));\n    // These dynamic keys are reserved from Terser property mangling in bundle-scenes-core.ts.\n    _vertexWGSL = injectSlots(_vertexWGSL, sorted, \"_vertexSlots\");\n\n    let _fragmentWGSL = template._fragmentTemplate;\n    _fragmentWGSL = _fragmentWGSL.replace(\"/*SU*/\", SCENE_UBO_WGSL);\n    _fragmentWGSL = _fragmentWGSL.replace(\"/*MU*/\", meshStruct + materialStruct);\n    _fragmentWGSL = _fragmentWGSL.replace(\"/*FI*/\", `struct FragmentInput{\\n${varyBody}\\n}`);\n    _fragmentWGSL = _fragmentWGSL.replace(\"/*HF*/\", helpers.join(\"\\n\"));\n    _fragmentWGSL = _fragmentWGSL.replace(\"/*FB*/\", fDecls.join(\"\\n\"));\n    _fragmentWGSL = injectSlots(_fragmentWGSL, sorted, \"_fragmentSlots\");\n\n    const _meshBGLDescriptor = { entries: meshBGL };\n    const _shadowBGLDescriptor = shadowBGL.length ? { entries: shadowBGL } : null;\n\n    return {\n        _vertexWGSL,\n        _fragmentWGSL,\n        _meshBGLDescriptor,\n        _shadowBGLDescriptor,\n        _vertexBufferLayouts,\n        _meshUboSpec,\n        _materialUboSpec,\n        _fragmentKey,\n    };\n}\n","import type { Mesh } from \"../mesh/mesh.js\";\n\nexport const MSH_HAS_TANGENTS = 1 << 0;\nexport const MSH_HAS_SKELETON = 1 << 1;\nexport const MSH_HAS_SKELETON_8 = 1 << 2;\nexport const MSH_HAS_MORPH_TARGETS = 1 << 3;\nexport const MSH_HAS_THIN_INSTANCES = 1 << 4;\nexport const MSH_HAS_INSTANCE_COLOR = 1 << 5;\nexport const MSH_HAS_VERTEX_COLOR = 1 << 6;\nexport const MSH_HAS_UV2 = 1 << 7;\nexport const MSH_RECEIVE_SHADOWS = 1 << 8;\n\n/** @internal Compute mesh/pass feature bits shared by material renderers. */\nexport function _computeMeshFeatures(mesh: Mesh, receiveShadows = false): number {\n    const gpu = mesh._gpu;\n    let features = 0;\n    if (gpu.tangentBuffer) {\n        features |= MSH_HAS_TANGENTS;\n    }\n    if (mesh.skeleton) {\n        features |= MSH_HAS_SKELETON;\n        if (mesh.skeleton.joints1Buffer) {\n            features |= MSH_HAS_SKELETON_8;\n        }\n    }\n    if (mesh.morphTargets) {\n        features |= MSH_HAS_MORPH_TARGETS;\n    }\n    if (mesh.thinInstances) {\n        features |= MSH_HAS_THIN_INSTANCES;\n        if (mesh.thinInstances.colors) {\n            features |= MSH_HAS_INSTANCE_COLOR;\n        }\n    }\n    if (gpu.colorBuffer) {\n        features |= MSH_HAS_VERTEX_COLOR;\n    }\n    if (gpu.uv2Buffer) {\n        features |= MSH_HAS_UV2;\n    }\n    if (receiveShadows) {\n        features |= MSH_RECEIVE_SHADOWS;\n    }\n    return features;\n}\n"],"names":[],"mappings":";AASA,MAAM,eAAe;AACrB,MAAM,iBAAiB;AAEvB,SAAS,SAAS,WAAwD;AACtE,QAAM,2BAAW,IAAA;AACjB,aAAW,KAAK,WAAW;AACvB,QAAI,KAAK,IAAI,EAAE,GAAG,GAAG;AACjB,YAAM,MAAA;AAAA,IACV;AACA,SAAK,IAAI,EAAE,KAAK,CAAC;AAAA,EACrB;AACA,QAAM,4BAAY,IAAA;AAClB,QAAM,2BAAW,IAAA;AACjB,aAAW,KAAK,WAAW;AACvB,QAAI,CAAC,MAAM,IAAI,EAAE,GAAG,GAAG;AACnB,YAAM,IAAI,EAAE,KAAK,CAAC;AAAA,IACtB;AACA,eAAW,KAAK,EAAE,iBAAiB,CAAA,GAAI;AACnC,UAAI,CAAC,KAAK,IAAI,CAAC,GAAG;AACd,cAAM,MAAA;AAAA,MACV;AACA,YAAM,IAAI,EAAE,MAAM,MAAM,IAAI,EAAE,GAAG,KAAK,KAAK,CAAC;AAC5C,UAAI,MAAM,KAAK,IAAI,CAAC;AACpB,UAAI,CAAC,KAAK;AACN,cAAM,CAAA;AACN,aAAK,IAAI,GAAG,GAAG;AAAA,MACnB;AACA,UAAI,KAAK,EAAE,GAAG;AAAA,IAClB;AAAA,EACJ;AACA,QAAM,IAAc,CAAA;AACpB,aAAW,CAAC,IAAI,CAAC,KAAK,OAAO;AACzB,QAAI,MAAM,GAAG;AACT,QAAE,KAAK,EAAE;AAAA,IACb;AAAA,EACJ;AACA,IAAE,KAAA;AACF,QAAM,MAAwB,CAAA;AAC9B,MAAI,KAAK;AACT,SAAO,KAAK,EAAE,QAAQ;AAClB,UAAM,KAAK,EAAE,IAAI;AACjB,QAAI,KAAK,KAAK,IAAI,EAAE,CAAE;AACtB,eAAW,KAAK,KAAK,IAAI,EAAE,KAAK,CAAA,GAAI;AAChC,YAAM,MAAM,MAAM,IAAI,CAAC,KAAK,KAAK;AACjC,YAAM,IAAI,GAAG,EAAE;AACf,UAAI,OAAO,GAAG;AACV,YAAI,IAAI;AACR,eAAO,IAAI,EAAE,UAAU,EAAE,CAAC,IAAK,GAAG;AAC9B;AAAA,QACJ;AACA,UAAE,OAAO,GAAG,GAAG,CAAC;AAAA,MACpB;AAAA,IACJ;AAAA,EACJ;AACA,MAAI,IAAI,WAAW,UAAU,QAAQ;AACjC,UAAM,MAAA;AAAA,EACV;AACA,SAAO;AACX;AAEA,SAAS,MAAmC,MAAoB,OAA0B;AACtF,QAAM,2BAAW,IAAA;AACjB,QAAM,MAAW,CAAA;AACjB,aAAW,KAAK,MAAM;AAClB,QAAI,CAAC,KAAK,IAAI,EAAE,KAAK,GAAG;AACpB,WAAK,IAAI,EAAE,KAAK;AAChB,UAAI,KAAK,CAAC;AAAA,IACd;AAAA,EACJ;AACA,aAAW,KAAK,OAAO;AACnB,QAAI,CAAC,KAAK,IAAI,EAAE,KAAK,GAAG;AACpB,WAAK,IAAI,EAAE,KAAK;AAChB,UAAI,KAAK,CAAC;AAAA,IACd;AAAA,EACJ;AACA,SAAO;AACX;AAEA,SAAS,SAAS,SAAiB,MAA4C;AAC3E,QAAM,IAA6B,EAAE,SAAS,YAAY,KAAK,YAAA;AAC/D,UAAQ,KAAK,MAAM,OAAA;AAAA,IACf,KAAK;AACD,QAAE,SAAS,EAAE,MAAM,UAAA;AACnB;AAAA,IACJ,KAAK,WAAW;AACZ,YAAM,MAAM,KAAK,MAAM,iBAAiB,qBAAqB,UAAU,KAAK,MAAM,iBAAiB,oBAAoB,SAAS;AAChI,QAAE,UAAU,EAAE,YAAa,KAAK,MAAM,eAAe,KAA8B,eAAe,KAAK,MAAM,aAAa,SAAS,MAAM,IAAI,SAAS,KAAA;AACtJ;AAAA,IACJ;AAAA,IACA,KAAK;AACD,QAAE,UAAU;AAAA,QACR,MAAM,KAAK,MAAM,iBAAiB,uBAAuB,eAAe,KAAK,MAAM,iBAAiB,0BAA0B,kBAAkB;AAAA,MAAA;AAEpJ;AAAA,IACJ,KAAK;AACD,QAAE,iBAAiB,EAAE,QAAQ,KAAK,MAAM,SAAoC,QAAQ,KAAK,MAAM,QAAA;AAC/F;AAAA,EAAA;AAER,SAAO;AACX;AAEA,SAAS,SAAS,GAAW,GAAW,GAAwB;AAC5D,UAAQ,EAAE,MAAM,OAAA;AAAA,IACZ,KAAK;AACD,aAAO,UAAU,CAAC,aAAa,CAAC,kBAAkB,EAAE,KAAK,IAAI,EAAE,KAAK;AAAA,IACxE,KAAK;AACD,aAAO,UAAU,CAAC,aAAa,CAAC,SAAS,EAAE,KAAK,IAAI,EAAE,MAAM,YAAY;AAAA,IAC5E,KAAK;AACD,aAAO,UAAU,CAAC,aAAa,CAAC,SAAS,EAAE,KAAK,IAAI,EAAE,MAAM,iBAAiB,0BAA0B,YAAY,EAAE,MAAM,YAAY;AAAA,IAC3I,KAAK;AACD,aAAO,UAAU,CAAC,aAAa,CAAC,SAAS,EAAE,KAAK,uBAAuB,EAAE,MAAM,OAAO,IAAI,EAAE,MAAM,OAAO;AAAA,EAAA;AAErH;AAEA,MAAM,UAAU;AAChB,SAAS,YAAY,KAAa,QAAmC,KAAgD;AACjH,SAAO,IAAI,QAAQ,SAAS,CAAC,GAAG,SAAiB;AAC7C,UAAM,QAAkB,CAAA;AACxB,eAAW,KAAK,QAAQ;AACpB,YAAM,IAAI,EAAE,GAAG;AACf,UAAI,uBAAI,OAAoC;AACxC,cAAM,KAAK,EAAE,IAAiC,CAAE;AAAA,MACpD;AAAA,IACJ;AACA,WAAO,MAAM,KAAK,IAAI;AAAA,EAC1B,CAAC;AACL;AAEO,SAAS,cAAc,UAA0B,WAAsD;;AAC1G,QAAM,SAAS,SAAS,SAAS;AAGjC,QAAM,YAA+B,CAAA;AACrC,QAAM,eAA0B,CAAA;AAChC,QAAM,UAAoB,CAAA;AAC1B,QAAM,WAAqB,CAAA;AAC3B,QAAM,YAAsB,CAAA;AAC5B,aAAW,KAAK,QAAQ;AACpB,QAAI,EAAE,mBAAmB;AACrB,gBAAU,KAAK,GAAG,EAAE,iBAAiB;AAAA,IACzC;AACA,QAAI,EAAE,WAAW;AACb,mBAAa,KAAK,GAAG,EAAE,SAAS;AAAA,IACpC;AACA,QAAI,EAAE,kBAAkB;AACpB,cAAQ,KAAK,EAAE,gBAAgB;AAAA,IACnC;AACA,QAAI,EAAE,wBAAwB;AAC1B,eAAS,KAAK,EAAE,sBAAsB;AAAA,IAC1C;AACA,eAAW,KAAK,EAAE,mBAAmB,CAAA,GAAI;AACrC,gBAAU,KAAK,YAAY,EAAE,QAAQ,KAAK,EAAE,KAAK,IAAI,EAAE,KAAK,GAAG;AAAA,IACnE;AAAA,EACJ;AAGA,QAAM,WAAW,MAAM,SAAS,uBAAuB,SAAS;AAChE,QAAM,aAAuB,CAAA;AAC7B,QAAM,uBAAgD,CAAA;AACtD,QAAM,6BAAa,IAAA;AACnB,QAAM,mCAAmB,IAAA;AACzB,WAAS,IAAI,GAAG,IAAI,SAAS,QAAQ,KAAK;AACtC,UAAM,IAAI,SAAS,CAAC;AACpB,eAAW,KAAK,aAAa,CAAC,KAAK,EAAE,KAAK,IAAI,EAAE,KAAK,GAAG;AACxD,QAAI,EAAE,cAAc;AAChB,UAAI,CAAC,OAAO,IAAI,EAAE,YAAY,GAAG;AAC7B,eAAO,IAAI,EAAE,cAAc,CAAA,CAAE;AAC7B,qBAAa,IAAI,EAAE,cAAc,CAAC;AAAA,MACtC;AACA,aAAO,IAAI,EAAE,YAAY,EAAG,KAAK,EAAE,KAAK,GAAG,KAAK,EAAE,WAAW,GAAG,KAAK,EAAE,YAAY;AAAA,IACvF,OAAO;AACH,2BAAqB,KAAK;AAAA,QACtB,aAAa,EAAE;AAAA,QACf,UAAU,EAAE,aAAa;AAAA,QACzB,YAAY,CAAC,EAAE,gBAAgB,GAAG,QAAQ,EAAE,WAAW,GAAG,QAAQ,EAAE,WAAA,CAAY;AAAA,MAAA,CACnF;AAAA,IACL;AAAA,EACJ;AACA,aAAW,CAAC,KAAK,KAAK,KAAK,QAAQ;AAC/B,UAAM,IAAI,aAAa,IAAI,GAAG;AAC9B,yBAAqB,KAAK;AAAA,MACtB,aAAa,EAAE;AAAA,MACf,UAAU,EAAE,aAAa;AAAA,MACzB,YAAY,MAAM,IAAI,CAAC,OAAO,EAAE,gBAAgB,EAAE,KAAK,QAAQ,EAAE,KAAK,QAAQ,EAAE,MAAM;AAAA,IAAA,CACzF;AAAA,EACL;AACA,MAAI,UAAU,SAAS;AACvB,aAAW,KAAK,QAAQ;AACpB,QAAI,EAAE,wBAAwB;AAC1B,YAAM,IAAI,EAAE,uBAAuB,OAAO;AAC1C,2BAAqB,KAAK,GAAG,EAAE,QAAQ;AACvC,gBAAU,EAAE;AAAA,IAChB;AAAA,EACJ;AAGA,QAAM,UAAU,MAAM,SAAS,eAAe,YAAY;AAC1D,QAAM,WAAW;AAAA,IAAwC,QAAQ,IAAI,CAAC,GAAG,MAAM,aAAa,CAAC,KAAK,EAAE,KAAK,IAAI,EAAE,KAAK,GAAG,EAAE,KAAK,IAAI;AAGlI,QAAM,iBAAiB,CAAC,EAAE,SAAS,0BAA0B,SAAS,uBAAuB,SAAS;AACtG,QAAM,aAAa,CAAC,GAAG,SAAS,kBAAkB;AAClD,QAAM,iBAAiB,iBAAiB,CAAC,GAAG,SAAS,sBAAsB,IAAI,CAAA;AAC/E,aAAW,KAAK,QAAQ;AACpB,SAAI,OAAE,eAAF,mBAAc,QAAQ;AACtB,OAAC,iBAAiB,iBAAiB,YAAY,KAAK,GAAG,EAAE,UAAU;AAAA,IACvE;AAAA,EACJ;AACA,QAAM,eAAe,iBAAiB,UAAU;AAChD,QAAM,mBAAmB,iBAAiB,iBAAiB,cAAc,IAAI;AAG7E,QAAM,UAAqC,CAAC,EAAE,SAAS,GAAG,YAAY,eAAe,gBAAgB,QAAQ,EAAE,MAAM,UAAA,GAAa;AAClI,MAAI,gBAAgB;AAChB,YAAQ,KAAK,EAAE,SAAS,GAAG,YAAY,gBAAgB,QAAQ,EAAE,MAAM,UAAA,EAAU,CAAG;AAAA,EACxF;AACA,QAAM,YAAuC,CAAA;AAC7C,QAAM,SAAmB,CAAA;AACzB,QAAM,SAAmB,CAAA;AACzB,MAAI,KAAK,iBAAiB,IAAI,GAC1B,KAAK;AAET,WAAS,WAAW,GAAgB,WAAoB;AACpD,UAAM,WAAW,EAAE,WAAW;AAC9B,UAAM,IAAI,WAAW,OAAO;AAC5B,UAAM,IAAI,WAAW,IAAI;AACzB,KAAC,WAAW,YAAY,SAAS,KAAK,SAAS,GAAG,CAAC,CAAC;AACpD,UAAM,IAAI,SAAS,GAAG,GAAG,CAAC;AAC1B,QAAI,EAAE,cAAc,cAAc;AAC9B,aAAO,KAAK,CAAC;AAAA,IACjB;AACA,QAAI,EAAE,cAAc,gBAAgB;AAChC,aAAO,KAAK,CAAC;AAAA,IACjB;AAAA,EACJ;AAEA,aAAW,KAAK,SAAS,uBAAuB,CAAA,GAAI;AAChD,eAAW,CAAO;AAAA,EACtB;AACA,aAAW,KAAK,QAAQ;AACpB,eAAW,KAAK,EAAE,mBAAmB,CAAA,GAAI;AACrC,iBAAW,CAAO;AAAA,IACtB;AAAA,EACJ;AACA,aAAW,KAAK,SAAS,iBAAiB,CAAA,GAAI;AAC1C,eAAW,CAAQ;AAAA,EACvB;AACA,aAAW,KAAK,QAAQ;AACpB,eAAW,MAAM,EAAE,aAAa,CAAA,GAAI,OAAO,CAAC,OAAO,EAAE,UAAU,YAAY,MAAM,GAAG;AAChF,iBAAW,CAAQ;AAAA,IACvB;AAAA,EACJ;AACA,aAAW,KAAK,QAAQ;AACpB,eAAW,MAAM,EAAE,aAAa,CAAA,GAAI,OAAO,CAAC,MAAM,EAAE,WAAW,QAAQ,GAAG;AACtE,iBAAW,CAAQ;AAAA,IACvB;AAAA,EACJ;AAEA,QAAM,eAAe,OAAO,IAAI,CAAC,MAAM,EAAE,GAAG,EAAE,KAAK,GAAG;AACtD,QAAM,WAAW,UAAU,SAAS,UAAU,KAAK,IAAI,IAAI,OAAO,MAAM,WAAW,KAAK,IAAI;AAC5F,QAAM,aAAa;AAAA,EAAyB,aAAa,WAAW;AAAA;AACpE,QAAM,iBAAiB,mBAAmB;AAAA;AAAA,EAA+B,iBAAiB,WAAW;AAAA;AAAA,gEAAsE;AAE3K,MAAI,cAAc,SAAS;AAC3B,gBAAc,YAAY,QAAQ,UAAU,cAAc;AAC1D,gBAAc,YAAY,QAAQ,UAAU,UAAU;AACtD,gBAAc,YAAY,QAAQ,UAAU;AAAA,EAAwB,WAAW,KAAK,IAAI,CAAC;AAAA,EAAK;AAC9F,gBAAc,YAAY,QAAQ,UAAU;AAAA,EAAyB,QAAQ;AAAA,EAAK;AAClF,gBAAc,YAAY,QAAQ,UAAU,OAAO,KAAK,IAAI,CAAC;AAC7D,gBAAc,YAAY,QAAQ,UAAU,OAAO;AACnD,gBAAc,YAAY,QAAQ,UAAU,SAAS,KAAK,IAAI,CAAC;AAE/D,gBAAc,YAAY,aAAa,QAAQ,cAAc;AAE7D,MAAI,gBAAgB,SAAS;AAC7B,kBAAgB,cAAc,QAAQ,UAAU,cAAc;AAC9D,kBAAgB,cAAc,QAAQ,UAAU,aAAa,cAAc;AAC3E,kBAAgB,cAAc,QAAQ,UAAU;AAAA,EAA0B,QAAQ;AAAA,EAAK;AACvF,kBAAgB,cAAc,QAAQ,UAAU,QAAQ,KAAK,IAAI,CAAC;AAClE,kBAAgB,cAAc,QAAQ,UAAU,OAAO,KAAK,IAAI,CAAC;AACjE,kBAAgB,YAAY,eAAe,QAAQ,gBAAgB;AAEnE,QAAM,qBAAqB,EAAE,SAAS,QAAA;AACtC,QAAM,uBAAuB,UAAU,SAAS,EAAE,SAAS,cAAc;AAEzE,SAAO;AAAA,IACH;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EAAA;AAER;AC9SO,MAAM,mBAAmB,KAAK;AAC9B,MAAM,mBAAmB,KAAK;AAC9B,MAAM,qBAAqB,KAAK;AAChC,MAAM,wBAAwB,KAAK;AACnC,MAAM,yBAAyB,KAAK;AACpC,MAAM,yBAAyB,KAAK;AACpC,MAAM,uBAAuB,KAAK;AAClC,MAAM,cAAc,KAAK;AACzB,MAAM,sBAAsB,KAAK;AAGjC,SAAS,qBAAqB,MAAY,iBAAiB,OAAe;AAC7E,QAAM,MAAM,KAAK;AACjB,MAAI,WAAW;AACf,MAAI,IAAI,eAAe;AACnB,gBAAY;AAAA,EAChB;AACA,MAAI,KAAK,UAAU;AACf,gBAAY;AACZ,QAAI,KAAK,SAAS,eAAe;AAC7B,kBAAY;AAAA,IAChB;AAAA,EACJ;AACA,MAAI,KAAK,cAAc;AACnB,gBAAY;AAAA,EAChB;AACA,MAAI,KAAK,eAAe;AACpB,gBAAY;AACZ,QAAI,KAAK,cAAc,QAAQ;AAC3B,kBAAY;AAAA,IAChB;AAAA,EACJ;AACA,MAAI,IAAI,aAAa;AACjB,gBAAY;AAAA,EAChB;AACA,MAAI,IAAI,WAAW;AACf,gBAAY;AAAA,EAChB;AACA,MAAI,gBAAgB;AAChB,gBAAY;AAAA,EAChB;AACA,SAAO;AACX;"}

package/min-block-CHtBngNl.js

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

package/min-block-CHtBngNl.js.map

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

package/mod-block-Ceizv8Y7.js

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

package/mod-block-Ceizv8Y7.js.map

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

package/morph-fragment-DOVo70gP.js

@@ -0,0 +1,59 @@
+import { b as MSH_HAS_MORPH_TARGETS } from "./mesh-features-BLENkYVt.js";
+const STAGE_VERTEX = 1;
+const MORPH_PRE_SKINNING = `var morphedPos = position;
+var morphedNorm = normal;
+let mCol = i32(vertexIndex % morph.texWidth);
+let mRowInBand = i32(vertexIndex / morph.texWidth);
+for (var i = 0u; i < morph.count; i = i + 1u) {
+  let w = morph.weights[i];
+  let posBase = i32(i * 2u) * i32(morph.rowsPerBand);
+  let normBase = i32(i * 2u + 1u) * i32(morph.rowsPerBand);
+  morphedPos = morphedPos + w * textureLoad(morphTargets, vec2<i32>(mCol, posBase + mRowInBand), 0).xyz;
+  morphedNorm = morphedNorm + w * textureLoad(morphTargets, vec2<i32>(mCol, normBase + mRowInBand), 0).xyz;
+}`;
+function createMorphFragment() {
+  return {
+    _id: "morph",
+    _vertexBuiltins: [{ _name: "vertexIndex", _builtin: "vertex_index", _type: "u32" }],
+    _vertexHelperFunctions: `struct morphUniforms {
+weights: vec4<f32>,
+count: u32,
+texWidth: u32,
+rowsPerBand: u32,
+_p0: u32,
+}`,
+    _vertexBindings: [
+      { _name: "morphTargets", _type: { _kind: "texture", _textureType: "texture_2d<f32>", _sampleType: "unfilterable-float" }, _visibility: STAGE_VERTEX },
+      { _name: "morph", _type: { _kind: "uniform-buffer" }, _visibility: STAGE_VERTEX }
+    ],
+    _vertexSlots: {
+      VR: MORPH_PRE_SKINNING
+    }
+  };
+}
+const pbrExt = {
+  id: "morph",
+  phase: "vertex",
+  frag(ctx) {
+    if (!(ctx._meshFeatures & MSH_HAS_MORPH_TARGETS)) {
+      return null;
+    }
+    return createMorphFragment();
+  },
+  bind(ctx, entries, b) {
+    const mesh = ctx._mesh;
+    if (!(ctx._meshFeatures & MSH_HAS_MORPH_TARGETS) || !(mesh == null ? void 0 : mesh.morphTargets)) {
+      return b;
+    }
+    entries.push({ binding: b++, resource: mesh.morphTargets.texture.createView() });
+    if (mesh.morphTargets.weightsBuffer) {
+      entries.push({ binding: b++, resource: { buffer: mesh.morphTargets.weightsBuffer } });
+    }
+    return b;
+  }
+};
+export {
+  createMorphFragment,
+  pbrExt
+};
+//# sourceMappingURL=morph-fragment-DOVo70gP.js.map

package/morph-fragment-DOVo70gP.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"morph-fragment-DOVo70gP.js","sources":["../src/material/pbr/fragments/morph-fragment.ts"],"sourcesContent":["/**\n * Morph Target Fragment\n *\n * Vertex-stage morph target animation: texture-based morph deltas\n * applied before skinning. Only bundled when a scene uses morph targets.\n */\n\nimport type { ShaderFragment } from \"../../../shader/fragment-types.js\";\n\n// WebGPU shader stage constants\nconst STAGE_VERTEX = 0x1;\n\nconst MORPH_PRE_SKINNING = `var morphedPos = position;\nvar morphedNorm = normal;\nlet mCol = i32(vertexIndex % morph.texWidth);\nlet mRowInBand = i32(vertexIndex / morph.texWidth);\nfor (var i = 0u; i < morph.count; i = i + 1u) {\n  let w = morph.weights[i];\n  let posBase = i32(i * 2u) * i32(morph.rowsPerBand);\n  let normBase = i32(i * 2u + 1u) * i32(morph.rowsPerBand);\n  morphedPos = morphedPos + w * textureLoad(morphTargets, vec2<i32>(mCol, posBase + mRowInBand), 0).xyz;\n  morphedNorm = morphedNorm + w * textureLoad(morphTargets, vec2<i32>(mCol, normBase + mRowInBand), 0).xyz;\n}`;\n\n/**\n * Create a morph target fragment.\n * The morph extension modifies position/normal variables before the world\n * transform, using morphedPos/morphedNorm in place of position/normal.\n */\nexport function createMorphFragment(): ShaderFragment {\n    return {\n        _id: \"morph\",\n\n        _vertexBuiltins: [{ _name: \"vertexIndex\", _builtin: \"vertex_index\", _type: \"u32\" }],\n\n        _vertexHelperFunctions: `struct morphUniforms {\\nweights: vec4<f32>,\\ncount: u32,\\ntexWidth: u32,\\nrowsPerBand: u32,\\n_p0: u32,\\n}`,\n\n        _vertexBindings: [\n            { _name: \"morphTargets\", _type: { _kind: \"texture\", _textureType: \"texture_2d<f32>\" as const, _sampleType: \"unfilterable-float\" as const }, _visibility: STAGE_VERTEX },\n            { _name: \"morph\", _type: { _kind: \"uniform-buffer\" as const }, _visibility: STAGE_VERTEX },\n        ],\n\n        _vertexSlots: {\n            VR: MORPH_PRE_SKINNING,\n        },\n    };\n}\n\nimport type { PbrExt } from \"../pbr-flags.js\";\nimport { MSH_HAS_MORPH_TARGETS } from \"../../mesh-features.js\";\n\nexport const pbrExt: PbrExt = {\n    id: \"morph\",\n    phase: \"vertex\",\n    frag(ctx) {\n        if (!(ctx._meshFeatures & MSH_HAS_MORPH_TARGETS)) {\n            return null;\n        }\n        return createMorphFragment();\n    },\n    bind(ctx, entries, b) {\n        const mesh = ctx._mesh;\n        if (!(ctx._meshFeatures & MSH_HAS_MORPH_TARGETS) || !mesh?.morphTargets) {\n            return b;\n        }\n        entries.push({ binding: b++, resource: mesh.morphTargets.texture.createView() });\n        // Weights UBO is pushed separately by the pipeline (needs engine-side buffer handle).\n        // Caller supplies weightsBuffer on mesh.morphTargets.\n        if (mesh.morphTargets.weightsBuffer) {\n            entries.push({ binding: b++, resource: { buffer: mesh.morphTargets.weightsBuffer } });\n        }\n        return b;\n    },\n};\n"],"names":[],"mappings":";AAUA,MAAM,eAAe;AAErB,MAAM,qBAAqB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAiBpB,SAAS,sBAAsC;AAClD,SAAO;AAAA,IACH,KAAK;AAAA,IAEL,iBAAiB,CAAC,EAAE,OAAO,eAAe,UAAU,gBAAgB,OAAO,OAAO;AAAA,IAElF,wBAAwB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAExB,iBAAiB;AAAA,MACb,EAAE,OAAO,gBAAgB,OAAO,EAAE,OAAO,WAAW,cAAc,mBAA4B,aAAa,wBAAiC,aAAa,aAAA;AAAA,MACzJ,EAAE,OAAO,SAAS,OAAO,EAAE,OAAO,iBAAA,GAA6B,aAAa,aAAA;AAAA,IAAa;AAAA,IAG7F,cAAc;AAAA,MACV,IAAI;AAAA,IAAA;AAAA,EACR;AAER;AAKO,MAAM,SAAiB;AAAA,EAC1B,IAAI;AAAA,EACJ,OAAO;AAAA,EACP,KAAK,KAAK;AACN,QAAI,EAAE,IAAI,gBAAgB,wBAAwB;AAC9C,aAAO;AAAA,IACX;AACA,WAAO,oBAAA;AAAA,EACX;AAAA,EACA,KAAK,KAAK,SAAS,GAAG;AAClB,UAAM,OAAO,IAAI;AACjB,QAAI,EAAE,IAAI,gBAAgB,0BAA0B,EAAC,6BAAM,eAAc;AACrE,aAAO;AAAA,IACX;AACA,YAAQ,KAAK,EAAE,SAAS,KAAK,UAAU,KAAK,aAAa,QAAQ,WAAA,EAAW,CAAG;AAG/E,QAAI,KAAK,aAAa,eAAe;AACjC,cAAQ,KAAK,EAAE,SAAS,KAAK,UAAU,EAAE,QAAQ,KAAK,aAAa,cAAA,EAAc,CAAG;AAAA,IACxF;AACA,WAAO;AAAA,EACX;AACJ;"}

package/morph-targets-55z342ZB.js

@@ -0,0 +1,35 @@
+const PASSTHROUGH_KINDS = /* @__PURE__ */ new Set(["tangent", "uv", "uv2"]);
+const emitter = {
+  className: "MorphTargetsBlock",
+  stage: "vertex",
+  emit(block, outputName, stage, state, ctx) {
+    state.usesMorphTargets = true;
+    const kind = outputName.replace(/Output$/, "");
+    const input = block.inputs.get(kind);
+    if (!(input == null ? void 0 : input.source)) {
+      return fallback(kind);
+    }
+    const v = ctx.resolve(block, kind, stage, state);
+    if (kind === "position") {
+      const base = ctx.cast(v, "vec3f").expr;
+      return { expr: `nme_morphPosition(${base}, vertexIndex)`, type: "vec3f" };
+    }
+    if (kind === "normal") {
+      const base = ctx.cast(v, "vec3f").expr;
+      return { expr: `nme_morphNormal(${base}, vertexIndex)`, type: "vec3f" };
+    }
+    if (PASSTHROUGH_KINDS.has(kind)) {
+      return v;
+    }
+    return v;
+  }
+};
+function fallback(kind) {
+  const type = kind === "uv" || kind === "uv2" ? "vec2f" : kind === "tangent" ? "vec4f" : "vec3f";
+  const zero = type === "vec2f" ? "vec2<f32>(0.0)" : type === "vec4f" ? "vec4<f32>(0.0)" : "vec3<f32>(0.0)";
+  return { expr: zero, type };
+}
+export {
+  emitter
+};
+//# sourceMappingURL=morph-targets-55z342ZB.js.map