@babylonjs/lite 0.1.1

package/cloud-block-BeVrangc.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cloud-block-BeVrangc.js","sources":["../src/material/node/blocks/cloud-block.ts"],"sourcesContent":["import type { BlockEmitter, NodeBlock, NodeBuildState, NodeEmitContext, NodeExpr, Stage } from \"../node-types.js\";\n\nfunction optional(block: NodeBlock, inputName: string, stage: Stage, state: NodeBuildState, ctx: NodeEmitContext): NodeExpr | null {\n    const input = block.inputs.get(inputName);\n    return input?.source ? ctx.resolve(block, inputName, stage, state) : null;\n}\n\nfunction scalarOffset(block: NodeBlock, inputName: string, stage: Stage, state: NodeBuildState, ctx: NodeEmitContext): string | null {\n    const value = optional(block, inputName, stage, state, ctx);\n    return value ? ctx.cast(value, \"f32\").expr : null;\n}\n\nexport const emitter: BlockEmitter = {\n    className: \"CloudBlock\",\n    emit(block, _outputName, stage, state, ctx) {\n        const seed = ctx.resolve(block, \"seed\", stage, state);\n        if (seed.type !== \"vec2f\" && seed.type !== \"vec3f\") {\n            throw new Error(`NodeMaterial: CloudBlock requires vec2 or vec3 seed; got ${seed.type}`);\n        }\n\n        state[stage].helpers.set(\n            \"nme_cloudNoise\",\n            `fn nme_cloudRandom(p: f32) -> f32 {\nvar temp = fract(p * 0.011);\ntemp *= temp + 7.5;\ntemp *= temp + temp;\nreturn fract(temp);\n}\nfn nme_cloudNoise2(x: vec2<f32>, chaos: vec2<f32>) -> f32 {\nlet stepv = chaos * vec2<f32>(75.0, 120.0) + vec2<f32>(75.0, 120.0);\nlet i = floor(x);\nlet f = fract(x);\nlet n = dot(i, stepv);\nlet u = f * f * (vec2<f32>(3.0) - 2.0 * f);\nreturn mix(mix(nme_cloudRandom(n + dot(stepv, vec2<f32>(0.0, 0.0))), nme_cloudRandom(n + dot(stepv, vec2<f32>(1.0, 0.0))), u.x), mix(nme_cloudRandom(n + dot(stepv, vec2<f32>(0.0, 1.0))), nme_cloudRandom(n + dot(stepv, vec2<f32>(1.0, 1.0))), u.x), u.y);\n}\nfn nme_cloudNoise3(x: vec3<f32>, chaos: vec3<f32>) -> f32 {\nlet stepv = chaos * vec3<f32>(60.0, 120.0, 75.0) + vec3<f32>(60.0, 120.0, 75.0);\nlet i = floor(x);\nlet f = fract(x);\nlet n = dot(i, stepv);\nlet u = f * f * (vec3<f32>(3.0) - 2.0 * f);\nreturn mix(mix(mix(nme_cloudRandom(n + dot(stepv, vec3<f32>(0.0, 0.0, 0.0))), nme_cloudRandom(n + dot(stepv, vec3<f32>(1.0, 0.0, 0.0))), u.x), mix(nme_cloudRandom(n + dot(stepv, vec3<f32>(0.0, 1.0, 0.0))), nme_cloudRandom(n + dot(stepv, vec3<f32>(1.0, 1.0, 0.0))), u.x), u.y), mix(mix(nme_cloudRandom(n + dot(stepv, vec3<f32>(0.0, 0.0, 1.0))), nme_cloudRandom(n + dot(stepv, vec3<f32>(1.0, 0.0, 1.0))), u.x), mix(nme_cloudRandom(n + dot(stepv, vec3<f32>(0.0, 1.0, 1.0))), nme_cloudRandom(n + dot(stepv, vec3<f32>(1.0, 1.0, 1.0))), u.x), u.y), u.z);\n}`\n        );\n\n        const octaves = Math.max(0, Math.trunc(typeof block.serialized.octaves === \"number\" ? block.serialized.octaves : 6));\n        const helperKey = `nme_cloudFbm_${octaves}`;\n        state[stage].helpers.set(\n            helperKey,\n            `fn nme_cloudFbm2_${octaves}(st: vec2<f32>, chaos: vec2<f32>) -> f32 {\nvar value = 0.0;\nvar amplitude = 0.5;\nvar tempST = st;\nfor (var i = 0; i < ${octaves}; i = i + 1) {\nvalue += amplitude * nme_cloudNoise2(tempST, chaos);\ntempST *= 2.0;\namplitude *= 0.5;\n}\nreturn value;\n}\nfn nme_cloudFbm3_${octaves}(x: vec3<f32>, chaos: vec3<f32>) -> f32 {\nvar value = 0.0;\nvar amplitude = 0.5;\nvar tempX = x;\nfor (var i = 0; i < ${octaves}; i = i + 1) {\nvalue += amplitude * nme_cloudNoise3(tempX, chaos);\ntempX *= 2.0;\namplitude *= 0.5;\n}\nreturn value;\n}`\n        );\n\n        const st = ctx.temp(state, \"cloudSeed\");\n        state[stage].body.push(`var ${st}: ${seed.type === \"vec2f\" ? \"vec2<f32>\" : \"vec3<f32>\"} = ${seed.expr};`);\n        const offsetX = scalarOffset(block, \"offsetX\", stage, state, ctx);\n        const offsetY = scalarOffset(block, \"offsetY\", stage, state, ctx);\n        const offsetZ = scalarOffset(block, \"offsetZ\", stage, state, ctx);\n        if (offsetX) {\n            state[stage].body.push(`${st}.x += 0.1 * ${offsetX};`);\n        }\n        if (offsetY) {\n            state[stage].body.push(`${st}.y += 0.1 * ${offsetY};`);\n        }\n        if (offsetZ && seed.type === \"vec3f\") {\n            state[stage].body.push(`${st}.z += 0.1 * ${offsetZ};`);\n        }\n\n        const chaos = optional(block, \"chaos\", stage, state, ctx);\n        const chaosExpr = chaos ? ctx.cast(chaos, seed.type).expr : seed.type === \"vec2f\" ? \"vec2<f32>(0.0, 0.0)\" : \"vec3<f32>(0.0, 0.0, 0.0)\";\n        return { expr: seed.type === \"vec2f\" ? `nme_cloudFbm2_${octaves}(${st}, ${chaosExpr})` : `nme_cloudFbm3_${octaves}(${st}, ${chaosExpr})`, type: \"f32\" };\n    },\n};\n"],"names":[],"mappings":"AAEA,SAAS,SAAS,OAAkB,WAAmB,OAAc,OAAuB,KAAuC;AAC/H,QAAM,QAAQ,MAAM,OAAO,IAAI,SAAS;AACxC,UAAO,+BAAO,UAAS,IAAI,QAAQ,OAAO,WAAW,OAAO,KAAK,IAAI;AACzE;AAEA,SAAS,aAAa,OAAkB,WAAmB,OAAc,OAAuB,KAAqC;AACjI,QAAM,QAAQ,SAAS,OAAO,WAAW,OAAO,OAAO,GAAG;AAC1D,SAAO,QAAQ,IAAI,KAAK,OAAO,KAAK,EAAE,OAAO;AACjD;AAEO,MAAM,UAAwB;AAAA,EACjC,WAAW;AAAA,EACX,KAAK,OAAO,aAAa,OAAO,OAAO,KAAK;AACxC,UAAM,OAAO,IAAI,QAAQ,OAAO,QAAQ,OAAO,KAAK;AACpD,QAAI,KAAK,SAAS,WAAW,KAAK,SAAS,SAAS;AAChD,YAAM,IAAI,MAAM,4DAA4D,KAAK,IAAI,EAAE;AAAA,IAC3F;AAEA,UAAM,KAAK,EAAE,QAAQ;AAAA,MACjB;AAAA,MACA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAAA;AAwBJ,UAAM,UAAU,KAAK,IAAI,GAAG,KAAK,MAAM,OAAO,MAAM,WAAW,YAAY,WAAW,MAAM,WAAW,UAAU,CAAC,CAAC;AACnH,UAAM,YAAY,gBAAgB,OAAO;AACzC,UAAM,KAAK,EAAE,QAAQ;AAAA,MACjB;AAAA,MACA,oBAAoB,OAAO;AAAA;AAAA;AAAA;AAAA,sBAIjB,OAAO;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,mBAOV,OAAO;AAAA;AAAA;AAAA;AAAA,sBAIJ,OAAO;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAAA;AASrB,UAAM,KAAK,IAAI,KAAK,OAAO,WAAW;AACtC,UAAM,KAAK,EAAE,KAAK,KAAK,OAAO,EAAE,KAAK,KAAK,SAAS,UAAU,cAAc,WAAW,MAAM,KAAK,IAAI,GAAG;AACxG,UAAM,UAAU,aAAa,OAAO,WAAW,OAAO,OAAO,GAAG;AAChE,UAAM,UAAU,aAAa,OAAO,WAAW,OAAO,OAAO,GAAG;AAChE,UAAM,UAAU,aAAa,OAAO,WAAW,OAAO,OAAO,GAAG;AAChE,QAAI,SAAS;AACT,YAAM,KAAK,EAAE,KAAK,KAAK,GAAG,EAAE,eAAe,OAAO,GAAG;AAAA,IACzD;AACA,QAAI,SAAS;AACT,YAAM,KAAK,EAAE,KAAK,KAAK,GAAG,EAAE,eAAe,OAAO,GAAG;AAAA,IACzD;AACA,QAAI,WAAW,KAAK,SAAS,SAAS;AAClC,YAAM,KAAK,EAAE,KAAK,KAAK,GAAG,EAAE,eAAe,OAAO,GAAG;AAAA,IACzD;AAEA,UAAM,QAAQ,SAAS,OAAO,SAAS,OAAO,OAAO,GAAG;AACxD,UAAM,YAAY,QAAQ,IAAI,KAAK,OAAO,KAAK,IAAI,EAAE,OAAO,KAAK,SAAS,UAAU,wBAAwB;AAC5G,WAAO,EAAE,MAAM,KAAK,SAAS,UAAU,iBAAiB,OAAO,IAAI,EAAE,KAAK,SAAS,MAAM,iBAAiB,OAAO,IAAI,EAAE,KAAK,SAAS,KAAK,MAAM,MAAA;AAAA,EACpJ;AACJ;"}

