pelican-engine 0.0.0-stage → 0.3.1

package/lib/renderer/graph-expressions.js

@@ -0,0 +1,485 @@
+import { GRAPH_INPUT_TYPES, GRAPH_OPERATIONS, GRAPH_TYPES } from "../sdk/index.js";
+const own = (object, key) => Object.prototype.hasOwnProperty.call(object, key);
+function fail(code, id) {
+    throw new Error(`TC_GRAPH_${code}:${id}`);
+}
+const types = GRAPH_TYPES;
+const numeric = (type) => type !== "bool";
+const width = (type) => (type.startsWith("vec") ? Number(type[3]) : 1);
+const unary = new Set(GRAPH_OPERATIONS.unary);
+const binary = new Set(GRAPH_OPERATIONS.binary);
+const ternary = new Set(GRAPH_OPERATIONS.ternary);
+function valueChecked(value, type, id) {
+    const finite = (n) => typeof n === "number" && Number.isFinite(n) && Number.isFinite(Math.fround(n));
+    if (type === "bool" && typeof value === "boolean")
+        return value;
+    if (type === "float" && finite(value))
+        return value;
+    if (type.startsWith("vec") && Array.isArray(value) && value.length === width(type) && Array.from(value).every(finite))
+        return [...value];
+    return fail("VALUE", id);
+}
+function broadcast(types, id) {
+    const vector = types.find((t) => width(t) > 1) ?? "float";
+    if (types.some((t) => !numeric(t) || (t !== "float" && t !== vector)))
+        fail("TYPE", id);
+    return vector;
+}
+function swizzle(node, type) {
+    const mask = node.components;
+    if (width(type) === 1 || typeof mask !== "string" || !/^(?:[xyzw]{1,4}|[rgba]{1,4})$/.test(mask))
+        fail("TYPE", node.id);
+    const family = /^[rgba]+$/.test(mask) ? "rgba" : "xyzw";
+    const indices = [...mask].map((c) => family.indexOf(c));
+    if (indices.some((i) => i >= width(type)))
+        fail("TYPE", node.id);
+    return indices.map((i) => "xyzw"[i]).join("");
+}
+function operationType(node, args) {
+    const op = node.op, id = node.id;
+    const require = (condition, result) => (condition ? result : fail("TYPE", id));
+    const a = args[0], b = args[1];
+    if (op === "sampleTexture")
+        return require(a === "vec2", "vec4");
+    if (op === "swizzle") {
+        const n = swizzle(node, a).length;
+        return n === 1 ? "float" : `vec${n}`;
+    }
+    if (op.startsWith("compose"))
+        return require(args.every((t) => t === "float"), `vec${args.length}`);
+    if (op === "not")
+        return require(a === "bool", "bool");
+    if (op === "and" || op === "or")
+        return require(a === "bool" && b === "bool", "bool");
+    if (["lessThan", "lessEqual", "greaterThan", "greaterEqual"].includes(op))
+        return require(a === "float" && b === "float", "bool");
+    if (op === "equal")
+        return require(a === b && (a === "float" || a === "bool"), "bool");
+    if (op === "select")
+        return require(a === b && args[2] === "bool", a);
+    if (op === "dot")
+        return require(a === b && width(a) > 1, "float");
+    if (op === "cross")
+        return require(a === "vec3" && b === "vec3", "vec3");
+    if (op === "normalize")
+        return require(width(a) > 1, a);
+    if (op === "length")
+        return require(numeric(a), "float");
+    if (op === "add" || op === "subtract")
+        return require(a === b && numeric(a), a);
+    if (op === "mix")
+        return require(a === b && numeric(a) && (args[2] === "float" || args[2] === a), a);
+    if (unary.has(op))
+        return require(numeric(a), a);
+    if (binary.has(op) || op === "clamp" || op === "smoothstep")
+        return broadcast(args, id);
+    return fail("OP", id);
+}
+/** Renderer-private traversal. Only output-reachable nodes invoke builder callbacks. */
+export function mapTypedGraph(graph, builder) {
+    if (!graph || !Array.isArray(graph.nodes) || !graph.nodeTypes || typeof graph.output !== "string")
+        fail("IR", "graph");
+    const nodes = new Map(), values = new Map(), active = new Set();
+    if (graph.parameters !== undefined &&
+        (!Array.isArray(graph.parameters) || Array.from(graph.parameters).some((p) => !p || typeof p.name !== "string")))
+        fail("IR", "parameters");
+    const parameters = new Map((graph.parameters ?? []).map((p) => [p.name, p]));
+    if (parameters.size !== (graph.parameters?.length ?? 0))
+        fail("IR", "parameters");
+    for (const node of graph.nodes) {
+        if (!node || typeof node.id !== "string" || nodes.has(node.id))
+            fail("IR", node?.id ?? "graph");
+        nodes.set(node.id, node);
+    }
+    const typeOf = (id) => {
+        if (!nodes.has(id))
+            fail("REF", id);
+        const type = graph.nodeTypes[id];
+        if (!own(graph.nodeTypes, id) || !types.includes(type))
+            fail("TYPE", id);
+        return type;
+    };
+    const stack = [{ id: graph.output, ready: false }];
+    if (graph.outputType !== typeOf(graph.output))
+        fail("TYPE", graph.output);
+    while (stack.length) {
+        const { id, ready } = stack.pop();
+        if (values.has(id))
+            continue;
+        const type = typeOf(id), node = nodes.get(id);
+        const checked = (expected) => (expected === type ? expected : fail("TYPE", id));
+        const refs = "inputs" in node ? node.inputs : [];
+        if (!Array.isArray(refs) || refs.some((ref) => typeof ref !== "string"))
+            fail("REF", id);
+        if (!ready) {
+            if (active.has(id))
+                fail("CYCLE", id);
+            active.add(id);
+            stack.push({ id, ready: true });
+            for (let i = refs.length - 1; i >= 0; i--)
+                stack.push({ id: refs[i], ready: false });
+            continue;
+        }
+        let result, expected;
+        if (node.op === "float" || node.op === "bool" || node.op === "vec2" || node.op === "vec3" || node.op === "vec4") {
+            expected = checked(node.op);
+            result = builder.constant(valueChecked(node.value, expected, id), expected, node);
+        }
+        else if (node.op === "time" || node.op === "input") {
+            const name = node.op === "time" ? "time" : node.name;
+            if (node.op === "input" && !own(GRAPH_INPUT_TYPES, node.name))
+                fail("CONTEXT", id);
+            expected = checked(name === "time" ? "float" : GRAPH_INPUT_TYPES[name]);
+            result = builder.input(name, expected, node);
+        }
+        else if (node.op === "parameter") {
+            const parameter = parameters.get(node.name);
+            if (!parameter || !types.includes(parameter.type))
+                fail("CONTEXT", id);
+            expected = checked(parameter.type);
+            result = builder.parameter(node.name, expected, valueChecked(parameter.default, expected, id), node);
+        }
+        else if (node.op === "sampleFrame" || node.op === "sampleHistory") {
+            if (refs.length !== 1 || typeOf(refs[0]) !== "vec2" || typeof node.channel !== "string" || !node.channel.length)
+                fail("TYPE", id);
+            expected = checked("vec4");
+            const callback = node.op === "sampleFrame" ? builder.frame : builder.history;
+            if (!callback)
+                fail("CONTEXT", id);
+            result = callback(node.channel, values.get(refs[0]), node);
+        }
+        else if (node.op === "readBuffer") {
+            if (refs.length !== 1 || typeOf(refs[0]) !== "float" || !graph.bufferTypes || !own(graph.bufferTypes, node.buffer) || !types.includes(graph.bufferTypes[node.buffer]))
+                fail("TYPE", id);
+            expected = checked(graph.bufferTypes[node.buffer]);
+            if (!builder.buffer)
+                fail("CONTEXT", id);
+            result = builder.buffer(node.buffer, values.get(refs[0]), expected, node);
+        }
+        else {
+            const op = node.op;
+            const count = unary.has(op) || op === "not" || op === "swizzle" || op === "sampleTexture"
+                ? 1
+                : binary.has(op) || op === "compose2"
+                    ? 2
+                    : ternary.has(op) || op === "compose3"
+                        ? 3
+                        : op === "compose4"
+                            ? 4
+                            : fail("OP", id);
+            if (refs.length !== count)
+                fail("TYPE", id);
+            const inputTypes = refs.map(typeOf);
+            expected = checked(operationType(node, inputTypes));
+            if (node.op === "sampleTexture") {
+                const asset = typeof node.texture === "string" ? node.texture : node.texture?.id;
+                if (typeof asset !== "string" || !asset.length)
+                    fail("CONTEXT", id);
+                result = builder.texture(asset, values.get(refs[0]), node);
+            }
+            else
+                result = builder.operation(node, refs.map((ref) => values.get(ref)), expected, inputTypes);
+        }
+        values.set(id, result);
+        active.delete(id);
+    }
+    return values.get(graph.output);
+}
+const components = (v) => (typeof v === "number" ? [v] : v);
+function arithmetic(node, args, type) {
+    const [a, b, c] = args, op = node.op;
+    const aa = components(a), bb = components(b);
+    const componentwise = (fn) => {
+        const result = Array.from({ length: width(type) }, (_, i) => fn(...args.map((v) => {
+            const a = components(v);
+            return a[a.length === 1 ? 0 : i];
+        })));
+        return type === "float" ? result[0] : result;
+    };
+    const clamp = (v, lo, hi) => Math.min(Math.max(v, lo), hi);
+    switch (op) {
+        case "not":
+            return !a;
+        case "and":
+            return Boolean(a && b);
+        case "or":
+            return Boolean(a || b);
+        case "equal":
+            return a === b;
+        case "lessThan":
+            return a < b;
+        case "lessEqual":
+            return a <= b;
+        case "greaterThan":
+            return a > b;
+        case "greaterEqual":
+            return a >= b;
+        case "select":
+            return c ? b : a;
+        case "compose2":
+        case "compose3":
+        case "compose4":
+            return [...args];
+        case "swizzle": {
+            const v = [...swizzle(node, `vec${aa.length}`)].map((c) => aa["xyzw".indexOf(c)]);
+            return v.length === 1 ? v[0] : v;
+        }
+        case "length":
+            return Math.hypot(...aa);
+        case "normalize": {
+            const scale = Math.max(...aa.map(Math.abs));
+            const v = scale === 0 ? aa.map(() => 0) : aa.map((n) => n / scale);
+            const len = Math.hypot(...v);
+            return v.map((n) => (len === 0 ? 0 : n / len));
+        }
+        case "dot":
+            return aa.reduce((sum, n, i) => sum + n * bb[i], 0);
+        case "cross":
+            return [aa[1] * bb[2] - aa[2] * bb[1], aa[2] * bb[0] - aa[0] * bb[2], aa[0] * bb[1] - aa[1] * bb[0]];
+        case "add":
+            return componentwise((x, y) => x + y);
+        case "subtract":
+            return componentwise((x, y) => x - y);
+        case "multiply":
+            return componentwise((x, y) => x * y);
+        case "safeDivide":
+            return componentwise((x, y) => (y === 0 ? 0 : x / y));
+        case "min":
+            return componentwise(Math.min);
+        case "max":
+            return componentwise(Math.max);
+        case "step":
+            return componentwise((edge, v) => (v < edge ? 0 : 1));
+        case "mix":
+            return componentwise((x, y, t) => x * (1 - t) + y * t);
+        case "clamp":
+            return componentwise(clamp);
+        case "smoothstep":
+            return componentwise((lo, hi, v) => {
+                const t = clamp(hi === lo ? 0 : (v - lo) / (hi - lo), 0, 1);
+                return t * t * (3 - 2 * t);
+            });
+        case "sin":
+            return componentwise(Math.sin);
+        case "cos":
+            return componentwise(Math.cos);
+        case "abs":
+            return componentwise(Math.abs);
+        case "floor":
+            return componentwise(Math.floor);
+        case "ceil":
+            return componentwise(Math.ceil);
+        case "fract":
+            return componentwise((x) => x - Math.floor(x));
+        case "negate":
+            return componentwise((x) => -x);
+        case "saturate":
+            return componentwise((x) => clamp(x, 0, 1));
+        case "safeSqrt":
+            return componentwise((x) => Math.sqrt(Math.max(x, 0)));
+        default:
+            return fail("OP", node.id);
+    }
+}
+/** f64 intermediates intentionally preserve legacy CPU evaluation. */
+export function evaluateTypedGraph(graph, context = {}) {
+    if (!context || typeof context !== "object" || Array.isArray(context))
+        fail("CONTEXT", "graph");
+    if (context.precision !== undefined && context.precision !== "f32" && context.precision !== "f64")
+        fail("CONTEXT", "precision");
+    const round = (value, id) => {
+        if (context.precision !== "f32" || typeof value === "boolean")
+            return value;
+        const rounded = typeof value === "number" ? Math.fround(value) : value.map(Math.fround);
+        if (typeof rounded !== "boolean" && components(rounded).some(number => !Number.isFinite(number)))
+            fail("ARITHMETIC", id);
+        return rounded;
+    };
+    for (const record of [context.parameters, context.inputs]) {
+        if (record !== undefined && (!record || typeof record !== "object" || Array.isArray(record)))
+            fail("CONTEXT", "graph");
+    }
+    const result = mapTypedGraph(graph, {
+        constant: (value, _type, node) => round(value, node.id),
+        input: (name, type, node) => {
+            const value = name === "time"
+                ? context.time === undefined
+                    ? 0
+                    : context.time
+                : context.inputs && own(context.inputs, name)
+                    ? context.inputs[name]
+                    : undefined;
+            if (value === undefined)
+                fail("CONTEXT", node.id);
+            return round(valueChecked(value, type, node.id), node.id);
+        },
+        parameter: (name, type, fallback, node) => round(valueChecked(context.parameters && own(context.parameters, name) ? context.parameters[name] : fallback, type, node.id), node.id),
+        texture: (asset, uv, node) => {
+            if (typeof context.sampleTexture !== "function")
+                fail("CONTEXT", node.id);
+            return round(valueChecked(context.sampleTexture(asset, [...uv]), "vec4", node.id), node.id);
+        },
+        buffer: (name, index, type, node) => {
+            if (typeof context.readBuffer !== "function" || typeof index !== "number")
+                fail("CONTEXT", node.id);
+            return round(valueChecked(context.readBuffer(name, index), type, node.id), node.id);
+        },
+        frame: (channel, uv, node) => {
+            if (!context.sampleFrame)
+                fail("CONTEXT", node.id);
+            return round(valueChecked(context.sampleFrame(channel, [...uv]), "vec4", node.id), node.id);
+        },
+        history: (channel, uv, node) => {
+            if (!context.sampleHistory)
+                fail("CONTEXT", node.id);
+            return round(valueChecked(context.sampleHistory(channel, [...uv]), "vec4", node.id), node.id);
+        },
+        operation: (node, inputs, type) => {
+            const value = arithmetic(node, inputs, type);
+            if (typeof value !== "boolean" && components(value).some((n) => !Number.isFinite(n)))
+                fail("ARITHMETIC", node.id);
+            return round(value, node.id);
+        },
+    });
+    return Array.isArray(result) ? [...result] : result;
+}
+const wgslType = (type) => (type === "float" ? "f32" : type === "bool" ? "bool" : `${type}f`);
+const literal = (value) => (Object.is(value, -0) ? "-0.0" : /[.e]/i.test(String(value)) ? String(value) : `${value}.0`);
+/** Bindings contain trusted engine code, never SDK/user-provided shader source. */
+export function lowerGraphWGSL(graph, bindings) {
+    if (!bindings || typeof bindings.prefix !== "string" || !/^[A-Za-z][A-Za-z0-9_]*$/.test(bindings.prefix))
+        fail("PREFIX", "graph");
+    const lines = [], helpers = new Map(), prefix = bindings.prefix;
+    const emit = (expression, type) => {
+        const symbol = `${prefix}_g${lines.length}`;
+        lines.push(`let ${symbol}: ${wgslType(type)} = ${expression};`);
+        return symbol;
+    };
+    const binding = (callback, args, id) => {
+        if (typeof callback !== "function")
+            fail("CONTEXT", id);
+        const result = callback(...args);
+        return typeof result === "string" && result.trim().length ? result : fail("CONTEXT", id);
+    };
+    const helper = (kind, type) => {
+        const name = `${prefix}_${kind}_${type}`, t = wgslType(type), zero = `${t}(0.0)`, one = `${t}(1.0)`;
+        if (!helpers.has(name)) {
+            if (kind === "safeDivide")
+                helpers.set(name, `fn ${name}(a: ${t}, b: ${t}) -> ${t} {\n  let zero = b == ${zero};\n  let denominator = select(b, ${one}, zero);\n  return select(a / denominator, ${zero}, zero);\n}`);
+            else {
+                const maximum = Array.from({ length: width(type) }, (_, i) => `abs(v.${"xyzw"[i]})`).reduce((a, b) => `max(${a}, ${b})`);
+                helpers.set(name, `fn ${name}(v: ${t}) -> ${t} {\n  let scale = ${maximum};\n  if (scale == 0.0) { return ${zero}; }\n  let scaled = v / scale;\n  return scaled / length(scaled);\n}`);
+            }
+        }
+        return name;
+    };
+    const result = mapTypedGraph(graph, {
+        constant: (value, type) => emit(typeof value === "boolean"
+            ? String(value)
+            : typeof value === "number"
+                ? literal(value)
+                : `${wgslType(type)}(${value.map(literal).join(", ")})`, type),
+        input: (name, type, node) => emit(binding(bindings.input, [name, type], node.id), type),
+        parameter: (name, type, _fallback, node) => emit(binding(bindings.parameter, [name, type], node.id), type),
+        texture: (asset, uv, node) => emit(binding(bindings.sampleTexture, [asset, uv], node.id), "vec4"),
+        buffer: (name, index, type, node) => {
+            if (!bindings.readBuffer)
+                fail("CONTEXT", node.id);
+            return emit(binding(bindings.readBuffer, [name, index, type], node.id), type);
+        },
+        frame: (channel, uv, node) => {
+            if (!bindings.sampleFrame)
+                fail("CONTEXT", node.id);
+            return emit(binding(bindings.sampleFrame, [channel, uv], node.id), "vec4");
+        },
+        history: (channel, uv, node) => {
+            if (!bindings.sampleHistory)
+                fail("CONTEXT", node.id);
+            return emit(binding(bindings.sampleHistory, [channel, uv], node.id), "vec4");
+        },
+        operation: (node, inputs, type, inputTypes) => {
+            const op = node.op, t = wgslType(type);
+            const cast = (symbol, index) => (inputTypes[index] === "float" && width(type) > 1 ? `${t}(${symbol})` : symbol);
+            const [a, b, c] = inputs.map(cast);
+            let expression;
+            switch (op) {
+                case "add":
+                case "subtract":
+                case "multiply":
+                    expression = `(${a} ${{ add: "+", subtract: "-", multiply: "*" }[op]} ${b})`;
+                    break;
+                case "lessThan":
+                case "lessEqual":
+                case "greaterThan":
+                case "greaterEqual":
+                case "equal":
+                case "and":
+                case "or": {
+                    const operator = { lessThan: "<", lessEqual: "<=", greaterThan: ">", greaterEqual: ">=", equal: "==", and: "&&", or: "||" }[op];
+                    expression = `(${a} ${operator} ${b})`;
+                    break;
+                }
+                case "not":
+                    expression = `(!${a})`;
+                    break;
+                case "negate":
+                    expression = `(-${a})`;
+                    break;
+                case "select":
+                    expression = `select(${a}, ${b}, ${inputs[2]})`;
+                    break;
+                case "compose2":
+                case "compose3":
+                case "compose4":
+                    expression = `${t}(${inputs.join(", ")})`;
+                    break;
+                case "swizzle":
+                    expression = `${inputs[0]}.${swizzle(node, inputTypes[0])}`;
+                    break;
+                case "safeDivide":
+                    expression = `${helper("safeDivide", type)}(${a}, ${b})`;
+                    break;
+                case "normalize":
+                    expression = `${helper("safeNormalize", type)}(${a})`;
+                    break;
+                case "safeSqrt":
+                    expression = `sqrt(max(${a}, ${t}(0.0)))`;
+                    break;
+                case "saturate":
+                    expression = `clamp(${a}, ${t}(0.0), ${t}(1.0))`;
+                    break;
+                case "length":
+                    expression = inputTypes[0] === "float" ? `abs(${a})` : `length(${a})`;
+                    break;
+                case "smoothstep": {
+                    const tt = emit(`clamp(${helper("safeDivide", type)}(${c} - ${a}, ${b} - ${a}), ${t}(0.0), ${t}(1.0))`, type);
+                    expression = `(${tt} * ${tt} * (${t}(3.0) - ${t}(2.0) * ${tt}))`;
+                    break;
+                }
+                case "sin":
+                case "cos":
+                case "abs":
+                case "floor":
+                case "ceil":
+                case "fract":
+                    expression = `${op}(${a})`;
+                    break;
+                case "min":
+                case "max":
+                case "dot":
+                case "cross":
+                case "step":
+                    expression = `${op}(${a}, ${b})`;
+                    break;
+                case "mix":
+                case "clamp":
+                    expression = `${op}(${a}, ${b}, ${c})`;
+                    break;
+                default:
+                    return fail("OP", node.id);
+            }
+            return emit(expression, type);
+        },
+    });
+    return { helpers: [...helpers.values()].join("\n"), code: lines.join("\n"), result, type: graph.outputType };
+}

