pelican-engine 0.0.0-stage → 0.3.1

package/lib/renderer/graph.js

@@ -0,0 +1,214 @@
+import * as TSL from "three/tsl";
+import { Vector2, Vector3, Vector4 } from "three";
+import { compileGraphDeclaration } from "../compiler/graph.js";
+import { evaluateTypedGraph, lowerGraphWGSL, } from "./graph-expressions.js";
+import { typedGraphToTSL } from "./graph-tsl.js";
+function typedGraph(graph) {
+    if (!graph || graph.nodeTypes !== undefined)
+        return graph;
+    // M0 reference fixtures and serialized graphs predate per-node type metadata.
+    const result = compileGraphDeclaration({
+        nodes: graph.nodes,
+        output: graph.output,
+        ...(graph.parameters ? { parameters: graph.parameters } : {}),
+    }, graph.outputType);
+    if (result.issues.length)
+        throw Error(result.issues[0].code + ": " + result.issues[0].message);
+    return result.graph;
+}
+/** Legacy signatures remain compatible; typed material adapters supply richer bindings. */
+export function graphToTSL(input, time) {
+    const graph = typedGraph(input);
+    const parameters = new Map((graph.parameters ?? []).map((p) => {
+        const value = Array.isArray(p.default)
+            ? p.default.length === 2
+                ? new Vector2(...p.default)
+                : p.default.length === 3
+                    ? new Vector3(...p.default)
+                    : new Vector4(...p.default)
+            : p.default;
+        return [p.name, TSL.uniform(value, p.type)];
+    }));
+    return typedGraphToTSL(graph, time, parameters, new Map());
+}
+export function evaluateGraph(graph, time) {
+    return evaluateTypedGraph(typedGraph(graph), { time });
+}
+/** The active check prevents uncancellable GPU promises from creating late resources. */
+export async function withGraphGPUDeadline(device, prefix, work, timeoutMs = 10000) {
+    let stopped = false, timer;
+    let scope;
+    device.pushErrorScope("validation");
+    const closeScope = () => (scope ??= device.popErrorScope());
+    const active = () => {
+        if (stopped)
+            throw Error(prefix + "_CANCELLED: GPU graph work is no longer active.");
+    };
+    try {
+        return await Promise.race([
+            Promise.resolve()
+                .then(() => work(active))
+                .then(async (value) => {
+                active();
+                const validation = await closeScope();
+                active();
+                if (validation)
+                    throw Error(prefix + "_GPU: " + validation.message);
+                return value;
+            }),
+            device.lost.then((info) => {
+                throw Error(prefix + "_DEVICE_LOST: " + info.reason);
+            }),
+            new Promise((_, reject) => {
+                timer = setTimeout(() => reject(Error(prefix +
+                    "_TIMEOUT: GPU graph work exceeded " +
+                    timeoutMs +
+                    "ms.")), timeoutMs);
+            }),
+        ]);
+    }
+    finally {
+        stopped = true;
+        clearTimeout(timer);
+        // popErrorScope may itself wait for a stuck device; cleanup must not await it.
+        void closeScope().catch(() => null);
+    }
+}
+export async function runComputeGraph(device, input, count, workgroupSize, time, parameters = {}) {
+    if (!Number.isSafeInteger(count) ||
+        count < 1 ||
+        count > 65536 ||
+        count * 16 > device.limits.maxStorageBufferBindingSize ||
+        count * 16 > device.limits.maxBufferSize)
+        throw Error("TC_COMPUTE_COUNT: Count must fit the validated output budget.");
+    if (!Number.isSafeInteger(workgroupSize) ||
+        workgroupSize < 1 ||
+        workgroupSize > 256 ||
+        workgroupSize > device.limits.maxComputeWorkgroupSizeX ||
+        workgroupSize > device.limits.maxComputeInvocationsPerWorkgroup ||
+        Math.ceil(count / workgroupSize) >
+            device.limits.maxComputeWorkgroupsPerDimension)
+        throw Error("TC_COMPUTE_WORKGROUP: Dispatch exceeds actual device limits.");
+    const graph = typedGraph(input);
+    if (graph.nodes.some((node) => node.op === "sampleTexture"))
+        throw Error("TC_COMPUTE_TEXTURE: Compute texture bindings are not supported yet.");
+    if (graph.nodes.some(node => node.op === "readBuffer"))
+        throw Error("TC_COMPUTE_BINDING: Buffered kernels require the managed compute service and explicit buffer bindings.");
+    const context = {
+        time,
+        parameters,
+        inputs: { index: 0 },
+    };
+    const expected = evaluateTypedGraph(graph, context);
+    const declarations = graph.parameters ?? [];
+    const uniforms = new Float32Array((declarations.length + 1) * 4);
+    uniforms[0] = time;
+    for (let i = 0; i < declarations.length; i++) {
+        const p = declarations[i], value = Object.hasOwn(parameters, p.name)
+            ? parameters[p.name]
+            : p.default;
+        if (typeof value === "number" || typeof value === "boolean")
+            uniforms[(i + 1) * 4] = Number(value);
+        else
+            uniforms.set(value, (i + 1) * 4);
+    }
+    const lowered = lowerGraphWGSL(graph, {
+        prefix: "tcCompute",
+        input: (name) => {
+            if (name === "time")
+                return "params[0].x";
+            if (name === "index")
+                return "f32(id.x)";
+            throw Error("TC_GRAPH_CONTEXT: Unsupported compute input " + name);
+        },
+        parameter: (name, type) => {
+            const index = declarations.findIndex((p) => p.name === name) + 1;
+            if (index === 0)
+                throw Error("TC_GRAPH_PARAMETER: " + name);
+            const base = "params[" + index + "]";
+            return type === "float"
+                ? base + ".x"
+                : type === "bool"
+                    ? "(" + base + ".x != 0.0)"
+                    : base + "." + "xyzw".slice(0, Number(type.slice(3)));
+        },
+        sampleTexture: () => {
+            throw Error("TC_COMPUTE_TEXTURE: A compute texture binding must be supplied by the engine resource API.");
+        },
+    });
+    const value = lowered.type === "float"
+        ? "vec4f(" + lowered.result + ",0,0,1)"
+        : lowered.type === "bool"
+            ? "vec4f(select(0.0,1.0," + lowered.result + "),0,0,1)"
+            : lowered.type === "vec2"
+                ? "vec4f(" + lowered.result + ",0,1)"
+                : lowered.type === "vec3"
+                    ? "vec4f(" + lowered.result + ",1)"
+                    : lowered.result;
+    const source = "@group(0) @binding(0) var<storage,read_write> result:array<vec4f>; @group(0) @binding(1) var<uniform> params:array<vec4f," +
+        (declarations.length + 1) +
+        ">;\n" +
+        lowered.helpers +
+        "\n@compute @workgroup_size(" +
+        workgroupSize +
+        ") fn main(@builtin(global_invocation_id) id:vec3u){if(id.x>=" +
+        count +
+        "u){return;}\n" +
+        lowered.code +
+        "\nresult[id.x]=" +
+        value +
+        ";}";
+    const buffers = [];
+    try {
+        const values = await withGraphGPUDeadline(device, "TC_COMPUTE", async (active) => {
+            active();
+            const module = device.createShaderModule({
+                code: source,
+                label: "pelican controlled compute graph",
+            });
+            const info = await module.getCompilationInfo();
+            active();
+            const errors = info.messages.filter((m) => m.type === "error");
+            if (errors.length)
+                throw Error("TC_COMPUTE_SHADER: " + errors.map((e) => e.message).join("; "));
+            const pipeline = await device.createComputePipelineAsync({
+                layout: "auto",
+                compute: { module, entryPoint: "main" },
+            });
+            active();
+            const make = (size, usage) => {
+                const b = device.createBuffer({ size, usage });
+                buffers.push(b);
+                return b;
+            };
+            const output = make(count * 16, GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC), uniform = make(uniforms.byteLength, GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST), read = make(count * 16, GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ);
+            device.queue.writeBuffer(uniform, 0, uniforms);
+            const group = device.createBindGroup({
+                layout: pipeline.getBindGroupLayout(0),
+                entries: [
+                    { binding: 0, resource: { buffer: output } },
+                    { binding: 1, resource: { buffer: uniform } },
+                ],
+            });
+            const encoder = device.createCommandEncoder(), pass = encoder.beginComputePass();
+            pass.setPipeline(pipeline);
+            pass.setBindGroup(0, group);
+            pass.dispatchWorkgroups(Math.ceil(count / workgroupSize));
+            pass.end();
+            encoder.copyBufferToBuffer(output, 0, read, 0, count * 16);
+            device.queue.submit([encoder.finish()]);
+            await read.mapAsync(GPUMapMode.READ);
+            active();
+            const values = Array.from(new Float32Array(read.getMappedRange().slice(0)));
+            read.unmap();
+            if (values.some((value) => !Number.isFinite(value)))
+                throw Error("TC_COMPUTE_NONFINITE: Graph arithmetic produced a nonfinite result; reduce parameter magnitude.");
+            return values;
+        });
+        return { count, outputType: graph.outputType, values, expected };
+    }
+    finally {
+        for (const buffer of buffers)
+            buffer.destroy();
+    }
+}