package/color-converter-block-CvwKiW4k.js

@@ -0,0 +1,123 @@
+function tryResolve(block, inputName, stage, state, ctx) {
+  const input = block.inputs.get(inputName);
+  if (!(input == null ? void 0 : input.source)) {
+    return null;
+  }
+  return ctx.resolve(block, inputName, stage, state);
+}
+function ensureRgb2HslHelper(state, stage) {
+  state[stage].helpers.set(
+    "nme_rgb2hsl",
+    `fn nme_rgb2hsl(color: vec3<f32>) -> vec3<f32> {
+    let r = color.x;
+    let g = color.y;
+    let b = color.z;
+    let maxc = max(r, max(g, b));
+    let minc = min(r, min(g, b));
+    var h = 0.0;
+    var s = 0.0;
+    let l = (maxc + minc) / 2.0;
+    if (maxc != minc) {
+        let d = maxc - minc;
+        if (l > 0.5) {
+            s = d / (2.0 - maxc - minc);
+        } else {
+            s = d / (maxc + minc);
+        }
+        if (maxc == r) {
+            var add = 0.0;
+            if (g < b) {
+                add = 6.0;
+            }
+            h = (g - b) / d + add;
+        } else if (maxc == g) {
+            h = (b - r) / d + 2.0;
+        } else if (maxc == b) {
+            h = (r - g) / d + 4.0;
+        }
+        h = h / 6.0;
+    }
+    return vec3<f32>(h, s, l);
+}`
+  );
+}
+function ensureHsl2RgbHelper(state, stage) {
+  state[stage].helpers.set(
+    "nme_hue2rgb",
+    `fn nme_hue2rgb(p: f32, q: f32, tt: f32) -> f32 {
+    var t = tt;
+    if (t < 0.0) {
+        t = t + 1.0;
+    }
+    if (t > 1.0) {
+        t = t - 1.0;
+    }
+    if (t < 1.0 / 6.0) {
+        return p + (q - p) * 6.0 * t;
+    }
+    if (t < 1.0 / 2.0) {
+        return q;
+    }
+    if (t < 2.0 / 3.0) {
+        return p + (q - p) * (2.0 / 3.0 - t) * 6.0;
+    }
+    return p;
+}`
+  );
+  state[stage].helpers.set(
+    "nme_hsl2rgb",
+    `fn nme_hsl2rgb(hsl: vec3<f32>) -> vec3<f32> {
+    let h = hsl.x;
+    let s = hsl.y;
+    let l = hsl.z;
+    var r: f32;
+    var g: f32;
+    var b: f32;
+    if (s == 0.0) {
+        r = l;
+        g = l;
+        b = l;
+    } else {
+        var q: f32;
+        if (l < 0.5) {
+            q = l * (1.0 + s);
+        } else {
+            q = l + s - l * s;
+        }
+        let p = 2.0 * l - q;
+        r = nme_hue2rgb(p, q, h + 1.0 / 3.0);
+        g = nme_hue2rgb(p, q, h);
+        b = nme_hue2rgb(p, q, h - 1.0 / 3.0);
+    }
+    return vec3<f32>(r, g, b);
+}`
+  );
+}
+const emitter = {
+  className: "ColorConverterBlock",
+  emit(block, outputName, stage, state, ctx) {
+    const rgb = tryResolve(block, "rgb", stage, state, ctx);
+    if (rgb) {
+      const rgbExpr = ctx.cast(rgb, "vec3f").expr;
+      if (outputName === "hsl") {
+        ensureRgb2HslHelper(state, stage);
+        return { expr: `nme_rgb2hsl(${rgbExpr})`, type: "vec3f" };
+      }
+      return { expr: rgbExpr, type: "vec3f" };
+    }
+    const hsl = tryResolve(block, "hsl", stage, state, ctx);
+    if (hsl) {
+      const hslExpr = ctx.cast(hsl, "vec3f").expr;
+      if (outputName === "rgb") {
+        ensureHsl2RgbHelper(state, stage);
+        return { expr: `nme_hsl2rgb(${hslExpr})`, type: "vec3f" };
+      }
+      return { expr: hslExpr, type: "vec3f" };
+    }
+    return { expr: "vec3<f32>(0.0, 0.0, 0.0)", type: "vec3f" };
+  }
+};
+export {
+  emitter
+};
+//# sourceMappingURL=color-converter-block-CvwKiW4k.js.map

package/color-converter-block-CvwKiW4k.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"color-converter-block-CvwKiW4k.js","sources":["../src/material/node/blocks/color-converter-block.ts"],"sourcesContent":["import type { BlockEmitter, NodeBlock, NodeBuildState, NodeEmitContext, NodeExpr, 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?.source) {\n        return null;\n    }\n    return ctx.resolve(block, inputName, stage, state);\n}\n\nfunction ensureRgb2HslHelper(state: NodeBuildState, stage: Stage): void {\n    state[stage].helpers.set(\n        \"nme_rgb2hsl\",\n        `fn nme_rgb2hsl(color: vec3<f32>) -> vec3<f32> {\n    let r = color.x;\n    let g = color.y;\n    let b = color.z;\n    let maxc = max(r, max(g, b));\n    let minc = min(r, min(g, b));\n    var h = 0.0;\n    var s = 0.0;\n    let l = (maxc + minc) / 2.0;\n    if (maxc != minc) {\n        let d = maxc - minc;\n        if (l > 0.5) {\n            s = d / (2.0 - maxc - minc);\n        } else {\n            s = d / (maxc + minc);\n        }\n        if (maxc == r) {\n            var add = 0.0;\n            if (g < b) {\n                add = 6.0;\n            }\n            h = (g - b) / d + add;\n        } else if (maxc == g) {\n            h = (b - r) / d + 2.0;\n        } else if (maxc == b) {\n            h = (r - g) / d + 4.0;\n        }\n        h = h / 6.0;\n    }\n    return vec3<f32>(h, s, l);\n}`\n    );\n}\n\nfunction ensureHsl2RgbHelper(state: NodeBuildState, stage: Stage): void {\n    state[stage].helpers.set(\n        \"nme_hue2rgb\",\n        `fn nme_hue2rgb(p: f32, q: f32, tt: f32) -> f32 {\n    var t = tt;\n    if (t < 0.0) {\n        t = t + 1.0;\n    }\n    if (t > 1.0) {\n        t = t - 1.0;\n    }\n    if (t < 1.0 / 6.0) {\n        return p + (q - p) * 6.0 * t;\n    }\n    if (t < 1.0 / 2.0) {\n        return q;\n    }\n    if (t < 2.0 / 3.0) {\n        return p + (q - p) * (2.0 / 3.0 - t) * 6.0;\n    }\n    return p;\n}`\n    );\n    state[stage].helpers.set(\n        \"nme_hsl2rgb\",\n        `fn nme_hsl2rgb(hsl: vec3<f32>) -> vec3<f32> {\n    let h = hsl.x;\n    let s = hsl.y;\n    let l = hsl.z;\n    var r: f32;\n    var g: f32;\n    var b: f32;\n    if (s == 0.0) {\n        r = l;\n        g = l;\n        b = l;\n    } else {\n        var q: f32;\n        if (l < 0.5) {\n            q = l * (1.0 + s);\n        } else {\n            q = l + s - l * s;\n        }\n        let p = 2.0 * l - q;\n        r = nme_hue2rgb(p, q, h + 1.0 / 3.0);\n        g = nme_hue2rgb(p, q, h);\n        b = nme_hue2rgb(p, q, h - 1.0 / 3.0);\n    }\n    return vec3<f32>(r, g, b);\n}`\n    );\n}\n\nexport const emitter: BlockEmitter = {\n    className: \"ColorConverterBlock\",\n    emit(block, outputName, stage, state, ctx) {\n        const rgb = tryResolve(block, \"rgb\", stage, state, ctx);\n        if (rgb) {\n            const rgbExpr = ctx.cast(rgb, \"vec3f\").expr;\n            if (outputName === \"hsl\") {\n                ensureRgb2HslHelper(state, stage);\n                return { expr: `nme_rgb2hsl(${rgbExpr})`, type: \"vec3f\" };\n            }\n            return { expr: rgbExpr, type: \"vec3f\" };\n        }\n\n        const hsl = tryResolve(block, \"hsl\", stage, state, ctx);\n        if (hsl) {\n            const hslExpr = ctx.cast(hsl, \"vec3f\").expr;\n            if (outputName === \"rgb\") {\n                ensureHsl2RgbHelper(state, stage);\n                return { expr: `nme_hsl2rgb(${hslExpr})`, type: \"vec3f\" };\n            }\n            return { expr: hslExpr, type: \"vec3f\" };\n        }\n\n        return { expr: \"vec3<f32>(0.0, 0.0, 0.0)\", type: \"vec3f\" };\n    },\n};\n"],"names":[],"mappings":"AAEA,SAAS,WAAW,OAAkB,WAAmB,OAAc,OAAuB,KAAuC;AACjI,QAAM,QAAQ,MAAM,OAAO,IAAI,SAAS;AACxC,MAAI,EAAC,+BAAO,SAAQ;AAChB,WAAO;AAAA,EACX;AACA,SAAO,IAAI,QAAQ,OAAO,WAAW,OAAO,KAAK;AACrD;AAEA,SAAS,oBAAoB,OAAuB,OAAoB;AACpE,QAAM,KAAK,EAAE,QAAQ;AAAA,IACjB;AAAA,IACA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAAA;AAgCR;AAEA,SAAS,oBAAoB,OAAuB,OAAoB;AACpE,QAAM,KAAK,EAAE,QAAQ;AAAA,IACjB;AAAA,IACA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAAA;AAoBJ,QAAM,KAAK,EAAE,QAAQ;AAAA,IACjB;AAAA,IACA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAAA;AA0BR;AAEO,MAAM,UAAwB;AAAA,EACjC,WAAW;AAAA,EACX,KAAK,OAAO,YAAY,OAAO,OAAO,KAAK;AACvC,UAAM,MAAM,WAAW,OAAO,OAAO,OAAO,OAAO,GAAG;AACtD,QAAI,KAAK;AACL,YAAM,UAAU,IAAI,KAAK,KAAK,OAAO,EAAE;AACvC,UAAI,eAAe,OAAO;AACtB,4BAAoB,OAAO,KAAK;AAChC,eAAO,EAAE,MAAM,eAAe,OAAO,KAAK,MAAM,QAAA;AAAA,MACpD;AACA,aAAO,EAAE,MAAM,SAAS,MAAM,QAAA;AAAA,IAClC;AAEA,UAAM,MAAM,WAAW,OAAO,OAAO,OAAO,OAAO,GAAG;AACtD,QAAI,KAAK;AACL,YAAM,UAAU,IAAI,KAAK,KAAK,OAAO,EAAE;AACvC,UAAI,eAAe,OAAO;AACtB,4BAAoB,OAAO,KAAK;AAChC,eAAO,EAAE,MAAM,eAAe,OAAO,KAAK,MAAM,QAAA;AAAA,MACpD;AACA,aAAO,EAAE,MAAM,SAAS,MAAM,QAAA;AAAA,IAClC;AAEA,WAAO,EAAE,MAAM,4BAA4B,MAAM,QAAA;AAAA,EACrD;AACJ;"}

