Ampandheaust
e7546e4b78
Amp-Thread-ID: https://ampcode.com/threads/T-01a033d4-0e44-708e-af0e-6166283416ff Co-authored-by: Heaust Azure <heaust.azure@gmail.com>
689 lines
22 KiB
TypeScript
689 lines
22 KiB
TypeScript
import type {
|
||
GraphLayoutNodeV1,
|
||
GraphLayoutV2,
|
||
GraphLink,
|
||
GraphSnapshot,
|
||
JsonValue,
|
||
ParameterValue,
|
||
} from "fxnode";
|
||
import { renderGraphComposition } from "./catalog";
|
||
|
||
type PlainObject = Record<string, any>;
|
||
type GraphSource = GraphLayoutV2 | GraphSnapshot;
|
||
|
||
export const physicalRenderGraphSchema = "yawn.render-graph/v1";
|
||
|
||
const physicalTypes = {
|
||
frameIn: "yawn.rg.physical.frame-in",
|
||
frameOut: "yawn.rg.physical.frame-out",
|
||
buffer: "yawn.rg.physical.buffer",
|
||
texture: "yawn.rg.physical.texture",
|
||
sampler: "yawn.rg.physical.sampler",
|
||
external: "yawn.rg.physical.external",
|
||
renderPipeline: "yawn.rg.physical.render-pipeline",
|
||
computePipeline: "yawn.rg.physical.compute-pipeline",
|
||
renderPass: "yawn.rg.physical.render-pass",
|
||
computePass: "yawn.rg.physical.compute-pass",
|
||
} as const;
|
||
|
||
function plainRecord(value: unknown): value is PlainObject {
|
||
if (!value || typeof value !== "object" || Array.isArray(value)) return false;
|
||
const prototype = Object.getPrototypeOf(value);
|
||
return prototype === Object.prototype || prototype === null;
|
||
}
|
||
|
||
function parameterString(node: any, key: string): string {
|
||
const parameter = node.parameters?.[key] as ParameterValue | undefined;
|
||
if (parameter?.kind !== "string")
|
||
throw new Error(
|
||
`${String(node.label || node.id)} has no ${key} declaration`,
|
||
);
|
||
return parameter.value;
|
||
}
|
||
|
||
function declaration(node: any): PlainObject {
|
||
let parsed: unknown;
|
||
try {
|
||
parsed = JSON.parse(parameterString(node, "declaration"));
|
||
} catch (error) {
|
||
throw new Error(
|
||
`${String(node.label || node.id)} has an invalid physical declaration`,
|
||
{ cause: error },
|
||
);
|
||
}
|
||
if (!plainRecord(parsed))
|
||
throw new Error(
|
||
`${String(node.label || node.id)} declaration must be an object`,
|
||
);
|
||
return parsed;
|
||
}
|
||
|
||
function cloned<T>(value: T): T {
|
||
return structuredClone(value);
|
||
}
|
||
|
||
function withoutResource(value: PlainObject): PlainObject {
|
||
const result = cloned(value);
|
||
delete result.resource;
|
||
return result;
|
||
}
|
||
|
||
function summarizeSize(value: unknown): string {
|
||
return Array.isArray(value) ? value.join(" × ") : "automatic size";
|
||
}
|
||
|
||
function drawSummary(pass: PlainObject): string {
|
||
if (pass.type === "compute") {
|
||
const dispatch = Array.isArray(pass.dispatch)
|
||
? pass.dispatch.join(" × ")
|
||
: "1 × 1 × 1";
|
||
return `${dispatch} workgroups · ${(pass.bindings ?? []).length} bindings`;
|
||
}
|
||
const draw = plainRecord(pass.draw) ? pass.draw : {};
|
||
const count = Number(draw.indices || draw.vertices || 3);
|
||
const primitive = draw.indices ? "indices" : "vertices";
|
||
const instances = Number(draw.instances ?? 1);
|
||
return `${count} ${primitive} × ${instances} · ${(pass.bindings ?? []).length} bindings · ${(pass.color ?? []).length} color`;
|
||
}
|
||
|
||
function layoutNode(
|
||
id: string,
|
||
typeId: keyof typeof renderGraphComposition.nodes,
|
||
label: string,
|
||
details: string,
|
||
value: PlainObject,
|
||
position: { readonly x: number; readonly y: number },
|
||
code?: string,
|
||
): GraphLayoutNodeV1 {
|
||
const definition = renderGraphComposition.nodes[typeId];
|
||
const parameters = Object.fromEntries(
|
||
Object.entries(definition.parameters).map(([key, schema]) => [
|
||
key,
|
||
cloned(schema.default),
|
||
]),
|
||
) as Record<string, ParameterValue>;
|
||
parameters.details = { kind: "string", value: details };
|
||
parameters.declaration = { kind: "string", value: JSON.stringify(value) };
|
||
if (code !== undefined) parameters.code = { kind: "string", value: code };
|
||
const sockets = Object.entries(definition.sockets).map(([key, socket]) => ({
|
||
id: `${id}:${key}` as GraphLayoutNodeV1["sockets"][number]["id"],
|
||
key,
|
||
label: socket.title,
|
||
direction: socket.direction,
|
||
dataType: socket.type,
|
||
accepts:
|
||
socket.direction === "input"
|
||
? cloned(
|
||
renderGraphComposition.socketTypes[
|
||
socket.type as keyof typeof renderGraphComposition.socketTypes
|
||
].acceptsFrom,
|
||
)
|
||
: [],
|
||
maxIncomingLinks: socket.maxIncomingLinks,
|
||
...(socket.value ? { defaultValue: cloned(socket.value.default) } : {}),
|
||
visible: socket.visible,
|
||
}));
|
||
return {
|
||
id: id as GraphLayoutNodeV1["id"],
|
||
typeId,
|
||
typeVersion: definition.version,
|
||
position,
|
||
size: {
|
||
x: typeId.includes("pass") ? 228 : 210,
|
||
y: Math.max(98, 47 + definition.ui.length * 24),
|
||
},
|
||
label,
|
||
parameters,
|
||
sockets,
|
||
muted: false,
|
||
collapsed: false,
|
||
extensions: { physical: true },
|
||
};
|
||
}
|
||
|
||
function layoutLink(
|
||
index: number,
|
||
from: GraphLayoutNodeV1,
|
||
fromSocket: string,
|
||
to: GraphLayoutNodeV1,
|
||
toSocket: string,
|
||
relation: string,
|
||
relationIndex = 0,
|
||
descriptor: PlainObject = {},
|
||
): GraphLink {
|
||
return {
|
||
id: `physical-link-${index}` as GraphLink["id"],
|
||
fromNodeId: from.id,
|
||
fromSocketId: `${from.id}:${fromSocket}` as GraphLink["fromSocketId"],
|
||
toNodeId: to.id,
|
||
toSocketId: `${to.id}:${toSocket}` as GraphLink["toSocketId"],
|
||
muted: false,
|
||
extensions: {
|
||
relation,
|
||
index: relationIndex,
|
||
descriptor: descriptor as JsonValue,
|
||
},
|
||
};
|
||
}
|
||
|
||
function resetPassRelations(pass: PlainObject): PlainObject {
|
||
const result = cloned(pass);
|
||
result.pipeline = "";
|
||
if (Object.hasOwn(result, "after")) result.after = [];
|
||
if (Object.hasOwn(result, "bindings")) result.bindings = [];
|
||
if (Object.hasOwn(result, "color")) result.color = [];
|
||
if (Object.hasOwn(result, "depth")) result.depth = null;
|
||
if (Object.hasOwn(result, "vertexBuffers")) result.vertexBuffers = [];
|
||
if (Object.hasOwn(result, "indexBuffer")) result.indexBuffer = null;
|
||
return result;
|
||
}
|
||
|
||
/** Expands a concrete Yawn graph into editable physical FxNode declarations. */
|
||
export function materializeRenderGraph(
|
||
graphValue: object,
|
||
preset = "custom",
|
||
): GraphLayoutV2 {
|
||
if (!plainRecord(graphValue))
|
||
throw new TypeError("Render graph must be plain data");
|
||
const graph = cloned(graphValue);
|
||
const buffers = Array.isArray(graph.resources?.buffers)
|
||
? graph.resources.buffers
|
||
: [];
|
||
const textures = Array.isArray(graph.resources?.textures)
|
||
? graph.resources.textures
|
||
: [];
|
||
const samplers = Array.isArray(graph.resources?.samplers)
|
||
? graph.resources.samplers
|
||
: [];
|
||
const renderPipelines = Array.isArray(graph.pipelines?.render)
|
||
? graph.pipelines.render
|
||
: [];
|
||
const computePipelines = Array.isArray(graph.pipelines?.compute)
|
||
? graph.pipelines.compute
|
||
: [];
|
||
const passes = Array.isArray(graph.passes) ? graph.passes : [];
|
||
const nodes: GraphLayoutNodeV1[] = [];
|
||
const links: GraphLink[] = [];
|
||
const resources = new Map<string, GraphLayoutNodeV1>();
|
||
const pipelines = new Map<string, GraphLayoutNodeV1>();
|
||
const passNodes = new Map<string, GraphLayoutNodeV1>();
|
||
const passLevels = new Map<string, number>();
|
||
const levelOf = (pass: PlainObject, visiting = new Set<string>()): number => {
|
||
const id = String(pass.id);
|
||
const known = passLevels.get(id);
|
||
if (known !== undefined) return known;
|
||
if (visiting.has(id)) return 0;
|
||
visiting.add(id);
|
||
const dependencies = (pass.after ?? [])
|
||
.map((dependency: string) =>
|
||
passes.find((candidate: PlainObject) => candidate.id === dependency),
|
||
)
|
||
.filter(Boolean)
|
||
.map((dependency: PlainObject) => levelOf(dependency, visiting));
|
||
visiting.delete(id);
|
||
const level = dependencies.length ? Math.max(...dependencies) + 1 : 0;
|
||
passLevels.set(id, level);
|
||
return level;
|
||
};
|
||
passes.forEach((pass: PlainObject) => levelOf(pass));
|
||
const addUnique = (
|
||
map: Map<string, GraphLayoutNodeV1>,
|
||
id: unknown,
|
||
node: GraphLayoutNodeV1,
|
||
kind: string,
|
||
) => {
|
||
if (typeof id !== "string" || !id)
|
||
throw new Error(`${kind} requires an ID`);
|
||
if (map.has(id)) throw new Error(`Duplicate ${kind} ID ${id}`);
|
||
map.set(id, node);
|
||
nodes.push(node);
|
||
};
|
||
|
||
const resourceEntries = [
|
||
...buffers.map((value: PlainObject, index: number) => ({
|
||
kind: "buffer",
|
||
value,
|
||
index,
|
||
})),
|
||
...textures.map((value: PlainObject, index: number) => ({
|
||
kind: "texture",
|
||
value,
|
||
index,
|
||
})),
|
||
...samplers.map((value: PlainObject, index: number) => ({
|
||
kind: "sampler",
|
||
value,
|
||
index,
|
||
})),
|
||
];
|
||
const resourceLevels = new Map<number, number>();
|
||
const resourceLevel = (id: string): number => {
|
||
const levels = passes
|
||
.filter((pass: PlainObject) =>
|
||
[
|
||
...(pass.bindings ?? []),
|
||
...(pass.color ?? []),
|
||
...(pass.vertexBuffers ?? []),
|
||
...(pass.depth ? [pass.depth] : []),
|
||
...(pass.indexBuffer ? [pass.indexBuffer] : []),
|
||
].some((item: PlainObject) => item?.resource === id),
|
||
)
|
||
.map((pass: PlainObject) => levelOf(pass));
|
||
return levels.length ? Math.min(...levels) : 0;
|
||
};
|
||
const resourcePosition = (id: string) => {
|
||
const level = resourceLevel(id);
|
||
const row = resourceLevels.get(level) ?? 0;
|
||
resourceLevels.set(level, row + 1);
|
||
return { x: 40 + level * 280, y: -420 - row * 142 };
|
||
};
|
||
for (const entry of resourceEntries) {
|
||
const typeId =
|
||
physicalTypes[entry.kind as "buffer" | "texture" | "sampler"];
|
||
const details =
|
||
entry.kind === "buffer"
|
||
? `${String(entry.value.array || "rows")} · ${(entry.value.usage ?? []).join(" + ") || "copy"}${entry.value.sync ? ` · ${entry.value.sync} sync` : ""}`
|
||
: entry.kind === "texture"
|
||
? `${String(entry.value.format || "format")} · ${summarizeSize(entry.value.size)} · ${(entry.value.usage ?? []).join(" + ") || "texture"}`
|
||
: `${Object.keys(entry.value.descriptor ?? {}).join(" · ") || "default filtering"}`;
|
||
const node = layoutNode(
|
||
`physical-${entry.kind}-${entry.index}`,
|
||
typeId,
|
||
`${entry.kind[0]!.toUpperCase()}${entry.kind.slice(1)} · ${String(entry.value.id)}`,
|
||
details,
|
||
entry.value,
|
||
resourcePosition(entry.value.id),
|
||
);
|
||
addUnique(resources, entry.value.id, node, "resource");
|
||
}
|
||
|
||
const referencedResources = new Set<string>();
|
||
for (const pass of passes) {
|
||
for (const item of [
|
||
...(pass.bindings ?? []),
|
||
...(pass.color ?? []),
|
||
...(pass.vertexBuffers ?? []),
|
||
...(pass.depth ? [pass.depth] : []),
|
||
...(pass.indexBuffer ? [pass.indexBuffer] : []),
|
||
]) {
|
||
if (typeof item?.resource === "string")
|
||
referencedResources.add(item.resource);
|
||
}
|
||
}
|
||
let externalIndex = 0;
|
||
for (const id of referencedResources) {
|
||
if (resources.has(id)) continue;
|
||
const node = layoutNode(
|
||
`physical-external-${externalIndex}`,
|
||
physicalTypes.external,
|
||
id === "canvas" ? "Canvas surface" : `External · ${id}`,
|
||
id === "canvas"
|
||
? "Current WebGPU swap-chain texture"
|
||
: "Externally supplied resource",
|
||
{ id, external: true },
|
||
resourcePosition(id),
|
||
);
|
||
externalIndex++;
|
||
addUnique(resources, id, node, "resource");
|
||
}
|
||
|
||
const pipelineEntries = [
|
||
...renderPipelines.map((value: PlainObject, index: number) => ({
|
||
kind: "render",
|
||
value,
|
||
index,
|
||
})),
|
||
...computePipelines.map((value: PlainObject, index: number) => ({
|
||
kind: "compute",
|
||
value,
|
||
index,
|
||
})),
|
||
];
|
||
for (const [layoutIndex, entry] of pipelineEntries.entries()) {
|
||
const value = cloned(entry.value);
|
||
const code = typeof value.code === "string" ? value.code : "";
|
||
delete value.code;
|
||
const details =
|
||
entry.kind === "render"
|
||
? `${String(value.vertex?.entry || "vertex")} → ${String(value.fragment?.entry || "fragment")} · ${value.fragment?.targets?.length ?? 0} targets · ${code.split("\n").length} WGSL lines`
|
||
: `${String(value.entry || "main")} · ${code.split("\n").length} WGSL lines`;
|
||
const consumerLevels = passes
|
||
.filter((pass: PlainObject) => pass.pipeline === value.id)
|
||
.map((pass: PlainObject) => levelOf(pass));
|
||
const pipelineLevel = consumerLevels.length
|
||
? Math.min(...consumerLevels)
|
||
: layoutIndex;
|
||
const pipelineRow = pipelineEntries
|
||
.slice(0, layoutIndex)
|
||
.filter((candidate) =>
|
||
passes.some(
|
||
(pass: PlainObject) =>
|
||
pass.pipeline === candidate.value.id &&
|
||
levelOf(pass) === pipelineLevel,
|
||
),
|
||
).length;
|
||
const node = layoutNode(
|
||
`physical-${entry.kind}-pipeline-${entry.index}`,
|
||
entry.kind === "render"
|
||
? physicalTypes.renderPipeline
|
||
: physicalTypes.computePipeline,
|
||
`${entry.kind === "render" ? "Render" : "Compute"} pipeline · ${String(value.id)}`,
|
||
details,
|
||
value,
|
||
{
|
||
x: 280 + pipelineLevel * 280,
|
||
y: 590 + pipelineRow * 142,
|
||
},
|
||
code,
|
||
);
|
||
addUnique(pipelines, value.id, node, "pipeline");
|
||
}
|
||
|
||
const frameIn = layoutNode(
|
||
"physical-frame-in",
|
||
physicalTypes.frameIn,
|
||
"Frame In",
|
||
"Resources ready",
|
||
{ kind: "frame-in" },
|
||
{ x: 30, y: 280 },
|
||
);
|
||
nodes.push(frameIn);
|
||
|
||
const passRows = new Map<number, number>();
|
||
for (const [index, pass] of passes.entries()) {
|
||
const level = levelOf(pass);
|
||
const row = passRows.get(level) ?? 0;
|
||
passRows.set(level, row + 1);
|
||
const node = layoutNode(
|
||
`physical-pass-${index}`,
|
||
pass.type === "compute"
|
||
? physicalTypes.computePass
|
||
: physicalTypes.renderPass,
|
||
`${pass.type === "compute" ? "Compute" : "Render"} pass · ${String(pass.id)}`,
|
||
drawSummary(pass),
|
||
resetPassRelations(pass),
|
||
{ x: 280 + level * 280, y: 280 - row * 300 },
|
||
);
|
||
addUnique(passNodes, pass.id, node, "pass");
|
||
}
|
||
|
||
const terminalDependencies = new Set(
|
||
passes.flatMap((pass: PlainObject) =>
|
||
Array.isArray(pass.after) ? pass.after : [],
|
||
),
|
||
);
|
||
const maximumLevel = Math.max(0, ...passLevels.values());
|
||
const frameOut = layoutNode(
|
||
"physical-frame-out",
|
||
physicalTypes.frameOut,
|
||
"Frame Out",
|
||
"GPU work submitted",
|
||
{ kind: "frame-out" },
|
||
{ x: 280 + (maximumLevel + 1) * 280, y: 280 },
|
||
);
|
||
nodes.push(frameOut);
|
||
|
||
const connect = (
|
||
from: GraphLayoutNodeV1 | undefined,
|
||
fromSocket: string,
|
||
to: GraphLayoutNodeV1,
|
||
toSocket: string,
|
||
relation: string,
|
||
index = 0,
|
||
descriptor: PlainObject = {},
|
||
) => {
|
||
if (!from)
|
||
throw new Error(
|
||
`${to.label} references a missing ${relation} declaration`,
|
||
);
|
||
links.push(
|
||
layoutLink(
|
||
links.length,
|
||
from,
|
||
fromSocket,
|
||
to,
|
||
toSocket,
|
||
relation,
|
||
index,
|
||
descriptor,
|
||
),
|
||
);
|
||
};
|
||
for (const pass of passes) {
|
||
const target = passNodes.get(pass.id)!;
|
||
const after = Array.isArray(pass.after) ? pass.after : [];
|
||
if (after.length) {
|
||
after.forEach((id: string, index: number) =>
|
||
connect(passNodes.get(id), "pass", target, "after", "after", index),
|
||
);
|
||
} else {
|
||
connect(frameIn, "frame", target, "after", "frame", 0);
|
||
}
|
||
connect(
|
||
pipelines.get(pass.pipeline),
|
||
"pipeline",
|
||
target,
|
||
"pipeline",
|
||
"pipeline",
|
||
0,
|
||
);
|
||
(pass.bindings ?? []).forEach((item: PlainObject, index: number) =>
|
||
connect(
|
||
resources.get(item.resource),
|
||
"resource",
|
||
target,
|
||
"bindings",
|
||
"binding",
|
||
index,
|
||
withoutResource(item),
|
||
),
|
||
);
|
||
(pass.color ?? []).forEach((item: PlainObject, index: number) =>
|
||
connect(
|
||
resources.get(item.resource),
|
||
"resource",
|
||
target,
|
||
"color",
|
||
"color",
|
||
index,
|
||
withoutResource(item),
|
||
),
|
||
);
|
||
if (pass.depth)
|
||
connect(
|
||
resources.get(pass.depth.resource),
|
||
"resource",
|
||
target,
|
||
"depth",
|
||
"depth",
|
||
0,
|
||
withoutResource(pass.depth),
|
||
);
|
||
(pass.vertexBuffers ?? []).forEach((item: PlainObject, index: number) =>
|
||
connect(
|
||
resources.get(item.resource),
|
||
"resource",
|
||
target,
|
||
"vertex",
|
||
"vertex",
|
||
index,
|
||
withoutResource(item),
|
||
),
|
||
);
|
||
if (pass.indexBuffer)
|
||
connect(
|
||
resources.get(pass.indexBuffer.resource),
|
||
"resource",
|
||
target,
|
||
"index",
|
||
"index",
|
||
0,
|
||
withoutResource(pass.indexBuffer),
|
||
);
|
||
if (!terminalDependencies.has(pass.id))
|
||
connect(target, "pass", frameOut, "after", "frame-out", 0);
|
||
}
|
||
|
||
return {
|
||
schemaVersion: 2,
|
||
graphId: `yawn-physical-${preset}` as GraphLayoutV2["graphId"],
|
||
catalogVersion: renderGraphComposition.version,
|
||
nodes,
|
||
links,
|
||
metadata: {
|
||
schema: physicalRenderGraphSchema,
|
||
preset,
|
||
renderGraphId: String(graph.id || "scene"),
|
||
},
|
||
};
|
||
}
|
||
|
||
export function isPhysicalRenderGraph(layout: GraphSource): boolean {
|
||
return layout?.metadata?.schema === physicalRenderGraphSchema;
|
||
}
|
||
|
||
function relationDescriptor(link: GraphLink): PlainObject {
|
||
return plainRecord(link.extensions?.descriptor)
|
||
? cloned(link.extensions.descriptor)
|
||
: {};
|
||
}
|
||
|
||
/** Reconstructs a Yawn graph from physical nodes and their typed relationships. */
|
||
export function reconstructRenderGraph(layout: GraphSource): PlainObject {
|
||
if (!isPhysicalRenderGraph(layout))
|
||
throw new TypeError("FxNode layout is not a physical render graph");
|
||
const activeNodes = layout.nodes.filter((node: any) => !node.muted);
|
||
const byNodeId = new Map(
|
||
activeNodes.map((node: any) => [String(node.id), node]),
|
||
);
|
||
const frameIn = activeNodes.filter(
|
||
(node: any) => node.typeId === physicalTypes.frameIn,
|
||
);
|
||
const frameOut = activeNodes.filter(
|
||
(node: any) => node.typeId === physicalTypes.frameOut,
|
||
);
|
||
if (frameIn.length !== 1 || frameOut.length !== 1)
|
||
throw new Error(
|
||
"Physical loadout requires exactly one Frame In and Frame Out",
|
||
);
|
||
|
||
const resources = {
|
||
buffers: [] as PlainObject[],
|
||
textures: [] as PlainObject[],
|
||
samplers: [] as PlainObject[],
|
||
};
|
||
const pipelines = {
|
||
render: [] as PlainObject[],
|
||
compute: [] as PlainObject[],
|
||
};
|
||
const passes: PlainObject[] = [];
|
||
const passByNodeId = new Map<string, PlainObject>();
|
||
for (const node of activeNodes as any[]) {
|
||
if (node.typeId === physicalTypes.buffer)
|
||
resources.buffers.push(declaration(node));
|
||
else if (node.typeId === physicalTypes.texture)
|
||
resources.textures.push(declaration(node));
|
||
else if (node.typeId === physicalTypes.sampler)
|
||
resources.samplers.push(declaration(node));
|
||
else if (
|
||
node.typeId === physicalTypes.renderPipeline ||
|
||
node.typeId === physicalTypes.computePipeline
|
||
) {
|
||
const pipeline = declaration(node);
|
||
pipeline.code = parameterString(node, "code");
|
||
pipelines[
|
||
node.typeId === physicalTypes.renderPipeline ? "render" : "compute"
|
||
].push(pipeline);
|
||
} else if (
|
||
node.typeId === physicalTypes.renderPass ||
|
||
node.typeId === physicalTypes.computePass
|
||
) {
|
||
const pass = declaration(node);
|
||
if (Array.isArray(pass.after)) pass.after = [];
|
||
if (Array.isArray(pass.bindings)) pass.bindings = [];
|
||
if (Array.isArray(pass.color)) pass.color = [];
|
||
if (Array.isArray(pass.vertexBuffers)) pass.vertexBuffers = [];
|
||
if (Object.hasOwn(pass, "depth")) pass.depth = null;
|
||
if (Object.hasOwn(pass, "indexBuffer")) pass.indexBuffer = null;
|
||
pass.pipeline = "";
|
||
passes.push(pass);
|
||
passByNodeId.set(String(node.id), pass);
|
||
}
|
||
}
|
||
|
||
const sourceId = (node: any): string => {
|
||
const value = declaration(node).id;
|
||
if (typeof value !== "string" || !value)
|
||
throw new Error(`${String(node.label || node.id)} requires an ID`);
|
||
return value;
|
||
};
|
||
const incoming = layout.links
|
||
.filter(
|
||
(link) =>
|
||
!link.muted &&
|
||
byNodeId.has(String(link.fromNodeId)) &&
|
||
byNodeId.has(String(link.toNodeId)),
|
||
)
|
||
.sort(
|
||
(left, right) =>
|
||
Number(left.extensions?.index ?? 0) -
|
||
Number(right.extensions?.index ?? 0),
|
||
);
|
||
for (const link of incoming) {
|
||
const source = byNodeId.get(String(link.fromNodeId));
|
||
const target = byNodeId.get(String(link.toNodeId));
|
||
const pass = passByNodeId.get(String(link.toNodeId));
|
||
if (!source || !target || !pass) continue;
|
||
const socket = target.sockets.find(
|
||
(candidate: any) => String(candidate.id) === String(link.toSocketId),
|
||
)?.key;
|
||
if (socket === "after") {
|
||
if (
|
||
source.typeId === physicalTypes.renderPass ||
|
||
source.typeId === physicalTypes.computePass
|
||
) {
|
||
if (!Array.isArray(pass.after)) pass.after = [];
|
||
pass.after.push(sourceId(source));
|
||
}
|
||
} else if (socket === "pipeline") {
|
||
pass.pipeline = sourceId(source);
|
||
} else if (socket === "bindings") {
|
||
if (!Array.isArray(pass.bindings)) pass.bindings = [];
|
||
const descriptor = relationDescriptor(link);
|
||
if (!Object.hasOwn(descriptor, "group")) descriptor.group = 0;
|
||
if (!Object.hasOwn(descriptor, "binding"))
|
||
descriptor.binding = pass.bindings.length;
|
||
pass.bindings.push({ ...descriptor, resource: sourceId(source) });
|
||
} else if (socket === "color") {
|
||
if (!Array.isArray(pass.color)) pass.color = [];
|
||
pass.color.push({
|
||
...relationDescriptor(link),
|
||
resource: sourceId(source),
|
||
});
|
||
} else if (socket === "depth") {
|
||
pass.depth = { ...relationDescriptor(link), resource: sourceId(source) };
|
||
} else if (socket === "vertex") {
|
||
if (!Array.isArray(pass.vertexBuffers)) pass.vertexBuffers = [];
|
||
const descriptor = relationDescriptor(link);
|
||
if (!Object.hasOwn(descriptor, "slot"))
|
||
descriptor.slot = pass.vertexBuffers.length;
|
||
pass.vertexBuffers.push({ ...descriptor, resource: sourceId(source) });
|
||
} else if (socket === "index") {
|
||
pass.indexBuffer = {
|
||
...relationDescriptor(link),
|
||
resource: sourceId(source),
|
||
};
|
||
}
|
||
}
|
||
for (const pass of passes) {
|
||
if (!pass.pipeline)
|
||
throw new Error(`Pass ${String(pass.id)} has no pipeline`);
|
||
}
|
||
return {
|
||
id: String(layout.metadata.renderGraphId || "scene"),
|
||
resources,
|
||
pipelines,
|
||
passes,
|
||
};
|
||
}
|