package/lib/renderer/managed-texture-sampling.js

@@ -0,0 +1,29 @@
+/** CPU vertex-geometry oracle only; GPU presentation never uploads this result. */
+export function sampleManagedTexture(descriptor, uv, sampler) {
+    const shape = descriptor.texture;
+    if (!shape || descriptor.type !== "vec4" || !Number.isSafeInteger(shape.width) || !Number.isSafeInteger(shape.height) || shape.width < 1 || shape.height < 1 || shape.width * shape.height !== descriptor.values.length)
+        throw new Error("TC_RENDER_TEXTURE_RESOURCE: Expected a live linear rgba32float descriptor with matching dimensions.");
+    const f = Math.fround, u = f(uv[0]), v = f(uv[1]);
+    if (!Number.isFinite(u) || !Number.isFinite(v))
+        return [0, 0, 0, 0];
+    const normalize = (value, wrap = "clamp") => wrap === "repeat" ? f(value - Math.floor(value)) : wrap === "mirror" ? f(1 - Math.abs(f(value - f(2 * Math.floor(f(value * 0.5)))) - 1)) : Math.max(0, Math.min(1, value));
+    const address = (index, size, wrap = "clamp") => {
+        if (wrap === "clamp")
+            return Math.max(0, Math.min(size - 1, index));
+        const period = wrap === "mirror" ? size * 2 : size, cell = ((index % period) + period) % period;
+        return wrap === "mirror" ? Math.min(cell, size * 2 - 1 - cell) : cell;
+    };
+    const read = (x, y) => {
+        const value = descriptor.values[address(y, shape.height, sampler.wrapV) * shape.width + address(x, shape.width, sampler.wrapU)];
+        if (!Array.isArray(value) || value.length !== 4 || value.some(v => !Number.isFinite(f(v))))
+            throw new Error("TC_RENDER_TEXTURE_RESOURCE: Invalid sampled Vec4 texel.");
+        return value;
+    };
+    const x = f(normalize(u, sampler.wrapU) * shape.width), y = f(normalize(v, sampler.wrapV) * shape.height);
+    if (sampler.filter === "nearest")
+        return read(Math.floor(x), Math.floor(y)).map(f);
+    const px = f(x - 0.5), py = f(y - 0.5), bx = Math.floor(px), by = Math.floor(py), wx = f(px - bx), wy = f(py - by);
+    const a = read(bx, by), b = read(bx + 1, by), c = read(bx, by + 1), d = read(bx + 1, by + 1);
+    const mix = (left, right, weight) => f(f(f(left) * f(1 - weight)) + f(f(right) * weight));
+    return [0, 1, 2, 3].map(i => mix(mix(a[i], b[i], wx), mix(c[i], d[i], wx), wy));
+}