package/color-merger-CCu21ZII.js

@@ -0,0 +1,57 @@
+function tryResolve(block, inputName, stage, state, ctx) {
+  const input = block.inputs.get(inputName);
+  if (!(input == null ? void 0 : input.source)) {
+    return null;
+  }
+  return ctx.resolve(block, inputName, stage, state);
+}
+function swizzleChar(raw, fallback) {
+  const s = typeof raw === "string" && raw.length > 0 ? raw[0] : fallback;
+  if (s === "r" || s === "x") {
+    return "x";
+  }
+  if (s === "g" || s === "y") {
+    return "y";
+  }
+  if (s === "b" || s === "z") {
+    return "z";
+  }
+  if (s === "a" || s === "w") {
+    return "w";
+  }
+  return fallback;
+}
+function swizzle(block, len) {
+  const s = swizzleChar(block.serialized.rSwizzle, "x") + swizzleChar(block.serialized.gSwizzle, "y") + swizzleChar(block.serialized.bSwizzle, "z") + swizzleChar(block.serialized.aSwizzle, "w");
+  return `.${s.slice(0, len)}`;
+}
+const emitter = {
+  className: "ColorMergerBlock",
+  emit(block, outputName, stage, state, ctx) {
+    const rgb = tryResolve(block, "rgb", stage, state, ctx);
+    const a = tryResolve(block, "a", stage, state, ctx);
+    if (rgb) {
+      const rgbExpr = ctx.cast(rgb, "vec3f").expr;
+      const aExpr2 = a ? ctx.cast(a, "f32").expr : "0.0";
+      if (outputName === "rgba") {
+        return { expr: `(vec4<f32>(${rgbExpr}, ${aExpr2})${swizzle(block, 4)})`, type: "vec4f" };
+      }
+      return { expr: `((${rgbExpr})${swizzle(block, 3)})`, type: "vec3f" };
+    }
+    const r = tryResolve(block, "r", stage, state, ctx);
+    const g = tryResolve(block, "g", stage, state, ctx);
+    const b = tryResolve(block, "b", stage, state, ctx);
+    const rExpr = r ? ctx.cast(r, "f32").expr : "0.0";
+    const gExpr = g ? ctx.cast(g, "f32").expr : "0.0";
+    const bExpr = b ? ctx.cast(b, "f32").expr : "0.0";
+    const aExpr = a ? ctx.cast(a, "f32").expr : "0.0";
+    if (outputName === "rgba") {
+      return { expr: `(vec4<f32>(${rExpr}, ${gExpr}, ${bExpr}, ${aExpr})${swizzle(block, 4)})`, type: "vec4f" };
+    }
+    return { expr: `(vec3<f32>(${rExpr}, ${gExpr}, ${bExpr})${swizzle(block, 3)})`, type: "vec3f" };
+  }
+};
+export {
+  emitter
+};
+//# sourceMappingURL=color-merger-CCu21ZII.js.map

package/color-merger-CCu21ZII.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"color-merger-CCu21ZII.js","sources":["../src/material/node/blocks/color-merger.ts"],"sourcesContent":["/** ColorMergerBlock emitter.\n *\n *  BJS inputs: `rgb `, `r`, `g`, `b`, `a`. Outputs: `rgba`, `rgb`.\n *  The serialized swizzle fields (`rSwizzle`, `gSwizzle`, `bSwizzle`,\n *  `aSwizzle`) remap components after construction.\n */\n\nimport type { BlockEmitter, NodeBlock, NodeBuildState, NodeEmitContext, NodeExpr, 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?.source) {\n        return null;\n    }\n    return ctx.resolve(block, inputName, stage, state);\n}\n\nfunction swizzleChar(raw: unknown, fallback: string): string {\n    const s = typeof raw === \"string\" && raw.length > 0 ? raw[0]! : fallback;\n    if (s === \"r\" || s === \"x\") {\n        return \"x\";\n    }\n    if (s === \"g\" || s === \"y\") {\n        return \"y\";\n    }\n    if (s === \"b\" || s === \"z\") {\n        return \"z\";\n    }\n    if (s === \"a\" || s === \"w\") {\n        return \"w\";\n    }\n    return fallback;\n}\n\nfunction swizzle(block: NodeBlock, len: 3 | 4): string {\n    const s =\n        swizzleChar(block.serialized.rSwizzle, \"x\") +\n        swizzleChar(block.serialized.gSwizzle, \"y\") +\n        swizzleChar(block.serialized.bSwizzle, \"z\") +\n        swizzleChar(block.serialized.aSwizzle, \"w\");\n    return `.${s.slice(0, len)}`;\n}\n\nexport const emitter: BlockEmitter = {\n    className: \"ColorMergerBlock\",\n    emit(block, outputName, stage, state, ctx) {\n        const rgb = tryResolve(block, \"rgb\", stage, state, ctx);\n        const a = tryResolve(block, \"a\", stage, state, ctx);\n\n        if (rgb) {\n            const rgbExpr = ctx.cast(rgb, \"vec3f\").expr;\n            const aExpr = a ? ctx.cast(a, \"f32\").expr : \"0.0\";\n            if (outputName === \"rgba\") {\n                return { expr: `(vec4<f32>(${rgbExpr}, ${aExpr})${swizzle(block, 4)})`, type: \"vec4f\" };\n            }\n            return { expr: `((${rgbExpr})${swizzle(block, 3)})`, type: \"vec3f\" };\n        }\n\n        const r = tryResolve(block, \"r\", stage, state, ctx);\n        const g = tryResolve(block, \"g\", stage, state, ctx);\n        const b = tryResolve(block, \"b\", stage, state, ctx);\n        const rExpr = r ? ctx.cast(r, \"f32\").expr : \"0.0\";\n        const gExpr = g ? ctx.cast(g, \"f32\").expr : \"0.0\";\n        const bExpr = b ? ctx.cast(b, \"f32\").expr : \"0.0\";\n        const aExpr = a ? ctx.cast(a, \"f32\").expr : \"0.0\";\n        if (outputName === \"rgba\") {\n            return { expr: `(vec4<f32>(${rExpr}, ${gExpr}, ${bExpr}, ${aExpr})${swizzle(block, 4)})`, type: \"vec4f\" };\n        }\n        return { expr: `(vec3<f32>(${rExpr}, ${gExpr}, ${bExpr})${swizzle(block, 3)})`, type: \"vec3f\" };\n    },\n};\n"],"names":["aExpr"],"mappings":"AASA,SAAS,WAAW,OAAkB,WAAmB,OAAc,OAAuB,KAAuC;AACjI,QAAM,QAAQ,MAAM,OAAO,IAAI,SAAS;AACxC,MAAI,EAAC,+BAAO,SAAQ;AAChB,WAAO;AAAA,EACX;AACA,SAAO,IAAI,QAAQ,OAAO,WAAW,OAAO,KAAK;AACrD;AAEA,SAAS,YAAY,KAAc,UAA0B;AACzD,QAAM,IAAI,OAAO,QAAQ,YAAY,IAAI,SAAS,IAAI,IAAI,CAAC,IAAK;AAChE,MAAI,MAAM,OAAO,MAAM,KAAK;AACxB,WAAO;AAAA,EACX;AACA,MAAI,MAAM,OAAO,MAAM,KAAK;AACxB,WAAO;AAAA,EACX;AACA,MAAI,MAAM,OAAO,MAAM,KAAK;AACxB,WAAO;AAAA,EACX;AACA,MAAI,MAAM,OAAO,MAAM,KAAK;AACxB,WAAO;AAAA,EACX;AACA,SAAO;AACX;AAEA,SAAS,QAAQ,OAAkB,KAAoB;AACnD,QAAM,IACF,YAAY,MAAM,WAAW,UAAU,GAAG,IAC1C,YAAY,MAAM,WAAW,UAAU,GAAG,IAC1C,YAAY,MAAM,WAAW,UAAU,GAAG,IAC1C,YAAY,MAAM,WAAW,UAAU,GAAG;AAC9C,SAAO,IAAI,EAAE,MAAM,GAAG,GAAG,CAAC;AAC9B;AAEO,MAAM,UAAwB;AAAA,EACjC,WAAW;AAAA,EACX,KAAK,OAAO,YAAY,OAAO,OAAO,KAAK;AACvC,UAAM,MAAM,WAAW,OAAO,OAAO,OAAO,OAAO,GAAG;AACtD,UAAM,IAAI,WAAW,OAAO,KAAK,OAAO,OAAO,GAAG;AAElD,QAAI,KAAK;AACL,YAAM,UAAU,IAAI,KAAK,KAAK,OAAO,EAAE;AACvC,YAAMA,SAAQ,IAAI,IAAI,KAAK,GAAG,KAAK,EAAE,OAAO;AAC5C,UAAI,eAAe,QAAQ;AACvB,eAAO,EAAE,MAAM,cAAc,OAAO,KAAKA,MAAK,IAAI,QAAQ,OAAO,CAAC,CAAC,KAAK,MAAM,QAAA;AAAA,MAClF;AACA,aAAO,EAAE,MAAM,KAAK,OAAO,IAAI,QAAQ,OAAO,CAAC,CAAC,KAAK,MAAM,QAAA;AAAA,IAC/D;AAEA,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,QAAQ,IAAI,IAAI,KAAK,GAAG,KAAK,EAAE,OAAO;AAC5C,UAAM,QAAQ,IAAI,IAAI,KAAK,GAAG,KAAK,EAAE,OAAO;AAC5C,UAAM,QAAQ,IAAI,IAAI,KAAK,GAAG,KAAK,EAAE,OAAO;AAC5C,UAAM,QAAQ,IAAI,IAAI,KAAK,GAAG,KAAK,EAAE,OAAO;AAC5C,QAAI,eAAe,QAAQ;AACvB,aAAO,EAAE,MAAM,cAAc,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,KAAK,IAAI,QAAQ,OAAO,CAAC,CAAC,KAAK,MAAM,QAAA;AAAA,IACpG;AACA,WAAO,EAAE,MAAM,cAAc,KAAK,KAAK,KAAK,KAAK,KAAK,IAAI,QAAQ,OAAO,CAAC,CAAC,KAAK,MAAM,QAAA;AAAA,EAC1F;AACJ;"}

