@holoscript/engine 6.0.3 → 6.0.4

package/dist/shader/index.js

@@ -0,0 +1,3044 @@
+import "../chunk-AKLW2MUS.js";
+
+// src/shader/graph/ShaderGraphTypes.ts
+var TYPE_SIZES = {
+  float: 1,
+  vec2: 2,
+  vec3: 3,
+  vec4: 4,
+  mat2: 4,
+  mat3: 9,
+  mat4: 16,
+  int: 1,
+  ivec2: 2,
+  ivec3: 3,
+  ivec4: 4,
+  bool: 1,
+  sampler2D: 0,
+  samplerCube: 0
+};
+function areTypesCompatible(from, to) {
+  if (from === to) return true;
+  if (from === "sampler2D" || from === "samplerCube") return false;
+  if (to === "sampler2D" || to === "samplerCube") return false;
+  if (from === "float" && (to === "vec2" || to === "vec3" || to === "vec4")) return true;
+  if (from === "int" && to === "float") return true;
+  if (from === "vec3" && to === "vec4") return true;
+  if (from === "vec4" && to === "vec3") return true;
+  return false;
+}
+function getTypeConversion(from, to, expr) {
+  if (from === to) return expr;
+  if (from === "float") {
+    if (to === "vec2") return `vec2<f32>(${expr})`;
+    if (to === "vec3") return `vec3<f32>(${expr})`;
+    if (to === "vec4") return `vec4<f32>(${expr})`;
+  }
+  if (from === "int" && to === "float") return `f32(${expr})`;
+  if (from === "vec3" && to === "vec4") return `vec4<f32>(${expr}, 1.0)`;
+  if (from === "vec4" && to === "vec3") return `(${expr}).xyz`;
+  return expr;
+}
+var INPUT_NODES = [
+  {
+    type: "input_position",
+    name: "World Position",
+    category: "input",
+    description: "World space position",
+    inputs: [],
+    outputs: [{ id: "position", name: "Position", type: "vec3" }],
+    generateCode: () => "in.worldPosition"
+  },
+  {
+    type: "input_normal",
+    name: "World Normal",
+    category: "input",
+    description: "World space normal",
+    inputs: [],
+    outputs: [{ id: "normal", name: "Normal", type: "vec3" }],
+    generateCode: () => "in.worldNormal"
+  },
+  {
+    type: "input_uv",
+    name: "UV Coordinates",
+    category: "input",
+    description: "Texture coordinates",
+    inputs: [],
+    outputs: [{ id: "uv", name: "UV", type: "vec2" }],
+    generateCode: () => "in.uv"
+  },
+  {
+    type: "input_time",
+    name: "Time",
+    category: "input",
+    description: "Scene time in seconds",
+    inputs: [],
+    outputs: [{ id: "time", name: "Time", type: "float" }],
+    generateCode: () => "scene.time"
+  },
+  {
+    type: "input_camera_position",
+    name: "Camera Position",
+    category: "input",
+    description: "Camera world position",
+    inputs: [],
+    outputs: [{ id: "position", name: "Position", type: "vec3" }],
+    generateCode: () => "camera.position"
+  },
+  {
+    type: "input_view_direction",
+    name: "View Direction",
+    category: "input",
+    description: "Direction from surface to camera",
+    inputs: [],
+    outputs: [{ id: "direction", name: "Direction", type: "vec3" }],
+    generateCode: () => "normalize(camera.position - in.worldPosition)"
+  },
+  {
+    type: "constant_float",
+    name: "Float",
+    category: "input",
+    description: "Constant float value",
+    inputs: [],
+    outputs: [{ id: "value", name: "Value", type: "float" }],
+    defaultProperties: { value: 0 },
+    generateCode: (node) => `${node.properties?.value ?? 0}`
+  },
+  {
+    type: "constant_vec2",
+    name: "Vector2",
+    category: "input",
+    description: "Constant vec2 value",
+    inputs: [],
+    outputs: [{ id: "value", name: "Value", type: "vec2" }],
+    defaultProperties: { x: 0, y: 0 },
+    generateCode: (node) => {
+      const x = node.properties?.x ?? 0;
+      const y = node.properties?.y ?? 0;
+      return `vec2<f32>(${x}, ${y})`;
+    }
+  },
+  {
+    type: "constant_vec3",
+    name: "Vector3",
+    category: "input",
+    description: "Constant vec3 value",
+    inputs: [],
+    outputs: [{ id: "value", name: "Value", type: "vec3" }],
+    defaultProperties: { x: 0, y: 0, z: 0 },
+    generateCode: (node) => {
+      const x = node.properties?.x ?? 0;
+      const y = node.properties?.y ?? 0;
+      const z = node.properties?.z ?? 0;
+      return `vec3<f32>(${x}, ${y}, ${z})`;
+    }
+  },
+  {
+    type: "constant_color",
+    name: "Color",
+    category: "input",
+    description: "Constant color value",
+    inputs: [],
+    outputs: [{ id: "color", name: "Color", type: "vec4" }],
+    defaultProperties: { r: 1, g: 1, b: 1, a: 1 },
+    generateCode: (node) => {
+      const r = node.properties?.r ?? 1;
+      const g = node.properties?.g ?? 1;
+      const b = node.properties?.b ?? 1;
+      const a = node.properties?.a ?? 1;
+      return `vec4<f32>(${r}, ${g}, ${b}, ${a})`;
+    }
+  }
+];
+var MATH_NODES = [
+  {
+    type: "math_add",
+    name: "Add",
+    category: "math",
+    description: "Add two values",
+    inputs: [
+      { id: "a", name: "A", type: "float", defaultValue: 0 },
+      { id: "b", name: "B", type: "float", defaultValue: 0 }
+    ],
+    outputs: [{ id: "result", name: "Result", type: "float" }],
+    generateCode: (_, inputs) => `(${inputs.a} + ${inputs.b})`
+  },
+  {
+    type: "math_subtract",
+    name: "Subtract",
+    category: "math",
+    description: "Subtract two values",
+    inputs: [
+      { id: "a", name: "A", type: "float", defaultValue: 0 },
+      { id: "b", name: "B", type: "float", defaultValue: 0 }
+    ],
+    outputs: [{ id: "result", name: "Result", type: "float" }],
+    generateCode: (_, inputs) => `(${inputs.a} - ${inputs.b})`
+  },
+  {
+    type: "math_multiply",
+    name: "Multiply",
+    category: "math",
+    description: "Multiply two values",
+    inputs: [
+      { id: "a", name: "A", type: "float", defaultValue: 1 },
+      { id: "b", name: "B", type: "float", defaultValue: 1 }
+    ],
+    outputs: [{ id: "result", name: "Result", type: "float" }],
+    generateCode: (_, inputs) => `(${inputs.a} * ${inputs.b})`
+  },
+  {
+    type: "math_divide",
+    name: "Divide",
+    category: "math",
+    description: "Divide two values",
+    inputs: [
+      { id: "a", name: "A", type: "float", defaultValue: 1 },
+      { id: "b", name: "B", type: "float", defaultValue: 1 }
+    ],
+    outputs: [{ id: "result", name: "Result", type: "float" }],
+    generateCode: (_, inputs) => `(${inputs.a} / max(${inputs.b}, 0.0001))`
+  },
+  {
+    type: "math_power",
+    name: "Power",
+    category: "math",
+    description: "Raise to power",
+    inputs: [
+      { id: "base", name: "Base", type: "float", defaultValue: 2 },
+      { id: "exp", name: "Exponent", type: "float", defaultValue: 2 }
+    ],
+    outputs: [{ id: "result", name: "Result", type: "float" }],
+    generateCode: (_, inputs) => `pow(${inputs.base}, ${inputs.exp})`
+  },
+  {
+    type: "math_sqrt",
+    name: "Square Root",
+    category: "math",
+    description: "Square root",
+    inputs: [{ id: "value", name: "Value", type: "float", defaultValue: 1 }],
+    outputs: [{ id: "result", name: "Result", type: "float" }],
+    generateCode: (_, inputs) => `sqrt(max(${inputs.value}, 0.0))`
+  },
+  {
+    type: "math_abs",
+    name: "Absolute",
+    category: "math",
+    description: "Absolute value",
+    inputs: [{ id: "value", name: "Value", type: "float", defaultValue: 0 }],
+    outputs: [{ id: "result", name: "Result", type: "float" }],
+    generateCode: (_, inputs) => `abs(${inputs.value})`
+  },
+  {
+    type: "math_negate",
+    name: "Negate",
+    category: "math",
+    description: "Negate value",
+    inputs: [{ id: "value", name: "Value", type: "float", defaultValue: 0 }],
+    outputs: [{ id: "result", name: "Result", type: "float" }],
+    generateCode: (_, inputs) => `(-${inputs.value})`
+  },
+  {
+    type: "math_min",
+    name: "Minimum",
+    category: "math",
+    description: "Minimum of two values",
+    inputs: [
+      { id: "a", name: "A", type: "float", defaultValue: 0 },
+      { id: "b", name: "B", type: "float", defaultValue: 0 }
+    ],
+    outputs: [{ id: "result", name: "Result", type: "float" }],
+    generateCode: (_, inputs) => `min(${inputs.a}, ${inputs.b})`
+  },
+  {
+    type: "math_max",
+    name: "Maximum",
+    category: "math",
+    description: "Maximum of two values",
+    inputs: [
+      { id: "a", name: "A", type: "float", defaultValue: 0 },
+      { id: "b", name: "B", type: "float", defaultValue: 0 }
+    ],
+    outputs: [{ id: "result", name: "Result", type: "float" }],
+    generateCode: (_, inputs) => `max(${inputs.a}, ${inputs.b})`
+  },
+  {
+    type: "math_clamp",
+    name: "Clamp",
+    category: "math",
+    description: "Clamp value between min and max",
+    inputs: [
+      { id: "value", name: "Value", type: "float", defaultValue: 0 },
+      { id: "min", name: "Min", type: "float", defaultValue: 0 },
+      { id: "max", name: "Max", type: "float", defaultValue: 1 }
+    ],
+    outputs: [{ id: "result", name: "Result", type: "float" }],
+    generateCode: (_, inputs) => `clamp(${inputs.value}, ${inputs.min}, ${inputs.max})`
+  },
+  {
+    type: "math_saturate",
+    name: "Saturate",
+    category: "math",
+    description: "Clamp between 0 and 1",
+    inputs: [{ id: "value", name: "Value", type: "float", defaultValue: 0 }],
+    outputs: [{ id: "result", name: "Result", type: "float" }],
+    generateCode: (_, inputs) => `saturate(${inputs.value})`
+  },
+  {
+    type: "math_lerp",
+    name: "Lerp",
+    category: "math",
+    description: "Linear interpolation",
+    inputs: [
+      { id: "a", name: "A", type: "float", defaultValue: 0 },
+      { id: "b", name: "B", type: "float", defaultValue: 1 },
+      { id: "t", name: "T", type: "float", defaultValue: 0.5 }
+    ],
+    outputs: [{ id: "result", name: "Result", type: "float" }],
+    generateCode: (_, inputs) => `mix(${inputs.a}, ${inputs.b}, ${inputs.t})`
+  },
+  {
+    type: "math_smoothstep",
+    name: "Smoothstep",
+    category: "math",
+    description: "Smooth Hermite interpolation",
+    inputs: [
+      { id: "edge0", name: "Edge0", type: "float", defaultValue: 0 },
+      { id: "edge1", name: "Edge1", type: "float", defaultValue: 1 },
+      { id: "x", name: "X", type: "float", defaultValue: 0.5 }
+    ],
+    outputs: [{ id: "result", name: "Result", type: "float" }],
+    generateCode: (_, inputs) => `smoothstep(${inputs.edge0}, ${inputs.edge1}, ${inputs.x})`
+  },
+  {
+    type: "math_step",
+    name: "Step",
+    category: "math",
+    description: "Step function",
+    inputs: [
+      { id: "edge", name: "Edge", type: "float", defaultValue: 0.5 },
+      { id: "x", name: "X", type: "float", defaultValue: 0 }
+    ],
+    outputs: [{ id: "result", name: "Result", type: "float" }],
+    generateCode: (_, inputs) => `step(${inputs.edge}, ${inputs.x})`
+  },
+  {
+    type: "math_fract",
+    name: "Fraction",
+    category: "math",
+    description: "Fractional part",
+    inputs: [{ id: "value", name: "Value", type: "float", defaultValue: 0 }],
+    outputs: [{ id: "result", name: "Result", type: "float" }],
+    generateCode: (_, inputs) => `fract(${inputs.value})`
+  },
+  {
+    type: "math_floor",
+    name: "Floor",
+    category: "math",
+    description: "Floor value",
+    inputs: [{ id: "value", name: "Value", type: "float", defaultValue: 0 }],
+    outputs: [{ id: "result", name: "Result", type: "float" }],
+    generateCode: (_, inputs) => `floor(${inputs.value})`
+  },
+  {
+    type: "math_ceil",
+    name: "Ceiling",
+    category: "math",
+    description: "Ceiling value",
+    inputs: [{ id: "value", name: "Value", type: "float", defaultValue: 0 }],
+    outputs: [{ id: "result", name: "Result", type: "float" }],
+    generateCode: (_, inputs) => `ceil(${inputs.value})`
+  },
+  {
+    type: "math_round",
+    name: "Round",
+    category: "math",
+    description: "Round value",
+    inputs: [{ id: "value", name: "Value", type: "float", defaultValue: 0 }],
+    outputs: [{ id: "result", name: "Result", type: "float" }],
+    generateCode: (_, inputs) => `round(${inputs.value})`
+  },
+  {
+    type: "math_mod",
+    name: "Modulo",
+    category: "math",
+    description: "Modulo operation",
+    inputs: [
+      { id: "a", name: "A", type: "float", defaultValue: 0 },
+      { id: "b", name: "B", type: "float", defaultValue: 1 }
+    ],
+    outputs: [{ id: "result", name: "Result", type: "float" }],
+    generateCode: (_, inputs) => `(${inputs.a} % ${inputs.b})`
+  }
+];
+var TRIG_NODES = [
+  {
+    type: "trig_sin",
+    name: "Sine",
+    category: "math",
+    description: "Sine function",
+    inputs: [{ id: "angle", name: "Angle", type: "float", defaultValue: 0 }],
+    outputs: [{ id: "result", name: "Result", type: "float" }],
+    generateCode: (_, inputs) => `sin(${inputs.angle})`
+  },
+  {
+    type: "trig_cos",
+    name: "Cosine",
+    category: "math",
+    description: "Cosine function",
+    inputs: [{ id: "angle", name: "Angle", type: "float", defaultValue: 0 }],
+    outputs: [{ id: "result", name: "Result", type: "float" }],
+    generateCode: (_, inputs) => `cos(${inputs.angle})`
+  },
+  {
+    type: "trig_tan",
+    name: "Tangent",
+    category: "math",
+    description: "Tangent function",
+    inputs: [{ id: "angle", name: "Angle", type: "float", defaultValue: 0 }],
+    outputs: [{ id: "result", name: "Result", type: "float" }],
+    generateCode: (_, inputs) => `tan(${inputs.angle})`
+  },
+  {
+    type: "trig_asin",
+    name: "Arcsine",
+    category: "math",
+    description: "Arcsine function",
+    inputs: [{ id: "value", name: "Value", type: "float", defaultValue: 0 }],
+    outputs: [{ id: "result", name: "Result", type: "float" }],
+    generateCode: (_, inputs) => `asin(${inputs.value})`
+  },
+  {
+    type: "trig_acos",
+    name: "Arccosine",
+    category: "math",
+    description: "Arccosine function",
+    inputs: [{ id: "value", name: "Value", type: "float", defaultValue: 0 }],
+    outputs: [{ id: "result", name: "Result", type: "float" }],
+    generateCode: (_, inputs) => `acos(${inputs.value})`
+  },
+  {
+    type: "trig_atan",
+    name: "Arctangent",
+    category: "math",
+    description: "Arctangent function",
+    inputs: [{ id: "value", name: "Value", type: "float", defaultValue: 0 }],
+    outputs: [{ id: "result", name: "Result", type: "float" }],
+    generateCode: (_, inputs) => `atan(${inputs.value})`
+  },
+  {
+    type: "trig_atan2",
+    name: "Arctangent2",
+    category: "math",
+    description: "Two-argument arctangent",
+    inputs: [
+      { id: "y", name: "Y", type: "float", defaultValue: 0 },
+      { id: "x", name: "X", type: "float", defaultValue: 1 }
+    ],
+    outputs: [{ id: "result", name: "Result", type: "float" }],
+    generateCode: (_, inputs) => `atan2(${inputs.y}, ${inputs.x})`
+  },
+  {
+    type: "trig_radians",
+    name: "Degrees to Radians",
+    category: "math",
+    description: "Convert degrees to radians",
+    inputs: [{ id: "degrees", name: "Degrees", type: "float", defaultValue: 0 }],
+    outputs: [{ id: "result", name: "Radians", type: "float" }],
+    generateCode: (_, inputs) => `radians(${inputs.degrees})`
+  },
+  {
+    type: "trig_degrees",
+    name: "Radians to Degrees",
+    category: "math",
+    description: "Convert radians to degrees",
+    inputs: [{ id: "radians", name: "Radians", type: "float", defaultValue: 0 }],
+    outputs: [{ id: "result", name: "Degrees", type: "float" }],
+    generateCode: (_, inputs) => `degrees(${inputs.radians})`
+  }
+];
+var VECTOR_NODES = [
+  {
+    type: "vector_make_vec2",
+    name: "Make Vec2",
+    category: "vector",
+    description: "Create vec2 from components",
+    inputs: [
+      { id: "x", name: "X", type: "float", defaultValue: 0 },
+      { id: "y", name: "Y", type: "float", defaultValue: 0 }
+    ],
+    outputs: [{ id: "vector", name: "Vector", type: "vec2" }],
+    generateCode: (_, inputs) => `vec2<f32>(${inputs.x}, ${inputs.y})`
+  },
+  {
+    type: "vector_make_vec3",
+    name: "Make Vec3",
+    category: "vector",
+    description: "Create vec3 from components",
+    inputs: [
+      { id: "x", name: "X", type: "float", defaultValue: 0 },
+      { id: "y", name: "Y", type: "float", defaultValue: 0 },
+      { id: "z", name: "Z", type: "float", defaultValue: 0 }
+    ],
+    outputs: [{ id: "vector", name: "Vector", type: "vec3" }],
+    generateCode: (_, inputs) => `vec3<f32>(${inputs.x}, ${inputs.y}, ${inputs.z})`
+  },
+  {
+    type: "vector_make_vec4",
+    name: "Make Vec4",
+    category: "vector",
+    description: "Create vec4 from components",
+    inputs: [
+      { id: "x", name: "X", type: "float", defaultValue: 0 },
+      { id: "y", name: "Y", type: "float", defaultValue: 0 },
+      { id: "z", name: "Z", type: "float", defaultValue: 0 },
+      { id: "w", name: "W", type: "float", defaultValue: 1 }
+    ],
+    outputs: [{ id: "vector", name: "Vector", type: "vec4" }],
+    generateCode: (_, inputs) => `vec4<f32>(${inputs.x}, ${inputs.y}, ${inputs.z}, ${inputs.w})`
+  },
+  {
+    type: "vector_split_vec2",
+    name: "Split Vec2",
+    category: "vector",
+    description: "Split vec2 into components",
+    inputs: [{ id: "vector", name: "Vector", type: "vec2", defaultValue: [0, 0] }],
+    outputs: [
+      { id: "x", name: "X", type: "float" },
+      { id: "y", name: "Y", type: "float" }
+    ],
+    generateCode: (_, inputs) => inputs.vector
+  },
+  {
+    type: "vector_split_vec3",
+    name: "Split Vec3",
+    category: "vector",
+    description: "Split vec3 into components",
+    inputs: [{ id: "vector", name: "Vector", type: "vec3", defaultValue: [0, 0, 0] }],
+    outputs: [
+      { id: "x", name: "X", type: "float" },
+      { id: "y", name: "Y", type: "float" },
+      { id: "z", name: "Z", type: "float" }
+    ],
+    generateCode: (_, inputs) => inputs.vector
+  },
+  {
+    type: "vector_split_vec4",
+    name: "Split Vec4",
+    category: "vector",
+    description: "Split vec4 into components",
+    inputs: [{ id: "vector", name: "Vector", type: "vec4", defaultValue: [0, 0, 0, 1] }],
+    outputs: [
+      { id: "x", name: "X", type: "float" },
+      { id: "y", name: "Y", type: "float" },
+      { id: "z", name: "Z", type: "float" },
+      { id: "w", name: "W", type: "float" }
+    ],
+    generateCode: (_, inputs) => inputs.vector
+  },
+  {
+    type: "vector_normalize",
+    name: "Normalize",
+    category: "vector",
+    description: "Normalize vector",
+    inputs: [{ id: "vector", name: "Vector", type: "vec3", defaultValue: [1, 0, 0] }],
+    outputs: [{ id: "result", name: "Result", type: "vec3" }],
+    generateCode: (_, inputs) => `normalize(${inputs.vector})`
+  },
+  {
+    type: "vector_length",
+    name: "Length",
+    category: "vector",
+    description: "Vector length",
+    inputs: [{ id: "vector", name: "Vector", type: "vec3", defaultValue: [0, 0, 0] }],
+    outputs: [{ id: "length", name: "Length", type: "float" }],
+    generateCode: (_, inputs) => `length(${inputs.vector})`
+  },
+  {
+    type: "vector_distance",
+    name: "Distance",
+    category: "vector",
+    description: "Distance between vectors",
+    inputs: [
+      { id: "a", name: "A", type: "vec3", defaultValue: [0, 0, 0] },
+      { id: "b", name: "B", type: "vec3", defaultValue: [0, 0, 0] }
+    ],
+    outputs: [{ id: "distance", name: "Distance", type: "float" }],
+    generateCode: (_, inputs) => `distance(${inputs.a}, ${inputs.b})`
+  },
+  {
+    type: "vector_dot",
+    name: "Dot Product",
+    category: "vector",
+    description: "Dot product",
+    inputs: [
+      { id: "a", name: "A", type: "vec3", defaultValue: [1, 0, 0] },
+      { id: "b", name: "B", type: "vec3", defaultValue: [1, 0, 0] }
+    ],
+    outputs: [{ id: "result", name: "Result", type: "float" }],
+    generateCode: (_, inputs) => `dot(${inputs.a}, ${inputs.b})`
+  },
+  {
+    type: "vector_cross",
+    name: "Cross Product",
+    category: "vector",
+    description: "Cross product",
+    inputs: [
+      { id: "a", name: "A", type: "vec3", defaultValue: [1, 0, 0] },
+      { id: "b", name: "B", type: "vec3", defaultValue: [0, 1, 0] }
+    ],
+    outputs: [{ id: "result", name: "Result", type: "vec3" }],
+    generateCode: (_, inputs) => `cross(${inputs.a}, ${inputs.b})`
+  },
+  {
+    type: "vector_reflect",
+    name: "Reflect",
+    category: "vector",
+    description: "Reflect vector",
+    inputs: [
+      { id: "incident", name: "Incident", type: "vec3", defaultValue: [1, 0, 0] },
+      { id: "normal", name: "Normal", type: "vec3", defaultValue: [0, 1, 0] }
+    ],
+    outputs: [{ id: "result", name: "Result", type: "vec3" }],
+    generateCode: (_, inputs) => `reflect(${inputs.incident}, ${inputs.normal})`
+  },
+  {
+    type: "vector_refract",
+    name: "Refract",
+    category: "vector",
+    description: "Refract vector",
+    inputs: [
+      { id: "incident", name: "Incident", type: "vec3", defaultValue: [1, 0, 0] },
+      { id: "normal", name: "Normal", type: "vec3", defaultValue: [0, 1, 0] },
+      { id: "eta", name: "Eta", type: "float", defaultValue: 1 }
+    ],
+    outputs: [{ id: "result", name: "Result", type: "vec3" }],
+    generateCode: (_, inputs) => `refract(${inputs.incident}, ${inputs.normal}, ${inputs.eta})`
+  }
+];
+var COLOR_NODES = [
+  {
+    type: "color_blend",
+    name: "Blend",
+    category: "color",
+    description: "Blend two colors",
+    inputs: [
+      { id: "a", name: "A", type: "vec4", defaultValue: [0, 0, 0, 1] },
+      { id: "b", name: "B", type: "vec4", defaultValue: [1, 1, 1, 1] },
+      { id: "factor", name: "Factor", type: "float", defaultValue: 0.5 }
+    ],
+    outputs: [{ id: "result", name: "Result", type: "vec4" }],
+    generateCode: (_, inputs) => `mix(${inputs.a}, ${inputs.b}, ${inputs.factor})`
+  },
+  {
+    type: "color_hue_shift",
+    name: "Hue Shift",
+    category: "color",
+    description: "Shift hue of color",
+    inputs: [
+      { id: "color", name: "Color", type: "vec3", defaultValue: [1, 0, 0] },
+      { id: "shift", name: "Shift", type: "float", defaultValue: 0 }
+    ],
+    outputs: [{ id: "result", name: "Result", type: "vec3" }],
+    generateCode: (_, inputs) => `hueShift(${inputs.color}, ${inputs.shift})`
+  },
+  {
+    type: "color_saturation",
+    name: "Saturation",
+    category: "color",
+    description: "Adjust color saturation",
+    inputs: [
+      { id: "color", name: "Color", type: "vec3", defaultValue: [1, 0.5, 0.5] },
+      { id: "saturation", name: "Saturation", type: "float", defaultValue: 1 }
+    ],
+    outputs: [{ id: "result", name: "Result", type: "vec3" }],
+    generateCode: (_, inputs) => {
+      return `mix(vec3<f32>(dot(${inputs.color}, vec3<f32>(0.299, 0.587, 0.114))), ${inputs.color}, ${inputs.saturation})`;
+    }
+  },
+  {
+    type: "color_brightness",
+    name: "Brightness",
+    category: "color",
+    description: "Adjust color brightness",
+    inputs: [
+      { id: "color", name: "Color", type: "vec3", defaultValue: [0.5, 0.5, 0.5] },
+      { id: "brightness", name: "Brightness", type: "float", defaultValue: 1 }
+    ],
+    outputs: [{ id: "result", name: "Result", type: "vec3" }],
+    generateCode: (_, inputs) => `(${inputs.color} * ${inputs.brightness})`
+  },
+  {
+    type: "color_contrast",
+    name: "Contrast",
+    category: "color",
+    description: "Adjust color contrast",
+    inputs: [
+      { id: "color", name: "Color", type: "vec3", defaultValue: [0.5, 0.5, 0.5] },
+      { id: "contrast", name: "Contrast", type: "float", defaultValue: 1 }
+    ],
+    outputs: [{ id: "result", name: "Result", type: "vec3" }],
+    generateCode: (_, inputs) => `((${inputs.color} - vec3<f32>(0.5)) * ${inputs.contrast} + vec3<f32>(0.5))`
+  },
+  {
+    type: "color_invert",
+    name: "Invert",
+    category: "color",
+    description: "Invert color",
+    inputs: [{ id: "color", name: "Color", type: "vec3", defaultValue: [0.5, 0.5, 0.5] }],
+    outputs: [{ id: "result", name: "Result", type: "vec3" }],
+    generateCode: (_, inputs) => `(vec3<f32>(1.0) - ${inputs.color})`
+  },
+  {
+    type: "color_grayscale",
+    name: "Grayscale",
+    category: "color",
+    description: "Convert to grayscale",
+    inputs: [{ id: "color", name: "Color", type: "vec3", defaultValue: [1, 0, 0] }],
+    outputs: [{ id: "result", name: "Gray", type: "float" }],
+    generateCode: (_, inputs) => `dot(${inputs.color}, vec3<f32>(0.299, 0.587, 0.114))`
+  }
+];
+var TEXTURE_NODES = [
+  {
+    type: "texture_sample",
+    name: "Sample Texture",
+    category: "texture",
+    description: "Sample a 2D texture",
+    inputs: [
+      { id: "texture", name: "Texture", type: "sampler2D" },
+      { id: "uv", name: "UV", type: "vec2", defaultValue: [0, 0] }
+    ],
+    outputs: [{ id: "color", name: "Color", type: "vec4" }],
+    generateCode: (node, inputs) => {
+      const textureId = node.properties?.textureId ?? "defaultTexture";
+      return `textureSample(${textureId}, ${textureId}Sampler, ${inputs.uv})`;
+    }
+  },
+  {
+    type: "texture_sample_level",
+    name: "Sample Texture Level",
+    category: "texture",
+    description: "Sample texture at specific mip level",
+    inputs: [
+      { id: "texture", name: "Texture", type: "sampler2D" },
+      { id: "uv", name: "UV", type: "vec2", defaultValue: [0, 0] },
+      { id: "level", name: "Level", type: "float", defaultValue: 0 }
+    ],
+    outputs: [{ id: "color", name: "Color", type: "vec4" }],
+    generateCode: (node, inputs) => {
+      const textureId = node.properties?.textureId ?? "defaultTexture";
+      return `textureSampleLevel(${textureId}, ${textureId}Sampler, ${inputs.uv}, ${inputs.level})`;
+    }
+  },
+  {
+    type: "texture_tiling_offset",
+    name: "Tiling and Offset",
+    category: "texture",
+    description: "Apply tiling and offset to UVs",
+    inputs: [
+      { id: "uv", name: "UV", type: "vec2", defaultValue: [0, 0] },
+      { id: "tiling", name: "Tiling", type: "vec2", defaultValue: [1, 1] },
+      { id: "offset", name: "Offset", type: "vec2", defaultValue: [0, 0] }
+    ],
+    outputs: [{ id: "result", name: "Result", type: "vec2" }],
+    generateCode: (_, inputs) => `(${inputs.uv} * ${inputs.tiling} + ${inputs.offset})`
+  }
+];
+var UTILITY_NODES = [
+  {
+    type: "utility_fresnel",
+    name: "Fresnel",
+    category: "utility",
+    description: "Fresnel effect",
+    inputs: [
+      { id: "normal", name: "Normal", type: "vec3", defaultValue: [0, 1, 0] },
+      { id: "viewDir", name: "View Dir", type: "vec3", defaultValue: [0, 0, 1] },
+      { id: "power", name: "Power", type: "float", defaultValue: 5 }
+    ],
+    outputs: [{ id: "result", name: "Result", type: "float" }],
+    generateCode: (_, inputs) => `pow(1.0 - saturate(dot(${inputs.normal}, ${inputs.viewDir})), ${inputs.power})`
+  },
+  {
+    type: "utility_noise_simple",
+    name: "Simple Noise",
+    category: "utility",
+    description: "Simple value noise",
+    inputs: [{ id: "uv", name: "UV", type: "vec2", defaultValue: [0, 0] }],
+    outputs: [{ id: "noise", name: "Noise", type: "float" }],
+    generateCode: (_, inputs) => `simpleNoise(${inputs.uv})`
+  },
+  {
+    type: "utility_gradient_noise",
+    name: "Gradient Noise",
+    category: "utility",
+    description: "Perlin-like gradient noise",
+    inputs: [{ id: "uv", name: "UV", type: "vec2", defaultValue: [0, 0] }],
+    outputs: [{ id: "noise", name: "Noise", type: "float" }],
+    generateCode: (_, inputs) => `gradientNoise(${inputs.uv})`
+  },
+  {
+    type: "utility_voronoi",
+    name: "Voronoi",
+    category: "utility",
+    description: "Voronoi noise",
+    inputs: [
+      { id: "uv", name: "UV", type: "vec2", defaultValue: [0, 0] },
+      { id: "scale", name: "Scale", type: "float", defaultValue: 5 }
+    ],
+    outputs: [
+      { id: "cells", name: "Cells", type: "float" },
+      { id: "distance", name: "Distance", type: "float" }
+    ],
+    generateCode: (_, inputs) => `voronoi(${inputs.uv} * ${inputs.scale})`
+  },
+  {
+    type: "utility_remap",
+    name: "Remap",
+    category: "utility",
+    description: "Remap value from one range to another",
+    inputs: [
+      { id: "value", name: "Value", type: "float", defaultValue: 0 },
+      { id: "inMin", name: "In Min", type: "float", defaultValue: 0 },
+      { id: "inMax", name: "In Max", type: "float", defaultValue: 1 },
+      { id: "outMin", name: "Out Min", type: "float", defaultValue: 0 },
+      { id: "outMax", name: "Out Max", type: "float", defaultValue: 1 }
+    ],
+    outputs: [{ id: "result", name: "Result", type: "float" }],
+    generateCode: (_, inputs) => {
+      return `(${inputs.outMin} + (${inputs.value} - ${inputs.inMin}) * (${inputs.outMax} - ${inputs.outMin}) / (${inputs.inMax} - ${inputs.inMin}))`;
+    }
+  },
+  {
+    type: "utility_if",
+    name: "Branch",
+    category: "utility",
+    description: "Conditional selection",
+    inputs: [
+      { id: "condition", name: "Condition", type: "float", defaultValue: 0 },
+      { id: "true", name: "True", type: "float", defaultValue: 1 },
+      { id: "false", name: "False", type: "float", defaultValue: 0 }
+    ],
+    outputs: [{ id: "result", name: "Result", type: "float" }],
+    generateCode: (_, inputs) => `select(${inputs.false}, ${inputs.true}, ${inputs.condition} > 0.5)`
+  },
+  {
+    type: "utility_compare",
+    name: "Compare",
+    category: "utility",
+    description: "Compare two values",
+    inputs: [
+      { id: "a", name: "A", type: "float", defaultValue: 0 },
+      { id: "b", name: "B", type: "float", defaultValue: 0 }
+    ],
+    outputs: [
+      { id: "equal", name: "A == B", type: "float" },
+      { id: "less", name: "A < B", type: "float" },
+      { id: "greater", name: "A > B", type: "float" }
+    ],
+    generateCode: (_, inputs) => `compareValues(${inputs.a}, ${inputs.b})`
+  }
+];
+var ADVANCED_MATERIAL_NODES = [
+  {
+    type: "blackbody",
+    name: "Blackbody Radiation",
+    category: "material",
+    description: "Convert temperature (Kelvin) to emission color via Planck approximation",
+    inputs: [
+      { id: "temperature", name: "Temperature K", type: "float", defaultValue: 5500 },
+      { id: "intensity", name: "Intensity", type: "float", defaultValue: 1 }
+    ],
+    outputs: [{ id: "color", name: "Color", type: "vec3" }],
+    generateCode: (_, inputs) => `blackbodyColor(${inputs.temperature}, ${inputs.intensity})`
+  },
+  {
+    type: "sparkle",
+    name: "Sparkle / Glitter",
+    category: "material",
+    description: "Stochastic micro-facet flashing for glitter, metallic paint, mica",
+    inputs: [
+      { id: "uv", name: "UV", type: "vec2", defaultValue: [0, 0] },
+      { id: "density", name: "Density", type: "float", defaultValue: 50 },
+      { id: "size", name: "Size", type: "float", defaultValue: 0.02 },
+      { id: "intensity", name: "Intensity", type: "float", defaultValue: 1 },
+      { id: "viewDir", name: "View Dir", type: "vec3", defaultValue: [0, 0, 1] },
+      { id: "normal", name: "Normal", type: "vec3", defaultValue: [0, 0, 1] }
+    ],
+    outputs: [
+      { id: "flash", name: "Flash", type: "float" },
+      { id: "color", name: "Color", type: "vec3" }
+    ],
+    generateCode: (_, inputs) => `sparkleFlash(${inputs.uv}, ${inputs.density}, ${inputs.size}, ${inputs.intensity}, ${inputs.viewDir}, ${inputs.normal})`
+  },
+  {
+    type: "animated_pattern",
+    name: "Animated Pattern",
+    category: "material",
+    description: "Time-varying surface patterns: ripple, flicker, pulse, flow, wave, noise",
+    inputs: [
+      { id: "uv", name: "UV", type: "vec2", defaultValue: [0, 0] },
+      { id: "time", name: "Time", type: "float", defaultValue: 0 },
+      { id: "patternType", name: "Pattern (0-7)", type: "float", defaultValue: 0 },
+      { id: "speed", name: "Speed", type: "float", defaultValue: 1 },
+      { id: "amplitude", name: "Amplitude", type: "float", defaultValue: 1 },
+      { id: "scale", name: "Scale", type: "float", defaultValue: 1 }
+    ],
+    outputs: [
+      { id: "value", name: "Value", type: "float" },
+      { id: "offset", name: "UV Offset", type: "vec2" }
+    ],
+    generateCode: (_, inputs) => `animatedPattern(${inputs.uv}, ${inputs.time}, ${inputs.patternType}, ${inputs.speed}, ${inputs.amplitude}, ${inputs.scale})`
+  },
+  {
+    type: "weathering",
+    name: "Weathering",
+    category: "material",
+    description: "Procedural surface degradation: rust, moss, crack, peel, patina, frost",
+    inputs: [
+      { id: "uv", name: "UV", type: "vec2", defaultValue: [0, 0] },
+      { id: "progress", name: "Progress", type: "float", defaultValue: 0 },
+      { id: "weatherType", name: "Type (0-9)", type: "float", defaultValue: 0 },
+      { id: "seed", name: "Seed", type: "float", defaultValue: 42 },
+      { id: "baseColor", name: "Base Color", type: "vec3", defaultValue: [1, 1, 1] }
+    ],
+    outputs: [
+      { id: "color", name: "Weathered Color", type: "vec3" },
+      { id: "mask", name: "Mask", type: "float" },
+      { id: "roughnessMod", name: "Roughness Mod", type: "float" }
+    ],
+    generateCode: (_, inputs) => `weatheringSurface(${inputs.uv}, ${inputs.progress}, ${inputs.weatherType}, ${inputs.seed}, ${inputs.baseColor})`
+  },
+  {
+    type: "dual_layer_blend",
+    name: "Dual Layer Blend",
+    category: "material",
+    description: "Blend two material layers (paint over rust, moss over stone, snow on branches)",
+    inputs: [
+      { id: "baseColor", name: "Base Color", type: "vec3", defaultValue: [0.5, 0.5, 0.5] },
+      { id: "baseRoughness", name: "Base Rough", type: "float", defaultValue: 0.5 },
+      { id: "baseMetallic", name: "Base Metal", type: "float", defaultValue: 0 },
+      { id: "topColor", name: "Top Color", type: "vec3", defaultValue: [1, 1, 1] },
+      { id: "topRoughness", name: "Top Rough", type: "float", defaultValue: 0.5 },
+      { id: "topMetallic", name: "Top Metal", type: "float", defaultValue: 0 },
+      { id: "blendFactor", name: "Blend", type: "float", defaultValue: 0.5 },
+      { id: "blendMode", name: "Mode (0-3)", type: "float", defaultValue: 0 },
+      { id: "normal", name: "Normal", type: "vec3", defaultValue: [0, 0, 1] },
+      { id: "uv", name: "UV", type: "vec2", defaultValue: [0, 0] }
+    ],
+    outputs: [
+      { id: "color", name: "Color", type: "vec3" },
+      { id: "roughness", name: "Roughness", type: "float" },
+      { id: "metallic", name: "Metallic", type: "float" }
+    ],
+    generateCode: (_, inputs) => `dualLayerBlend(${inputs.baseColor}, ${inputs.baseRoughness}, ${inputs.baseMetallic}, ${inputs.topColor}, ${inputs.topRoughness}, ${inputs.topMetallic}, ${inputs.blendFactor}, ${inputs.blendMode}, ${inputs.normal}, ${inputs.uv})`
+  },
+  {
+    type: "fluorescence",
+    name: "Fluorescence",
+    category: "material",
+    description: "UV-reactive emission: absorb short wavelengths, emit longer ones",
+    inputs: [
+      { id: "lightColor", name: "Light Color", type: "vec3", defaultValue: [1, 1, 1] },
+      { id: "excitationColor", name: "Excitation", type: "vec3", defaultValue: [0.2, 0, 0.5] },
+      { id: "emissionColor", name: "Emission", type: "vec3", defaultValue: [0, 1, 0] },
+      { id: "intensity", name: "Intensity", type: "float", defaultValue: 1 }
+    ],
+    outputs: [{ id: "emission", name: "Emission", type: "vec3" }],
+    generateCode: (_, inputs) => `fluorescenceEmit(${inputs.lightColor}, ${inputs.excitationColor}, ${inputs.emissionColor}, ${inputs.intensity})`
+  },
+  {
+    type: "retroreflection",
+    name: "Retroreflection",
+    category: "material",
+    description: "Light bounces back toward source (road signs, safety vests, cat eyes)",
+    inputs: [
+      { id: "viewDir", name: "View Dir", type: "vec3", defaultValue: [0, 0, 1] },
+      { id: "lightDir", name: "Light Dir", type: "vec3", defaultValue: [0, 1, 0] },
+      { id: "normal", name: "Normal", type: "vec3", defaultValue: [0, 0, 1] },
+      { id: "intensity", name: "Intensity", type: "float", defaultValue: 1 }
+    ],
+    outputs: [{ id: "reflectance", name: "Reflectance", type: "float" }],
+    generateCode: (_, inputs) => `retroReflect(${inputs.viewDir}, ${inputs.lightDir}, ${inputs.normal}, ${inputs.intensity})`
+  }
+];
+var VOLUMETRIC_NODES = [
+  {
+    type: "volume_density",
+    name: "Volume Density",
+    category: "volumetric",
+    description: "Sample/generate volume density at a 3D position",
+    inputs: [
+      { id: "position", name: "Position", type: "vec3", defaultValue: [0, 0, 0] },
+      { id: "baseDensity", name: "Base Density", type: "float", defaultValue: 0.5 },
+      { id: "noiseScale", name: "Noise Scale", type: "float", defaultValue: 4 },
+      { id: "noiseOctaves", name: "Octaves", type: "float", defaultValue: 4 },
+      { id: "time", name: "Time", type: "float", defaultValue: 0 }
+    ],
+    outputs: [{ id: "density", name: "Density", type: "float" }],
+    generateCode: (_, inputs) => `volumeDensity(${inputs.position}, ${inputs.baseDensity}, ${inputs.noiseScale}, ${inputs.noiseOctaves}, ${inputs.time})`
+  },
+  {
+    type: "volume_noise_3d",
+    name: "3D FBM Noise",
+    category: "volumetric",
+    description: "Fractal Brownian motion noise in 3D for volumetric density",
+    inputs: [
+      { id: "position", name: "Position", type: "vec3", defaultValue: [0, 0, 0] },
+      { id: "octaves", name: "Octaves", type: "float", defaultValue: 4 },
+      { id: "lacunarity", name: "Lacunarity", type: "float", defaultValue: 2 },
+      { id: "gain", name: "Gain", type: "float", defaultValue: 0.5 }
+    ],
+    outputs: [{ id: "noise", name: "Noise", type: "float" }],
+    generateCode: (_, inputs) => `fbmNoise3D(${inputs.position}, i32(${inputs.octaves}), ${inputs.lacunarity}, ${inputs.gain})`
+  },
+  {
+    type: "volume_curl_noise",
+    name: "Curl Noise 3D",
+    category: "volumetric",
+    description: "Divergence-free curl noise for smoke/fire turbulence",
+    inputs: [
+      { id: "position", name: "Position", type: "vec3", defaultValue: [0, 0, 0] },
+      { id: "scale", name: "Scale", type: "float", defaultValue: 1 }
+    ],
+    outputs: [{ id: "curl", name: "Curl", type: "vec3" }],
+    generateCode: (_, inputs) => `curlNoise3D(${inputs.position} * ${inputs.scale})`
+  },
+  {
+    type: "volume_scatter",
+    name: "Volume Scattering",
+    category: "volumetric",
+    description: "Beer-Lambert absorption + Henyey-Greenstein phase function",
+    inputs: [
+      { id: "density", name: "Density", type: "float", defaultValue: 0.5 },
+      { id: "scattering", name: "Scattering", type: "float", defaultValue: 0.5 },
+      { id: "absorption", name: "Absorption", type: "float", defaultValue: 0.1 },
+      { id: "stepLength", name: "Step Length", type: "float", defaultValue: 0.1 },
+      { id: "lightDir", name: "Light Dir", type: "vec3", defaultValue: [0, 1, 0] },
+      { id: "viewDir", name: "View Dir", type: "vec3", defaultValue: [0, 0, 1] },
+      { id: "anisotropy", name: "Phase Aniso", type: "float", defaultValue: 0.3 }
+    ],
+    outputs: [
+      { id: "transmittance", name: "Transmittance", type: "float" },
+      { id: "inScatter", name: "In-Scatter", type: "float" }
+    ],
+    generateCode: (_, inputs) => `volumeScatter(${inputs.density}, ${inputs.scattering}, ${inputs.absorption}, ${inputs.stepLength}, ${inputs.lightDir}, ${inputs.viewDir}, ${inputs.anisotropy})`
+  },
+  {
+    type: "volume_emission",
+    name: "Volume Emission",
+    category: "volumetric",
+    description: "Self-luminous volume contribution (fire, neon gas, aurora)",
+    inputs: [
+      { id: "density", name: "Density", type: "float", defaultValue: 0.5 },
+      { id: "emissionColor", name: "Emission Color", type: "vec3", defaultValue: [1, 0.5, 0] },
+      { id: "intensity", name: "Intensity", type: "float", defaultValue: 1 },
+      { id: "temperature", name: "Temperature K", type: "float", defaultValue: 0 }
+    ],
+    outputs: [{ id: "emission", name: "Emission", type: "vec3" }],
+    generateCode: (_, inputs) => `volumeEmission(${inputs.density}, ${inputs.emissionColor}, ${inputs.intensity}, ${inputs.temperature})`
+  },
+  {
+    type: "volume_height_fog",
+    name: "Height Fog",
+    category: "volumetric",
+    description: "Height-attenuated fog density with exponential falloff",
+    inputs: [
+      { id: "position", name: "Position", type: "vec3", defaultValue: [0, 0, 0] },
+      { id: "groundLevel", name: "Ground Y", type: "float", defaultValue: 0 },
+      { id: "density", name: "Density", type: "float", defaultValue: 0.5 },
+      { id: "falloff", name: "Falloff", type: "float", defaultValue: 2 }
+    ],
+    outputs: [{ id: "density", name: "Density", type: "float" }],
+    generateCode: (_, inputs) => `heightFogDensity(${inputs.position}, ${inputs.groundLevel}, ${inputs.density}, ${inputs.falloff})`
+  },
+  {
+    type: "volume_fire_density",
+    name: "Fire Density",
+    category: "volumetric",
+    description: "Fire-specific density: buoyancy, turbulence, temperature \u2192 emission",
+    inputs: [
+      { id: "position", name: "Position", type: "vec3", defaultValue: [0, 0, 0] },
+      { id: "time", name: "Time", type: "float", defaultValue: 0 },
+      { id: "turbulence", name: "Turbulence", type: "float", defaultValue: 0.5 },
+      { id: "riseSpeed", name: "Rise Speed", type: "float", defaultValue: 1 },
+      { id: "scale", name: "Scale", type: "float", defaultValue: 2 }
+    ],
+    outputs: [
+      { id: "density", name: "Density", type: "float" },
+      { id: "temperature", name: "Temperature", type: "float" }
+    ],
+    generateCode: (_, inputs) => `fireDensity(${inputs.position}, ${inputs.time}, ${inputs.turbulence}, ${inputs.riseSpeed}, ${inputs.scale})`
+  }
+];
+var OUTPUT_NODES = [
+  {
+    type: "output_surface",
+    name: "Surface Output",
+    category: "output",
+    description: "PBR surface output with SSS, sheen, anisotropy, clearcoat, iridescence",
+    inputs: [
+      { id: "baseColor", name: "Base Color", type: "vec3", defaultValue: [1, 1, 1] },
+      { id: "metallic", name: "Metallic", type: "float", defaultValue: 0 },
+      { id: "roughness", name: "Roughness", type: "float", defaultValue: 0.5 },
+      { id: "normal", name: "Normal", type: "vec3", defaultValue: [0, 0, 1] },
+      { id: "emission", name: "Emission", type: "vec3", defaultValue: [0, 0, 0] },
+      { id: "alpha", name: "Alpha", type: "float", defaultValue: 1 },
+      { id: "ao", name: "AO", type: "float", defaultValue: 1 },
+      // Advanced PBR
+      { id: "sheenColor", name: "Sheen Color", type: "vec3", defaultValue: [0, 0, 0] },
+      { id: "sheenRoughness", name: "Sheen Roughness", type: "float", defaultValue: 0 },
+      { id: "subsurfaceThickness", name: "SSS Thickness", type: "float", defaultValue: 0 },
+      { id: "subsurfaceColor", name: "SSS Color", type: "vec3", defaultValue: [1, 1, 1] },
+      { id: "anisotropy", name: "Anisotropy", type: "float", defaultValue: 0 },
+      { id: "anisotropyRotation", name: "Aniso Rotation", type: "float", defaultValue: 0 },
+      { id: "clearcoat", name: "Clearcoat", type: "float", defaultValue: 0 },
+      { id: "clearcoatRoughness", name: "Clearcoat Rough", type: "float", defaultValue: 0 },
+      { id: "iridescence", name: "Iridescence", type: "float", defaultValue: 0 },
+      // Exotic optics
+      { id: "sparkleIntensity", name: "Sparkle", type: "float", defaultValue: 0 },
+      { id: "sparkleDensity", name: "Sparkle Density", type: "float", defaultValue: 0 },
+      { id: "fluorescenceColor", name: "Fluorescence", type: "vec3", defaultValue: [0, 0, 0] },
+      { id: "fluorescenceIntensity", name: "Fluor Intensity", type: "float", defaultValue: 0 },
+      { id: "blackbodyTemp", name: "Blackbody K", type: "float", defaultValue: 0 },
+      { id: "retroreflection", name: "Retroreflect", type: "float", defaultValue: 0 }
+    ],
+    outputs: [],
+    generateCode: (_, inputs) => {
+      return `SurfaceOutput(
+        ${inputs.baseColor},
+        ${inputs.metallic},
+        ${inputs.roughness},
+        ${inputs.normal},
+        ${inputs.emission},
+        ${inputs.alpha},
+        ${inputs.ao},
+        ${inputs.sheenColor},
+        ${inputs.sheenRoughness},
+        ${inputs.subsurfaceThickness},
+        ${inputs.subsurfaceColor},
+        ${inputs.anisotropy},
+        ${inputs.anisotropyRotation},
+        ${inputs.clearcoat},
+        ${inputs.clearcoatRoughness},
+        ${inputs.iridescence},
+        ${inputs.sparkleIntensity},
+        ${inputs.sparkleDensity},
+        ${inputs.fluorescenceColor},
+        ${inputs.fluorescenceIntensity},
+        ${inputs.blackbodyTemp},
+        ${inputs.retroreflection}
+      )`;
+    }
+  },
+  {
+    type: "output_unlit",
+    name: "Unlit Output",
+    category: "output",
+    description: "Unlit color output",
+    inputs: [{ id: "color", name: "Color", type: "vec4", defaultValue: [1, 1, 1, 1] }],
+    outputs: [],
+    generateCode: (_, inputs) => `${inputs.color}`
+  },
+  {
+    type: "output_vertex_offset",
+    name: "Vertex Offset",
+    category: "output",
+    description: "Vertex position offset",
+    inputs: [{ id: "offset", name: "Offset", type: "vec3", defaultValue: [0, 0, 0] }],
+    outputs: [],
+    generateCode: (_, inputs) => inputs.offset
+  },
+  {
+    type: "output_volume",
+    name: "Volume Output",
+    category: "output",
+    description: "Volumetric output \u2014 ray-marched density, color, emission, scattering",
+    inputs: [
+      { id: "density", name: "Density", type: "float", defaultValue: 0.5 },
+      { id: "color", name: "Color", type: "vec3", defaultValue: [1, 1, 1] },
+      { id: "emission", name: "Emission", type: "vec3", defaultValue: [0, 0, 0] },
+      { id: "scattering", name: "Scattering", type: "float", defaultValue: 0.5 },
+      { id: "absorption", name: "Absorption", type: "float", defaultValue: 0.1 },
+      { id: "steps", name: "Steps", type: "float", defaultValue: 64 },
+      { id: "maxDistance", name: "Max Dist", type: "float", defaultValue: 10 }
+    ],
+    outputs: [],
+    generateCode: (_, inputs) => {
+      return `VolumeOutput(
+        ${inputs.density},
+        ${inputs.color},
+        ${inputs.emission},
+        ${inputs.scattering},
+        ${inputs.absorption},
+        ${inputs.steps},
+        ${inputs.maxDistance}
+      )`;
+    }
+  }
+];
+var SCREEN_SPACE_NODES = [
+  {
+    type: "caustics",
+    name: "Caustics",
+    category: "material",
+    description: "Underwater caustic light patterns from refracted light",
+    inputs: [
+      { id: "position", name: "Position", type: "vec3", defaultValue: [0, 0, 0] },
+      { id: "time", name: "Time", type: "float", defaultValue: 0 },
+      { id: "scale", name: "Scale", type: "float", defaultValue: 1 },
+      { id: "speed", name: "Speed", type: "float", defaultValue: 1 },
+      { id: "intensity", name: "Intensity", type: "float", defaultValue: 1 },
+      { id: "color", name: "Color", type: "vec3", defaultValue: [0.2, 0.5, 0.8] }
+    ],
+    outputs: [
+      { id: "caustic", name: "Caustic", type: "vec3" },
+      { id: "mask", name: "Mask", type: "float" }
+    ],
+    generateCode: (_, inputs) => `causticPattern(${inputs.position}, ${inputs.time}, ${inputs.scale}, ${inputs.speed}, ${inputs.intensity}, ${inputs.color})`
+  },
+  {
+    type: "displacement_map",
+    name: "Displacement Map",
+    category: "material",
+    description: "Vertex displacement from height/normal map",
+    inputs: [
+      { id: "position", name: "Position", type: "vec3", defaultValue: [0, 0, 0] },
+      { id: "normal", name: "Normal", type: "vec3", defaultValue: [0, 1, 0] },
+      { id: "height", name: "Height", type: "float", defaultValue: 0 },
+      { id: "strength", name: "Strength", type: "float", defaultValue: 1 },
+      { id: "midLevel", name: "Mid Level", type: "float", defaultValue: 0.5 }
+    ],
+    outputs: [{ id: "displaced", name: "Displaced", type: "vec3" }],
+    generateCode: (_, inputs) => `displacementMap(${inputs.position}, ${inputs.normal}, ${inputs.height}, ${inputs.strength}, ${inputs.midLevel})`
+  },
+  {
+    type: "parallax_occlusion",
+    name: "Parallax Occlusion",
+    category: "material",
+    description: "Parallax occlusion mapping for depth illusion without extra geometry",
+    inputs: [
+      { id: "uv", name: "UV", type: "vec2", defaultValue: [0, 0] },
+      { id: "viewDir", name: "View Dir", type: "vec3", defaultValue: [0, 0, 1] },
+      { id: "heightScale", name: "Height Scale", type: "float", defaultValue: 0.05 },
+      { id: "numLayers", name: "Layers", type: "float", defaultValue: 32 }
+    ],
+    outputs: [
+      { id: "adjustedUV", name: "Adjusted UV", type: "vec2" },
+      { id: "depth", name: "Depth", type: "float" }
+    ],
+    generateCode: (_, inputs) => `parallaxOcclusionMap(${inputs.uv}, ${inputs.viewDir}, ${inputs.heightScale}, ${inputs.numLayers})`
+  },
+  {
+    type: "screen_space_reflection",
+    name: "Screen Space Reflection",
+    category: "material",
+    description: "SSR \u2014 ray-marched reflections in screen space",
+    inputs: [
+      { id: "uv", name: "UV", type: "vec2", defaultValue: [0, 0] },
+      { id: "normal", name: "Normal", type: "vec3", defaultValue: [0, 1, 0] },
+      { id: "viewDir", name: "View Dir", type: "vec3", defaultValue: [0, 0, 1] },
+      { id: "roughness", name: "Roughness", type: "float", defaultValue: 0.1 },
+      { id: "maxSteps", name: "Max Steps", type: "float", defaultValue: 64 },
+      { id: "stepSize", name: "Step Size", type: "float", defaultValue: 0.1 }
+    ],
+    outputs: [
+      { id: "reflection", name: "Reflection", type: "vec3" },
+      { id: "hitMask", name: "Hit Mask", type: "float" }
+    ],
+    generateCode: (_, inputs) => `screenSpaceReflect(${inputs.uv}, ${inputs.normal}, ${inputs.viewDir}, ${inputs.roughness}, ${inputs.maxSteps}, ${inputs.stepSize})`
+  },
+  {
+    type: "screen_space_gi",
+    name: "Screen Space GI",
+    category: "material",
+    description: "Approximate global illumination from screen-space data",
+    inputs: [
+      { id: "uv", name: "UV", type: "vec2", defaultValue: [0, 0] },
+      { id: "normal", name: "Normal", type: "vec3", defaultValue: [0, 1, 0] },
+      { id: "radius", name: "Radius", type: "float", defaultValue: 1 },
+      { id: "samples", name: "Samples", type: "float", defaultValue: 16 },
+      { id: "bounceIntensity", name: "Bounce", type: "float", defaultValue: 1 }
+    ],
+    outputs: [{ id: "indirectLight", name: "Indirect", type: "vec3" }],
+    generateCode: (_, inputs) => `screenSpaceGI(${inputs.uv}, ${inputs.normal}, ${inputs.radius}, ${inputs.samples}, ${inputs.bounceIntensity})`
+  },
+  {
+    type: "water_surface",
+    name: "Water Surface",
+    category: "material",
+    description: "Combined water surface effect with waves, refraction, foam, and caustics",
+    inputs: [
+      { id: "position", name: "Position", type: "vec3", defaultValue: [0, 0, 0] },
+      { id: "time", name: "Time", type: "float", defaultValue: 0 },
+      { id: "waveScale", name: "Wave Scale", type: "float", defaultValue: 1 },
+      { id: "waveSpeed", name: "Wave Speed", type: "float", defaultValue: 1 },
+      { id: "depth", name: "Water Depth", type: "float", defaultValue: 5 },
+      { id: "foamThreshold", name: "Foam Thresh", type: "float", defaultValue: 0.7 }
+    ],
+    outputs: [
+      { id: "displacement", name: "Displacement", type: "vec3" },
+      { id: "normal", name: "Normal", type: "vec3" },
+      { id: "foam", name: "Foam", type: "float" },
+      { id: "caustic", name: "Caustic", type: "float" }
+    ],
+    generateCode: (_, inputs) => `waterSurface(${inputs.position}, ${inputs.time}, ${inputs.waveScale}, ${inputs.waveSpeed}, ${inputs.depth}, ${inputs.foamThreshold})`
+  },
+  {
+    type: "caustics_refractive",
+    name: "Refractive Caustics",
+    category: "material",
+    description: "Chromatic refractive caustics with RGB dispersion for prismatic light patterns",
+    inputs: [
+      { id: "position", name: "Position", type: "vec3", defaultValue: [0, 0, 0] },
+      { id: "time", name: "Time", type: "float", defaultValue: 0 },
+      { id: "scale", name: "Scale", type: "float", defaultValue: 1 },
+      { id: "speed", name: "Speed", type: "float", defaultValue: 1 },
+      { id: "intensity", name: "Intensity", type: "float", defaultValue: 1 },
+      { id: "dispersion", name: "Dispersion", type: "float", defaultValue: 0.05 }
+    ],
+    outputs: [
+      { id: "caustic", name: "Caustic", type: "vec3" },
+      { id: "mask", name: "Mask", type: "float" }
+    ],
+    generateCode: (_, inputs) => `causticChromatic(${inputs.position}, ${inputs.time}, ${inputs.scale}, ${inputs.speed}, ${inputs.intensity}, ${inputs.dispersion})`
+  },
+  {
+    type: "displacement_enhanced",
+    name: "Enhanced Displacement",
+    category: "material",
+    description: "Displacement with reconstructed normal and optional anisotropic weighting",
+    inputs: [
+      { id: "position", name: "Position", type: "vec3", defaultValue: [0, 0, 0] },
+      { id: "normal", name: "Normal", type: "vec3", defaultValue: [0, 1, 0] },
+      { id: "tangent", name: "Tangent", type: "vec3", defaultValue: [1, 0, 0] },
+      { id: "height", name: "Height", type: "float", defaultValue: 0 },
+      { id: "strength", name: "Strength", type: "float", defaultValue: 1 },
+      { id: "anisotropy", name: "Anisotropy", type: "float", defaultValue: 0 },
+      { id: "midLevel", name: "Mid Level", type: "float", defaultValue: 0.5 }
+    ],
+    outputs: [
+      { id: "displaced", name: "Displaced", type: "vec3" },
+      { id: "reconstructedNormal", name: "Normal", type: "vec3" }
+    ],
+    generateCode: (_, inputs) => `anisotropicDisplacement(${inputs.position}, ${inputs.normal}, ${inputs.tangent}, ${inputs.height}, ${inputs.strength}, ${inputs.anisotropy}, ${inputs.midLevel})`
+  },
+  {
+    type: "underwater_foam",
+    name: "Underwater Foam",
+    category: "material",
+    description: "Procedural underwater foam patches driven by turbulence",
+    inputs: [
+      { id: "position", name: "Position", type: "vec3", defaultValue: [0, 0, 0] },
+      { id: "time", name: "Time", type: "float", defaultValue: 0 },
+      { id: "scale", name: "Scale", type: "float", defaultValue: 1 },
+      { id: "threshold", name: "Threshold", type: "float", defaultValue: 0.6 }
+    ],
+    outputs: [{ id: "foam", name: "Foam", type: "float" }],
+    generateCode: (_, inputs) => `underwaterFoam(${inputs.position}, ${inputs.time}, ${inputs.scale}, ${inputs.threshold})`
+  }
+];
+var ALL_NODE_TEMPLATES = [
+  ...INPUT_NODES,
+  ...MATH_NODES,
+  ...TRIG_NODES,
+  ...VECTOR_NODES,
+  ...COLOR_NODES,
+  ...TEXTURE_NODES,
+  ...UTILITY_NODES,
+  ...ADVANCED_MATERIAL_NODES,
+  ...VOLUMETRIC_NODES,
+  ...SCREEN_SPACE_NODES,
+  ...OUTPUT_NODES
+];
+function getNodeTemplate(type) {
+  return ALL_NODE_TEMPLATES.find((t) => t.type === type);
+}
+
+// src/shader/graph/ShaderGraph.ts
+var ShaderGraph = class _ShaderGraph {
+  id;
+  name;
+  description;
+  nodes;
+  connections;
+  version = "1.0.0";
+  metadata;
+  nodeCounter = 0;
+  connectionCounter = 0;
+  constructor(name, id) {
+    this.id = id ?? this.generateId("graph");
+    this.name = name ?? "Untitled Shader";
+    this.nodes = /* @__PURE__ */ new Map();
+    this.connections = [];
+  }
+  /**
+   * Generate unique ID
+   */
+  generateId(prefix) {
+    return `${prefix}_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+  }
+  /**
+   * Create a node from a template
+   */
+  createNode(type, position = { x: 0, y: 0 }) {
+    const template = getNodeTemplate(type);
+    if (!template) {
+      console.warn(`Unknown node type: ${type}`);
+      return null;
+    }
+    const nodeId = `node_${++this.nodeCounter}`;
+    const node = {
+      id: nodeId,
+      type: template.type,
+      name: template.name,
+      category: template.category,
+      inputs: template.inputs.map((input) => ({
+        ...input,
+        direction: "input"
+      })),
+      outputs: template.outputs.map((output) => ({
+        ...output,
+        direction: "output"
+      })),
+      position,
+      properties: template.defaultProperties ? { ...template.defaultProperties } : void 0
+    };
+    this.nodes.set(nodeId, node);
+    return node;
+  }
+  /**
+   * Add a custom node
+   */
+  addCustomNode(node) {
+    const nodeId = `node_${++this.nodeCounter}`;
+    const fullNode = {
+      ...node,
+      id: nodeId
+    };
+    this.nodes.set(nodeId, fullNode);
+    return fullNode;
+  }
+  /**
+   * Get a node by ID
+   */
+  getNode(nodeId) {
+    return this.nodes.get(nodeId);
+  }
+  /**
+   * Remove a node by ID
+   */
+  removeNode(nodeId) {
+    const node = this.nodes.get(nodeId);
+    if (!node) return false;
+    this.connections = this.connections.filter(
+      (conn) => conn.fromNode !== nodeId && conn.toNode !== nodeId
+    );
+    return this.nodes.delete(nodeId);
+  }
+  /**
+   * Update node position
+   */
+  setNodePosition(nodeId, x, y) {
+    const node = this.nodes.get(nodeId);
+    if (!node) return false;
+    node.position = { x, y };
+    return true;
+  }
+  /**
+   * Update node property
+   */
+  setNodeProperty(nodeId, key, value) {
+    const node = this.nodes.get(nodeId);
+    if (!node) return false;
+    if (!node.properties) node.properties = {};
+    node.properties[key] = value;
+    return true;
+  }
+  /**
+   * Get node property
+   */
+  getNodeProperty(nodeId, key) {
+    const node = this.nodes.get(nodeId);
+    return node?.properties?.[key];
+  }
+  /**
+   * Connect two ports
+   */
+  connect(fromNodeId, fromPortId, toNodeId, toPortId) {
+    const fromNode = this.nodes.get(fromNodeId);
+    const toNode = this.nodes.get(toNodeId);
+    if (!fromNode || !toNode) {
+      console.warn("Invalid node IDs for connection");
+      return null;
+    }
+    const fromPort = fromNode.outputs.find((p) => p.id === fromPortId);
+    const toPort = toNode.inputs.find((p) => p.id === toPortId);
+    if (!fromPort || !toPort) {
+      console.warn("Invalid port IDs for connection");
+      return null;
+    }
+    if (!areTypesCompatible(fromPort.type, toPort.type)) {
+      console.warn(`Type mismatch: ${fromPort.type} -> ${toPort.type}`);
+      return null;
+    }
+    const existingIdx = this.connections.findIndex(
+      (c) => c.toNode === toNodeId && c.toPort === toPortId
+    );
+    if (existingIdx >= 0) {
+      const existing = this.connections[existingIdx];
+      this.disconnectPort(existing.toNode, existing.toPort);
+      this.connections.splice(existingIdx, 1);
+    }
+    if (this.wouldCreateCycle(fromNodeId, toNodeId)) {
+      console.warn("Connection would create a cycle");
+      return null;
+    }
+    const connection = {
+      id: `conn_${++this.connectionCounter}`,
+      fromNode: fromNodeId,
+      fromPort: fromPortId,
+      toNode: toNodeId,
+      toPort: toPortId
+    };
+    this.connections.push(connection);
+    toPort.connected = {
+      nodeId: fromNodeId,
+      portId: fromPortId
+    };
+    return connection;
+  }
+  /**
+   * Disconnect a port
+   */
+  disconnectPort(nodeId, portId) {
+    const node = this.nodes.get(nodeId);
+    if (!node) return false;
+    const inputPort = node.inputs.find((p) => p.id === portId);
+    if (inputPort) {
+      inputPort.connected = void 0;
+    }
+    const initialLength = this.connections.length;
+    this.connections = this.connections.filter(
+      (c) => !(c.toNode === nodeId && c.toPort === portId) && !(c.fromNode === nodeId && c.fromPort === portId)
+    );
+    return this.connections.length !== initialLength;
+  }
+  /**
+   * Get all connections for a node
+   */
+  getNodeConnections(nodeId) {
+    return this.connections.filter((c) => c.fromNode === nodeId || c.toNode === nodeId);
+  }
+  /**
+   * Get input connections for a node
+   */
+  getInputConnections(nodeId) {
+    return this.connections.filter((c) => c.toNode === nodeId);
+  }
+  /**
+   * Get output connections for a node
+   */
+  getOutputConnections(nodeId) {
+    return this.connections.filter((c) => c.fromNode === nodeId);
+  }
+  /**
+   * Check if connection would create a cycle
+   */
+  wouldCreateCycle(fromNodeId, toNodeId) {
+    if (fromNodeId === toNodeId) return true;
+    const visited = /* @__PURE__ */ new Set();
+    const queue = [toNodeId];
+    while (queue.length > 0) {
+      const current = queue.shift();
+      if (current === fromNodeId) return true;
+      if (visited.has(current)) continue;
+      visited.add(current);
+      const outputConnections = this.getOutputConnections(current);
+      for (const conn of outputConnections) {
+        queue.push(conn.toNode);
+      }
+    }
+    return false;
+  }
+  /**
+   * Get nodes by category
+   */
+  getNodesByCategory(category) {
+    return Array.from(this.nodes.values()).filter((n) => n.category === category);
+  }
+  /**
+   * Get all output nodes
+   */
+  getOutputNodes() {
+    return this.getNodesByCategory("output");
+  }
+  /**
+   * Get topologically sorted nodes (dependency order)
+   */
+  getTopologicalOrder() {
+    const sorted = [];
+    const visited = /* @__PURE__ */ new Set();
+    const visiting = /* @__PURE__ */ new Set();
+    const visit = (nodeId) => {
+      if (visited.has(nodeId)) return true;
+      if (visiting.has(nodeId)) return false;
+      visiting.add(nodeId);
+      const node = this.nodes.get(nodeId);
+      if (!node) return true;
+      const inputConns = this.getInputConnections(nodeId);
+      for (const conn of inputConns) {
+        if (!visit(conn.fromNode)) return false;
+      }
+      visiting.delete(nodeId);
+      visited.add(nodeId);
+      sorted.push(node);
+      return true;
+    };
+    const outputNodes = this.getOutputNodes();
+    for (const output of outputNodes) {
+      visit(output.id);
+    }
+    for (const node of this.nodes.values()) {
+      visit(node.id);
+    }
+    return sorted;
+  }
+  /**
+   * Validate the graph
+   */
+  validate() {
+    const errors = [];
+    const warnings = [];
+    const outputNodes = this.getOutputNodes();
+    if (outputNodes.length === 0) {
+      errors.push("Graph has no output nodes");
+    }
+    for (const node of this.nodes.values()) {
+      for (const input of node.inputs) {
+        if (input.required && !input.connected && input.defaultValue === void 0) {
+          errors.push(
+            `Node "${node.name}" (${node.id}): Required input "${input.name}" is not connected`
+          );
+        }
+      }
+    }
+    for (const node of this.nodes.values()) {
+      if (node.category !== "output") {
+        const connections = this.getNodeConnections(node.id);
+        if (connections.length === 0) {
+          warnings.push(`Node "${node.name}" (${node.id}) is not connected to anything`);
+        }
+      }
+    }
+    return {
+      valid: errors.length === 0,
+      errors,
+      warnings
+    };
+  }
+  /**
+   * Clear the graph
+   */
+  clear() {
+    this.nodes.clear();
+    this.connections = [];
+    this.nodeCounter = 0;
+    this.connectionCounter = 0;
+  }
+  /**
+   * Duplicate a node
+   */
+  duplicateNode(nodeId, offset = { x: 50, y: 50 }) {
+    const original = this.nodes.get(nodeId);
+    if (!original) return null;
+    const duplicate = {
+      type: original.type,
+      name: original.name,
+      category: original.category,
+      inputs: original.inputs.map((i) => ({ ...i, connected: void 0 })),
+      outputs: original.outputs.map((o) => ({ ...o })),
+      position: {
+        x: original.position.x + offset.x,
+        y: original.position.y + offset.y
+      },
+      properties: original.properties ? { ...original.properties } : void 0,
+      preview: original.preview
+    };
+    return this.addCustomNode(duplicate);
+  }
+  /**
+   * Get available node templates
+   */
+  static getAvailableNodeTemplates() {
+    return ALL_NODE_TEMPLATES;
+  }
+  /**
+   * Get node templates by category
+   */
+  static getNodeTemplatesByCategory(category) {
+    return ALL_NODE_TEMPLATES.filter((t) => t.category === category);
+  }
+  /**
+   * Serialize to JSON
+   */
+  toJSON() {
+    return {
+      id: this.id,
+      name: this.name,
+      description: this.description,
+      version: this.version,
+      metadata: this.metadata,
+      nodes: Array.from(this.nodes.entries()).map(([id, node]) => {
+        const { id: _nodeId, ...rest } = node;
+        return {
+          id,
+          ...rest
+        };
+      }),
+      connections: this.connections
+    };
+  }
+  /**
+   * Deserialize from JSON
+   */
+  static fromJSON(json) {
+    const graph = new _ShaderGraph(json.name, json.id);
+    graph.description = json.description;
+    graph.version = json.version ?? "1.0.0";
+    graph.metadata = json.metadata;
+    for (const nodeData of json.nodes) {
+      graph.nodes.set(nodeData.id, nodeData);
+    }
+    graph.connections = json.connections ?? [];
+    return graph;
+  }
+  /**
+   * Serialize to JSON string
+   */
+  serialize() {
+    return JSON.stringify(this.toJSON(), null, 2);
+  }
+  /**
+   * Deserialize from JSON string
+   */
+  static deserialize(json) {
+    return _ShaderGraph.fromJSON(JSON.parse(json));
+  }
+};
+
+// src/shader/graph/ShaderGraphCompiler.ts
+var ShaderGraphCompiler = class {
+  graph;
+  options;
+  variableCounter = 0;
+  nodeVariables = /* @__PURE__ */ new Map();
+  uniforms = [];
+  textures = [];
+  warnings = [];
+  errors = [];
+  constructor(graph, options) {
+    this.graph = graph;
+    this.options = {
+      target: options?.target ?? "wgsl",
+      optimize: options?.optimize ?? true,
+      debug: options?.debug ?? false,
+      defines: options?.defines ?? {}
+    };
+  }
+  /**
+   * Compile the shader graph
+   */
+  compile() {
+    this.reset();
+    const validation = this.graph.validate();
+    if (!validation.valid) {
+      return {
+        vertexCode: "",
+        fragmentCode: "",
+        uniforms: [],
+        textures: [],
+        warnings: validation.warnings,
+        errors: validation.errors
+      };
+    }
+    this.warnings = validation.warnings;
+    const sortedNodes = this.graph.getTopologicalOrder();
+    const fragmentBody = this.generateFragmentBody(sortedNodes);
+    const vertexBody = this.generateVertexBody(sortedNodes);
+    const vertexCode = this.generateVertexShader(vertexBody);
+    const fragmentCode = this.generateFragmentShader(fragmentBody);
+    return {
+      vertexCode,
+      fragmentCode,
+      uniforms: this.uniforms,
+      textures: this.textures,
+      warnings: this.warnings,
+      errors: this.errors
+    };
+  }
+  /**
+   * Reset compilation state
+   */
+  reset() {
+    this.variableCounter = 0;
+    this.nodeVariables.clear();
+    this.uniforms = [];
+    this.textures = [];
+    this.warnings = [];
+    this.errors = [];
+  }
+  /**
+   * Generate a unique variable name
+   */
+  generateVariable() {
+    return `v_${this.variableCounter++}`;
+  }
+  /**
+   * Get or create variable for a node output
+   */
+  getOutputVariable(nodeId, portId) {
+    if (!this.nodeVariables.has(nodeId)) {
+      this.nodeVariables.set(nodeId, /* @__PURE__ */ new Map());
+    }
+    const nodeVars = this.nodeVariables.get(nodeId);
+    if (!nodeVars.has(portId)) {
+      nodeVars.set(portId, this.generateVariable());
+    }
+    return nodeVars.get(portId);
+  }
+  /**
+   * Get input expression for a node input
+   */
+  getInputExpression(node, portId, connections) {
+    const port = node.inputs.find((p) => p.id === portId);
+    if (!port) {
+      return "0.0";
+    }
+    const connection = connections.find((c) => c.toNode === node.id && c.toPort === portId);
+    if (connection) {
+      const sourceNode = this.graph.getNode(connection.fromNode);
+      const sourcePort = sourceNode?.outputs.find((p) => p.id === connection.fromPort);
+      if (sourceNode && sourcePort) {
+        const varName = this.getOutputVariable(connection.fromNode, connection.fromPort);
+        if (sourcePort.type !== port.type) {
+          return getTypeConversion(sourcePort.type, port.type, varName);
+        }
+        return varName;
+      }
+    }
+    return this.getDefaultValueCode(port.type, port.defaultValue);
+  }
+  /**
+   * Get WGSL code for default value
+   */
+  getDefaultValueCode(type, value) {
+    if (value === void 0) {
+      return this.getZeroValue(type);
+    }
+    if (typeof value === "number") {
+      if (type === "float") return `${value}`;
+      if (type === "int") return `${Math.floor(value)}i`;
+      return `${value}`;
+    }
+    if (Array.isArray(value)) {
+      switch (type) {
+        case "vec2":
+          return `vec2<f32>(${value[0] ?? 0}, ${value[1] ?? 0})`;
+        case "vec3":
+          return `vec3<f32>(${value[0] ?? 0}, ${value[1] ?? 0}, ${value[2] ?? 0})`;
+        case "vec4":
+          return `vec4<f32>(${value[0] ?? 0}, ${value[1] ?? 0}, ${value[2] ?? 0}, ${value[3] ?? 1})`;
+        default:
+          return this.getZeroValue(type);
+      }
+    }
+    return this.getZeroValue(type);
+  }
+  /**
+   * Get zero value for a type
+   */
+  getZeroValue(type) {
+    switch (type) {
+      case "float":
+        return "0.0";
+      case "vec2":
+        return "vec2<f32>(0.0)";
+      case "vec3":
+        return "vec3<f32>(0.0)";
+      case "vec4":
+        return "vec4<f32>(0.0, 0.0, 0.0, 1.0)";
+      case "int":
+        return "0i";
+      case "ivec2":
+        return "vec2<i32>(0)";
+      case "ivec3":
+        return "vec3<i32>(0)";
+      case "ivec4":
+        return "vec4<i32>(0)";
+      case "bool":
+        return "false";
+      case "mat2":
+        return "mat2x2<f32>(1.0, 0.0, 0.0, 1.0)";
+      case "mat3":
+        return "mat3x3<f32>(1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0)";
+      case "mat4":
+        return "mat4x4<f32>(1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0)";
+      default:
+        return "0.0";
+    }
+  }
+  /**
+   * Get WGSL type name
+   */
+  getWGSLType(type) {
+    switch (type) {
+      case "float":
+        return "f32";
+      case "vec2":
+        return "vec2<f32>";
+      case "vec3":
+        return "vec3<f32>";
+      case "vec4":
+        return "vec4<f32>";
+      case "int":
+        return "i32";
+      case "ivec2":
+        return "vec2<i32>";
+      case "ivec3":
+        return "vec3<i32>";
+      case "ivec4":
+        return "vec4<i32>";
+      case "bool":
+        return "bool";
+      case "mat2":
+        return "mat2x2<f32>";
+      case "mat3":
+        return "mat3x3<f32>";
+      case "mat4":
+        return "mat4x4<f32>";
+      default:
+        return "f32";
+    }
+  }
+  /**
+   * Generate fragment shader body
+   */
+  generateFragmentBody(nodes) {
+    const lines = [];
+    const connections = this.graph.connections;
+    for (const node of nodes) {
+      if (node.category === "output" && node.type !== "output_surface" && node.type !== "output_unlit" && node.type !== "output_volume") {
+        continue;
+      }
+      const template = getNodeTemplate(node.type);
+      if (!template) {
+        this.warnings.push(`No template found for node type: ${node.type}`);
+        continue;
+      }
+      const inputs = {};
+      for (const port of node.inputs) {
+        inputs[port.id] = this.getInputExpression(node, port.id, connections);
+      }
+      const code = template.generateCode(node, inputs);
+      if (node.type === "output_surface") {
+        lines.push(`// Surface output`);
+        lines.push(`let baseColor = ${inputs.baseColor};`);
+        lines.push(`let metallic = ${inputs.metallic};`);
+        lines.push(`let roughness = ${inputs.roughness};`);
+        lines.push(`let normal = ${inputs.normal};`);
+        lines.push(`let emission = ${inputs.emission};`);
+        lines.push(`let alpha = ${inputs.alpha};`);
+        lines.push(`let ao = ${inputs.ao};`);
+        lines.push(`let sheenColor = ${inputs.sheenColor ?? "vec3<f32>(0.0)"};`);
+        lines.push(`let sheenRoughness = ${inputs.sheenRoughness ?? "0.0"};`);
+        lines.push(`let subsurfaceThickness = ${inputs.subsurfaceThickness ?? "0.0"};`);
+        lines.push(`let subsurfaceColor = ${inputs.subsurfaceColor ?? "vec3<f32>(0.0)"};`);
+        lines.push(`let anisotropyVal = ${inputs.anisotropy ?? "0.0"};`);
+        lines.push(`let anisotropyRotation = ${inputs.anisotropyRotation ?? "0.0"};`);
+        lines.push(`let clearcoatVal = ${inputs.clearcoat ?? "0.0"};`);
+        lines.push(`let clearcoatRoughnessVal = ${inputs.clearcoatRoughness ?? "0.0"};`);
+        lines.push(`let iridescenceVal = ${inputs.iridescence ?? "0.0"};`);
+        lines.push(`let sparkleIntensity = ${inputs.sparkleIntensity ?? "0.0"};`);
+        lines.push(`let sparkleDensity = ${inputs.sparkleDensity ?? "0.0"};`);
+        lines.push(`let fluorescenceColor = ${inputs.fluorescenceColor ?? "vec3<f32>(0.0)"};`);
+        lines.push(`let fluorescenceIntensity = ${inputs.fluorescenceIntensity ?? "0.0"};`);
+        lines.push(`let blackbodyTemp = ${inputs.blackbodyTemp ?? "0.0"};`);
+        lines.push(`let retroreflectionVal = ${inputs.retroreflection ?? "0.0"};`);
+      } else if (node.type === "output_volume") {
+        lines.push(`// Volumetric output \u2014 ray march`);
+        lines.push(`let volDensity = ${inputs.density ?? "0.5"};`);
+        lines.push(`let volColor = ${inputs.color ?? "vec3<f32>(1.0)"};`);
+        lines.push(`let volEmission = ${inputs.emission ?? "vec3<f32>(0.0)"};`);
+        lines.push(`let volScattering = ${inputs.scattering ?? "0.5"};`);
+        lines.push(`let volAbsorption = ${inputs.absorption ?? "0.1"};`);
+        lines.push(`let volSteps = ${inputs.steps ?? "64.0"};`);
+        lines.push(`let volMaxDist = ${inputs.maxDistance ?? "10.0"};`);
+      } else if (node.type === "output_unlit") {
+        lines.push(`// Unlit output`);
+        lines.push(`let finalColor = ${inputs.color};`);
+      } else if (node.outputs.length > 0) {
+        if (this.options.debug) {
+          lines.push(`// ${node.name} (${node.id})`);
+        }
+        if (node.outputs.length === 1) {
+          const varName = this.getOutputVariable(node.id, node.outputs[0].id);
+          const wgslType = this.getWGSLType(node.outputs[0].type);
+          lines.push(`let ${varName}: ${wgslType} = ${code};`);
+        } else {
+          this.generateMultiOutputCode(node, inputs, lines);
+        }
+      }
+    }
+    return lines.join("\n  ");
+  }
+  /**
+   * Generate code for nodes with multiple outputs
+   */
+  generateMultiOutputCode(node, inputs, lines) {
+    const template = getNodeTemplate(node.type);
+    if (!template) return;
+    if (node.type.startsWith("vector_split_")) {
+      const inputExpr = inputs.vector;
+      for (const output of node.outputs) {
+        const varName = this.getOutputVariable(node.id, output.id);
+        const wgslType = this.getWGSLType(output.type);
+        lines.push(`let ${varName}: ${wgslType} = (${inputExpr}).${output.id};`);
+      }
+      return;
+    }
+    const baseCode = template.generateCode(node, inputs);
+    const tempVar = this.generateVariable();
+    lines.push(`let ${tempVar} = ${baseCode};`);
+    for (const output of node.outputs) {
+      const varName = this.getOutputVariable(node.id, output.id);
+      lines.push(`let ${varName} = ${tempVar}.${output.id};`);
+    }
+  }
+  /**
+   * Generate vertex shader body
+   */
+  generateVertexBody(nodes) {
+    const lines = [];
+    const connections = this.graph.connections;
+    const vertexOffsetNode = nodes.find((n) => n.type === "output_vertex_offset");
+    if (vertexOffsetNode) {
+      const template = getNodeTemplate(vertexOffsetNode.type);
+      if (template) {
+        const inputs = {};
+        for (const port of vertexOffsetNode.inputs) {
+          inputs[port.id] = this.getInputExpression(vertexOffsetNode, port.id, connections);
+        }
+        lines.push(`// Vertex offset`);
+        lines.push(`let vertexOffset = ${inputs.offset};`);
+        lines.push(`let worldPos = in.position + vertexOffset;`);
+      }
+    } else {
+      lines.push(`let worldPos = in.position;`);
+    }
+    return lines.join("\n  ");
+  }
+  /**
+   * Generate complete vertex shader
+   */
+  generateVertexShader(body) {
+    return `// Generated by HoloScript Shader Graph Compiler
+// Graph: ${this.graph.name}
+
+struct VertexInput {
+  @location(0) position: vec3<f32>,
+  @location(1) normal: vec3<f32>,
+  @location(2) uv: vec2<f32>,
+  @location(3) tangent: vec4<f32>,
+};
+
+struct VertexOutput {
+  @builtin(position) clipPosition: vec4<f32>,
+  @location(0) worldPosition: vec3<f32>,
+  @location(1) worldNormal: vec3<f32>,
+  @location(2) uv: vec2<f32>,
+};
+
+struct CameraUniforms {
+  viewProjection: mat4x4<f32>,
+  view: mat4x4<f32>,
+  projection: mat4x4<f32>,
+  position: vec3<f32>,
+};
+
+struct ModelUniforms {
+  model: mat4x4<f32>,
+  normalMatrix: mat3x3<f32>,
+};
+
+@group(0) @binding(0) var<uniform> camera: CameraUniforms;
+@group(1) @binding(0) var<uniform> model: ModelUniforms;
+
+@vertex
+fn main(in: VertexInput) -> VertexOutput {
+  var out: VertexOutput;
+
+  ${body}
+
+  let worldPosition = (model.model * vec4<f32>(worldPos, 1.0)).xyz;
+  let worldNormal = normalize(model.normalMatrix * in.normal);
+
+  out.worldPosition = worldPosition;
+  out.worldNormal = worldNormal;
+  out.uv = in.uv;
+  out.clipPosition = camera.viewProjection * vec4<f32>(worldPosition, 1.0);
+
+  return out;
+}
+`;
+  }
+  /**
+   * Generate complete fragment shader
+   */
+  generateFragmentShader(body) {
+    const textureBindings = this.generateTextureBindings();
+    const uniformBindings = this.generateUniformBindings();
+    const helperFunctions = this.generateHelperFunctions();
+    return `// Generated by HoloScript Shader Graph Compiler
+// Graph: ${this.graph.name}
+
+struct FragmentInput {
+  @location(0) worldPosition: vec3<f32>,
+  @location(1) worldNormal: vec3<f32>,
+  @location(2) uv: vec2<f32>,
+};
+
+struct CameraUniforms {
+  viewProjection: mat4x4<f32>,
+  view: mat4x4<f32>,
+  projection: mat4x4<f32>,
+  position: vec3<f32>,
+};
+
+struct SceneUniforms {
+  ambientColor: vec3<f32>,
+  time: f32,
+  deltaTime: f32,
+};
+
+struct LightData {
+  position: vec3<f32>,
+  color: vec3<f32>,
+  intensity: f32,
+};
+
+@group(0) @binding(0) var<uniform> camera: CameraUniforms;
+@group(0) @binding(1) var<uniform> scene: SceneUniforms;
+@group(0) @binding(2) var<uniform> light: LightData;
+${textureBindings}
+${uniformBindings}
+
+const PI: f32 = 3.14159265359;
+
+${helperFunctions}
+
+@fragment
+fn main(in: FragmentInput) -> @location(0) vec4<f32> {
+  ${body}
+
+  // PBR lighting calculation
+  let N = normalize(normal);
+  let V = normalize(camera.position - in.worldPosition);
+  let L = normalize(light.position - in.worldPosition);
+  let H = normalize(V + L);
+  let NdotV = max(dot(N, V), 0.0);
+  let NdotL = max(dot(N, L), 0.0);
+  let NdotH = max(dot(N, H), 0.0);
+  let VdotH = max(dot(V, H), 0.0);
+
+  let F0 = mix(vec3<f32>(0.04), baseColor, metallic);
+
+  // Cook-Torrance BRDF
+  let NDF = distributionGGX(N, H, roughness);
+  let G = geometrySmith(N, V, L, roughness);
+  let F = fresnelSchlick(VdotH, F0);
+
+  let numerator = NDF * G * F;
+  let denominator = 4.0 * NdotV * NdotL + 0.0001;
+  let specular = numerator / denominator;
+
+  let kS = F;
+  let kD = (vec3<f32>(1.0) - kS) * (1.0 - metallic);
+
+  var Lo = (kD * baseColor / PI + specular) * light.color * light.intensity * NdotL;
+
+  // Sheen \u2014 soft fuzzy reflection layer (fabrics, velvet)
+  if (sheenRoughness > 0.0 || length(sheenColor) > 0.0) {
+    let sheenD = distributionGGX(N, H, sheenRoughness);
+    let sheenTerm = sheenColor * sheenD * NdotL;
+    Lo = Lo + sheenTerm * light.color * light.intensity;
+  }
+
+  // Clearcoat \u2014 protective clear layer (car paint, varnish)
+  if (clearcoatVal > 0.0) {
+    let ccNDF = distributionGGX(N, H, clearcoatRoughnessVal);
+    let ccG = geometrySmith(N, V, L, clearcoatRoughnessVal);
+    let ccF = fresnelSchlick(VdotH, vec3<f32>(0.04));
+    let ccSpec = (ccNDF * ccG * ccF) / (4.0 * NdotV * NdotL + 0.0001);
+    Lo = Lo + ccSpec * clearcoatVal * light.color * light.intensity * NdotL;
+  }
+
+  // Subsurface scattering approximation (skin, wax, leaves, jade)
+  var sssContrib = vec3<f32>(0.0);
+  if (subsurfaceThickness > 0.0) {
+    let scatterVec = normalize(L + N * 0.5);
+    let sssNdotL = max(dot(V, -scatterVec), 0.0);
+    let sssFalloff = pow(sssNdotL, 3.0) * subsurfaceThickness;
+    sssContrib = subsurfaceColor * sssFalloff * light.color * light.intensity;
+    Lo = Lo + sssContrib;
+  }
+
+  // Iridescence \u2014 thin-film interference (soap bubbles, oil slicks, beetles)
+  if (iridescenceVal > 0.0) {
+    let thinFilmPhase = VdotH * 6.28318;
+    let iriColor = vec3<f32>(
+      0.5 + 0.5 * cos(thinFilmPhase),
+      0.5 + 0.5 * cos(thinFilmPhase + 2.094),
+      0.5 + 0.5 * cos(thinFilmPhase + 4.189)
+    );
+    Lo = mix(Lo, Lo * iriColor, iridescenceVal * 0.5);
+  }
+
+  // Sparkle/glitter \u2014 stochastic micro-facet flashing
+  if (sparkleIntensity > 0.0) {
+    let sparkleUV = in.uv * sparkleDensity;
+    let sparkleCell = floor(sparkleUV);
+    let sparkleRand = simpleNoise(sparkleCell);
+    let sparkleAngle = sparkleRand * 6.28318;
+    let sparkleNormal = vec3<f32>(cos(sparkleAngle) * 0.3, sin(sparkleAngle) * 0.3, 0.9);
+    let sparkleReflect = max(dot(reflect(-V, normalize(sparkleNormal)), L), 0.0);
+    let sparkleFlash = pow(sparkleReflect, 64.0) * step(0.85, sparkleRand) * sparkleIntensity;
+    Lo = Lo + vec3<f32>(sparkleFlash) * light.color * light.intensity;
+  }
+
+  // Blackbody radiation \u2014 temperature-driven emission color (Planck approximation)
+  if (blackbodyTemp > 0.0) {
+    let bbColor = blackbodyColor(blackbodyTemp, 1.0);
+    Lo = Lo + bbColor;
+  }
+
+  // Fluorescence \u2014 absorb short \u03BB, re-emit longer \u03BB
+  if (fluorescenceIntensity > 0.0) {
+    let excitationMatch = dot(normalize(light.color), normalize(fluorescenceColor));
+    let fluorEmit = fluorescenceColor * max(excitationMatch, 0.3) * fluorescenceIntensity;
+    Lo = Lo + fluorEmit;
+  }
+
+  // Retroreflection \u2014 light bounces back toward source
+  if (retroreflectionVal > 0.0) {
+    let retroDot = max(dot(V, L), 0.0);
+    let retroTerm = pow(retroDot, 8.0) * retroreflectionVal;
+    Lo = Lo + baseColor * retroTerm * light.color * light.intensity;
+  }
+
+  var color = scene.ambientColor * baseColor * ao + Lo + emission;
+
+  // Volumetric contribution (if output_volume is connected)
+  // The volDensity variable is set by output_volume node; if absent the default is 0
+  // which makes the rayMarchVolume return transparent, so the surface pass dominates.
+
+  // Tone mapping (Reinhard)
+  color = color / (color + vec3<f32>(1.0));
+
+  // Gamma correction
+  color = pow(color, vec3<f32>(1.0 / 2.2));
+
+  return vec4<f32>(color, alpha);
+}
+`;
+  }
+  /**
+   * Generate texture bindings
+   */
+  generateTextureBindings() {
+    if (this.textures.length === 0) return "";
+    const lines = [];
+    for (const tex of this.textures) {
+      const binding = tex.binding;
+      lines.push(`@group(2) @binding(${binding}) var ${tex.name}: texture_2d<f32>;`);
+      lines.push(`@group(2) @binding(${binding + 1}) var ${tex.name}Sampler: sampler;`);
+    }
+    return lines.join("\n");
+  }
+  /**
+   * Generate uniform bindings
+   */
+  generateUniformBindings() {
+    if (this.uniforms.length === 0) return "";
+    const lines = ["struct MaterialUniforms {"];
+    for (const uniform of this.uniforms) {
+      const wgslType = this.getWGSLType(uniform.type);
+      lines.push(`  ${uniform.name}: ${wgslType},`);
+    }
+    lines.push("};");
+    lines.push("@group(2) @binding(100) var<uniform> material: MaterialUniforms;");
+    return lines.join("\n");
+  }
+  /**
+   * Generate helper functions
+   */
+  generateHelperFunctions() {
+    return `
+// PBR helper functions
+fn distributionGGX(N: vec3<f32>, H: vec3<f32>, roughness: f32) -> f32 {
+  let a = roughness * roughness;
+  let a2 = a * a;
+  let NdotH = max(dot(N, H), 0.0);
+  let NdotH2 = NdotH * NdotH;
+
+  let num = a2;
+  let denom = (NdotH2 * (a2 - 1.0) + 1.0);
+  let denom2 = PI * denom * denom;
+
+  return num / denom2;
+}
+
+fn geometrySchlickGGX(NdotV: f32, roughness: f32) -> f32 {
+  let r = roughness + 1.0;
+  let k = (r * r) / 8.0;
+
+  let num = NdotV;
+  let denom = NdotV * (1.0 - k) + k;
+
+  return num / denom;
+}
+
+fn geometrySmith(N: vec3<f32>, V: vec3<f32>, L: vec3<f32>, roughness: f32) -> f32 {
+  let NdotV = max(dot(N, V), 0.0);
+  let NdotL = max(dot(N, L), 0.0);
+  let ggx2 = geometrySchlickGGX(NdotV, roughness);
+  let ggx1 = geometrySchlickGGX(NdotL, roughness);
+
+  return ggx1 * ggx2;
+}
+
+fn fresnelSchlick(cosTheta: f32, F0: vec3<f32>) -> vec3<f32> {
+  return F0 + (vec3<f32>(1.0) - F0) * pow(saturate(1.0 - cosTheta), 5.0);
+}
+
+fn hueShift(color: vec3<f32>, shift: f32) -> vec3<f32> {
+  let k = vec3<f32>(0.57735);
+  let cosAngle = cos(shift);
+  return color * cosAngle + cross(k, color) * sin(shift) + k * dot(k, color) * (1.0 - cosAngle);
+}
+
+fn simpleNoise(uv: vec2<f32>) -> f32 {
+  return fract(sin(dot(uv, vec2<f32>(12.9898, 78.233))) * 43758.5453);
+}
+
+fn gradientNoise(uv: vec2<f32>) -> f32 {
+  let i = floor(uv);
+  let f = fract(uv);
+  let u = f * f * (3.0 - 2.0 * f);
+
+  let n00 = simpleNoise(i);
+  let n10 = simpleNoise(i + vec2<f32>(1.0, 0.0));
+  let n01 = simpleNoise(i + vec2<f32>(0.0, 1.0));
+  let n11 = simpleNoise(i + vec2<f32>(1.0, 1.0));
+
+  return mix(mix(n00, n10, u.x), mix(n01, n11, u.x), u.y);
+}
+
+fn voronoi(uv: vec2<f32>) -> vec2<f32> {
+  let n = floor(uv);
+  let f = fract(uv);
+
+  var minDist = 1.0;
+  var cellId = 0.0;
+
+  for (var j = -1; j <= 1; j++) {
+    for (var i = -1; i <= 1; i++) {
+      let neighbor = vec2<f32>(f32(i), f32(j));
+      let point = simpleNoise(n + neighbor);
+      let diff = neighbor + point - f;
+      let dist = length(diff);
+      if (dist < minDist) {
+        minDist = dist;
+        cellId = simpleNoise(n + neighbor);
+      }
+    }
+  }
+
+  return vec2<f32>(cellId, minDist);
+}
+
+// =========================================================================
+// Advanced Material Functions
+// =========================================================================
+
+// Blackbody radiation \u2014 Planck approximation: temperature (Kelvin) \u2192 RGB color
+fn blackbodyColor(tempK: f32, intensity: f32) -> vec3<f32> {
+  // CIE 1931 approximation for blackbody emission
+  let t = clamp(tempK, 1000.0, 40000.0) / 100.0;
+  var r: f32; var g: f32; var b: f32;
+
+  // Red channel
+  if (t <= 66.0) {
+    r = 1.0;
+  } else {
+    r = pow((t - 60.0) / 40.0, -0.1332);
+    r = clamp(r, 0.0, 1.0);
+  }
+
+  // Green channel
+  if (t <= 66.0) {
+    g = 0.39 * log(t) - 0.63;
+  } else {
+    g = 1.29 * pow((t - 60.0) / 40.0, -0.0755);
+  }
+  g = clamp(g, 0.0, 1.0);
+
+  // Blue channel
+  if (t >= 66.0) {
+    b = 1.0;
+  } else if (t <= 19.0) {
+    b = 0.0;
+  } else {
+    b = 0.543 * log(t - 10.0) - 1.19;
+    b = clamp(b, 0.0, 1.0);
+  }
+
+  return vec3<f32>(r, g, b) * intensity;
+}
+
+// Sparkle / Glitter \u2014 stochastic micro-facet flash
+fn sparkleFlash(uv: vec2<f32>, density: f32, size: f32, intensity: f32, viewDir: vec3<f32>, normal: vec3<f32>) -> vec2<f32> {
+  let cell = floor(uv * density);
+  let rand = simpleNoise(cell);
+  let threshold = 1.0 - size;
+  let flash = step(threshold, rand) * intensity;
+  return vec2<f32>(flash, rand);
+}
+
+// Animated pattern \u2014 time-varying surface effects
+fn animatedPattern(uv: vec2<f32>, time: f32, patternType: f32, speed: f32, amplitude: f32, scale: f32) -> vec2<f32> {
+  let t = time * speed;
+  let suv = uv * scale;
+  var value: f32 = 0.0;
+  var uvOffset = vec2<f32>(0.0);
+
+  let pType = i32(patternType);
+
+  // 0: ripple \u2014 concentric rings from center
+  if (pType == 0) {
+    let dist = length(suv - vec2<f32>(0.5));
+    value = sin(dist * 20.0 - t * 4.0) * 0.5 + 0.5;
+  }
+  // 1: flicker \u2014 random temporal noise
+  else if (pType == 1) {
+    value = simpleNoise(vec2<f32>(t * 3.0, 0.0));
+  }
+  // 2: pulse \u2014 breathing sine wave
+  else if (pType == 2) {
+    value = sin(t * 2.0) * 0.5 + 0.5;
+  }
+  // 3: flow \u2014 directional scroll
+  else if (pType == 3) {
+    uvOffset = vec2<f32>(t * 0.1, 0.0);
+    value = simpleNoise(suv + uvOffset);
+  }
+  // 4: breathe \u2014 slow amplitude modulation
+  else if (pType == 4) {
+    value = sin(t * 0.5) * 0.5 + 0.5;
+    value = value * value; // ease-in
+  }
+  // 5: scroll \u2014 vertical scroll
+  else if (pType == 5) {
+    uvOffset = vec2<f32>(0.0, t * 0.1);
+    value = gradientNoise(suv + uvOffset);
+  }
+  // 6: wave \u2014 sinusoidal displacement
+  else if (pType == 6) {
+    value = sin(suv.x * 10.0 + t * 3.0) * sin(suv.y * 10.0 + t * 2.0) * 0.5 + 0.5;
+  }
+  // 7: noise \u2014 animated Perlin
+  else {
+    value = gradientNoise(suv + vec2<f32>(t * 0.2));
+  }
+
+  return vec2<f32>(value * amplitude, 0.0);
+}
+
+// Weathering \u2014 procedural surface degradation
+fn weatheringSurface(uv: vec2<f32>, progress: f32, weatherType: f32, seed: f32, baseColor: vec3<f32>) -> vec3<f32> {
+  let noise1 = gradientNoise(uv * 8.0 + vec2<f32>(seed));
+  let noise2 = simpleNoise(uv * 16.0 + vec2<f32>(seed * 2.0));
+  let mask = smoothstep(1.0 - progress, 1.0 - progress + 0.2, noise1);
+
+  let wType = i32(weatherType);
+  var weatherColor = vec3<f32>(0.5);
+
+  // 0: rust
+  if (wType == 0) { weatherColor = vec3<f32>(0.55, 0.22, 0.08); }
+  // 1: moss
+  else if (wType == 1) { weatherColor = vec3<f32>(0.29, 0.49, 0.25); }
+  // 2: crack \u2014 darken along cracks
+  else if (wType == 2) { weatherColor = baseColor * 0.3; }
+  // 3: peel \u2014 reveal underlayer
+  else if (wType == 3) { weatherColor = vec3<f32>(0.85, 0.82, 0.78); }
+  // 4: patina
+  else if (wType == 4) { weatherColor = vec3<f32>(0.29, 0.55, 0.49); }
+  // 5: frost
+  else if (wType == 5) { weatherColor = vec3<f32>(0.9, 0.95, 1.0); }
+  // 6: burn
+  else if (wType == 6) { weatherColor = vec3<f32>(0.1, 0.08, 0.05); }
+  // 7: erosion
+  else if (wType == 7) { weatherColor = baseColor * (0.5 + noise2 * 0.3); }
+  // 8: stain
+  else if (wType == 8) { weatherColor = mix(baseColor, vec3<f32>(0.4, 0.35, 0.25), 0.6); }
+  // 9: dust
+  else { weatherColor = mix(baseColor, vec3<f32>(0.75, 0.7, 0.65), 0.4); }
+
+  return mix(baseColor, weatherColor, mask);
+}
+
+// Dual-layer material blend
+fn dualLayerBlend(
+  baseCol: vec3<f32>, baseRough: f32, baseMetal: f32,
+  topCol: vec3<f32>, topRough: f32, topMetal: f32,
+  blend: f32, mode: f32, normal: vec3<f32>, uv: vec2<f32>
+) -> vec3<f32> {
+  var factor = blend;
+
+  let modeInt = i32(mode);
+  // 0: linear
+  // 1: height-based (top appears on upward-facing surfaces)
+  if (modeInt == 1) {
+    factor = factor * max(normal.y, 0.0);
+  }
+  // 2: noise-based
+  else if (modeInt == 2) {
+    let n = gradientNoise(uv * 8.0);
+    factor = smoothstep(0.5 - blend * 0.5, 0.5 + blend * 0.5, n);
+  }
+  // 3: fresnel-based (top appears at grazing angles)
+  else if (modeInt == 3) {
+    factor = factor; // fresnel computed in main lighting \u2014 blend is direct here
+  }
+
+  return mix(baseCol, topCol, factor);
+}
+
+// Fluorescence \u2014 absorb excitation wavelengths, emit shifted color
+fn fluorescenceEmit(lightColor: vec3<f32>, excitationColor: vec3<f32>, emissionColor: vec3<f32>, intensity: f32) -> vec3<f32> {
+  let match = dot(normalize(lightColor), normalize(excitationColor));
+  return emissionColor * max(match, 0.0) * intensity;
+}
+
+// Retroreflection \u2014 light reflects back toward its source
+fn retroReflect(viewDir: vec3<f32>, lightDir: vec3<f32>, normal: vec3<f32>, intensity: f32) -> f32 {
+  let retroDot = max(dot(viewDir, lightDir), 0.0);
+  return pow(retroDot, 8.0) * intensity;
+}
+
+// =========================================================================
+// Volumetric Material Functions \u2014 Ray Marching, 3D Noise, Scattering
+// =========================================================================
+
+// 3D noise \u2014 hash-based, for volumetric density
+fn noise3D(p: vec3<f32>) -> f32 {
+  let i = floor(p);
+  let f = fract(p);
+  let u = f * f * (3.0 - 2.0 * f);
+
+  let n000 = simpleNoise(i.xy + vec2<f32>(0.0, i.z * 37.0));
+  let n100 = simpleNoise(i.xy + vec2<f32>(1.0, i.z * 37.0));
+  let n010 = simpleNoise(i.xy + vec2<f32>(0.0, (i.z + 1.0) * 37.0 + 17.0));
+  let n110 = simpleNoise(i.xy + vec2<f32>(1.0, (i.z + 1.0) * 37.0 + 17.0));
+  let n001 = simpleNoise(i.xy + vec2<f32>(i.z * 37.0 + 59.0, 0.0));
+  let n101 = simpleNoise(i.xy + vec2<f32>(i.z * 37.0 + 60.0, 0.0));
+  let n011 = simpleNoise(i.xy + vec2<f32>((i.z + 1.0) * 37.0 + 59.0, 17.0));
+  let n111 = simpleNoise(i.xy + vec2<f32>((i.z + 1.0) * 37.0 + 60.0, 17.0));
+
+  let x0 = mix(mix(n000, n100, u.x), mix(n010, n110, u.x), u.y);
+  let x1 = mix(mix(n001, n101, u.x), mix(n011, n111, u.x), u.y);
+  return mix(x0, x1, u.z);
+}
+
+// Fractal Brownian Motion in 3D \u2014 layered noise octaves
+fn fbmNoise3D(p: vec3<f32>, octaves: i32, lacunarity: f32, gain: f32) -> f32 {
+  var value = 0.0;
+  var amplitude = 1.0;
+  var frequency = 1.0;
+  var pos = p;
+
+  for (var i = 0; i < octaves; i++) {
+    value = value + amplitude * noise3D(pos * frequency);
+    amplitude = amplitude * gain;
+    frequency = frequency * lacunarity;
+  }
+
+  return value;
+}
+
+// Curl noise 3D \u2014 divergence-free noise for smoke/fire turbulence
+fn curlNoise3D(p: vec3<f32>) -> vec3<f32> {
+  let eps = 0.01;
+  let dx = vec3<f32>(eps, 0.0, 0.0);
+  let dy = vec3<f32>(0.0, eps, 0.0);
+  let dz = vec3<f32>(0.0, 0.0, eps);
+
+  let dFzdy = noise3D(p + dy) - noise3D(p - dy);
+  let dFydz = noise3D(p + dz) - noise3D(p - dz);
+  let dFxdz = noise3D(p + dz + dx) - noise3D(p - dz + dx);
+  let dFzdx = noise3D(p + dx) - noise3D(p - dx);
+  let dFydx = noise3D(p + dx + dy) - noise3D(p - dx + dy);
+  let dFxdy = noise3D(p + dy + dx) - noise3D(p - dy + dx);
+
+  return vec3<f32>(
+    dFzdy - dFydz,
+    dFxdz - dFzdx,
+    dFydx - dFxdy
+  ) / (2.0 * eps);
+}
+
+// Volume density at a 3D position with FBM noise
+fn volumeDensity(pos: vec3<f32>, baseDensity: f32, noiseScale: f32, noiseOctaves: f32, time: f32) -> f32 {
+  let animatedPos = pos + vec3<f32>(0.0, time * 0.1, 0.0);
+  let n = fbmNoise3D(animatedPos * noiseScale, i32(noiseOctaves), 2.0, 0.5);
+  return clamp(baseDensity * n, 0.0, 1.0);
+}
+
+// Height fog density \u2014 exponential falloff with height
+fn heightFogDensity(pos: vec3<f32>, groundLevel: f32, density: f32, falloff: f32) -> f32 {
+  let height = pos.y - groundLevel;
+  return density * exp(-max(height, 0.0) * falloff);
+}
+
+// Fire density \u2014 buoyant rising, turbulent, temperature-driven
+fn fireDensity(pos: vec3<f32>, time: f32, turbulence: f32, riseSpeed: f32, scale: f32) -> vec2<f32> {
+  // Rising motion
+  let risingPos = pos - vec3<f32>(0.0, time * riseSpeed, 0.0);
+  // Turbulence via curl noise
+  let curl = curlNoise3D(risingPos * scale * 0.5) * turbulence;
+  let distortedPos = risingPos + curl;
+  // Base density from FBM
+  let d = fbmNoise3D(distortedPos * scale, 4, 2.0, 0.5);
+  // Height falloff \u2014 fire thins out as it rises
+  let heightFade = exp(-max(pos.y, 0.0) * 0.5);
+  let density = clamp(d * heightFade, 0.0, 1.0);
+  // Temperature \u2014 hotter at base, cooler at top
+  let temperature = clamp(density * (1.0 - pos.y * 0.3) * 3000.0 + 800.0, 800.0, 3000.0);
+  return vec2<f32>(density, temperature);
+}
+
+// Henyey-Greenstein phase function \u2014 anisotropic light scattering
+fn henyeyGreenstein(cosTheta: f32, g: f32) -> f32 {
+  let g2 = g * g;
+  let denom = 1.0 + g2 - 2.0 * g * cosTheta;
+  return (1.0 - g2) / (4.0 * PI * pow(denom, 1.5));
+}
+
+// Beer-Lambert transmittance \u2014 light attenuation through absorbing medium
+fn beerLambert(density: f32, stepLen: f32, absorption: f32) -> f32 {
+  return exp(-density * absorption * stepLen);
+}
+
+// Volume scattering \u2014 transmittance + in-scattering at a sample point
+fn volumeScatter(density: f32, scattering: f32, absorption: f32, stepLen: f32, lightDir: vec3<f32>, viewDir: vec3<f32>, phaseAniso: f32) -> vec2<f32> {
+  let cosTheta = dot(normalize(lightDir), normalize(viewDir));
+  let phase = henyeyGreenstein(cosTheta, phaseAniso);
+  let transmittance = beerLambert(density, stepLen, absorption + scattering);
+  let inScatter = density * scattering * phase * stepLen;
+  return vec2<f32>(transmittance, inScatter);
+}
+
+// Volume emission \u2014 self-luminous contribution (fire, neon, aurora)
+fn volumeEmission(density: f32, emissionColor: vec3<f32>, intensity: f32, temperature: f32) -> vec3<f32> {
+  var emCol = emissionColor * intensity * density;
+  // If temperature > 0, blend with blackbody color
+  if (temperature > 0.0) {
+    let bbCol = blackbodyColor(temperature, 1.0);
+    emCol = emCol * bbCol;
+  }
+  return emCol;
+}
+
+// Ray-box intersection \u2014 returns (tNear, tFar) for axis-aligned bounding box
+fn rayBoxIntersect(rayOrigin: vec3<f32>, rayDir: vec3<f32>, boxMin: vec3<f32>, boxMax: vec3<f32>) -> vec2<f32> {
+  let invDir = 1.0 / rayDir;
+  let t1 = (boxMin - rayOrigin) * invDir;
+  let t2 = (boxMax - rayOrigin) * invDir;
+  let tMin = min(t1, t2);
+  let tMax = max(t1, t2);
+  let tNear = max(max(tMin.x, tMin.y), tMin.z);
+  let tFar = min(min(tMax.x, tMax.y), tMax.z);
+  return vec2<f32>(max(tNear, 0.0), tFar);
+}
+
+// Main ray march loop \u2014 integrates density, color, emission along a ray
+fn rayMarchVolume(
+  rayOrigin: vec3<f32>, rayDir: vec3<f32>,
+  volDensity: f32, volColor: vec3<f32>, volEmission: vec3<f32>,
+  scattering: f32, absorption: f32,
+  steps: f32, maxDist: f32
+) -> vec4<f32> {
+  // Intersect unit cube [-1,1]^3
+  let hit = rayBoxIntersect(rayOrigin, rayDir, vec3<f32>(-1.0), vec3<f32>(1.0));
+  if (hit.x > hit.y) {
+    return vec4<f32>(0.0); // Miss
+  }
+
+  let stepCount = i32(steps);
+  let tStart = hit.x;
+  let tEnd = min(hit.y, maxDist);
+  let stepLen = (tEnd - tStart) / f32(stepCount);
+
+  var accColor = vec3<f32>(0.0);
+  var accTransmittance = 1.0;
+
+  for (var i = 0; i < stepCount; i++) {
+    if (accTransmittance < 0.01) { break; } // Early exit
+
+    let t = tStart + (f32(i) + 0.5) * stepLen;
+    let samplePos = rayOrigin + rayDir * t;
+
+    // Sample density with noise
+    let d = volumeDensity(samplePos, volDensity, 4.0, 4.0, scene.time);
+    if (d < 0.001) { continue; } // Skip empty space
+
+    // Transmittance for this step (Beer-Lambert)
+    let stepTransmittance = beerLambert(d, stepLen, absorption + scattering);
+
+    // In-scattering from light
+    let lightDir = normalize(light.position - samplePos);
+    let cosTheta = dot(lightDir, rayDir);
+    let phase = henyeyGreenstein(cosTheta, 0.3);
+    let inScatter = d * scattering * phase * stepLen * light.intensity;
+
+    // Emission
+    let emissionContrib = volEmission * d * stepLen;
+
+    // Accumulate
+    let sampleColor = volColor * inScatter * light.color + emissionContrib;
+    accColor = accColor + sampleColor * accTransmittance;
+    accTransmittance = accTransmittance * stepTransmittance;
+  }
+
+  return vec4<f32>(accColor, 1.0 - accTransmittance);
+}
+
+// =========================================================================
+// Caustics \u2014 underwater refracted light patterns
+// =========================================================================
+
+// Voronoi-based caustic pattern (dual-layer for temporal stability)
+fn causticVoronoi(p: vec2<f32>) -> f32 {
+  let i = floor(p);
+  let f = fract(p);
+  var minDist = 1.0;
+  for (var y = -1; y <= 1; y++) {
+    for (var x = -1; x <= 1; x++) {
+      let neighbor = vec2<f32>(f32(x), f32(y));
+      let cellHash = fract(sin(dot(i + neighbor, vec2<f32>(127.1, 311.7))) * 43758.5453);
+      let cellHash2 = fract(sin(dot(i + neighbor, vec2<f32>(269.5, 183.3))) * 43758.5453);
+      let point = neighbor + vec2<f32>(cellHash, cellHash2) - f;
+      let dist = dot(point, point);
+      minDist = min(minDist, dist);
+    }
+  }
+  return sqrt(minDist);
+}
+
+fn causticPattern(
+  pos: vec3<f32>, time: f32, scale: f32, speed: f32,
+  intensity: f32, color: vec3<f32>
+) -> vec3<f32> {
+  // Dual-layer caustics for interference pattern
+  let uv1 = pos.xz * scale + vec2<f32>(time * speed * 0.3, time * speed * 0.7);
+  let uv2 = pos.xz * scale * 1.3 + vec2<f32>(-time * speed * 0.5, time * speed * 0.4);
+  let c1 = causticVoronoi(uv1);
+  let c2 = causticVoronoi(uv2);
+  // Combine layers \u2014 bright where both layers converge
+  let caustic = pow(1.0 - c1, 3.0) * pow(1.0 - c2, 3.0) * intensity;
+  return color * caustic;
+}
+
+// Chromatic refractive caustics: separate R/G/B with different IoR for prismatic effect
+fn causticChromatic(
+  pos: vec3<f32>, time: f32, scale: f32, speed: f32,
+  intensity: f32, dispersion: f32
+) -> vec3<f32> {
+  let baseUV = pos.xz * scale;
+  let t = time * speed;
+  // Offset UV per channel based on dispersion
+  let uvR = baseUV + vec2<f32>(t * 0.3 + dispersion, t * 0.7);
+  let uvG = baseUV + vec2<f32>(t * 0.3, t * 0.7);
+  let uvB = baseUV + vec2<f32>(t * 0.3 - dispersion, t * 0.7);
+  // Dual-layer per channel
+  let r = pow(1.0 - causticVoronoi(uvR), 3.0) * pow(1.0 - causticVoronoi(uvR * 1.3 + vec2<f32>(-t * 0.5, t * 0.4)), 3.0);
+  let g = pow(1.0 - causticVoronoi(uvG), 3.0) * pow(1.0 - causticVoronoi(uvG * 1.3 + vec2<f32>(-t * 0.5, t * 0.4)), 3.0);
+  let b = pow(1.0 - causticVoronoi(uvB), 3.0) * pow(1.0 - causticVoronoi(uvB * 1.3 + vec2<f32>(-t * 0.5, t * 0.4)), 3.0);
+  return vec3<f32>(r, g, b) * intensity;
+}
+
+// Turbulence-driven underwater foam patches
+fn underwaterFoam(
+  pos: vec3<f32>, time: f32, scale: f32, threshold: f32
+) -> f32 {
+  let uv = pos.xz * scale;
+  // Multi-octave turbulence
+  var turb = 0.0;
+  turb += abs(simpleNoise(uv * 2.0 + vec2<f32>(time * 0.1, 0.0)) - 0.5) * 2.0;
+  turb += abs(simpleNoise(uv * 4.0 + vec2<f32>(0.0, time * 0.15)) - 0.5) * 1.0;
+  turb += abs(simpleNoise(uv * 8.0 + vec2<f32>(time * 0.2, time * 0.1)) - 0.5) * 0.5;
+  turb /= 3.5;
+  return smoothstep(threshold, threshold + 0.15, turb);
+}
+
+// =========================================================================
+// Displacement Mapping \u2014 vertex offset along normal
+// =========================================================================
+
+fn displacementMap(
+  position: vec3<f32>, normal: vec3<f32>,
+  height: f32, strength: f32, midLevel: f32
+) -> vec3<f32> {
+  let offset = (height - midLevel) * strength;
+  return position + normal * offset;
+}
+
+// Reconstruct normal from height field via finite differences
+fn displacementNormal(
+  uv: vec2<f32>, texelSize: f32, strength: f32
+) -> vec3<f32> {
+  let hL = simpleNoise(uv - vec2<f32>(texelSize, 0.0)) * strength;
+  let hR = simpleNoise(uv + vec2<f32>(texelSize, 0.0)) * strength;
+  let hD = simpleNoise(uv - vec2<f32>(0.0, texelSize)) * strength;
+  let hU = simpleNoise(uv + vec2<f32>(0.0, texelSize)) * strength;
+  return normalize(vec3<f32>(hL - hR, 2.0 * texelSize, hD - hU));
+}
+
+// Anisotropic displacement along normal with tangent-space weighting
+fn anisotropicDisplacement(
+  position: vec3<f32>, normal: vec3<f32>, tangent: vec3<f32>,
+  height: f32, strength: f32, anisotropy: f32, midLevel: f32
+) -> vec3<f32> {
+  let offset = (height - midLevel) * strength;
+  let bitangent = cross(normal, tangent);
+  // Blend between isotropic (normal) and anisotropic (tangent-weighted) displacement
+  let isoDisp = normal * offset;
+  let anisoDisp = (tangent * anisotropy + normal * (1.0 - abs(anisotropy))) * offset;
+  return position + mix(isoDisp, anisoDisp, abs(anisotropy));
+}
+
+// =========================================================================
+// Parallax Occlusion Mapping \u2014 steep parallax with occlusion
+// =========================================================================
+
+fn parallaxOcclusionMap(
+  uv: vec2<f32>, viewDir: vec3<f32>,
+  heightScale: f32, numLayers: f32
+) -> vec2<f32> {
+  let layerCount = i32(numLayers);
+  let layerDepth = 1.0 / numLayers;
+  var currentLayerDepth = 0.0;
+  let deltaUV = viewDir.xy / viewDir.z * heightScale / numLayers;
+
+  var currentUV = uv;
+  var currentDepthMapValue = simpleNoise(currentUV); // Use noise as height
+
+  // Step through layers from front to back
+  for (var i = 0; i < layerCount; i++) {
+    if (currentLayerDepth >= currentDepthMapValue) { break; }
+    currentUV -= deltaUV;
+    currentDepthMapValue = simpleNoise(currentUV);
+    currentLayerDepth += layerDepth;
+  }
+
+  // Binary refinement for smoother result
+  let prevUV = currentUV + deltaUV;
+  let afterDepth = currentDepthMapValue - currentLayerDepth;
+  let beforeDepth = simpleNoise(prevUV) - currentLayerDepth + layerDepth;
+  let weight = afterDepth / (afterDepth - beforeDepth);
+  return mix(currentUV, prevUV, weight);
+}
+
+// =========================================================================
+// Screen-Space Reflections (SSR) \u2014 ray march in screen space
+// =========================================================================
+
+fn screenSpaceReflect(
+  uv: vec2<f32>, normal: vec3<f32>, viewDir: vec3<f32>,
+  roughness: f32, maxSteps: f32, stepSize: f32
+) -> vec3<f32> {
+  // Reflect view direction around surface normal
+  let reflectDir = reflect(viewDir, normal);
+
+  // Convert reflection to screen-space step direction
+  let screenStep = reflectDir.xy * stepSize;
+
+  var hitColor = vec3<f32>(0.0);
+  var hitMask = 0.0;
+  var sampleUV = uv;
+  var currentDepth = 0.0;
+  let steps = i32(maxSteps);
+
+  for (var i = 0; i < steps; i++) {
+    sampleUV += screenStep;
+
+    // Bounds check
+    if (sampleUV.x < 0.0 || sampleUV.x > 1.0 || sampleUV.y < 0.0 || sampleUV.y > 1.0) {
+      break;
+    }
+
+    // In a real implementation, we'd sample the depth buffer here
+    // For the shader graph, we approximate with noise-based depth
+    let sampleDepth = simpleNoise(sampleUV * 10.0);
+    currentDepth += stepSize;
+
+    if (currentDepth > sampleDepth) {
+      // Hit \u2014 sample color at hit point
+      hitColor = vec3<f32>(sampleUV, 0.5); // Placeholder: real impl samples color buffer
+      hitMask = 1.0;
+
+      // Fade with roughness (rough surfaces \u2192 less clear reflection)
+      hitMask *= 1.0 - roughness;
+
+      // Fade at screen edges
+      let edgeFade = 1.0 - pow(max(abs(sampleUV.x - 0.5), abs(sampleUV.y - 0.5)) * 2.0, 4.0);
+      hitMask *= max(edgeFade, 0.0);
+      break;
+    }
+  }
+
+  return hitColor * hitMask;
+}
+
+// =========================================================================
+// Screen-Space Global Illumination (SSGI) \u2014 approximate indirect lighting
+// =========================================================================
+
+fn screenSpaceGI(
+  uv: vec2<f32>, normal: vec3<f32>,
+  radius: f32, samples: f32, bounceIntensity: f32
+) -> vec3<f32> {
+  var indirect = vec3<f32>(0.0);
+  let sampleCount = i32(samples);
+  let goldenAngle = 2.399963; // Golden angle in radians
+
+  for (var i = 0; i < sampleCount; i++) {
+    let fi = f32(i);
+    // Fibonacci spiral sampling pattern
+    let r = sqrt(fi / samples) * radius;
+    let theta = fi * goldenAngle;
+    let offset = vec2<f32>(cos(theta), sin(theta)) * r;
+    let sampleUV = uv + offset * 0.01; // Scale to UV space
+
+    // Sample nearby color (in real impl, from color buffer)
+    let sampleColor = vec3<f32>(
+      simpleNoise(sampleUV * 20.0),
+      simpleNoise(sampleUV * 20.0 + vec2<f32>(37.0, 0.0)),
+      simpleNoise(sampleUV * 20.0 + vec2<f32>(0.0, 53.0))
+    );
+
+    // Weight by cosine of angle between sample direction and normal
+    let sampleDir = normalize(vec3<f32>(offset, 0.1));
+    let cosWeight = max(dot(sampleDir, normal), 0.0);
+
+    indirect += sampleColor * cosWeight;
+  }
+
+  indirect /= samples;
+  return indirect * bounceIntensity;
+}
+
+// =========================================================================
+// Water Surface \u2014 combined waves, normals, foam, caustics
+// =========================================================================
+
+struct WaterSurfaceResult {
+  displacement: vec3<f32>,
+  normal: vec3<f32>,
+  foam: f32,
+  caustic: f32,
+}
+
+fn gerstnerWave(pos: vec2<f32>, time: f32, dir: vec2<f32>, steepness: f32, wavelength: f32) -> vec3<f32> {
+  let k = 6.28318 / wavelength;
+  let c = sqrt(9.81 / k);
+  let d = normalize(dir);
+  let f = k * (dot(d, pos) - c * time);
+  let a = steepness / k;
+  return vec3<f32>(d.x * a * cos(f), a * sin(f), d.y * a * cos(f));
+}
+
+fn waterSurface(
+  pos: vec3<f32>, time: f32,
+  waveScale: f32, waveSpeed: f32,
+  waterDepth: f32, foamThreshold: f32
+) -> WaterSurfaceResult {
+  let scaledTime = time * waveSpeed;
+  let p = pos.xz * waveScale;
+
+  // Sum of Gerstner waves at different frequencies and directions
+  var displacement = vec3<f32>(0.0);
+  displacement += gerstnerWave(p, scaledTime, vec2<f32>(1.0, 0.3), 0.25, 4.0);
+  displacement += gerstnerWave(p, scaledTime, vec2<f32>(-0.5, 0.8), 0.15, 2.5);
+  displacement += gerstnerWave(p, scaledTime, vec2<f32>(0.3, -0.7), 0.1, 1.5);
+  displacement += gerstnerWave(p, scaledTime, vec2<f32>(-0.8, -0.3), 0.08, 0.8);
+
+  // Compute normal via finite differences on all 4 wave layers
+  let eps = 0.01;
+  let px = p + vec2<f32>(eps, 0.0);
+  let pz = p + vec2<f32>(0.0, eps);
+  var dx = vec3<f32>(0.0);
+  dx += gerstnerWave(px, scaledTime, vec2<f32>(1.0, 0.3), 0.25, 4.0);
+  dx += gerstnerWave(px, scaledTime, vec2<f32>(-0.5, 0.8), 0.15, 2.5);
+  dx += gerstnerWave(px, scaledTime, vec2<f32>(0.3, -0.7), 0.1, 1.5);
+  dx += gerstnerWave(px, scaledTime, vec2<f32>(-0.8, -0.3), 0.08, 0.8);
+  var dz = vec3<f32>(0.0);
+  dz += gerstnerWave(pz, scaledTime, vec2<f32>(1.0, 0.3), 0.25, 4.0);
+  dz += gerstnerWave(pz, scaledTime, vec2<f32>(-0.5, 0.8), 0.15, 2.5);
+  dz += gerstnerWave(pz, scaledTime, vec2<f32>(0.3, -0.7), 0.1, 1.5);
+  dz += gerstnerWave(pz, scaledTime, vec2<f32>(-0.8, -0.3), 0.08, 0.8);
+  let waterNormal = normalize(vec3<f32>(
+    -(dx.y - displacement.y) / eps,
+    1.0,
+    -(dz.y - displacement.y) / eps
+  ));
+
+  // Foam: where wave crests converge (Jacobian < threshold)
+  let jacobian = 1.0 - abs(displacement.x) * waveScale;
+  let foam = smoothstep(foamThreshold, foamThreshold + 0.1, 1.0 - jacobian);
+
+  // Caustics (project through water depth)
+  let causticsUV = p + displacement.xz * 0.5;
+  let c1 = causticVoronoi(causticsUV * 3.0 + vec2<f32>(scaledTime * 0.3, 0.0));
+  let caustic = pow(1.0 - c1, 4.0) * exp(-waterDepth * 0.3);
+
+  return WaterSurfaceResult(displacement, waterNormal, foam, caustic);
+}
+`;
+  }
+};
+function compileShaderGraph(graph, options) {
+  const compiler = new ShaderGraphCompiler(graph, options);
+  return compiler.compile();
+}
+export {
+  ADVANCED_MATERIAL_NODES,
+  ALL_NODE_TEMPLATES,
+  COLOR_NODES,
+  INPUT_NODES,
+  MATH_NODES,
+  OUTPUT_NODES,
+  SCREEN_SPACE_NODES,
+  ShaderGraph,
+  ShaderGraphCompiler,
+  TEXTURE_NODES,
+  TRIG_NODES,
+  TYPE_SIZES,
+  UTILITY_NODES,
+  VECTOR_NODES,
+  VOLUMETRIC_NODES,
+  areTypesCompatible,
+  compileShaderGraph,
+  getNodeTemplate,
+  getTypeConversion
+};