package/lib/renderer/graph-tsl.js

@@ -0,0 +1,141 @@
+import * as TSL from "three/tsl";
+import { mapTypedGraph } from "./graph-expressions.js";
+export function typedGraphToTSL(graph, time, parameters, textures, context) {
+    const construct = (type, value) => type === "bool"
+        ? TSL.bool(value)
+        : type === "float"
+            ? TSL.float(value)
+            : TSL[type](...(Array.isArray(value) ? value : [value]));
+    const safeDivide = (a, b, type) => {
+        const zero = b.equal(0);
+        return TSL.select(zero, construct(type, 0), a.div(TSL.select(zero, construct(type, 1), b)));
+    };
+    return mapTypedGraph(graph, {
+        constant: (value, type) => construct(type, value),
+        input(name) {
+            if (name === "time")
+                return time;
+            if (context?.inputs && Object.hasOwn(context.inputs, name))
+                return context.inputs[name];
+            if (name === "uv")
+                return TSL.uv(0);
+            if (name === "uv1")
+                return TSL.uv(1);
+            if (name === "positionWorld")
+                return TSL.positionWorld;
+            if (name === "normalWorld")
+                return TSL.normalWorldGeometry;
+            if (name === "viewDirectionWorld")
+                return TSL.cameraPosition.sub(TSL.positionWorld).normalize();
+            if (name === "vertexColor")
+                return TSL.vertexColor();
+            throw Error("TC_GRAPH_CONTEXT: raster material input " + name);
+        },
+        parameter(name) {
+            const value = parameters.get(name);
+            if (!value)
+                throw Error("TC_GRAPH_PARAMETER: " + name);
+            return value;
+        },
+        texture(asset, uv) {
+            if (Object.hasOwn(graph.textureSlots ?? {}, asset)) {
+                if (!context?.sampleTextureSlot)
+                    throw Error("TC_RENDER_TEXTURE_CAPABILITY: Managed texture sampling requires a render texture bridge.");
+                return context.sampleTextureSlot(asset, uv);
+            }
+            const texture = textures.get(asset);
+            if (!texture)
+                throw Error("TC_GRAPH_TEXTURE: " + asset);
+            return TSL.texture(texture, uv).level(TSL.float(0));
+        },
+        frame(channel, uv) {
+            if (!context?.sampleFrame)
+                throw Error("TC_GRAPH_CONTEXT: Frame sampling requires a postprocess source.");
+            return context.sampleFrame(channel, uv);
+        },
+        history(channel, uv) {
+            if (!context?.sampleHistory)
+                throw Error("TC_GRAPH_CONTEXT: History sampling requires a postprocess source.");
+            return context.sampleHistory(channel, uv);
+        },
+        buffer(name, index, type) {
+            if (!context?.readBuffer)
+                throw new Error("TC_GRAPH_CONTEXT: Buffer reads require a managed render slot.");
+            return context.readBuffer(name, index, type);
+        },
+        operation(node, inputs, type, inputTypes) {
+            const cast = (v, i) => inputTypes[i] === "float" && type.startsWith("vec")
+                ? construct(type, v)
+                : v;
+            const [a, b, c] = inputs.map(cast), op = node.op;
+            if (op === "compose2" || op === "compose3" || op === "compose4")
+                return TSL[type](...inputs);
+            if (op === "swizzle") {
+                const family = /^[rgba]+$/.test(node.components) ? "rgba" : "xyzw";
+                return inputs[0][[...node.components].map((c) => "xyzw"[family.indexOf(c)]).join("")];
+            }
+            if (op === "add")
+                return a.add(b);
+            if (op === "subtract")
+                return a.sub(b);
+            if (op === "multiply")
+                return a.mul(b);
+            if (op === "safeDivide")
+                return safeDivide(a, b, type);
+            if (op === "negate")
+                return a.negate();
+            if (op === "not")
+                return a.not();
+            if (op === "and")
+                return a.and(b);
+            if (op === "or")
+                return a.or(b);
+            if (op === "equal")
+                return a.equal(b);
+            if (op === "lessThan")
+                return a.lessThan(b);
+            if (op === "lessEqual")
+                return a.lessThanEqual(b);
+            if (op === "greaterThan")
+                return a.greaterThan(b);
+            if (op === "greaterEqual")
+                return a.greaterThanEqual(b);
+            if (op === "select")
+                return TSL.select(inputs[2], b, a);
+            if (op === "saturate")
+                return TSL.clamp(a, 0, 1);
+            if (op === "safeSqrt")
+                return TSL.sqrt(TSL.max(a, 0));
+            if (op === "normalize") {
+                const n = Number(type.slice(3));
+                let scale = TSL.abs(a.x);
+                for (let i = 1; i < n; i++)
+                    scale = TSL.max(scale, TSL.abs(a["xyzw"[i]]));
+                const scaled = a.div(TSL.select(scale.equal(0), 1, scale));
+                const length = TSL.length(scaled);
+                return scaled.div(TSL.select(length.equal(0), 1, length));
+            }
+            if (op === "smoothstep") {
+                const t = TSL.clamp(safeDivide(c.sub(a), b.sub(a), type), 0, 1);
+                return t.mul(t).mul(construct(type, 3).sub(t.mul(2)));
+            }
+            if (op === "length")
+                return inputTypes[0] === "float" ? TSL.abs(a) : TSL.length(a);
+            if (["sin", "cos", "abs", "floor", "ceil", "fract"].includes(op))
+                return TSL[op](a);
+            if (["min", "max", "dot", "cross", "step"].includes(op))
+                return TSL[op](a, b);
+            if (op === "mix" || op === "clamp")
+                return TSL[op](a, b, c);
+            throw Error("TC_GRAPH_OP: " + node.id + ":" + op);
+        },
+    });
+}
+/** normalNode expects an already oriented, normalized view-space normal. */
+export function materialGraphNormalToTSL(value) {
+    const scale = TSL.max(TSL.max(TSL.abs(value.x), TSL.abs(value.y)), TSL.abs(value.z));
+    const scaled = value.div(TSL.select(scale.equal(0), 1, scale));
+    const length = TSL.length(scaled);
+    const world = TSL.select(scale.equal(0), TSL.normalWorldGeometry, scaled.div(TSL.select(length.equal(0), 1, length)));
+    return TSL.negateOnBackSide(world.transformDirection(TSL.cameraViewMatrix));
+}