package/color-splitter-CGn1G4ow.js

@@ -0,0 +1,33 @@
+const COMPONENT = {
+  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" }
+};
+const emitter = {
+  className: "ColorSplitterBlock",
+  emit(block, outputName, stage, state, ctx) {
+    var _a;
+    let source = null;
+    for (const key of ["rgba", "rgb"]) {
+      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: ColorSplitterBlock (id=${block.id}) has no connected input`);
+    }
+    const c = COMPONENT[outputName];
+    if (!c) {
+      throw new Error(`NodeMaterial: ColorSplitterBlock has no output "${outputName}"`);
+    }
+    return { expr: `(${source.expr})${c.swizzle}`, type: c.type };
+  }
+};
+export {
+  emitter
+};
+//# sourceMappingURL=color-splitter-CGn1G4ow.js.map

package/color-splitter-CGn1G4ow.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"color-splitter-CGn1G4ow.js","sources":["../src/material/node/blocks/color-splitter.ts"],"sourcesContent":["/** ColorSplitterBlock — identical to VectorSplitter but with r/g/b/a naming. */\n\nimport type { BlockEmitter, NodeExpr, NodeValueType } from \"../node-types.js\";\n\nconst COMPONENT: 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\nexport const emitter: BlockEmitter = {\n    className: \"ColorSplitterBlock\",\n    emit(block, outputName, stage, state, ctx) {\n        let source: NodeExpr | null = null;\n        for (const key of [\"rgba\", \"rgb\"] 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: ColorSplitterBlock (id=${block.id}) has no connected input`);\n        }\n        const c = COMPONENT[outputName];\n        if (!c) {\n            throw new Error(`NodeMaterial: ColorSplitterBlock 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,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;AAX/C;AAYQ,QAAI,SAA0B;AAC9B,eAAW,OAAO,CAAC,QAAQ,KAAK,GAAY;AACxC,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,wCAAwC,MAAM,EAAE,0BAA0B;AAAA,IAC9F;AACA,UAAM,IAAI,UAAU,UAAU;AAC9B,QAAI,CAAC,GAAG;AACJ,YAAM,IAAI,MAAM,mDAAmD,UAAU,GAAG;AAAA,IACpF;AACA,WAAO,EAAE,MAAM,IAAI,OAAO,IAAI,IAAI,EAAE,OAAO,IAAI,MAAM,EAAE,KAAA;AAAA,EAC3D;AACJ;"}

package/conditional-block-Cd2pbejI.js

@@ -0,0 +1,51 @@
+import { w as widerType } from "./_math-factory-C-QqW-Wi.js";
+function connectedOrDefault(block, inputName, fallback, type, stage, state, ctx) {
+  const input = block.inputs.get(inputName);
+  if (input == null ? void 0 : input.source) {
+    return ctx.resolve(block, inputName, stage, state);
+  }
+  return { expr: fallback, type };
+}
+function conditionExpr(condition, a, b) {
+  switch (condition) {
+    case 0:
+      return `${a} == ${b}`;
+    case 1:
+      return `${a} != ${b}`;
+    case 2:
+      return `${a} < ${b}`;
+    case 3:
+      return `${a} > ${b}`;
+    case 4:
+      return `${a} <= ${b}`;
+    case 5:
+      return `${a} >= ${b}`;
+    case 6:
+      return `(((${a} + ${b}) - 2.0 * floor((${a} + ${b}) / 2.0)) > 0.0)`;
+    case 7:
+      return `(min(${a} + ${b}, 1.0) > 0.0)`;
+    case 8:
+      return `(${a} * ${b} > 0.0)`;
+    default:
+      throw new Error(`NodeMaterial: unknown ConditionalBlock condition ${condition}`);
+  }
+}
+const emitter = {
+  className: "ConditionalBlock",
+  emit(block, _outputName, stage, state, ctx) {
+    const a = ctx.cast(ctx.resolve(block, "a", stage, state), "f32").expr;
+    const b = ctx.cast(ctx.resolve(block, "b", stage, state), "f32").expr;
+    const trueValue = connectedOrDefault(block, "true", "1.0", "f32", stage, state, ctx);
+    const falseValue = connectedOrDefault(block, "false", "0.0", "f32", stage, state, ctx);
+    const outputType = widerType(trueValue.type, falseValue.type);
+    const t = ctx.cast(trueValue, outputType).expr;
+    const f = ctx.cast(falseValue, outputType).expr;
+    const rawCondition = block.serialized.condition;
+    const condition = typeof rawCondition === "number" ? rawCondition : 2;
+    return { expr: `select(${f}, ${t}, ${conditionExpr(condition, a, b)})`, type: outputType };
+  }
+};
+export {
+  emitter
+};
+//# sourceMappingURL=conditional-block-Cd2pbejI.js.map

package/conditional-block-Cd2pbejI.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"conditional-block-Cd2pbejI.js","sources":["../src/material/node/blocks/conditional-block.ts"],"sourcesContent":["import type { BlockEmitter, NodeExpr, NodeValueType } from \"../node-types.js\";\nimport { widerType } from \"./_math-factory.js\";\n\nfunction connectedOrDefault(\n    block: Parameters<BlockEmitter[\"emit\"]>[0],\n    inputName: string,\n    fallback: string,\n    type: NodeValueType,\n    stage: Parameters<BlockEmitter[\"emit\"]>[2],\n    state: Parameters<BlockEmitter[\"emit\"]>[3],\n    ctx: Parameters<BlockEmitter[\"emit\"]>[4]\n): NodeExpr {\n    const input = block.inputs.get(inputName);\n    if (input?.source) {\n        return ctx.resolve(block, inputName, stage, state);\n    }\n    return { expr: fallback, type };\n}\n\nfunction conditionExpr(condition: number, a: string, b: string): string {\n    switch (condition) {\n        case 0:\n            return `${a} == ${b}`;\n        case 1:\n            return `${a} != ${b}`;\n        case 2:\n            return `${a} < ${b}`;\n        case 3:\n            return `${a} > ${b}`;\n        case 4:\n            return `${a} <= ${b}`;\n        case 5:\n            return `${a} >= ${b}`;\n        case 6:\n            return `(((${a} + ${b}) - 2.0 * floor((${a} + ${b}) / 2.0)) > 0.0)`;\n        case 7:\n            return `(min(${a} + ${b}, 1.0) > 0.0)`;\n        case 8:\n            return `(${a} * ${b} > 0.0)`;\n        default:\n            throw new Error(`NodeMaterial: unknown ConditionalBlock condition ${condition}`);\n    }\n}\n\nexport const emitter: BlockEmitter = {\n    className: \"ConditionalBlock\",\n    emit(block, _outputName, stage, state, ctx) {\n        const a = ctx.cast(ctx.resolve(block, \"a\", stage, state), \"f32\").expr;\n        const b = ctx.cast(ctx.resolve(block, \"b\", stage, state), \"f32\").expr;\n        const trueValue = connectedOrDefault(block, \"true\", \"1.0\", \"f32\", stage, state, ctx);\n        const falseValue = connectedOrDefault(block, \"false\", \"0.0\", \"f32\", stage, state, ctx);\n        const outputType = widerType(trueValue.type, falseValue.type);\n        const t = ctx.cast(trueValue, outputType).expr;\n        const f = ctx.cast(falseValue, outputType).expr;\n        const rawCondition = block.serialized.condition;\n        const condition = typeof rawCondition === \"number\" ? rawCondition : 2;\n        return { expr: `select(${f}, ${t}, ${conditionExpr(condition, a, b)})`, type: outputType };\n    },\n};\n"],"names":[],"mappings":";AAGA,SAAS,mBACL,OACA,WACA,UACA,MACA,OACA,OACA,KACQ;AACR,QAAM,QAAQ,MAAM,OAAO,IAAI,SAAS;AACxC,MAAI,+BAAO,QAAQ;AACf,WAAO,IAAI,QAAQ,OAAO,WAAW,OAAO,KAAK;AAAA,EACrD;AACA,SAAO,EAAE,MAAM,UAAU,KAAA;AAC7B;AAEA,SAAS,cAAc,WAAmB,GAAW,GAAmB;AACpE,UAAQ,WAAA;AAAA,IACJ,KAAK;AACD,aAAO,GAAG,CAAC,OAAO,CAAC;AAAA,IACvB,KAAK;AACD,aAAO,GAAG,CAAC,OAAO,CAAC;AAAA,IACvB,KAAK;AACD,aAAO,GAAG,CAAC,MAAM,CAAC;AAAA,IACtB,KAAK;AACD,aAAO,GAAG,CAAC,MAAM,CAAC;AAAA,IACtB,KAAK;AACD,aAAO,GAAG,CAAC,OAAO,CAAC;AAAA,IACvB,KAAK;AACD,aAAO,GAAG,CAAC,OAAO,CAAC;AAAA,IACvB,KAAK;AACD,aAAO,MAAM,CAAC,MAAM,CAAC,oBAAoB,CAAC,MAAM,CAAC;AAAA,IACrD,KAAK;AACD,aAAO,QAAQ,CAAC,MAAM,CAAC;AAAA,IAC3B,KAAK;AACD,aAAO,IAAI,CAAC,MAAM,CAAC;AAAA,IACvB;AACI,YAAM,IAAI,MAAM,oDAAoD,SAAS,EAAE;AAAA,EAAA;AAE3F;AAEO,MAAM,UAAwB;AAAA,EACjC,WAAW;AAAA,EACX,KAAK,OAAO,aAAa,OAAO,OAAO,KAAK;AACxC,UAAM,IAAI,IAAI,KAAK,IAAI,QAAQ,OAAO,KAAK,OAAO,KAAK,GAAG,KAAK,EAAE;AACjE,UAAM,IAAI,IAAI,KAAK,IAAI,QAAQ,OAAO,KAAK,OAAO,KAAK,GAAG,KAAK,EAAE;AACjE,UAAM,YAAY,mBAAmB,OAAO,QAAQ,OAAO,OAAO,OAAO,OAAO,GAAG;AACnF,UAAM,aAAa,mBAAmB,OAAO,SAAS,OAAO,OAAO,OAAO,OAAO,GAAG;AACrF,UAAM,aAAa,UAAU,UAAU,MAAM,WAAW,IAAI;AAC5D,UAAM,IAAI,IAAI,KAAK,WAAW,UAAU,EAAE;AAC1C,UAAM,IAAI,IAAI,KAAK,YAAY,UAAU,EAAE;AAC3C,UAAM,eAAe,MAAM,WAAW;AACtC,UAAM,YAAY,OAAO,iBAAiB,WAAW,eAAe;AACpE,WAAO,EAAE,MAAM,UAAU,CAAC,KAAK,CAAC,KAAK,cAAc,WAAW,GAAG,CAAC,CAAC,KAAK,MAAM,WAAA;AAAA,EAClF;AACJ;"}

package/create-skeleton-C9JdIJnb.js

@@ -0,0 +1,44 @@
+import { e as createMappedBuffer } from "./index-C8HOR2sB.js";
+function createSkeleton(engine, joints, weights, boneCount, boneData, joints1, weights1) {
+  const device = engine._device;
+  const texWidth = boneCount * 4;
+  const boneTexture = device.createTexture({
+    size: [texWidth, 1],
+    format: "rgba32float",
+    usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST
+  });
+  device.queue.writeTexture({ texture: boneTexture }, boneData.buffer, { bytesPerRow: texWidth * 16 }, { width: texWidth, height: 1 });
+  const joints32 = new Uint32Array(joints.length);
+  for (let i = 0; i < joints.length; i++) {
+    joints32[i] = joints[i];
+  }
+  const jointsBuffer = createMappedBuffer(engine, joints32, GPUBufferUsage.VERTEX);
+  const weightsBuffer = createMappedBuffer(engine, weights, GPUBufferUsage.VERTEX);
+  let joints1Buffer = null;
+  let weights1Buffer = null;
+  if (joints1 && weights1) {
+    const joints132 = new Uint32Array(joints1.length);
+    for (let i = 0; i < joints1.length; i++) {
+      joints132[i] = joints1[i];
+    }
+    joints1Buffer = createMappedBuffer(engine, joints132, GPUBufferUsage.VERTEX);
+    weights1Buffer = createMappedBuffer(engine, weights1, GPUBufferUsage.VERTEX);
+  }
+  return {
+    boneTexture,
+    boneCount,
+    jointsBuffer,
+    weightsBuffer,
+    joints,
+    weights,
+    boneMatrices: boneData,
+    joints1Buffer,
+    weights1Buffer,
+    joints1: joints1 ?? null,
+    weights1: weights1 ?? null
+  };
+}
+export {
+  createSkeleton
+};
+//# sourceMappingURL=create-skeleton-C9JdIJnb.js.map

package/create-skeleton-C9JdIJnb.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-skeleton-C9JdIJnb.js","sources":["../src/skeleton/create-skeleton.ts"],"sourcesContent":["/** Skeleton GPU resource factory.\n *\n *  Dynamically imported by load-gltf.ts when a mesh has skeletal data.\n *  Scenes without skeletons never import this module.\n *  Skinning WGSL is now provided by the skeleton ShaderFragment\n *  (shader/fragments/skeleton-fragment.ts) and composed at pipeline\n *  creation time — no global registration needed. */\n\nimport type { EngineContext } from \"../engine/engine.js\";\nimport type { SkeletonData } from \"../animation/types.js\";\nimport { createMappedBuffer } from \"../resource/gpu-buffers.js\";\n\n/** Create skeleton GPU data from parsed glTF skin.\n *  @param engine   - Engine context (provides GPUDevice)\n *  @param joints   - Joint indices (4 per vertex, u8 or u16)\n *  @param weights  - Blend weights (4 per vertex, f32)\n *  @param boneCount - Number of bones (joints) in the skeleton\n *  @param boneData  - Initial bone matrices (Float32Array, 16 floats per bone)\n *  @param joints1  - Extra joint indices for 8-bone skinning (JOINTS_1)\n *  @param weights1 - Extra blend weights for 8-bone skinning (WEIGHTS_1)\n */\nexport function createSkeleton(\n    engine: EngineContext,\n    joints: Uint16Array | Uint8Array,\n    weights: Float32Array,\n    boneCount: number,\n    boneData: Float32Array,\n    joints1?: Uint16Array | Uint8Array | null,\n    weights1?: Float32Array | null\n): SkeletonData {\n    const device = engine._device;\n    // Bone texture: rgba32float, 4 texels per bone (one mat4 column each)\n    const texWidth = boneCount * 4;\n    const boneTexture = device.createTexture({\n        size: [texWidth, 1],\n        format: \"rgba32float\",\n        usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST,\n    });\n    device.queue.writeTexture({ texture: boneTexture }, boneData.buffer, { bytesPerRow: texWidth * 16 }, { width: texWidth, height: 1 });\n\n    // Expand joints to Uint32Array — pipeline reads uint32x4 vertex format\n    const joints32 = new Uint32Array(joints.length);\n    for (let i = 0; i < joints.length; i++) {\n        joints32[i] = joints[i]!;\n    }\n\n    const jointsBuffer = createMappedBuffer(engine, joints32, GPUBufferUsage.VERTEX);\n    const weightsBuffer = createMappedBuffer(engine, weights, GPUBufferUsage.VERTEX);\n\n    let joints1Buffer: GPUBuffer | null = null;\n    let weights1Buffer: GPUBuffer | null = null;\n    if (joints1 && weights1) {\n        const joints132 = new Uint32Array(joints1.length);\n        for (let i = 0; i < joints1.length; i++) {\n            joints132[i] = joints1[i]!;\n        }\n        joints1Buffer = createMappedBuffer(engine, joints132, GPUBufferUsage.VERTEX);\n        weights1Buffer = createMappedBuffer(engine, weights1, GPUBufferUsage.VERTEX);\n    }\n\n    return {\n        boneTexture,\n        boneCount,\n        jointsBuffer,\n        weightsBuffer,\n        joints,\n        weights,\n        boneMatrices: boneData,\n        joints1Buffer,\n        weights1Buffer,\n        joints1: joints1 ?? null,\n        weights1: weights1 ?? null,\n    };\n}\n"],"names":[],"mappings":";AAqBO,SAAS,eACZ,QACA,QACA,SACA,WACA,UACA,SACA,UACY;AACZ,QAAM,SAAS,OAAO;AAEtB,QAAM,WAAW,YAAY;AAC7B,QAAM,cAAc,OAAO,cAAc;AAAA,IACrC,MAAM,CAAC,UAAU,CAAC;AAAA,IAClB,QAAQ;AAAA,IACR,OAAO,gBAAgB,kBAAkB,gBAAgB;AAAA,EAAA,CAC5D;AACD,SAAO,MAAM,aAAa,EAAE,SAAS,YAAA,GAAe,SAAS,QAAQ,EAAE,aAAa,WAAW,MAAM,EAAE,OAAO,UAAU,QAAQ,GAAG;AAGnI,QAAM,WAAW,IAAI,YAAY,OAAO,MAAM;AAC9C,WAAS,IAAI,GAAG,IAAI,OAAO,QAAQ,KAAK;AACpC,aAAS,CAAC,IAAI,OAAO,CAAC;AAAA,EAC1B;AAEA,QAAM,eAAe,mBAAmB,QAAQ,UAAU,eAAe,MAAM;AAC/E,QAAM,gBAAgB,mBAAmB,QAAQ,SAAS,eAAe,MAAM;AAE/E,MAAI,gBAAkC;AACtC,MAAI,iBAAmC;AACvC,MAAI,WAAW,UAAU;AACrB,UAAM,YAAY,IAAI,YAAY,QAAQ,MAAM;AAChD,aAAS,IAAI,GAAG,IAAI,QAAQ,QAAQ,KAAK;AACrC,gBAAU,CAAC,IAAI,QAAQ,CAAC;AAAA,IAC5B;AACA,oBAAgB,mBAAmB,QAAQ,WAAW,eAAe,MAAM;AAC3E,qBAAiB,mBAAmB,QAAQ,UAAU,eAAe,MAAM;AAAA,EAC/E;AAEA,SAAO;AAAA,IACH;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA,cAAc;AAAA,IACd;AAAA,IACA;AAAA,IACA,SAAS,WAAW;AAAA,IACpB,UAAU,YAAY;AAAA,EAAA;AAE9B;"}

package/cross-block-DCrLwCpt.js

@@ -0,0 +1,12 @@
+const emitter = {
+  className: "CrossBlock",
+  emit(block, _outputName, stage, state, ctx) {
+    const left = ctx.cast(ctx.resolve(block, "left", stage, state), "vec3f").expr;
+    const right = ctx.cast(ctx.resolve(block, "right", stage, state), "vec3f").expr;
+    return { expr: `cross(${left}, ${right})`, type: "vec3f" };
+  }
+};
+export {
+  emitter
+};
+//# sourceMappingURL=cross-block-DCrLwCpt.js.map

package/cross-block-DCrLwCpt.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cross-block-DCrLwCpt.js","sources":["../src/material/node/blocks/cross-block.ts"],"sourcesContent":["import type { BlockEmitter } from \"../node-types.js\";\n\nexport const emitter: BlockEmitter = {\n    className: \"CrossBlock\",\n    emit(block, _outputName, stage, state, ctx) {\n        const left = ctx.cast(ctx.resolve(block, \"left\", stage, state), \"vec3f\").expr;\n        const right = ctx.cast(ctx.resolve(block, \"right\", stage, state), \"vec3f\").expr;\n        return { expr: `cross(${left}, ${right})`, type: \"vec3f\" };\n    },\n};\n"],"names":[],"mappings":"AAEO,MAAM,UAAwB;AAAA,EACjC,WAAW;AAAA,EACX,KAAK,OAAO,aAAa,OAAO,OAAO,KAAK;AACxC,UAAM,OAAO,IAAI,KAAK,IAAI,QAAQ,OAAO,QAAQ,OAAO,KAAK,GAAG,OAAO,EAAE;AACzE,UAAM,QAAQ,IAAI,KAAK,IAAI,QAAQ,OAAO,SAAS,OAAO,KAAK,GAAG,OAAO,EAAE;AAC3E,WAAO,EAAE,MAAM,SAAS,IAAI,KAAK,KAAK,KAAK,MAAM,QAAA;AAAA,EACrD;AACJ;"}

package/cubemap-skybox-material-DvXMVc4k.js

@@ -0,0 +1,79 @@
+import { D as targetSignatureKey, E as createDefaultPipelineDescriptor, F as getSceneBindGroupLayout } from "./index-C8HOR2sB.js";
+const SKYBOX_POS_BUFFER = [{ arrayStride: 12, attributes: [{ shaderLocation: 0, offset: 0, format: "float32x3" }] }];
+const _cmPipelines = /* @__PURE__ */ new Map();
+const _cmLayouts = /* @__PURE__ */ new Map();
+let _cmCachedDevice = null;
+function createCubemapSkyboxMaterial(label, vertCode, fragCode) {
+  function getLayout(engine) {
+    const device = engine._device;
+    if (_cmCachedDevice !== device) {
+      _cmPipelines.clear();
+      _cmLayouts.clear();
+      _cmCachedDevice = device;
+    }
+    const cached = _cmLayouts.get(label);
+    if (cached) {
+      return cached;
+    }
+    const layout = device.createBindGroupLayout({
+      label: `${label}-material`,
+      entries: [
+        { binding: 0, visibility: GPUShaderStage.VERTEX | GPUShaderStage.FRAGMENT, buffer: { type: "uniform" } },
+        { binding: 1, visibility: GPUShaderStage.FRAGMENT, texture: { sampleType: "float", viewDimension: "cube" } },
+        { binding: 2, visibility: GPUShaderStage.FRAGMENT, sampler: { type: "filtering" } }
+      ]
+    });
+    _cmLayouts.set(label, layout);
+    return layout;
+  }
+  return {
+    getPipeline(_engine, sig) {
+      const device = _engine._device;
+      if (_cmCachedDevice !== device) {
+        _cmPipelines.clear();
+        _cmLayouts.clear();
+        _cmCachedDevice = device;
+      }
+      const key = `${label}|${targetSignatureKey(sig)}`;
+      const cached = _cmPipelines.get(key);
+      if (cached) {
+        return cached;
+      }
+      const _vertModule = device.createShaderModule({ code: vertCode, label: `${label}-vert` });
+      const _fragModule = device.createShaderModule({ code: fragCode, label: `${label}-frag` });
+      const pipeline = device.createRenderPipeline(
+        createDefaultPipelineDescriptor({
+          _label: `${label}-pipeline`,
+          _engine,
+          _bgls: [getSceneBindGroupLayout(_engine), getLayout(_engine)],
+          _vertModule,
+          _fragModule,
+          _vertexBuffers: SKYBOX_POS_BUFFER,
+          _format: sig._colorFormat,
+          _depthStencilFormat: sig._depthStencilFormat,
+          _depthCompare: sig._depthCompare,
+          _msaaSamples: sig._sampleCount,
+          _depthWriteEnabled: false,
+          _flipY: sig._flipY
+        })
+      );
+      _cmPipelines.set(key, pipeline);
+      return pipeline;
+    },
+    createBindGroup(engine, meshUBO, cubeView, cubeSampler) {
+      const device = engine._device;
+      return device.createBindGroup({
+        layout: getLayout(engine),
+        entries: [
+          { binding: 0, resource: { buffer: meshUBO } },
+          { binding: 1, resource: cubeView },
+          { binding: 2, resource: cubeSampler }
+        ]
+      });
+    }
+  };
+}
+export {
+  createCubemapSkyboxMaterial as c
+};
+//# sourceMappingURL=cubemap-skybox-material-DvXMVc4k.js.map

package/cubemap-skybox-material-DvXMVc4k.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cubemap-skybox-material-DvXMVc4k.js","sources":["../src/material/pbr/cubemap-skybox-material.ts"],"sourcesContent":["/** Shared cubemap skybox material factory — used by DDS and HDR skyboxes.\n *  BGL: binding 0 = uniform buffer, binding 1 = cube texture, binding 2 = sampler. */\n\nimport type { EngineContext } from \"../../engine/engine.js\";\nimport type { RenderTargetSignature } from \"../../engine/render-target.js\";\nimport { createDefaultPipelineDescriptor, getSceneBindGroupLayout } from \"../../render/scene-helpers.js\";\nimport { targetSignatureKey } from \"../../engine/render-target.js\";\n\nconst SKYBOX_POS_BUFFER: GPUVertexBufferLayout[] = [{ arrayStride: 12, attributes: [{ shaderLocation: 0, offset: 0, format: \"float32x3\" as GPUVertexFormat }] }];\n\nexport interface CubemapSkyboxMaterial {\n    getPipeline(engine: EngineContext, sig: RenderTargetSignature): GPURenderPipeline;\n    createBindGroup(engine: EngineContext, meshUBO: GPUBuffer, cubeView: GPUTextureView, cubeSampler: GPUSampler): GPUBindGroup;\n}\n\n/** Module-global pipeline + layout caches shared across all cubemap-skybox instances.\n *  Keyed by `${label}|${sigKey}` so HDR and DDS variants don't collide. */\nconst _cmPipelines = new Map<string, GPURenderPipeline>();\nconst _cmLayouts = new Map<string, GPUBindGroupLayout>();\nlet _cmCachedDevice: GPUDevice | null = null;\n\nexport function createCubemapSkyboxMaterial(label: string, vertCode: string, fragCode: string): CubemapSkyboxMaterial {\n    function getLayout(engine: EngineContext): GPUBindGroupLayout {\n        const device = engine._device;\n        if (_cmCachedDevice !== device) {\n            _cmPipelines.clear();\n            _cmLayouts.clear();\n            _cmCachedDevice = device;\n        }\n        const cached = _cmLayouts.get(label);\n        if (cached) {\n            return cached;\n        }\n        const layout = device.createBindGroupLayout({\n            label: `${label}-material`,\n            entries: [\n                { binding: 0, visibility: GPUShaderStage.VERTEX | GPUShaderStage.FRAGMENT, buffer: { type: \"uniform\" } },\n                { binding: 1, visibility: GPUShaderStage.FRAGMENT, texture: { sampleType: \"float\", viewDimension: \"cube\" } },\n                { binding: 2, visibility: GPUShaderStage.FRAGMENT, sampler: { type: \"filtering\" } },\n            ],\n        });\n        _cmLayouts.set(label, layout);\n        return layout;\n    }\n\n    return {\n        getPipeline(_engine, sig) {\n            const device = _engine._device;\n            if (_cmCachedDevice !== device) {\n                _cmPipelines.clear();\n                _cmLayouts.clear();\n                _cmCachedDevice = device;\n            }\n            const key = `${label}|${targetSignatureKey(sig)}`;\n            const cached = _cmPipelines.get(key);\n            if (cached) {\n                return cached;\n            }\n            const _vertModule = device.createShaderModule({ code: vertCode, label: `${label}-vert` });\n            const _fragModule = device.createShaderModule({ code: fragCode, label: `${label}-frag` });\n\n            const pipeline = device.createRenderPipeline(\n                createDefaultPipelineDescriptor({\n                    _label: `${label}-pipeline`,\n                    _engine,\n                    _bgls: [getSceneBindGroupLayout(_engine), getLayout(_engine)],\n                    _vertModule,\n                    _fragModule,\n                    _vertexBuffers: SKYBOX_POS_BUFFER,\n                    _format: sig._colorFormat!,\n                    _depthStencilFormat: sig._depthStencilFormat,\n                    _depthCompare: sig._depthCompare,\n                    _msaaSamples: sig._sampleCount,\n                    _depthWriteEnabled: false,\n                    _flipY: sig._flipY,\n                })\n            );\n            _cmPipelines.set(key, pipeline);\n            return pipeline;\n        },\n\n        createBindGroup(engine, meshUBO, cubeView, cubeSampler) {\n            const device = engine._device;\n            return device.createBindGroup({\n                layout: getLayout(engine),\n                entries: [\n                    { binding: 0, resource: { buffer: meshUBO } },\n                    { binding: 1, resource: cubeView },\n                    { binding: 2, resource: cubeSampler },\n                ],\n            });\n        },\n    };\n}\n"],"names":[],"mappings":";AAQA,MAAM,oBAA6C,CAAC,EAAE,aAAa,IAAI,YAAY,CAAC,EAAE,gBAAgB,GAAG,QAAQ,GAAG,QAAQ,YAAA,CAAgC,GAAG;AAS/J,MAAM,mCAAmB,IAAA;AACzB,MAAM,iCAAiB,IAAA;AACvB,IAAI,kBAAoC;AAEjC,SAAS,4BAA4B,OAAe,UAAkB,UAAyC;AAClH,WAAS,UAAU,QAA2C;AAC1D,UAAM,SAAS,OAAO;AACtB,QAAI,oBAAoB,QAAQ;AAC5B,mBAAa,MAAA;AACb,iBAAW,MAAA;AACX,wBAAkB;AAAA,IACtB;AACA,UAAM,SAAS,WAAW,IAAI,KAAK;AACnC,QAAI,QAAQ;AACR,aAAO;AAAA,IACX;AACA,UAAM,SAAS,OAAO,sBAAsB;AAAA,MACxC,OAAO,GAAG,KAAK;AAAA,MACf,SAAS;AAAA,QACL,EAAE,SAAS,GAAG,YAAY,eAAe,SAAS,eAAe,UAAU,QAAQ,EAAE,MAAM,UAAA,EAAU;AAAA,QACrG,EAAE,SAAS,GAAG,YAAY,eAAe,UAAU,SAAS,EAAE,YAAY,SAAS,eAAe,OAAA,EAAO;AAAA,QACzG,EAAE,SAAS,GAAG,YAAY,eAAe,UAAU,SAAS,EAAE,MAAM,YAAA,EAAY;AAAA,MAAE;AAAA,IACtF,CACH;AACD,eAAW,IAAI,OAAO,MAAM;AAC5B,WAAO;AAAA,EACX;AAEA,SAAO;AAAA,IACH,YAAY,SAAS,KAAK;AACtB,YAAM,SAAS,QAAQ;AACvB,UAAI,oBAAoB,QAAQ;AAC5B,qBAAa,MAAA;AACb,mBAAW,MAAA;AACX,0BAAkB;AAAA,MACtB;AACA,YAAM,MAAM,GAAG,KAAK,IAAI,mBAAmB,GAAG,CAAC;AAC/C,YAAM,SAAS,aAAa,IAAI,GAAG;AACnC,UAAI,QAAQ;AACR,eAAO;AAAA,MACX;AACA,YAAM,cAAc,OAAO,mBAAmB,EAAE,MAAM,UAAU,OAAO,GAAG,KAAK,QAAA,CAAS;AACxF,YAAM,cAAc,OAAO,mBAAmB,EAAE,MAAM,UAAU,OAAO,GAAG,KAAK,QAAA,CAAS;AAExF,YAAM,WAAW,OAAO;AAAA,QACpB,gCAAgC;AAAA,UAC5B,QAAQ,GAAG,KAAK;AAAA,UAChB;AAAA,UACA,OAAO,CAAC,wBAAwB,OAAO,GAAG,UAAU,OAAO,CAAC;AAAA,UAC5D;AAAA,UACA;AAAA,UACA,gBAAgB;AAAA,UAChB,SAAS,IAAI;AAAA,UACb,qBAAqB,IAAI;AAAA,UACzB,eAAe,IAAI;AAAA,UACnB,cAAc,IAAI;AAAA,UAClB,oBAAoB;AAAA,UACpB,QAAQ,IAAI;AAAA,QAAA,CACf;AAAA,MAAA;AAEL,mBAAa,IAAI,KAAK,QAAQ;AAC9B,aAAO;AAAA,IACX;AAAA,IAEA,gBAAgB,QAAQ,SAAS,UAAU,aAAa;AACpD,YAAM,SAAS,OAAO;AACtB,aAAO,OAAO,gBAAgB;AAAA,QAC1B,QAAQ,UAAU,MAAM;AAAA,QACxB,SAAS;AAAA,UACL,EAAE,SAAS,GAAG,UAAU,EAAE,QAAQ,UAAQ;AAAA,UAC1C,EAAE,SAAS,GAAG,UAAU,SAAA;AAAA,UACxB,EAAE,SAAS,GAAG,UAAU,YAAA;AAAA,QAAY;AAAA,MACxC,CACH;AAAA,IACL;AAAA,EAAA;AAER;"}

package/curve-block-BlJpXVYv.js

@@ -0,0 +1,89 @@
+import { aS as WGSL } from "./index-C8HOR2sB.js";
+function curveScalar(type, v) {
+  switch (type) {
+    case 0:
+      return `(1.0 - cos((${v} * 3.1415) / 2.0))`;
+    case 1:
+      return `sin((${v} * 3.1415) / 2.0)`;
+    case 2:
+      return `(-((cos(${v} * 3.1415) - 1.0)) / 2.0)`;
+    case 3:
+      return `(${v} * ${v})`;
+    case 4:
+      return `((1.0 - ${v}) * (1.0 - ${v}))`;
+    case 5:
+      return `select(1.0 - pow(-2.0 * ${v} + 2.0, 2.0) / 2.0, 2.0 * ${v} * ${v}, ${v} < 0.5)`;
+    case 6:
+      return `(${v} * ${v} * ${v})`;
+    case 7:
+      return `(1.0 - pow(1.0 - ${v}, 3.0))`;
+    case 8:
+      return `select(1.0 - pow(-2.0 * ${v} + 2.0, 3.0) / 2.0, 4.0 * ${v} * ${v} * ${v}, ${v} < 0.5)`;
+    case 9:
+      return `(${v} * ${v} * ${v} * ${v})`;
+    case 10:
+      return `(1.0 - pow(1.0 - ${v}, 4.0))`;
+    case 11:
+      return `select(1.0 - pow(-2.0 * ${v} + 2.0, 4.0) / 2.0, 8.0 * ${v} * ${v} * ${v} * ${v}, ${v} < 0.5)`;
+    case 12:
+      return `(${v} * ${v} * ${v} * ${v} * ${v})`;
+    case 13:
+      return `(1.0 - pow(1.0 - ${v}, 5.0))`;
+    case 14:
+      return `select(1.0 - pow(-2.0 * ${v} + 2.0, 5.0) / 2.0, 16.0 * ${v} * ${v} * ${v} * ${v} * ${v}, ${v} < 0.5)`;
+    case 15:
+      return `select(pow(2.0, 10.0 * ${v} - 10.0), 0.0, ${v} == 0.0)`;
+    case 16:
+      return `select(1.0 - pow(2.0, -10.0 * ${v}), 1.0, ${v} == 1.0)`;
+    case 17:
+      return `select(select(select((2.0 - pow(2.0, -20.0 * ${v} + 10.0)) / 2.0, pow(2.0, 20.0 * ${v} - 10.0) / 2.0, ${v} < 0.5), 1.0, ${v} == 1.0), 0.0, ${v} == 0.0)`;
+    case 18:
+      return `(1.0 - sqrt(1.0 - pow(${v}, 2.0)))`;
+    case 19:
+      return `sqrt(1.0 - pow(${v} - 1.0, 2.0))`;
+    case 20:
+      return `select((sqrt(1.0 - pow(-2.0 * ${v} + 2.0, 2.0)) + 1.0) / 2.0, (1.0 - sqrt(1.0 - pow(2.0 * ${v}, 2.0))) / 2.0, ${v} < 0.5)`;
+    case 21:
+      return `(2.70158 * ${v} * ${v} * ${v} - 1.70158 * ${v} * ${v})`;
+    case 22:
+      return `(2.70158 * pow(${v} - 1.0, 3.0) + 1.70158 * pow(${v} - 1.0, 2.0))`;
+    case 23:
+      return `select((pow(2.0 * ${v} - 2.0, 2.0) * (3.5949095 * (${v} * 2.0 - 2.0) + 3.5949095) + 2.0) / 2.0, (pow(2.0 * ${v}, 2.0) * (3.5949095 * 2.0 * ${v} - 2.5949095)) / 2.0, ${v} < 0.5)`;
+    case 24:
+      return `select(select(-pow(2.0, 10.0 * ${v} - 10.0) * sin((${v} * 10.0 - 10.75) * ((2.0 * 3.1415) / 3.0)), 1.0, ${v} == 1.0), 0.0, ${v} == 0.0)`;
+    case 25:
+      return `select(select(pow(2.0, -10.0 * ${v}) * sin((${v} * 10.0 - 0.75) * ((2.0 * 3.1415) / 3.0)) + 1.0, 1.0, ${v} == 1.0), 0.0, ${v} == 0.0)`;
+    case 26:
+      return `select(select(select((pow(2.0, -20.0 * ${v} + 10.0) * sin((20.0 * ${v} - 11.125) * ((2.0 * 3.1415) / 4.5))) / 2.0 + 1.0, -(pow(2.0, 20.0 * ${v} - 10.0) * sin((20.0 * ${v} - 11.125) * ((2.0 * 3.1415) / 4.5))) / 2.0, ${v} < 0.5), 1.0, ${v} == 1.0), 0.0, ${v} == 0.0)`;
+    default:
+      throw new Error(`NodeMaterial: unknown CurveBlock curveType ${type}`);
+  }
+}
+function curveExpr(type, input, inputType) {
+  if (inputType === "f32") {
+    return curveScalar(type, input);
+  }
+  if (inputType === "vec2f") {
+    return `${WGSL[inputType]}(${curveScalar(type, `(${input}).x`)}, ${curveScalar(type, `(${input}).y`)})`;
+  }
+  if (inputType === "vec3f") {
+    return `${WGSL[inputType]}(${curveScalar(type, `(${input}).x`)}, ${curveScalar(type, `(${input}).y`)}, ${curveScalar(type, `(${input}).z`)})`;
+  }
+  if (inputType === "vec4f") {
+    return `${WGSL[inputType]}(${curveScalar(type, `(${input}).x`)}, ${curveScalar(type, `(${input}).y`)}, ${curveScalar(type, `(${input}).z`)}, ${curveScalar(type, `(${input}).w`)})`;
+  }
+  throw new Error(`NodeMaterial: CurveBlock does not support ${inputType}`);
+}
+const emitter = {
+  className: "CurveBlock",
+  emit(block, _outputName, stage, state, ctx) {
+    const input = ctx.resolve(block, "input", stage, state);
+    const rawCurveType = block.serialized.curveType;
+    const curveType = typeof rawCurveType === "number" ? rawCurveType : 2;
+    return { expr: curveExpr(curveType, input.expr, input.type), type: input.type };
+  }
+};
+export {
+  emitter
+};
+//# sourceMappingURL=curve-block-BlJpXVYv.js.map

package/curve-block-BlJpXVYv.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"curve-block-BlJpXVYv.js","sources":["../src/material/node/blocks/curve-block.ts"],"sourcesContent":["import type { BlockEmitter, NodeValueType } from \"../node-types.js\";\nimport { WGSL } from \"../node-types.js\";\n\nfunction curveScalar(type: number, v: string): string {\n    switch (type) {\n        case 0:\n            return `(1.0 - cos((${v} * 3.1415) / 2.0))`;\n        case 1:\n            return `sin((${v} * 3.1415) / 2.0)`;\n        case 2:\n            return `(-((cos(${v} * 3.1415) - 1.0)) / 2.0)`;\n        case 3:\n            return `(${v} * ${v})`;\n        case 4:\n            return `((1.0 - ${v}) * (1.0 - ${v}))`;\n        case 5:\n            return `select(1.0 - pow(-2.0 * ${v} + 2.0, 2.0) / 2.0, 2.0 * ${v} * ${v}, ${v} < 0.5)`;\n        case 6:\n            return `(${v} * ${v} * ${v})`;\n        case 7:\n            return `(1.0 - pow(1.0 - ${v}, 3.0))`;\n        case 8:\n            return `select(1.0 - pow(-2.0 * ${v} + 2.0, 3.0) / 2.0, 4.0 * ${v} * ${v} * ${v}, ${v} < 0.5)`;\n        case 9:\n            return `(${v} * ${v} * ${v} * ${v})`;\n        case 10:\n            return `(1.0 - pow(1.0 - ${v}, 4.0))`;\n        case 11:\n            return `select(1.0 - pow(-2.0 * ${v} + 2.0, 4.0) / 2.0, 8.0 * ${v} * ${v} * ${v} * ${v}, ${v} < 0.5)`;\n        case 12:\n            return `(${v} * ${v} * ${v} * ${v} * ${v})`;\n        case 13:\n            return `(1.0 - pow(1.0 - ${v}, 5.0))`;\n        case 14:\n            return `select(1.0 - pow(-2.0 * ${v} + 2.0, 5.0) / 2.0, 16.0 * ${v} * ${v} * ${v} * ${v} * ${v}, ${v} < 0.5)`;\n        case 15:\n            return `select(pow(2.0, 10.0 * ${v} - 10.0), 0.0, ${v} == 0.0)`;\n        case 16:\n            return `select(1.0 - pow(2.0, -10.0 * ${v}), 1.0, ${v} == 1.0)`;\n        case 17:\n            return `select(select(select((2.0 - pow(2.0, -20.0 * ${v} + 10.0)) / 2.0, pow(2.0, 20.0 * ${v} - 10.0) / 2.0, ${v} < 0.5), 1.0, ${v} == 1.0), 0.0, ${v} == 0.0)`;\n        case 18:\n            return `(1.0 - sqrt(1.0 - pow(${v}, 2.0)))`;\n        case 19:\n            return `sqrt(1.0 - pow(${v} - 1.0, 2.0))`;\n        case 20:\n            return `select((sqrt(1.0 - pow(-2.0 * ${v} + 2.0, 2.0)) + 1.0) / 2.0, (1.0 - sqrt(1.0 - pow(2.0 * ${v}, 2.0))) / 2.0, ${v} < 0.5)`;\n        case 21:\n            return `(2.70158 * ${v} * ${v} * ${v} - 1.70158 * ${v} * ${v})`;\n        case 22:\n            return `(2.70158 * pow(${v} - 1.0, 3.0) + 1.70158 * pow(${v} - 1.0, 2.0))`;\n        case 23:\n            return `select((pow(2.0 * ${v} - 2.0, 2.0) * (3.5949095 * (${v} * 2.0 - 2.0) + 3.5949095) + 2.0) / 2.0, (pow(2.0 * ${v}, 2.0) * (3.5949095 * 2.0 * ${v} - 2.5949095)) / 2.0, ${v} < 0.5)`;\n        case 24:\n            return `select(select(-pow(2.0, 10.0 * ${v} - 10.0) * sin((${v} * 10.0 - 10.75) * ((2.0 * 3.1415) / 3.0)), 1.0, ${v} == 1.0), 0.0, ${v} == 0.0)`;\n        case 25:\n            return `select(select(pow(2.0, -10.0 * ${v}) * sin((${v} * 10.0 - 0.75) * ((2.0 * 3.1415) / 3.0)) + 1.0, 1.0, ${v} == 1.0), 0.0, ${v} == 0.0)`;\n        case 26:\n            return `select(select(select((pow(2.0, -20.0 * ${v} + 10.0) * sin((20.0 * ${v} - 11.125) * ((2.0 * 3.1415) / 4.5))) / 2.0 + 1.0, -(pow(2.0, 20.0 * ${v} - 10.0) * sin((20.0 * ${v} - 11.125) * ((2.0 * 3.1415) / 4.5))) / 2.0, ${v} < 0.5), 1.0, ${v} == 1.0), 0.0, ${v} == 0.0)`;\n        default:\n            throw new Error(`NodeMaterial: unknown CurveBlock curveType ${type}`);\n    }\n}\n\nfunction curveExpr(type: number, input: string, inputType: NodeValueType): string {\n    if (inputType === \"f32\") {\n        return curveScalar(type, input);\n    }\n    if (inputType === \"vec2f\") {\n        return `${WGSL[inputType]}(${curveScalar(type, `(${input}).x`)}, ${curveScalar(type, `(${input}).y`)})`;\n    }\n    if (inputType === \"vec3f\") {\n        return `${WGSL[inputType]}(${curveScalar(type, `(${input}).x`)}, ${curveScalar(type, `(${input}).y`)}, ${curveScalar(type, `(${input}).z`)})`;\n    }\n    if (inputType === \"vec4f\") {\n        return `${WGSL[inputType]}(${curveScalar(type, `(${input}).x`)}, ${curveScalar(type, `(${input}).y`)}, ${curveScalar(type, `(${input}).z`)}, ${curveScalar(type, `(${input}).w`)})`;\n    }\n    throw new Error(`NodeMaterial: CurveBlock does not support ${inputType}`);\n}\n\nexport const emitter: BlockEmitter = {\n    className: \"CurveBlock\",\n    emit(block, _outputName, stage, state, ctx) {\n        const input = ctx.resolve(block, \"input\", stage, state);\n        const rawCurveType = block.serialized.curveType;\n        const curveType = typeof rawCurveType === \"number\" ? rawCurveType : 2;\n        return { expr: curveExpr(curveType, input.expr, input.type), type: input.type };\n    },\n};\n"],"names":[],"mappings":"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"}

package/debug-block-D2pg4Yf6.js

@@ -0,0 +1,14 @@
+const emitter = {
+  className: "NodeMaterialDebugBlock",
+  emit(block, _outputName, stage, state, ctx) {
+    const input = block.inputs.get("debug");
+    if (!(input == null ? void 0 : input.source)) {
+      return { expr: "0.0", type: "f32" };
+    }
+    return ctx.resolve(block, "debug", stage, state);
+  }
+};
+export {
+  emitter
+};
+//# sourceMappingURL=debug-block-D2pg4Yf6.js.map

package/debug-block-D2pg4Yf6.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"debug-block-D2pg4Yf6.js","sources":["../src/material/node/blocks/debug-block.ts"],"sourcesContent":["import type { BlockEmitter } from \"../node-types.js\";\n\nexport const emitter: BlockEmitter = {\n    className: \"NodeMaterialDebugBlock\",\n    emit(block, _outputName, stage, state, ctx) {\n        const input = block.inputs.get(\"debug\");\n        if (!input?.source) {\n            return { expr: \"0.0\", type: \"f32\" };\n        }\n        return ctx.resolve(block, \"debug\", stage, state);\n    },\n};\n"],"names":[],"mappings":"AAEO,MAAM,UAAwB;AAAA,EACjC,WAAW;AAAA,EACX,KAAK,OAAO,aAAa,OAAO,OAAO,KAAK;AACxC,UAAM,QAAQ,MAAM,OAAO,IAAI,OAAO;AACtC,QAAI,EAAC,+BAAO,SAAQ;AAChB,aAAO,EAAE,MAAM,OAAO,MAAM,MAAA;AAAA,IAChC;AACA,WAAO,IAAI,QAAQ,OAAO,SAAS,OAAO,KAAK;AAAA,EACnD;AACJ;"}

package/derivative-block-B8KjtaWs.js

@@ -0,0 +1,20 @@
+const OUTPUT_FN = {
+  dx: "dpdx",
+  dy: "dpdy"
+};
+const emitter = {
+  className: "DerivativeBlock",
+  stage: "fragment",
+  emit(block, outputName, stage, state, ctx) {
+    const fn = OUTPUT_FN[outputName];
+    if (!fn) {
+      throw new Error(`NodeMaterial: DerivativeBlock output "${outputName}" is not supported`);
+    }
+    const input = ctx.resolve(block, "input", stage, state);
+    return { expr: `${fn}(${input.expr})`, type: input.type };
+  }
+};
+export {
+  emitter
+};
+//# sourceMappingURL=derivative-block-B8KjtaWs.js.map