572 lines
29 KiB
TypeScript
572 lines
29 KiB
TypeScript
import { blockedGate, capabilityIssue, readyGate, type CapabilityGateResult } from "./capability-gates";
|
|
import type { ErrorCode } from "./error";
|
|
|
|
export const COMPOSITOR_SCHEMA = 1 as const;
|
|
export const COMPOSITOR_BUDGET = {
|
|
maxNodes: 4_096,
|
|
maxLinks: 16_384,
|
|
maxResources: 4_096,
|
|
maxDimension: 8_192,
|
|
maxPixels: 16_777_216,
|
|
maxImageBytes: 256 * 1024 * 1024,
|
|
maxBlurRadius: 32,
|
|
maxOperations: 100_000_000,
|
|
maxFrameCacheBytes: 256 * 1024 * 1024,
|
|
} as const;
|
|
|
|
export const COMPOSITOR_NODE_TYPES = [
|
|
"IMAGE",
|
|
"RENDER_LAYER",
|
|
"CONSTANT_COLOR",
|
|
"TRANSFORM",
|
|
"INVERT",
|
|
"EXPOSURE",
|
|
"ALPHA_OVER",
|
|
"BLUR",
|
|
"MIX",
|
|
"VIEWER",
|
|
"COMPOSITE",
|
|
"UNSUPPORTED",
|
|
] as const;
|
|
|
|
export type CompositorNodeType = typeof COMPOSITOR_NODE_TYPES[number];
|
|
|
|
export const COMPOSITOR_WEBGPU_NODE_ALLOWLIST = [
|
|
"CONSTANT_COLOR",
|
|
"EXPOSURE",
|
|
"INVERT",
|
|
"COMPOSITE",
|
|
] as const;
|
|
export type CompositorWebGPUNodeType = typeof COMPOSITOR_WEBGPU_NODE_ALLOWLIST[number];
|
|
|
|
export type CompositorWebGPUInstructionIR =
|
|
| { nodeId: string; type: "CONSTANT_COLOR"; color: readonly [number, number, number, number] }
|
|
| { nodeId: string; type: "EXPOSURE"; exposure: number }
|
|
| { nodeId: string; type: "INVERT" }
|
|
| { nodeId: string; type: "COMPOSITE" };
|
|
|
|
export interface CompositorWebGPUPlanIR {
|
|
schemaVersion: typeof COMPOSITOR_SCHEMA;
|
|
graphId: string;
|
|
outputNodeId: string;
|
|
instructions: CompositorWebGPUInstructionIR[];
|
|
}
|
|
|
|
export interface CompositorResourceIR {
|
|
id: string;
|
|
kind: "IMAGE" | "RENDER_LAYER";
|
|
sourceId: string;
|
|
width?: number;
|
|
height?: number;
|
|
sha256?: string;
|
|
}
|
|
|
|
export interface CompositorNodeIR {
|
|
id: string;
|
|
type: CompositorNodeType;
|
|
name: string;
|
|
blenderType?: string;
|
|
properties: Record<string, unknown>;
|
|
}
|
|
|
|
export interface CompositorLinkIR {
|
|
fromNodeId: string;
|
|
fromSocket: string;
|
|
toNodeId: string;
|
|
toSocket: string;
|
|
}
|
|
|
|
export interface CompositorGraphIR {
|
|
schemaVersion: typeof COMPOSITOR_SCHEMA;
|
|
id: string;
|
|
name: string;
|
|
outputNodeId: string;
|
|
nodes: CompositorNodeIR[];
|
|
links: CompositorLinkIR[];
|
|
resources: CompositorResourceIR[];
|
|
}
|
|
|
|
export interface CompositorImageBuffer {
|
|
width: number;
|
|
height: number;
|
|
data: Float32Array;
|
|
colorSpace: "LINEAR_SRGB";
|
|
}
|
|
|
|
export interface CompositorExecutionResult {
|
|
composite: CompositorImageBuffer;
|
|
viewers: Map<string, CompositorImageBuffer>;
|
|
evaluatedNodeIds: string[];
|
|
}
|
|
|
|
export interface CompositorCachedExecutionResult extends CompositorExecutionResult {
|
|
cacheKey: string;
|
|
cacheHit: boolean;
|
|
}
|
|
|
|
interface CompositorFrameCacheEntry {
|
|
result: CompositorExecutionResult;
|
|
byteLength: number;
|
|
}
|
|
|
|
function cloneImage(image: CompositorImageBuffer): CompositorImageBuffer {
|
|
return { ...image, data: image.data.slice() };
|
|
}
|
|
|
|
function cloneExecution(result: CompositorExecutionResult): CompositorExecutionResult {
|
|
return { composite: cloneImage(result.composite), viewers: new Map([...result.viewers].map(([id, image]) => [id, cloneImage(image)])), evaluatedNodeIds: [...result.evaluatedNodeIds] };
|
|
}
|
|
|
|
function executionBytes(result: CompositorExecutionResult): number {
|
|
const unique = new Set<ArrayBuffer>();
|
|
unique.add(result.composite.data.buffer as ArrayBuffer);
|
|
for (const image of result.viewers.values()) unique.add(image.data.buffer as ArrayBuffer);
|
|
return [...unique].reduce((total, buffer) => total + buffer.byteLength, 0);
|
|
}
|
|
|
|
export class CompositorFrameCache {
|
|
readonly maxBytes: number;
|
|
private readonly entries = new Map<string, CompositorFrameCacheEntry>();
|
|
private currentBytes = 0;
|
|
|
|
constructor(maxBytes = COMPOSITOR_BUDGET.maxFrameCacheBytes) {
|
|
if (!Number.isSafeInteger(maxBytes) || maxBytes < 1 || maxBytes > COMPOSITOR_BUDGET.maxFrameCacheBytes) throw new CompositorValidationError("COMPOSITOR_BUDGET_EXCEEDED", "Compositor frame cache byte budget is invalid");
|
|
this.maxBytes = maxBytes;
|
|
}
|
|
|
|
get byteLength(): number { return this.currentBytes; }
|
|
get size(): number { return this.entries.size; }
|
|
|
|
get(key: string): CompositorExecutionResult | undefined {
|
|
const entry = this.entries.get(key);
|
|
if (!entry) return undefined;
|
|
this.entries.delete(key);
|
|
this.entries.set(key, entry);
|
|
return cloneExecution(entry.result);
|
|
}
|
|
|
|
set(key: string, result: CompositorExecutionResult): void {
|
|
const clone = cloneExecution(result);
|
|
const byteLength = executionBytes(clone);
|
|
if (byteLength > this.maxBytes) throw new CompositorValidationError("COMPOSITOR_BUDGET_EXCEEDED", "Compositor frame exceeds the cache byte budget");
|
|
const previous = this.entries.get(key);
|
|
if (previous) { this.currentBytes -= previous.byteLength; this.entries.delete(key); }
|
|
while (this.currentBytes + byteLength > this.maxBytes) {
|
|
const oldest = this.entries.entries().next().value as [string, CompositorFrameCacheEntry] | undefined;
|
|
if (!oldest) break;
|
|
this.entries.delete(oldest[0]);
|
|
this.currentBytes -= oldest[1].byteLength;
|
|
}
|
|
this.entries.set(key, { result: clone, byteLength });
|
|
this.currentBytes += byteLength;
|
|
}
|
|
}
|
|
|
|
export class CompositorValidationError extends Error {
|
|
readonly code: ErrorCode;
|
|
|
|
constructor(code: ErrorCode, message: string) {
|
|
super(`${code}: ${message}`);
|
|
this.name = "CompositorValidationError";
|
|
this.code = code;
|
|
}
|
|
}
|
|
|
|
const SHA256 = /^[a-f0-9]{64}$/;
|
|
const SUPPORTED = new Set<CompositorNodeType>(COMPOSITOR_NODE_TYPES.filter((type) => type !== "UNSUPPORTED"));
|
|
|
|
function record(value: unknown): value is Record<string, unknown> {
|
|
return typeof value === "object" && value !== null && !Array.isArray(value);
|
|
}
|
|
|
|
function text(value: unknown, name: string): string {
|
|
if (typeof value !== "string" || value.length === 0 || value.length > 256) {
|
|
throw new CompositorValidationError("COMPOSITOR_GRAPH_INVALID", `${name} is invalid`);
|
|
}
|
|
return value;
|
|
}
|
|
|
|
function finite(value: unknown, name: string, minimum: number, maximum: number): number {
|
|
if (typeof value !== "number" || !Number.isFinite(value) || value < minimum || value > maximum) {
|
|
throw new CompositorValidationError("COMPOSITOR_GRAPH_INVALID", `${name} is outside the bounded range`);
|
|
}
|
|
return value;
|
|
}
|
|
|
|
function properties(value: unknown, index: number): Record<string, unknown> {
|
|
if (!record(value)) throw new CompositorValidationError("COMPOSITOR_GRAPH_INVALID", `nodes[${index}].properties must be an object`);
|
|
let encoded: string;
|
|
try { encoded = JSON.stringify(value); }
|
|
catch { throw new CompositorValidationError("COMPOSITOR_GRAPH_INVALID", `nodes[${index}].properties is not serializable`); }
|
|
if (new TextEncoder().encode(encoded).byteLength > 64 * 1024) {
|
|
throw new CompositorValidationError("COMPOSITOR_BUDGET_EXCEEDED", `nodes[${index}].properties exceeds 64 KiB`);
|
|
}
|
|
return value;
|
|
}
|
|
|
|
function validateNodeProperties(node: CompositorNodeIR, index: number): void {
|
|
const value = node.properties;
|
|
const allowed = (names: string[]): void => {
|
|
if (Object.keys(value).some((key) => !names.includes(key))) {
|
|
throw new CompositorValidationError("COMPOSITOR_GRAPH_INVALID", `nodes[${index}] contains unsupported properties`);
|
|
}
|
|
};
|
|
if (node.type === "IMAGE" || node.type === "RENDER_LAYER") {
|
|
allowed(["resourceId"]);
|
|
text(value.resourceId, `nodes[${index}].properties.resourceId`);
|
|
}
|
|
else if (node.type === "CONSTANT_COLOR") {
|
|
allowed(["color"]);
|
|
if (!Array.isArray(value.color) || value.color.length !== 4) throw new CompositorValidationError("COMPOSITOR_GRAPH_INVALID", `nodes[${index}].color must contain RGBA`);
|
|
value.color.forEach((channel, channelIndex) => finite(channel, `nodes[${index}].color[${channelIndex}]`, -65504, 65504));
|
|
}
|
|
else if (node.type === "TRANSFORM") {
|
|
allowed(["translateX", "translateY", "scaleX", "scaleY"]);
|
|
for (const key of ["translateX", "translateY"] as const) if (value[key] !== undefined) finite(value[key], `nodes[${index}].${key}`, -1_000_000, 1_000_000);
|
|
for (const key of ["scaleX", "scaleY"] as const) if (value[key] !== undefined) finite(value[key], `nodes[${index}].${key}`, 0.0001, 10_000);
|
|
}
|
|
else if (node.type === "EXPOSURE") {
|
|
allowed(["exposure"]);
|
|
finite(value.exposure ?? 0, `nodes[${index}].exposure`, -20, 20);
|
|
}
|
|
else if (node.type === "BLUR") {
|
|
allowed(["radius"]);
|
|
const radius = finite(value.radius ?? 0, `nodes[${index}].radius`, 0, COMPOSITOR_BUDGET.maxBlurRadius);
|
|
if (!Number.isSafeInteger(radius)) throw new CompositorValidationError("COMPOSITOR_GRAPH_INVALID", `nodes[${index}].radius must be an integer`);
|
|
}
|
|
else if (node.type === "MIX") {
|
|
allowed(["factor"]);
|
|
finite(value.factor ?? 0.5, `nodes[${index}].factor`, 0, 1);
|
|
}
|
|
else if (["INVERT", "ALPHA_OVER", "VIEWER", "COMPOSITE"].includes(node.type)) allowed([]);
|
|
else if (node.type === "UNSUPPORTED") {
|
|
if (!node.blenderType) throw new CompositorValidationError("COMPOSITOR_GRAPH_INVALID", `nodes[${index}] must preserve blenderType`);
|
|
}
|
|
}
|
|
|
|
function unsupportedCompositorNodeNames(graph: CompositorGraphIR): string[] {
|
|
return [...new Set(graph.nodes
|
|
.filter((node) => !SUPPORTED.has(node.type))
|
|
.map((node) => node.blenderType ?? node.type))].sort();
|
|
}
|
|
|
|
function assertCompositorGraphExecutable(graph: CompositorGraphIR): void {
|
|
const unsupported = unsupportedCompositorNodeNames(graph);
|
|
if (unsupported.length > 0) {
|
|
throw new CompositorValidationError("COMPOSITOR_NODE_UNSUPPORTED", `Compositor graph contains unsupported nodes: ${unsupported.join(", ")}`);
|
|
}
|
|
}
|
|
|
|
export function parseCompositorGraph(value: unknown): CompositorGraphIR {
|
|
if (!record(value) || value.schemaVersion !== COMPOSITOR_SCHEMA || !Array.isArray(value.nodes) ||
|
|
!Array.isArray(value.links) || !Array.isArray(value.resources)) {
|
|
throw new CompositorValidationError("PROTOCOL_MISMATCH", "Unsupported Compositor graph schema");
|
|
}
|
|
if (value.nodes.length === 0 || value.nodes.length > COMPOSITOR_BUDGET.maxNodes ||
|
|
value.links.length > COMPOSITOR_BUDGET.maxLinks || value.resources.length > COMPOSITOR_BUDGET.maxResources) {
|
|
throw new CompositorValidationError("COMPOSITOR_BUDGET_EXCEEDED", "Compositor graph exceeds the node, link or resource budget");
|
|
}
|
|
const nodeIds = new Set<string>();
|
|
const nodes = value.nodes.map((item, index): CompositorNodeIR => {
|
|
if (!record(item) || !COMPOSITOR_NODE_TYPES.includes(item.type as CompositorNodeType)) throw new CompositorValidationError("COMPOSITOR_GRAPH_INVALID", `nodes[${index}] is invalid`);
|
|
const id = text(item.id, `nodes[${index}].id`);
|
|
if (nodeIds.has(id)) throw new CompositorValidationError("COMPOSITOR_GRAPH_INVALID", `Duplicate node ${id}`);
|
|
nodeIds.add(id);
|
|
const node = { id, type: item.type as CompositorNodeType, name: text(item.name, `nodes[${index}].name`), properties: properties(item.properties ?? {}, index), blenderType: item.blenderType === undefined ? undefined : text(item.blenderType, `nodes[${index}].blenderType`) };
|
|
validateNodeProperties(node, index);
|
|
return node;
|
|
});
|
|
const resourceIds = new Set<string>();
|
|
const resources = value.resources.map((item, index): CompositorResourceIR => {
|
|
if (!record(item) || !["IMAGE", "RENDER_LAYER"].includes(item.kind as string)) throw new CompositorValidationError("COMPOSITOR_GRAPH_INVALID", `resources[${index}] is invalid`);
|
|
const id = text(item.id, `resources[${index}].id`);
|
|
if (resourceIds.has(id)) throw new CompositorValidationError("COMPOSITOR_GRAPH_INVALID", `Duplicate resource ${id}`);
|
|
resourceIds.add(id);
|
|
const width = item.width === undefined ? undefined : finite(item.width, `resources[${index}].width`, 1, COMPOSITOR_BUDGET.maxDimension);
|
|
const height = item.height === undefined ? undefined : finite(item.height, `resources[${index}].height`, 1, COMPOSITOR_BUDGET.maxDimension);
|
|
if ((width !== undefined && !Number.isSafeInteger(width)) || (height !== undefined && !Number.isSafeInteger(height))) throw new CompositorValidationError("COMPOSITOR_GRAPH_INVALID", `resources[${index}] dimensions must be integers`);
|
|
if (item.sha256 !== undefined && (typeof item.sha256 !== "string" || !SHA256.test(item.sha256))) throw new CompositorValidationError("COMPOSITOR_GRAPH_INVALID", `resources[${index}].sha256 is invalid`);
|
|
return { id, kind: item.kind as CompositorResourceIR["kind"], sourceId: text(item.sourceId, `resources[${index}].sourceId`), width, height, sha256: item.sha256 as string | undefined };
|
|
});
|
|
const destinations = new Set<string>();
|
|
const links = value.links.map((item, index): CompositorLinkIR => {
|
|
if (!record(item)) throw new CompositorValidationError("COMPOSITOR_GRAPH_INVALID", `links[${index}] is invalid`);
|
|
const link = { fromNodeId: text(item.fromNodeId, `links[${index}].fromNodeId`), fromSocket: text(item.fromSocket, `links[${index}].fromSocket`), toNodeId: text(item.toNodeId, `links[${index}].toNodeId`), toSocket: text(item.toSocket, `links[${index}].toSocket`) };
|
|
if (!nodeIds.has(link.fromNodeId) || !nodeIds.has(link.toNodeId)) throw new CompositorValidationError("COMPOSITOR_GRAPH_INVALID", `links[${index}] references a missing node`);
|
|
const destination = `${link.toNodeId}:${link.toSocket}`;
|
|
if (destinations.has(destination)) throw new CompositorValidationError("COMPOSITOR_GRAPH_INVALID", `Multiple links target ${destination}`);
|
|
destinations.add(destination);
|
|
return link;
|
|
});
|
|
const outputNodeId = text(value.outputNodeId, "outputNodeId");
|
|
if (!nodeIds.has(outputNodeId) || nodes.find((node) => node.id === outputNodeId)?.type !== "COMPOSITE") throw new CompositorValidationError("COMPOSITOR_GRAPH_INVALID", "outputNodeId must reference a COMPOSITE node");
|
|
const outgoing = new Map(nodes.map((node) => [node.id, [] as string[]]));
|
|
for (const link of links) outgoing.get(link.fromNodeId)?.push(link.toNodeId);
|
|
const active = new Set<string>();
|
|
const done = new Set<string>();
|
|
const visit = (id: string): void => {
|
|
if (active.has(id)) throw new CompositorValidationError("COMPOSITOR_GRAPH_CYCLE", `Compositor graph cycle includes ${id}`);
|
|
if (done.has(id)) return;
|
|
active.add(id);
|
|
for (const next of outgoing.get(id) ?? []) visit(next);
|
|
active.delete(id);
|
|
done.add(id);
|
|
};
|
|
nodes.forEach((node) => visit(node.id));
|
|
return { schemaVersion: COMPOSITOR_SCHEMA, id: text(value.id, "id"), name: text(value.name, "name"), outputNodeId, nodes, links, resources };
|
|
}
|
|
|
|
/** Compiles only the node types with an independent CPU/WebGPU golden. */
|
|
export function compileCompositorWebGPUPlan(value: unknown): CompositorWebGPUPlanIR {
|
|
const graph = parseCompositorGraph(value);
|
|
if (graph.resources.length !== 0) throw new CompositorValidationError("COMPOSITOR_NODE_UNSUPPORTED", "WebGPU compositor allowlist does not include resource inputs");
|
|
const unsupported = graph.nodes.filter((node) => !COMPOSITOR_WEBGPU_NODE_ALLOWLIST.includes(node.type as CompositorWebGPUNodeType));
|
|
if (unsupported.length > 0) {
|
|
const names = [...new Set(unsupported.map((node) => node.blenderType ?? node.type))].sort();
|
|
throw new CompositorValidationError("COMPOSITOR_NODE_UNSUPPORTED", `WebGPU compositor nodes are not allowlisted: ${names.join(", ")}`);
|
|
}
|
|
const byId = new Map(graph.nodes.map((node) => [node.id, node]));
|
|
const incoming = new Map<string, CompositorLinkIR[]>();
|
|
for (const link of graph.links) {
|
|
const links = incoming.get(link.toNodeId) ?? [];
|
|
links.push(link);
|
|
incoming.set(link.toNodeId, links);
|
|
}
|
|
const visited = new Set<string>();
|
|
const instructions: CompositorWebGPUInstructionIR[] = [];
|
|
const visit = (nodeId: string): void => {
|
|
if (visited.has(nodeId)) return;
|
|
const node = byId.get(nodeId);
|
|
if (!node) throw new CompositorValidationError("COMPOSITOR_GRAPH_INVALID", `Missing WebGPU compositor node ${nodeId}`);
|
|
const links = incoming.get(nodeId) ?? [];
|
|
if (node.type === "CONSTANT_COLOR") {
|
|
if (links.length !== 0) throw new CompositorValidationError("COMPOSITOR_GRAPH_INVALID", `${nodeId} constant input must be disconnected`);
|
|
const color = node.properties.color as number[];
|
|
instructions.push({ nodeId, type: "CONSTANT_COLOR", color: [color[0], color[1], color[2], color[3]] });
|
|
}
|
|
else {
|
|
if (links.length !== 1 || links[0].toSocket !== "Image") throw new CompositorValidationError("COMPOSITOR_GRAPH_INVALID", `${nodeId}.Image requires exactly one input`);
|
|
visit(links[0].fromNodeId);
|
|
if (node.type === "EXPOSURE") instructions.push({ nodeId, type: "EXPOSURE", exposure: Number(node.properties.exposure ?? 0) });
|
|
else if (node.type === "INVERT") instructions.push({ nodeId, type: "INVERT" });
|
|
else if (node.type === "COMPOSITE") instructions.push({ nodeId, type: "COMPOSITE" });
|
|
else throw new CompositorValidationError("COMPOSITOR_NODE_UNSUPPORTED", `${node.type} has no WebGPU golden`);
|
|
}
|
|
visited.add(nodeId);
|
|
};
|
|
visit(graph.outputNodeId);
|
|
if (visited.size !== graph.nodes.length || graph.links.length !== graph.nodes.length - 1 || instructions[0]?.type !== "CONSTANT_COLOR") {
|
|
throw new CompositorValidationError("COMPOSITOR_GRAPH_INVALID", "WebGPU compositor schema 1 requires one connected constant-to-composite chain");
|
|
}
|
|
return { schemaVersion: COMPOSITOR_SCHEMA, graphId: graph.id, outputNodeId: graph.outputNodeId, instructions };
|
|
}
|
|
|
|
function validateImage(image: CompositorImageBuffer, name: string): CompositorImageBuffer {
|
|
const pixels = image.width * image.height;
|
|
if (!Number.isSafeInteger(image.width) || !Number.isSafeInteger(image.height) || image.width < 1 || image.height < 1 ||
|
|
image.width > COMPOSITOR_BUDGET.maxDimension || image.height > COMPOSITOR_BUDGET.maxDimension || pixels > COMPOSITOR_BUDGET.maxPixels ||
|
|
image.data.length !== pixels * 4 || image.data.byteLength > COMPOSITOR_BUDGET.maxImageBytes) {
|
|
throw new CompositorValidationError("COMPOSITOR_BUDGET_EXCEEDED", `${name} exceeds the image budget`);
|
|
}
|
|
if (image.colorSpace !== "LINEAR_SRGB") throw new CompositorValidationError("COMPOSITOR_GRAPH_INVALID", `${name} must use LINEAR_SRGB`);
|
|
return image;
|
|
}
|
|
|
|
function allocate(width: number, height: number): CompositorImageBuffer {
|
|
const pixels = width * height;
|
|
if (!Number.isSafeInteger(width) || !Number.isSafeInteger(height) || width < 1 || height < 1 ||
|
|
width > COMPOSITOR_BUDGET.maxDimension || height > COMPOSITOR_BUDGET.maxDimension ||
|
|
pixels > COMPOSITOR_BUDGET.maxPixels || pixels * 16 > COMPOSITOR_BUDGET.maxImageBytes)
|
|
{
|
|
throw new CompositorValidationError("COMPOSITOR_BUDGET_EXCEEDED", "Compositor output exceeds the image budget");
|
|
}
|
|
return validateImage({ width, height, data: new Float32Array(width * height * 4), colorSpace: "LINEAR_SRGB" }, "Compositor output");
|
|
}
|
|
|
|
export function gateCompositorGraph(value: unknown, availableResourceIds: ReadonlySet<string>): CapabilityGateResult {
|
|
try {
|
|
const graph = parseCompositorGraph(value);
|
|
const unsupported = unsupportedCompositorNodeNames(graph);
|
|
if (unsupported.length > 0) return blockedGate("N-020", "COMPOSITOR_GRAPH", [capabilityIssue("COMPOSITOR_NODE_UNSUPPORTED", `Unsupported compositor nodes: ${unsupported.join(", ")}`)]);
|
|
const missing = graph.resources.filter((resource) => !availableResourceIds.has(resource.sourceId));
|
|
if (missing.length > 0) return blockedGate("N-020", "COMPOSITOR_GRAPH", [capabilityIssue("COMPOSITOR_RESOURCE_MISSING", `Missing compositor resources: ${missing.map((resource) => resource.sourceId).join(", ")}`)]);
|
|
return readyGate("N-020", "BOUNDED_CPU_COMPOSITOR");
|
|
}
|
|
catch (error) {
|
|
const code = error instanceof CompositorValidationError ? error.code : "COMPOSITOR_GRAPH_INVALID";
|
|
return blockedGate("N-020", "COMPOSITOR_GRAPH", [capabilityIssue(code, error instanceof Error ? error.message : "Invalid compositor graph")]);
|
|
}
|
|
}
|
|
|
|
export function executeCompositorGraph(
|
|
value: unknown,
|
|
sourceImages: ReadonlyMap<string, CompositorImageBuffer>,
|
|
options: { width?: number; height?: number; cancelled?: () => boolean } = {},
|
|
): CompositorExecutionResult {
|
|
const graph = parseCompositorGraph(value);
|
|
assertCompositorGraphExecutable(graph);
|
|
const byId = new Map(graph.nodes.map((node) => [node.id, node]));
|
|
const incoming = new Map<string, CompositorLinkIR>();
|
|
graph.links.forEach((link) => incoming.set(`${link.toNodeId}:${link.toSocket}`, link));
|
|
const outputs = new Map<string, CompositorImageBuffer>();
|
|
const viewers = new Map<string, CompositorImageBuffer>();
|
|
const evaluatedNodeIds: string[] = [];
|
|
let operationCounter = 0;
|
|
const checkCancelled = (operations = 1): void => {
|
|
operationCounter += operations;
|
|
if ((operationCounter === operations || operationCounter % 16_384 < operations) && options.cancelled?.()) throw new CompositorValidationError("COMPOSITOR_CANCELLED", "Compositor execution was cancelled");
|
|
};
|
|
const requireInput = (nodeId: string, socket: string): CompositorImageBuffer => {
|
|
const source = incoming.get(`${nodeId}:${socket}`)?.fromNodeId;
|
|
const image = source ? outputs.get(source) : undefined;
|
|
if (!image) throw new CompositorValidationError("COMPOSITOR_GRAPH_INVALID", `${nodeId}.${socket} is not connected to an evaluated image`);
|
|
return image;
|
|
};
|
|
const sameSize = (left: CompositorImageBuffer, right: CompositorImageBuffer, nodeId: string): void => {
|
|
if (left.width !== right.width || left.height !== right.height) throw new CompositorValidationError("COMPOSITOR_GRAPH_INVALID", `${nodeId} inputs have different dimensions`);
|
|
};
|
|
const evaluate = (id: string): CompositorImageBuffer => {
|
|
const existing = outputs.get(id);
|
|
if (existing) return existing;
|
|
checkCancelled();
|
|
const node = byId.get(id);
|
|
if (!node) throw new CompositorValidationError("COMPOSITOR_GRAPH_INVALID", `Missing node ${id}`);
|
|
for (const link of graph.links.filter((candidate) => candidate.toNodeId === id)) evaluate(link.fromNodeId);
|
|
let output: CompositorImageBuffer;
|
|
if (node.type === "UNSUPPORTED") throw new CompositorValidationError("COMPOSITOR_NODE_UNSUPPORTED", `${node.blenderType ?? node.name} is not executable locally`);
|
|
if (node.type === "IMAGE" || node.type === "RENDER_LAYER") {
|
|
const resourceId = node.properties.resourceId as string;
|
|
const resource = graph.resources.find((item) => item.id === resourceId);
|
|
const image = resource ? sourceImages.get(resource.sourceId) : undefined;
|
|
if (!image) throw new CompositorValidationError("COMPOSITOR_RESOURCE_MISSING", `Missing compositor resource ${resource?.sourceId ?? resourceId}`);
|
|
output = validateImage(image, node.id);
|
|
}
|
|
else if (node.type === "CONSTANT_COLOR") {
|
|
const width = options.width ?? 1;
|
|
const height = options.height ?? 1;
|
|
output = allocate(width, height);
|
|
const color = node.properties.color as number[];
|
|
for (let offset = 0; offset < output.data.length; offset += 4) { checkCancelled(); output.data.set(color, offset); }
|
|
}
|
|
else if (node.type === "TRANSFORM") {
|
|
const input = requireInput(id, "Image");
|
|
output = allocate(input.width, input.height);
|
|
const tx = Number(node.properties.translateX ?? 0), ty = Number(node.properties.translateY ?? 0);
|
|
const sx = Number(node.properties.scaleX ?? 1), sy = Number(node.properties.scaleY ?? 1);
|
|
for (let y = 0; y < input.height; y++) for (let x = 0; x < input.width; x++) {
|
|
checkCancelled();
|
|
const sourceX = Math.round((x - tx) / sx), sourceY = Math.round((y - ty) / sy);
|
|
if (sourceX < 0 || sourceX >= input.width || sourceY < 0 || sourceY >= input.height) continue;
|
|
output.data.set(input.data.subarray((sourceY * input.width + sourceX) * 4, (sourceY * input.width + sourceX) * 4 + 4), (y * input.width + x) * 4);
|
|
}
|
|
}
|
|
else if (node.type === "INVERT" || node.type === "EXPOSURE") {
|
|
const input = requireInput(id, "Image");
|
|
output = allocate(input.width, input.height);
|
|
const multiplier = node.type === "EXPOSURE" ? 2 ** Number(node.properties.exposure ?? 0) : 1;
|
|
for (let offset = 0; offset < input.data.length; offset += 4) {
|
|
checkCancelled();
|
|
for (let channel = 0; channel < 3; channel++) output.data[offset + channel] = node.type === "INVERT" ? 1 - input.data[offset + channel] : input.data[offset + channel] * multiplier;
|
|
output.data[offset + 3] = input.data[offset + 3];
|
|
}
|
|
}
|
|
else if (node.type === "MIX" || node.type === "ALPHA_OVER") {
|
|
const left = requireInput(id, node.type === "MIX" ? "A" : "Background");
|
|
const right = requireInput(id, node.type === "MIX" ? "B" : "Foreground");
|
|
sameSize(left, right, id);
|
|
output = allocate(left.width, left.height);
|
|
for (let offset = 0; offset < left.data.length; offset += 4) {
|
|
checkCancelled();
|
|
if (node.type === "MIX") {
|
|
const factor = Number(node.properties.factor ?? 0.5);
|
|
for (let channel = 0; channel < 4; channel++) output.data[offset + channel] = left.data[offset + channel] * (1 - factor) + right.data[offset + channel] * factor;
|
|
}
|
|
else {
|
|
const backgroundAlpha = left.data[offset + 3], foregroundAlpha = right.data[offset + 3];
|
|
const alpha = foregroundAlpha + backgroundAlpha * (1 - foregroundAlpha);
|
|
for (let channel = 0; channel < 3; channel++) output.data[offset + channel] = alpha > 0 ? (right.data[offset + channel] * foregroundAlpha + left.data[offset + channel] * backgroundAlpha * (1 - foregroundAlpha)) / alpha : 0;
|
|
output.data[offset + 3] = alpha;
|
|
}
|
|
}
|
|
}
|
|
else if (node.type === "BLUR") {
|
|
const input = requireInput(id, "Image");
|
|
const radius = Number(node.properties.radius ?? 0);
|
|
const operations = input.width * input.height * (radius * 2 + 1) ** 2;
|
|
if (operations > COMPOSITOR_BUDGET.maxOperations) throw new CompositorValidationError("COMPOSITOR_BUDGET_EXCEEDED", `${id} exceeds the blur operation budget`);
|
|
output = allocate(input.width, input.height);
|
|
for (let y = 0; y < input.height; y++) for (let x = 0; x < input.width; x++) {
|
|
checkCancelled((radius * 2 + 1) ** 2);
|
|
const target = (y * input.width + x) * 4;
|
|
let samples = 0;
|
|
for (let dy = -radius; dy <= radius; dy++) for (let dx = -radius; dx <= radius; dx++) {
|
|
const px = x + dx, py = y + dy;
|
|
if (px < 0 || py < 0 || px >= input.width || py >= input.height) continue;
|
|
const source = (py * input.width + px) * 4;
|
|
for (let channel = 0; channel < 4; channel++) output.data[target + channel] += input.data[source + channel];
|
|
samples++;
|
|
}
|
|
for (let channel = 0; channel < 4; channel++) output.data[target + channel] /= samples;
|
|
}
|
|
}
|
|
else {
|
|
output = requireInput(id, "Image");
|
|
if (node.type === "VIEWER") viewers.set(id, output);
|
|
}
|
|
outputs.set(id, output);
|
|
evaluatedNodeIds.push(id);
|
|
return output;
|
|
};
|
|
return { composite: evaluate(graph.outputNodeId), viewers, evaluatedNodeIds };
|
|
}
|
|
|
|
async function sha256Bytes(data: ArrayBuffer): Promise<string> {
|
|
const digest = await crypto.subtle.digest("SHA-256", data);
|
|
return Array.from(new Uint8Array(digest), (value) => value.toString(16).padStart(2, "0")).join("");
|
|
}
|
|
|
|
function stableJSON(value: unknown): string {
|
|
if (Array.isArray(value)) return `[${value.map(stableJSON).join(",")}]`;
|
|
if (record(value)) return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${stableJSON(value[key])}`).join(",")}}`;
|
|
return JSON.stringify(value);
|
|
}
|
|
|
|
export async function compositorFrameCacheKey(
|
|
value: unknown,
|
|
sourceImages: ReadonlyMap<string, CompositorImageBuffer>,
|
|
frame: number,
|
|
width?: number,
|
|
height?: number,
|
|
): Promise<string> {
|
|
const graph = parseCompositorGraph(value);
|
|
if (!Number.isSafeInteger(frame) || frame < -1_000_000 || frame > 1_000_000) throw new CompositorValidationError("COMPOSITOR_GRAPH_INVALID", "Compositor cache frame is invalid");
|
|
const sources: Array<{ id: string; width: number; height: number; sha256: string }> = [];
|
|
for (const resource of [...graph.resources].sort((left, right) => left.sourceId.localeCompare(right.sourceId))) {
|
|
const image = sourceImages.get(resource.sourceId);
|
|
if (!image) throw new CompositorValidationError("COMPOSITOR_RESOURCE_MISSING", `Missing compositor resource ${resource.sourceId}`);
|
|
validateImage(image, resource.sourceId);
|
|
const sha256 = await sha256Bytes(image.data.buffer.slice(image.data.byteOffset, image.data.byteOffset + image.data.byteLength) as ArrayBuffer);
|
|
if (resource.sha256 && resource.sha256 !== sha256) throw new CompositorValidationError("COMPOSITOR_RESOURCE_MISSING", `Compositor resource ${resource.sourceId} failed SHA-256 verification`);
|
|
sources.push({ id: resource.sourceId, width: image.width, height: image.height, sha256 });
|
|
}
|
|
const descriptor = new TextEncoder().encode(stableJSON({ graph, sources, frame, width: width ?? null, height: height ?? null }));
|
|
return sha256Bytes(descriptor.buffer as ArrayBuffer);
|
|
}
|
|
|
|
export async function executeCompositorGraphCached(
|
|
value: unknown,
|
|
sourceImages: ReadonlyMap<string, CompositorImageBuffer>,
|
|
cache: CompositorFrameCache,
|
|
options: { frame: number; width?: number; height?: number; cancelled?: () => boolean },
|
|
): Promise<CompositorCachedExecutionResult> {
|
|
assertCompositorGraphExecutable(parseCompositorGraph(value));
|
|
if (options.cancelled?.()) throw new CompositorValidationError("COMPOSITOR_CANCELLED", "Compositor execution was cancelled");
|
|
const cacheKey = await compositorFrameCacheKey(value, sourceImages, options.frame, options.width, options.height);
|
|
if (options.cancelled?.()) throw new CompositorValidationError("COMPOSITOR_CANCELLED", "Compositor execution was cancelled");
|
|
const cached = cache.get(cacheKey);
|
|
if (cached) return { ...cached, cacheKey, cacheHit: true };
|
|
const result = executeCompositorGraph(value, sourceImages, options);
|
|
cache.set(cacheKey, result);
|
|
return { ...result, cacheKey, cacheHit: false };
|
|
}
|