package/lib/renderer/material-graphs.js

@@ -0,0 +1,297 @@
+import { lowerGraphWGSL } from "./graph-expressions.js";
+export const DEFAULT_SURFACE_GRAPHS = /* wgsl */ String.raw `
+fn surfaceGraphOpacity(index:u32,bary:vec3f,front:bool)->vec2f{return vec2f(0);}
+fn surfaceGraphApply(index:u32,bary:vec3f,front:bool,view:vec3f,value:SurfaceValue)->SurfaceValue{return value;}
+`;
+/** Manual filtering over the eight vec4 fields in each existing material row. */
+function textureHelpers(helper, row, width, height, sampler) {
+    const wrap = (axis, mode = "clamp") => mode === "repeat"
+        ? `(${axis}-floor(${axis}))`
+        : mode === "mirror"
+            ? `(1.0-abs((${axis}-2.0*floor(${axis}*0.5))-1.0))`
+            : `clamp(${axis},0.0,1.0)`;
+    const address = (axis, size, mode = "clamp") => {
+        if (mode === "clamp")
+            return `let ${axis}=clamp(cell.${axis},0,${size - 1});`;
+        const period = mode === "mirror" ? size * 2 : size;
+        return `let ${axis}Wrapped=((cell.${axis}%${period})+${period})%${period};let ${axis}=${mode === "mirror" ? `min(${axis}Wrapped,${period - 1}-${axis}Wrapped)` : axis + "Wrapped"};`;
+    };
+    return /* wgsl */ `
+fn ${helper}Load(cell:vec2i)->vec4f{
+ ${address("x", width, sampler.wrapU)}${address("y", height, sampler.wrapV)}
+ let element=u32(y)*${width}u+u32(x);
+ let row=surfaceMaterials[${row}u+element/8u];
+ switch(element%8u){
+ case 0u:{return row.base;}case 1u:{return row.factors;}
+ case 2u:{return row.emission;}case 3u:{return row.maps0;}
+ case 4u:{return row.maps1;}case 5u:{return row.normal;}
+ case 6u:{return row.physical;}default:{return row.attenuation;}
+ }
+}
+fn ${helper}(uv:vec2f)->vec4f{
+ if(any((bitcast<vec2u>(uv)&vec2u(0x7f800000u))==vec2u(0x7f800000u))){return vec4f(0);}
+ let coord=vec2f(${wrap("uv.x", sampler.wrapU)},${wrap("uv.y", sampler.wrapV)})*vec2f(${width}.0,${height}.0);
+ ${sampler.filter === "nearest"
+        ? `return ${helper}Load(vec2i(floor(coord)));`
+        : `let pixel=coord-vec2f(0.5);let base=vec2i(floor(pixel));let weight=fract(pixel);
+ let a=${helper}Load(base);let b=${helper}Load(base+vec2i(1,0));
+ let c=${helper}Load(base+vec2i(0,1));let d=${helper}Load(base+vec2i(1,1));
+ let top=a*(1.0-weight.x)+b*weight.x;let bottom=c*(1.0-weight.x)+d*weight.x;
+ return top*(1.0-weight.y)+bottom*weight.y;`}
+}`;
+}
+/** Private compiled switches share texture/material bindings with the surface evaluator. */
+export function compileSurfaceGraphs(snapshot, bindings, maxMaterialBytes = Number.MAX_SAFE_INTEGER) {
+    const byUuid = new Map([...bindings].map(([material, binding]) => [material.uuid, binding]));
+    const rows = [], helpers = [], full = [], opacity = [];
+    const bufferCopies = [];
+    let bufferFloats = 0;
+    const put = (value) => {
+        const row = snapshot.materials.length + rows.length / 32, values = Array(32).fill(0);
+        if (typeof value === "number" || typeof value === "boolean")
+            values[0] = Number(value);
+        else
+            values.splice(0, value.length, ...value);
+        if (values.some((v) => !Number.isFinite(Math.fround(v))))
+            throw Error("TC_GRAPH_VALUE: Material parameters/time must fit finite f32.");
+        rows.push(...values);
+        return row;
+    };
+    // Allocate every parameter first so GPU ranges never overlap later materials' parameters.
+    const contexts = new Map();
+    for (const [index, material] of snapshot.materials.entries()) {
+        const binding = byUuid.get(material.uuid);
+        if (!binding || !Object.keys(binding.graphs).length)
+            continue;
+        const timed = Object.values(binding.graphs).some((graph) => graph.nodes.some((node) => node.op === "time"));
+        const time = put(timed ? binding.time : 0), parameterRows = new Map();
+        for (const graph of Object.values(binding.graphs))
+            for (const p of graph.parameters ?? [])
+                if (!parameterRows.has(p.name))
+                    parameterRows.set(p.name, put(Object.hasOwn(binding.parameters, p.name)
+                        ? binding.parameters[p.name]
+                        : p.default));
+        contexts.set(index, { time, parameterRows });
+    }
+    for (const [index, material] of snapshot.materials.entries()) {
+        const binding = byUuid.get(material.uuid), allocated = contexts.get(index);
+        if (!binding || !allocated)
+            continue;
+        const { time, parameterRows } = allocated;
+        const slots = new Map();
+        const textureSlots = new Map();
+        const textureSamplers = new Map();
+        const context = /* wgsl */ `let triangle=surfaceTriangle(index);let uv=triangle.ua*bary.x+triangle.ub*bary.y+triangle.uc*bary.z;let positionWorld=triangle.a.xyz*bary.x+triangle.b.xyz*bary.y+triangle.c.xyz*bary.z;let normalWorld=normalize(triangle.na.xyz*bary.x+triangle.nb.xyz*bary.y+triangle.nc.xyz*bary.z);let vertexColor=triangle.ca*bary.x+triangle.cb*bary.y+triangle.cc*bary.z;`;
+        const lower = (graph, channel) => lowerGraphWGSL(graph, {
+            prefix: "tcMaterial" + index + "_" + channel,
+            input: (name) => {
+                if (name === "time")
+                    return "surfaceMaterials[" + time + "u].base.x";
+                if (name === "uv")
+                    return "uv.xy";
+                if (name === "uv1")
+                    return "uv.zw";
+                if (name === "viewDirectionWorld")
+                    return "view";
+                if (["positionWorld", "normalWorld", "vertexColor"].includes(name))
+                    return name;
+                throw Error("TC_GRAPH_CONTEXT: material " + binding.id + " input " + name);
+            },
+            parameter: (name, type) => {
+                const row = parameterRows.get(name);
+                if (row === undefined)
+                    throw Error("TC_GRAPH_PARAMETER: " + binding.id + ":" + name);
+                const base = "surfaceMaterials[" + row + "u].base";
+                return type === "float"
+                    ? base + ".x"
+                    : type === "bool"
+                        ? "(" + base + ".x != 0.0)"
+                        : base + "." + "xyzw".slice(0, Number(type.slice(3)));
+            },
+            readBuffer: (name, element, type) => {
+                let slot = slots.get(name);
+                if (slot && slot.type !== type)
+                    throw Error("TC_RENDER_BUFFER_TYPE: " + binding.id + ":" + name);
+                if (!slot) {
+                    const descriptor = binding.buffers && Object.hasOwn(binding.buffers, name)
+                        ? binding.buffers[name]
+                        : undefined;
+                    if (!descriptor)
+                        throw Error("TC_RENDER_BUFFER_UNBOUND: " + binding.id + ":" + name);
+                    if (descriptor.type !== type)
+                        throw Error("TC_RENDER_BUFFER_TYPE: " + binding.id + ":" + name);
+                    const count = descriptor.values.length;
+                    if (!Number.isSafeInteger(count) || count < 1 || count > 0xffffffff)
+                        throw Error("TC_RENDER_BUFFER_COUNT: " + binding.id + ":" + name);
+                    const row = snapshot.materials.length + (rows.length + bufferFloats) / 32;
+                    const reserved = Math.ceil(count / 8) * 32;
+                    if ((row * 32 + reserved) * 4 > maxMaterialBytes)
+                        throw Error("TC_RENDER_BUFFER_LIMIT: Material table exceeds the device buffer limits.");
+                    bufferFloats += reserved;
+                    const helper = "tcMaterialBuffer" + index + "_" + slots.size;
+                    slot = { helper, type };
+                    slots.set(name, slot);
+                    bufferCopies.push({
+                        descriptor,
+                        byteOffset: row * 128,
+                        count,
+                        type,
+                        material: binding.id,
+                        name,
+                    });
+                    const resultType = type === "float" ? "f32" : type === "bool" ? "bool" : type + "f";
+                    const zero = type === "bool" ? "false" : resultType + "(0)";
+                    const value = type === "bool"
+                        ? "(value.x != 0.0)"
+                        : type === "float"
+                            ? "value.x"
+                            : "value." + "xyzw".slice(0, Number(type.slice(3)));
+                    helpers.push(/* wgsl */ `
+fn ${helper}(index:f32)->${resultType}{
+ if ((bitcast<u32>(index)&0x7f800000u)==0x7f800000u){return ${zero};}
+ if (!(index>=0.0 && index<4294967296.0 && floor(index)==index)){return ${zero};}
+ let element=u32(index);if(element>=${count}u){return ${zero};}
+ let row=surfaceMaterials[${row}u+element/8u];var value=vec4f(0);
+ switch (element%8u){
+ case 0u:{value=row.base;}case 1u:{value=row.factors;}
+ case 2u:{value=row.emission;}case 3u:{value=row.maps0;}
+ case 4u:{value=row.maps1;}case 5u:{value=row.normal;}
+ case 6u:{value=row.physical;}default:{value=row.attenuation;}
+ }
+ return ${value};
+}`);
+                }
+                return slot.helper + "(" + element + ")";
+            },
+            sampleTexture: (asset, uv) => {
+                const sampler = graph.textureSlots && Object.hasOwn(graph.textureSlots, asset)
+                    ? graph.textureSlots[asset]
+                    : undefined;
+                if (sampler) {
+                    let slot = textureSlots.get(asset);
+                    if (!slot) {
+                        const descriptor = binding.managedTextures &&
+                            Object.hasOwn(binding.managedTextures, asset)
+                            ? binding.managedTextures[asset]
+                            : undefined;
+                        if (!descriptor)
+                            throw Error("TC_RENDER_TEXTURE_UNBOUND: " + binding.id + ":" + asset);
+                        const shape = descriptor.texture, count = descriptor.values.length;
+                        if (descriptor.type !== "vec4" ||
+                            !shape ||
+                            !Number.isSafeInteger(shape.width) ||
+                            !Number.isSafeInteger(shape.height) ||
+                            shape.width < 1 ||
+                            shape.height < 1 ||
+                            !Number.isSafeInteger(count) ||
+                            count < 1 ||
+                            count > 0xffffffff ||
+                            shape.width * shape.height !== count)
+                            throw Error("TC_RENDER_TEXTURE_RESOURCE: " + binding.id + ":" + asset);
+                        const row = snapshot.materials.length + (rows.length + bufferFloats) / 32;
+                        const reserved = Math.ceil(count / 8) * 32;
+                        if ((row * 32 + reserved) * 4 > maxMaterialBytes)
+                            throw Error("TC_RENDER_TEXTURE_LIMIT: Material table exceeds the device buffer limits.");
+                        bufferFloats += reserved;
+                        slot = { row, width: shape.width, height: shape.height };
+                        textureSlots.set(asset, slot);
+                        bufferCopies.push({
+                            descriptor,
+                            byteOffset: row * 128,
+                            count,
+                            type: "vec4",
+                            material: binding.id,
+                            name: asset,
+                            texture: { width: shape.width, height: shape.height },
+                        });
+                    }
+                    const signature = JSON.stringify([
+                        asset,
+                        sampler.filter ?? "linear",
+                        sampler.wrapU ?? "clamp",
+                        sampler.wrapV ?? "clamp",
+                    ]);
+                    let helper = textureSamplers.get(signature);
+                    if (!helper) {
+                        helper = "tcMaterialTexture" + index + "_" + textureSamplers.size;
+                        textureSamplers.set(signature, helper);
+                        helpers.push(textureHelpers(helper, slot.row, slot.width, slot.height, sampler));
+                    }
+                    return helper + "(" + uv + ")";
+                }
+                const source = binding.textures.get(asset);
+                const id = snapshot.textures.findIndex((texture) => texture.uuid === source?.uuid);
+                if (id < 0)
+                    throw Error("TC_GRAPH_TEXTURE: " + binding.id + ":" + asset);
+                return "surfaceMap(" + id + ".0,vec4f(" + uv + "," + uv + "))";
+            },
+        });
+        const statements = [];
+        for (const [channel, graph] of Object.entries(binding.graphs)) {
+            const g = lower(graph, channel);
+            helpers.push(g.helpers);
+            statements.push(g.code);
+            const value = g.result;
+            if (channel === "baseColor")
+                statements.push("result.base=" +
+                    value +
+                    "*vec3f(triangle.b.w,triangle.c.w,triangle.na.w);if(triangle.nb.w>0.5){result.base*=vertexColor.rgb;}");
+            else if (channel === "emissive")
+                statements.push("result.emissive=" + value + ";");
+            else if (channel === "normalWorld")
+                statements.push("result.normal=surfaceGraphNormal(" +
+                    value +
+                    ",normalWorld)*surfaceNormalSign(surfaceMaterials[u32(triangle.a.w)],front);");
+            else if (channel === "opacity")
+                statements.push("result.alpha*=clamp(" + value + ",0.0,1.0);");
+            else
+                statements.push("result." +
+                    (channel === "opacity" ? "alpha" : channel) +
+                    "=clamp(" +
+                    value +
+                    ",0.0,1.0);");
+            if (channel === "opacity") {
+                const alpha = lower(graph, "coverage");
+                helpers.push(alpha.helpers);
+                opacity.push("case " +
+                    index +
+                    "u:{" +
+                    context +
+                    "let view=vec3f(0);" +
+                    alpha.code +
+                    "return vec2f(clamp(" +
+                    alpha.result +
+                    ",0.0,1.0),1);}");
+            }
+        }
+        full.push("case " + index + "u:{" + context + statements.join("\n") + "}");
+    }
+    const source = full.length
+        ? helpers.join("\n") +
+            /* wgsl */ `
+fn surfaceGraphOpacity(index:u32,bary:vec3f,front:bool)->vec2f{
+ switch u32(surfaceTriangle(index).a.w){${opacity.join("\n")}default:{}}return vec2f(0);
+}
+fn surfaceGraphApply(index:u32,bary:vec3f,front:bool,view:vec3f,value:SurfaceValue)->SurfaceValue{
+ var result=value;switch u32(surfaceTriangle(index).a.w){${full.join("\n")}default:{}}return result;
+}
+`
+        : DEFAULT_SURFACE_GRAPHS;
+    const tableRows = new Float32Array(rows.length + bufferFloats);
+    tableRows.set(rows);
+    return { source, rows: tableRows, materials: full.length, bufferCopies };
+}
+/** Proposal only: every graph emitter needs support, even with a black standard emissive. */
+export function graphEmissiveProposal(snapshot, bindings) {
+    const emitters = new Set([...bindings]
+        .filter(([, binding]) => binding.graphs.emissive)
+        .map(([material]) => material.uuid));
+    if (!emitters.size)
+        return snapshot;
+    return {
+        ...snapshot,
+        materials: snapshot.materials.map((material) => emitters.has(material.uuid)
+            ? { ...material, emissive: [1, 1, 1], emissiveIntensity: 1 }
+            : material),
+    };
+}