503 lines
25 KiB
TypeScript
503 lines
25 KiB
TypeScript
import type { ErrorCode } from "./error";
|
|
import type { MaterialIR, MaterialLinkIR, MaterialNodeIR } from "./scene-ir";
|
|
import type { ShaderGraphIR } from "./shader-graph";
|
|
|
|
export const SHADER_COMPILE_SCHEMA = 1 as const;
|
|
export const SHADER_COMPILE_TASK = "M10-07" as const;
|
|
export const SHADER_COMPILE_BACKEND = "WEBGL2_THREE_PHYSICAL" as const;
|
|
export type ShaderCompileBackend = typeof SHADER_COMPILE_BACKEND;
|
|
export type ShaderTextureColorSpace = "SRGB" | "NON_COLOR" | "LINEAR";
|
|
|
|
/**
|
|
* This is deliberately smaller than the Main writer allowlist. RGB and Value are
|
|
* constants used to feed the declared Math/Principled closure; no arbitrary GLSL
|
|
* or unknown Blender node can enter the browser material path.
|
|
*/
|
|
export const SHADER_COMPILE_ALLOWLIST = [
|
|
"RGB",
|
|
"VALUE",
|
|
"MATH",
|
|
"IMAGE_TEXTURE",
|
|
"NORMAL_MAP",
|
|
"PRINCIPLED",
|
|
"OUTPUT",
|
|
] as const;
|
|
|
|
export const SHADER_COMPILE_BUDGET = {
|
|
maxNodes: 128,
|
|
maxLinks: 512,
|
|
maxDepth: 64,
|
|
maxTextures: 16,
|
|
maxIdentifierBytes: 256,
|
|
maxNameBytes: 1_024,
|
|
} as const;
|
|
|
|
type CompileNodeType = typeof SHADER_COMPILE_ALLOWLIST[number];
|
|
type Issue = { code: ErrorCode; message: string; path?: string };
|
|
|
|
export interface ShaderCompiledMaterial {
|
|
baseColor: [number, number, number, number];
|
|
roughness: number;
|
|
metallic: number;
|
|
alpha: number;
|
|
ior: number;
|
|
specularIORLevel?: number;
|
|
transmissionWeight?: number;
|
|
coatWeight?: number;
|
|
coatRoughness?: number;
|
|
emissionStrength?: number;
|
|
emissionColor?: [number, number, number, number];
|
|
baseColorImageId?: string;
|
|
normalImageId?: string;
|
|
}
|
|
|
|
export interface ShaderCompileReport {
|
|
schemaVersion: typeof SHADER_COMPILE_SCHEMA;
|
|
taskId: typeof SHADER_COMPILE_TASK;
|
|
backend: typeof SHADER_COMPILE_BACKEND;
|
|
status: "COMPILED" | "BLOCKED";
|
|
materialId: string;
|
|
graphHash: string | null;
|
|
compileKey: string | null;
|
|
nodeOrder: string[];
|
|
compiledNodeTypes: CompileNodeType[];
|
|
textureBindings: Array<{ imageId: string; usage: "BASE_COLOR" | "NORMAL" }>;
|
|
instructions: Array<{ nodeId: string; type: CompileNodeType; operation?: string }>;
|
|
material?: ShaderCompiledMaterial;
|
|
issues: Issue[];
|
|
}
|
|
|
|
export interface ShaderCompileContext {
|
|
imageIds?: ReadonlySet<string>;
|
|
blockedImageIds?: ReadonlySet<string>;
|
|
rendererBackend?: string;
|
|
textureIdentities?: ReadonlyMap<string, {
|
|
assetId?: string;
|
|
sha256?: string;
|
|
colorSpace?: ShaderTextureColorSpace;
|
|
}>;
|
|
}
|
|
|
|
export interface ShaderCompileKeyInput {
|
|
graphHash: string | null;
|
|
rendererBackend: string;
|
|
textures: ReadonlyArray<{
|
|
imageId: string;
|
|
usage: "BASE_COLOR" | "NORMAL";
|
|
assetId: string | null;
|
|
sha256: string | null;
|
|
colorSpace: ShaderTextureColorSpace;
|
|
}>;
|
|
}
|
|
|
|
export function compileShaderGraph(
|
|
graph: ShaderGraphIR,
|
|
baseMaterial?: MaterialIR,
|
|
context: ShaderCompileContext = {},
|
|
): ShaderCompileReport {
|
|
const socketName = new Map<string, string>();
|
|
for (const node of graph.nodes) {
|
|
for (const socket of node.sockets) socketName.set(`${node.id}:${socket.id}`, socket.name);
|
|
}
|
|
const nodes: MaterialNodeIR[] = graph.nodes.map((node) => {
|
|
const outputDefault = node.sockets.find((socket) => socket.direction === "OUTPUT")?.defaultValue;
|
|
const defaultValue = typeof outputDefault === "number" ? [outputDefault]
|
|
: Array.isArray(outputDefault) && outputDefault.every(finite) ? [...outputDefault] : undefined;
|
|
return {
|
|
id: node.id,
|
|
type: node.type === "MATERIAL_OUTPUT" ? "OUTPUT" : node.type as MaterialNodeIR["type"],
|
|
name: node.name,
|
|
imageId: node.imageId,
|
|
defaultValue,
|
|
properties: node.type === "MATH" ? {
|
|
operation: node.properties?.operation as "ADD" | "SUBTRACT" | "MULTIPLY" | "DIVIDE" | "MINIMUM" | "MAXIMUM" | undefined,
|
|
} : undefined,
|
|
};
|
|
});
|
|
const material: MaterialIR = {
|
|
id: graph.materialId,
|
|
name: baseMaterial?.name ?? graph.materialId,
|
|
baseColor: baseMaterial?.baseColor ?? [0.8, 0.8, 0.8, 1],
|
|
roughness: baseMaterial?.roughness ?? 0.5,
|
|
metallic: baseMaterial?.metallic ?? 0,
|
|
emissionColor: baseMaterial?.emissionColor ?? [0, 0, 0, 1],
|
|
alpha: baseMaterial?.alpha ?? 1,
|
|
ior: baseMaterial?.ior ?? 1.45,
|
|
specularIORLevel: baseMaterial?.specularIORLevel,
|
|
transmissionWeight: baseMaterial?.transmissionWeight,
|
|
coatWeight: baseMaterial?.coatWeight,
|
|
coatRoughness: baseMaterial?.coatRoughness,
|
|
emissionStrength: baseMaterial?.emissionStrength,
|
|
nodes,
|
|
links: graph.links.map((link) => ({
|
|
fromNodeId: link.fromNodeId,
|
|
fromSocket: socketName.get(`${link.fromNodeId}:${link.fromSocketId}`) ?? link.fromSocketId,
|
|
toNodeId: link.toNodeId,
|
|
toSocket: socketName.get(`${link.toNodeId}:${link.toSocketId}`) ?? link.toSocketId,
|
|
})),
|
|
};
|
|
return compileMaterialGraph(material, context);
|
|
}
|
|
|
|
function finite(value: unknown): value is number {
|
|
return typeof value === "number" && Number.isFinite(value);
|
|
}
|
|
|
|
function finiteColor(value: unknown): value is number[] {
|
|
return Array.isArray(value) && (value.length === 3 || value.length === 4) && value.every((item) => finite(item) && item >= 0 && item <= 1);
|
|
}
|
|
|
|
function normalizeSocket(value: string): string {
|
|
return value.toLowerCase().replace(/[ _-]/g, "");
|
|
}
|
|
|
|
function scalarSocket(value: string): boolean {
|
|
const normalized = normalizeSocket(value);
|
|
return normalized === "value" || normalized === "value001" || normalized === "a" || normalized === "b";
|
|
}
|
|
|
|
function canonicalGraph(material: MaterialIR): string {
|
|
return JSON.stringify({
|
|
schemaVersion: 1,
|
|
materialId: material.id,
|
|
nodes: (material.nodes ?? []).map((node) => ({
|
|
id: node.id,
|
|
type: node.type,
|
|
name: node.name,
|
|
imageId: node.imageId ?? null,
|
|
defaultValue: node.defaultValue ?? null,
|
|
properties: node.properties ?? null,
|
|
})),
|
|
links: (material.links ?? []).map((link) => ({
|
|
fromNodeId: link.fromNodeId,
|
|
fromSocket: link.fromSocket,
|
|
toNodeId: link.toNodeId,
|
|
toSocket: link.toSocket,
|
|
})),
|
|
});
|
|
}
|
|
|
|
// A synchronous SHA-256 keeps viewport material creation deterministic without
|
|
// making every Three.js material allocation asynchronous. Native snapshots carry
|
|
// their own SHA-256; this is the fallback for protocol/unit fixtures.
|
|
function fallbackGraphHash(value: string): string {
|
|
const bytes = new TextEncoder().encode(value);
|
|
const words = new Uint32Array(64);
|
|
const constants = [
|
|
0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
|
|
0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
|
|
0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
|
|
0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
|
|
0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
|
|
0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
|
|
0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
|
|
0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2,
|
|
];
|
|
const state = new Uint32Array([0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19]);
|
|
const length = ((bytes.length + 9 + 63) >> 6) << 6;
|
|
const padded = new Uint8Array(length);
|
|
padded.set(bytes);
|
|
padded[bytes.length] = 0x80;
|
|
const bitLength = bytes.length * 8;
|
|
new DataView(padded.buffer).setUint32(length - 4, bitLength >>> 0, false);
|
|
for (let offset = 0; offset < padded.length; offset += 64) {
|
|
for (let index = 0; index < 16; index++) words[index] = new DataView(padded.buffer, offset + index * 4, 4).getUint32(0, false);
|
|
for (let index = 16; index < 64; index++) {
|
|
const a = words[index - 15];
|
|
const b = words[index - 2];
|
|
const s0 = ((a >>> 7) | (a << 25)) ^ ((a >>> 18) | (a << 14)) ^ (a >>> 3);
|
|
const s1 = ((b >>> 17) | (b << 15)) ^ ((b >>> 19) | (b << 13)) ^ (b >>> 10);
|
|
words[index] = (words[index - 16] + s0 + words[index - 7] + s1) >>> 0;
|
|
}
|
|
let [a, b, c, d, e, f, g, h] = state;
|
|
for (let index = 0; index < 64; index++) {
|
|
const S1 = ((e >>> 6) | (e << 26)) ^ ((e >>> 11) | (e << 21)) ^ ((e >>> 25) | (e << 7));
|
|
const choose = (e & f) ^ (~e & g);
|
|
const temp1 = (h + S1 + choose + constants[index] + words[index]) >>> 0;
|
|
const S0 = ((a >>> 2) | (a << 30)) ^ ((a >>> 13) | (a << 19)) ^ ((a >>> 22) | (a << 10));
|
|
const majority = (a & b) ^ (a & c) ^ (b & c);
|
|
const temp2 = (S0 + majority) >>> 0;
|
|
h = g; g = f; f = e; e = (d + temp1) >>> 0; d = c; c = b; b = a; a = (temp1 + temp2) >>> 0;
|
|
}
|
|
state[0] = (state[0] + a) >>> 0; state[1] = (state[1] + b) >>> 0; state[2] = (state[2] + c) >>> 0; state[3] = (state[3] + d) >>> 0;
|
|
state[4] = (state[4] + e) >>> 0; state[5] = (state[5] + f) >>> 0; state[6] = (state[6] + g) >>> 0; state[7] = (state[7] + h) >>> 0;
|
|
}
|
|
return Array.from(state, (word) => word.toString(16).padStart(8, "0")).join("");
|
|
}
|
|
|
|
function issue(code: ErrorCode, message: string, path?: string): Issue {
|
|
return { code, message, path };
|
|
}
|
|
|
|
export function createShaderCompileKey(input: ShaderCompileKeyInput): string {
|
|
const textures = [...input.textures].sort((left, right) =>
|
|
`${left.usage}:${left.imageId}`.localeCompare(`${right.usage}:${right.imageId}`));
|
|
return fallbackGraphHash(JSON.stringify({
|
|
schemaVersion: SHADER_COMPILE_SCHEMA,
|
|
graphHash: input.graphHash,
|
|
rendererBackend: input.rendererBackend,
|
|
textures,
|
|
}));
|
|
}
|
|
|
|
function linkKey(nodeId: string, socket: string): string {
|
|
return `${nodeId}:${normalizeSocket(socket)}`;
|
|
}
|
|
|
|
function sourceLink(incoming: ReadonlyMap<string, MaterialLinkIR>, nodeId: string, socket: string): MaterialLinkIR | undefined {
|
|
return incoming.get(linkKey(nodeId, socket));
|
|
}
|
|
|
|
function isScalarSource(node: MaterialNodeIR | undefined): boolean {
|
|
return node?.type === "VALUE" || node?.type === "MATH";
|
|
}
|
|
|
|
function targetScalarSocket(socket: string): boolean {
|
|
return new Set(["roughness", "metallic", "alpha", "ior", "speculariorlevel", "transmissionweight", "coatweight", "coatroughness", "emissionstrength"]).has(normalizeSocket(socket));
|
|
}
|
|
|
|
function boundedMaterialValue(name: string, value: number): boolean {
|
|
if (!finite(value)) return false;
|
|
if (["roughness", "metallic", "alpha", "speculariorlevel", "transmissionweight", "coatweight", "coatroughness"].includes(name)) return value >= 0 && value <= 1;
|
|
if (name === "ior") return value >= 1 && value <= 2.333;
|
|
return value >= 0 && value <= 1_000_000;
|
|
}
|
|
|
|
export function compileMaterialGraph(material: MaterialIR, context: ShaderCompileContext = {}): ShaderCompileReport {
|
|
const nodes = material.nodes ?? [];
|
|
const links = material.links ?? [];
|
|
const graphHash = material.shaderGraphHash ?? (nodes.length > 0 ? fallbackGraphHash(canonicalGraph(material)) : null);
|
|
const base: ShaderCompileReport = {
|
|
schemaVersion: SHADER_COMPILE_SCHEMA,
|
|
taskId: SHADER_COMPILE_TASK,
|
|
backend: SHADER_COMPILE_BACKEND,
|
|
status: "BLOCKED",
|
|
materialId: material.id,
|
|
graphHash,
|
|
nodeOrder: [],
|
|
compileKey: null,
|
|
compiledNodeTypes: [],
|
|
textureBindings: [],
|
|
instructions: [],
|
|
issues: [],
|
|
};
|
|
if (nodes.length === 0) return {
|
|
...base,
|
|
status: "COMPILED",
|
|
issues: [],
|
|
material: {
|
|
baseColor: material.baseColor,
|
|
roughness: material.roughness,
|
|
metallic: material.metallic,
|
|
alpha: material.alpha,
|
|
ior: material.ior,
|
|
specularIORLevel: material.specularIORLevel,
|
|
transmissionWeight: material.transmissionWeight,
|
|
coatWeight: material.coatWeight,
|
|
coatRoughness: material.coatRoughness,
|
|
emissionStrength: material.emissionStrength,
|
|
emissionColor: material.emissionColor,
|
|
},
|
|
};
|
|
if (nodes.length > SHADER_COMPILE_BUDGET.maxNodes) base.issues.push(issue("SHADER_NODE_UNSUPPORTED", "Shader graph exceeds the bounded compiler node budget", "nodes"));
|
|
if (links.length > SHADER_COMPILE_BUDGET.maxLinks) base.issues.push(issue("SHADER_NODE_UNSUPPORTED", "Shader graph exceeds the bounded compiler link budget", "links"));
|
|
if (base.issues.length > 0) return base;
|
|
const rendererBackend = context.rendererBackend ?? SHADER_COMPILE_BACKEND;
|
|
if (rendererBackend !== SHADER_COMPILE_BACKEND) {
|
|
base.issues.push(issue("CAPABILITY_MISSING", `Shader backend is not available: ${rendererBackend}`, "rendererBackend"));
|
|
return base;
|
|
}
|
|
if (material.shaderGraphHash !== undefined && !/^[0-9a-f]{64}$/.test(material.shaderGraphHash)) base.issues.push(issue("SHADER_INVALID_GRAPH", "Shader graph hash is not a lowercase SHA-256 digest", "shaderGraphHash"));
|
|
if (!finiteColor(material.baseColor) || !finiteColor(material.emissionColor)) base.issues.push(issue("SHADER_INVALID_GRAPH", "Material color defaults are invalid", "material"));
|
|
for (const [field, value] of [["roughness", material.roughness], ["metallic", material.metallic], ["alpha", material.alpha], ["ior", material.ior]] as const) {
|
|
if (!boundedMaterialValue(normalizeSocket(field), value)) base.issues.push(issue("SHADER_INVALID_GRAPH", `Material ${field} default is outside the compiler range`, field));
|
|
}
|
|
const byId = new Map<string, MaterialNodeIR>();
|
|
for (const [index, node] of nodes.entries()) {
|
|
if (new TextEncoder().encode(node.id).byteLength === 0 || new TextEncoder().encode(node.id).byteLength > SHADER_COMPILE_BUDGET.maxIdentifierBytes) base.issues.push(issue("SHADER_INVALID_GRAPH", "Shader node ID is empty or oversized", `nodes.${index}.id`));
|
|
if (new TextEncoder().encode(node.name).byteLength === 0 || new TextEncoder().encode(node.name).byteLength > SHADER_COMPILE_BUDGET.maxNameBytes) base.issues.push(issue("SHADER_INVALID_GRAPH", "Shader node name is empty or oversized", `nodes.${index}.name`));
|
|
if (byId.has(node.id)) base.issues.push(issue("SHADER_INVALID_GRAPH", `duplicate shader node ID: ${node.id}`, `nodes.${index}.id`));
|
|
byId.set(node.id, node);
|
|
if (!(SHADER_COMPILE_ALLOWLIST as readonly string[]).includes(node.type)) base.issues.push(issue("SHADER_NODE_UNSUPPORTED", `shader node ${node.type} is outside the M10-07 compiler allowlist`, `nodes.${index}.type`));
|
|
if (node.type === "MATH" && !["ADD", "SUBTRACT", "MULTIPLY", "DIVIDE", "MINIMUM", "MAXIMUM"].includes(node.properties?.operation ?? "")) base.issues.push(issue("SHADER_NODE_UNSUPPORTED", "Math operation is outside the M10-07 compiler allowlist", `nodes.${index}.properties.operation`));
|
|
if (node.type !== "MATH" && node.properties && Object.keys(node.properties).length > 0) base.issues.push(issue("SHADER_NODE_UNSUPPORTED", `properties are not compiled for ${node.type}`, `nodes.${index}.properties`));
|
|
}
|
|
const incoming = new Map<string, MaterialLinkIR>();
|
|
const edges = new Map<string, string[]>();
|
|
for (const [index, link] of links.entries()) {
|
|
const from = byId.get(link.fromNodeId);
|
|
const to = byId.get(link.toNodeId);
|
|
if (!from || !to) {
|
|
base.issues.push(issue("SHADER_INVALID_GRAPH", "shader link references an unknown node", `links.${index}`));
|
|
continue;
|
|
}
|
|
const targetKey = linkKey(to.id, link.toSocket);
|
|
if (incoming.has(targetKey)) base.issues.push(issue("SHADER_INVALID_GRAPH", `shader input has more than one link: ${targetKey}`, `links.${index}`));
|
|
incoming.set(targetKey, link);
|
|
edges.set(from.id, [...(edges.get(from.id) ?? []), to.id]);
|
|
}
|
|
const state = new Map<string, 0 | 1 | 2>();
|
|
const order: string[] = [];
|
|
const visit = (id: string, depth: number): void => {
|
|
if (depth > SHADER_COMPILE_BUDGET.maxDepth) {
|
|
base.issues.push(issue("SHADER_NODE_UNSUPPORTED", "Shader graph exceeds the bounded compile depth", "links"));
|
|
return;
|
|
}
|
|
const current = state.get(id) ?? 0;
|
|
if (current === 2) return;
|
|
if (current === 1) {
|
|
base.issues.push(issue("SHADER_GRAPH_CYCLE", "Shader graph contains a cycle", "links"));
|
|
return;
|
|
}
|
|
state.set(id, 1);
|
|
for (const next of edges.get(id) ?? []) visit(next, depth + 1);
|
|
state.set(id, 2);
|
|
order.push(id);
|
|
};
|
|
for (const node of nodes) visit(node.id, 0);
|
|
base.nodeOrder = [...new Set(order.reverse())];
|
|
const outputs = nodes.filter((node) => node.type === "OUTPUT");
|
|
const principled = nodes.filter((node) => node.type === "PRINCIPLED");
|
|
if (outputs.length !== 1 || principled.length !== 1) base.issues.push(issue("SHADER_INVALID_GRAPH", "Compiled Shader graph requires exactly one Principled and one Output node", "nodes"));
|
|
const output = outputs[0];
|
|
const shader = principled[0];
|
|
if (output && shader && !sourceLink(incoming, output.id, "Surface")) base.issues.push(issue("SHADER_INVALID_GRAPH", "Material Output Surface is not connected", "links"));
|
|
const textures = new Map<string, { imageId: string; usage: "BASE_COLOR" | "NORMAL" }>();
|
|
const compiled: ShaderCompiledMaterial = {
|
|
baseColor: material.baseColor,
|
|
roughness: material.roughness,
|
|
metallic: material.metallic,
|
|
alpha: material.alpha,
|
|
ior: material.ior,
|
|
specularIORLevel: material.specularIORLevel,
|
|
transmissionWeight: material.transmissionWeight,
|
|
coatWeight: material.coatWeight,
|
|
coatRoughness: material.coatRoughness,
|
|
emissionStrength: material.emissionStrength,
|
|
emissionColor: material.emissionColor,
|
|
};
|
|
const evaluated = new Map<string, number>();
|
|
const evaluating = new Set<string>();
|
|
const evalScalar = (nodeId: string, depth: number): number | undefined => {
|
|
if (depth > SHADER_COMPILE_BUDGET.maxDepth) return undefined;
|
|
const cached = evaluated.get(nodeId);
|
|
if (cached !== undefined) return cached;
|
|
if (evaluating.has(nodeId)) return undefined;
|
|
const node = byId.get(nodeId);
|
|
if (!node) return undefined;
|
|
evaluating.add(nodeId);
|
|
let value: number | undefined;
|
|
if (node.type === "VALUE") {
|
|
value = node.defaultValue?.length === 1 && finite(node.defaultValue[0]) ? node.defaultValue[0] : undefined;
|
|
}
|
|
else if (node.type === "MATH") {
|
|
const first = sourceLink(incoming, node.id, "Value") ?? sourceLink(incoming, node.id, "A");
|
|
const second = sourceLink(incoming, node.id, "Value_001") ?? sourceLink(incoming, node.id, "B");
|
|
const left = first ? evalScalar(first.fromNodeId, depth + 1) : undefined;
|
|
const right = second ? evalScalar(second.fromNodeId, depth + 1) : undefined;
|
|
if (left !== undefined && right !== undefined) {
|
|
switch (node.properties?.operation) {
|
|
case "ADD": value = left + right; break;
|
|
case "SUBTRACT": value = left - right; break;
|
|
case "MULTIPLY": value = left * right; break;
|
|
case "DIVIDE": value = Math.abs(right) > 1e-12 ? left / right : undefined; break;
|
|
case "MINIMUM": value = Math.min(left, right); break;
|
|
case "MAXIMUM": value = Math.max(left, right); break;
|
|
}
|
|
}
|
|
}
|
|
evaluating.delete(nodeId);
|
|
if (value !== undefined && finite(value)) evaluated.set(nodeId, value);
|
|
return value;
|
|
};
|
|
const evalColor = (link: MaterialLinkIR): [number, number, number, number] | undefined => {
|
|
const node = byId.get(link.fromNodeId);
|
|
if (node?.type === "RGB" && finiteColor(node.defaultValue)) {
|
|
return [node.defaultValue[0], node.defaultValue[1], node.defaultValue[2], node.defaultValue[3] ?? 1];
|
|
}
|
|
if (node?.type === "IMAGE_TEXTURE" && node.imageId) {
|
|
if (context.imageIds && !context.imageIds.has(node.imageId)) {
|
|
base.issues.push(issue("SHADER_EXTERNAL_RESOURCE_MISSING", `shader image is not present: ${node.imageId}`, `nodes.${node.id}.imageId`));
|
|
}
|
|
if (context.blockedImageIds?.has(node.imageId)) base.issues.push(issue("SHADER_EXTERNAL_RESOURCE_MISSING", `shader image is blocked: ${node.imageId}`, `nodes.${node.id}.imageId`));
|
|
textures.set(`BASE_COLOR:${node.imageId}`, { imageId: node.imageId, usage: "BASE_COLOR" });
|
|
compiled.baseColorImageId = node.imageId;
|
|
return undefined;
|
|
}
|
|
return undefined;
|
|
};
|
|
if (shader) {
|
|
for (const [socket, field] of [["Roughness", "roughness"], ["Metallic", "metallic"], ["Alpha", "alpha"], ["IOR", "ior"], ["Specular IOR Level", "specularIORLevel"], ["Transmission Weight", "transmissionWeight"], ["Coat Weight", "coatWeight"], ["Coat Roughness", "coatRoughness"], ["Emission Strength", "emissionStrength"]] as const) {
|
|
const link = sourceLink(incoming, shader.id, socket);
|
|
if (!link) continue;
|
|
const value = evalScalar(link.fromNodeId, 0);
|
|
const normalized = normalizeSocket(field);
|
|
if (value === undefined || !boundedMaterialValue(normalized, value)) base.issues.push(issue("SHADER_INVALID_GRAPH", `${socket} input is not a finite bounded constant`, `links.${socket}`));
|
|
else (compiled as unknown as Record<string, unknown>)[field] = value;
|
|
}
|
|
const colorLink = sourceLink(incoming, shader.id, "Base Color");
|
|
if (colorLink) {
|
|
const color = evalColor(colorLink);
|
|
if (color) compiled.baseColor = color;
|
|
else if (byId.get(colorLink.fromNodeId)?.type !== "IMAGE_TEXTURE") base.issues.push(issue("SHADER_INVALID_GRAPH", "Base Color must be an RGB constant or Image Texture", "links.BaseColor"));
|
|
}
|
|
const normalLink = sourceLink(incoming, shader.id, "Normal");
|
|
if (normalLink) {
|
|
const normalNode = byId.get(normalLink.fromNodeId);
|
|
if (normalNode?.type !== "NORMAL_MAP") base.issues.push(issue("SHADER_NODE_UNSUPPORTED", "Principled Normal must be driven by the declared Normal Map node", "links.Normal"));
|
|
else {
|
|
const imageLink = sourceLink(incoming, normalNode.id, "Color");
|
|
const imageNode = imageLink ? byId.get(imageLink.fromNodeId) : undefined;
|
|
if (!imageLink || imageNode?.type !== "IMAGE_TEXTURE" || !imageNode.imageId) base.issues.push(issue("SHADER_INVALID_GRAPH", "Normal Map requires an Image Texture Color input", `nodes.${normalNode.id}`));
|
|
else {
|
|
if (context.imageIds && !context.imageIds.has(imageNode.imageId)) base.issues.push(issue("SHADER_EXTERNAL_RESOURCE_MISSING", `shader image is not present: ${imageNode.imageId}`, `nodes.${imageNode.id}.imageId`));
|
|
if (context.blockedImageIds?.has(imageNode.imageId)) base.issues.push(issue("SHADER_EXTERNAL_RESOURCE_MISSING", `shader image is blocked: ${imageNode.imageId}`, `nodes.${imageNode.id}.imageId`));
|
|
textures.set(`NORMAL:${imageNode.imageId}`, { imageId: imageNode.imageId, usage: "NORMAL" });
|
|
compiled.normalImageId = imageNode.imageId;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
const supportedLink = (link: MaterialLinkIR): boolean => {
|
|
const from = byId.get(link.fromNodeId);
|
|
const to = byId.get(link.toNodeId);
|
|
if (!from || !to) return false;
|
|
const fromSocket = normalizeSocket(link.fromSocket);
|
|
const toSocket = normalizeSocket(link.toSocket);
|
|
if (to.type === "OUTPUT") return from.type === "PRINCIPLED" && fromSocket === "bsdf" && toSocket === "surface";
|
|
if (to.type === "PRINCIPLED") {
|
|
if (toSocket === "basecolor") return (from.type === "RGB" && fromSocket === "color") || (from.type === "IMAGE_TEXTURE" && fromSocket === "color");
|
|
if (toSocket === "normal") return from.type === "NORMAL_MAP" && fromSocket === "normal";
|
|
return targetScalarSocket(toSocket) && isScalarSource(from) && (from.type !== "MATH" || fromSocket === "value");
|
|
}
|
|
if (to.type === "NORMAL_MAP") return from.type === "IMAGE_TEXTURE" && fromSocket === "color" && toSocket === "color";
|
|
if (to.type === "MATH") return isScalarSource(from) && scalarSocket(toSocket) && fromSocket === "value";
|
|
return false;
|
|
};
|
|
for (const [index, link] of links.entries()) if (!supportedLink(link)) base.issues.push(issue("SHADER_NODE_UNSUPPORTED", `Shader link is outside the M10-07 compiled closure: ${link.fromNodeId}.${link.fromSocket} -> ${link.toNodeId}.${link.toSocket}`, `links.${index}`));
|
|
base.textureBindings = [...textures.values()];
|
|
const textureKeys = base.textureBindings.map((binding) => {
|
|
const identity = context.textureIdentities?.get(binding.imageId);
|
|
const sha256 = identity?.sha256 ?? null;
|
|
if (sha256 !== null && !/^[0-9a-f]{64}$/.test(sha256)) {
|
|
base.issues.push(issue("SHADER_INVALID_GRAPH", `texture SHA-256 is invalid: ${binding.imageId}`, `textures.${binding.imageId}.sha256`));
|
|
}
|
|
return {
|
|
imageId: binding.imageId,
|
|
usage: binding.usage,
|
|
assetId: identity?.assetId ?? null,
|
|
sha256,
|
|
colorSpace: identity?.colorSpace ?? (binding.usage === "BASE_COLOR" ? "SRGB" : "NON_COLOR"),
|
|
};
|
|
});
|
|
base.compileKey = createShaderCompileKey({ graphHash, rendererBackend, textures: textureKeys });
|
|
if (base.textureBindings.length > SHADER_COMPILE_BUDGET.maxTextures) base.issues.push(issue("SHADER_NODE_UNSUPPORTED", "Shader graph exceeds the bounded texture binding budget", "nodes"));
|
|
base.compiledNodeTypes = [...new Set(nodes.map((node) => node.type).filter((type): type is CompileNodeType => (SHADER_COMPILE_ALLOWLIST as readonly string[]).includes(type)))];
|
|
base.instructions = base.nodeOrder.map((nodeId) => {
|
|
const node = byId.get(nodeId) as MaterialNodeIR;
|
|
return { nodeId, type: node.type as CompileNodeType, ...(node.type === "MATH" ? { operation: node.properties?.operation } : {}) };
|
|
});
|
|
if (base.issues.length > 0) return base;
|
|
return { ...base, status: "COMPILED", material: compiled };
|
|
}
|