@triforge/shader-core 0.1.0

package/dist/nodes/process/PrincipledBSDF.js

@@ -0,0 +1,75 @@
+import { ProcessNode } from '../../core/ProcessNode.js';
+/**
+ * Principled BSDF — Blender "Principled BSDF" node equivalent.
+ *
+ * Inputs:  baseColor, metallic, roughness, ior, alpha, normal
+ * Outputs: BSDF (shader)
+ */
+export class PrincipledBSDF extends ProcessNode {
+    get nodeType() { return 'PrincipledBSDF'; }
+    get metadata() {
+        return { label: 'Principled BSDF', category: 'Shader', color: '#336699', cost: 'medium', costNote: 'Schlick Fresnel + GGX — heavier on mobile.' };
+    }
+    constructor(inputs = {}) {
+        super('PrincipledBSDF');
+        this._inputs = this.createInputs(inputs, {
+            baseColor: ['color', '#ffffff'],
+            metallic: ['float', 0.0],
+            roughness: ['float', 0.5],
+            ior: ['float', 1.5],
+            alpha: ['float', 1.0],
+            normal: ['color', null],
+        });
+        this._outputs = this.createOutputs({ BSDF: 'shader' });
+    }
+    getInputSockets() { return this._inputs; }
+    getOutputSockets() { return this._outputs; }
+    compileDefs() { return this.glslFunction ?? PrincipledBSDF.glslFunction; }
+    compileCall(ctx) {
+        const normal = this._inputs.normal.isConnected()
+            ? ctx.outputVar(this._inputs.normal.connection.node, this._inputs.normal.connection.name)
+            : 'normalize(vNormal)';
+        return `vec3 ${ctx.outputVar(this, 'BSDF')} = _st_principledBSDF(${ctx.resolveInput(this._inputs.baseColor)}, ${ctx.resolveInput(this._inputs.metallic)}, ${ctx.resolveInput(this._inputs.roughness)}, ${ctx.resolveInput(this._inputs.ior)}, ${ctx.resolveInput(this._inputs.alpha)}, ${normal});`;
+    }
+}
+PrincipledBSDF.instanceSpecificDef = false;
+PrincipledBSDF.glslFunction = `
+// Set these on material.uniforms after compile()
+#ifndef _ST_HAIR_LIGHT_UNIFORMS
+#define _ST_HAIR_LIGHT_UNIFORMS
+uniform vec3 uSunDirection;
+uniform vec3 uSunColor;
+uniform vec3 uAmbientColor;
+#endif
+
+vec3 _st_schlick(vec3 F0, float c) {
+  return F0 + (1.0 - F0) * pow(clamp(1.0 - c, 0.0, 1.0), 5.0);
+}
+float _st_ggx(float NdotH, float r) {
+  float a = r * r, a2 = a * a;
+  float d = (NdotH * NdotH) * (a2 - 1.0) + 1.0;
+  return a2 / max(3.14159 * d * d, 1e-7);
+}
+float _st_geo(float NdotX, float r) {
+  float k = (r + 1.0) * (r + 1.0) / 8.0;
+  return NdotX / max(NdotX * (1.0 - k) + k, 1e-7);
+}
+vec3 _st_principledBSDF(vec3 base, float metallic, float roughness, float ior, float alpha, vec3 N) {
+  vec3  V     = normalize(cameraPosition - vPosition);
+  vec3  L     = normalize(uSunDirection);
+  vec3  H     = normalize(L + V);
+  float r     = max(roughness, 0.04);
+  float NdotL = max(dot(N, L), 0.0);
+  float NdotV = max(dot(N, V), 1e-4);
+  float NdotH = max(dot(N, H), 0.0);
+  float HdotV = max(dot(H, V), 0.0);
+  float f0s   = pow((1.0 - ior) / (1.0 + ior), 2.0);
+  vec3  F0    = mix(vec3(f0s), base, metallic);
+  vec3  F     = _st_schlick(F0, HdotV);
+  float D     = _st_ggx(NdotH, r);
+  float G     = _st_geo(NdotL, r) * _st_geo(NdotV, r);
+  vec3  spec  = (D * G * F) / max(4.0 * NdotV * NdotL, 1e-7);
+  vec3  kD    = (1.0 - F) * (1.0 - metallic);
+  vec3  ambient = uAmbientColor * base;
+  return ambient + (kD * base / 3.14159 + spec * uSunColor) * NdotL;
+}`;

package/dist/nodes/process/PrincipledHair.d.ts

@@ -0,0 +1,63 @@
+import { ProcessNode } from '../../core/ProcessNode.js';
+import type { NodeMetadata } from '../../core/ShaderNode.js';
+import type { CompileContext } from '../../core/CompileContext.js';
+import type { OutputSocket } from '../../core/OutputSocket.js';
+export interface PrincipledHairInputs {
+    /** Base hair color. Blender: Color. */
+    color?: OutputSocket | string;
+    /** Longitudinal roughness — scattering along the strand axis. Blender: Roughness. */
+    roughness?: OutputSocket | number;
+    /** Azimuthal roughness — scattering around the strand. Blender: Radial Roughness. */
+    radialRoughness?: OutputSocket | number;
+    /** Clear-coat specular intensity. Blender: Coat. */
+    coat?: OutputSocket | number;
+    /** Index of refraction — affects R-lobe highlight color. Blender: IOR. */
+    ior?: OutputSocket | number;
+    /** Longitudinal shift of specular lobes. Blender: Offset. */
+    offset?: OutputSocket | number;
+    /** Per-strand color variation amount [0,1]. Blender: Random Color. */
+    randomColor?: OutputSocket | number;
+    /** Per-strand roughness variation amount [0,1]. Blender: Random Roughness. */
+    randomRoughness?: OutputSocket | number;
+    /** Random seed input — connect HairInfo.Random for per-strand variation. */
+    random?: OutputSocket | number;
+}
+/**
+ * Principled Hair BSDF — Blender "Principled Hair BSDF" node equivalent.
+ *
+ * Implements a Kajiya-Kay dual-lobe model suitable for real-time rendering:
+ *   • Diffuse:      sin(T, L)  — angle between tangent and light
+ *   • R lobe:       primary specular highlight (white, sharp, IOR-tinted)
+ *   • TRT lobe:     secondary specular (colored, broader, offset in opposite direction)
+ *   • Coat:         clear-coat gloss on top
+ *
+ * Connect HairInfo.TangentNormal to the internal `tangent` socket and
+ * HairInfo.Random to `random` for correct per-strand behavior.
+ *
+ * Inputs:  color, roughness, radialRoughness, coat, ior, offset,
+ *          randomColor, randomRoughness, random, tangent
+ * Outputs: BSDF (shader)
+ */
+export declare class PrincipledHair extends ProcessNode {
+    get nodeType(): string;
+    static instanceSpecificDef: boolean;
+    get metadata(): NodeMetadata;
+    static glslFunction: string;
+    private readonly _inputs;
+    private readonly _outputs;
+    constructor(inputs?: PrincipledHairInputs);
+    getInputSockets(): Record<string, import("../../core/InputSocket.js").InputSocket<unknown>>;
+    getOutputSockets(): Record<string, OutputSocket>;
+    compileDefs(): string;
+    vertexInjections(): ({
+        attrName: string;
+        attrType: "vec3";
+        varyingName: string;
+    } | {
+        attrName: string;
+        attrType: "float";
+        varyingName: string;
+    })[];
+    compileCall(ctx: CompileContext): string;
+}
+//# sourceMappingURL=PrincipledHair.d.ts.map

package/dist/nodes/process/PrincipledHair.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PrincipledHair.d.ts","sourceRoot":"","sources":["../../../src/nodes/process/PrincipledHair.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAA;AACvD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAA;AAC5D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAA;AAClE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAA;AAE9D,MAAM,WAAW,oBAAoB;IACnC,uCAAuC;IACvC,KAAK,CAAC,EAAa,YAAY,GAAG,MAAM,CAAA;IACxC,qFAAqF;IACrF,SAAS,CAAC,EAAS,YAAY,GAAG,MAAM,CAAA;IACxC,qFAAqF;IACrF,eAAe,CAAC,EAAG,YAAY,GAAG,MAAM,CAAA;IACxC,oDAAoD;IACpD,IAAI,CAAC,EAAc,YAAY,GAAG,MAAM,CAAA;IACxC,0EAA0E;IAC1E,GAAG,CAAC,EAAe,YAAY,GAAG,MAAM,CAAA;IACxC,6DAA6D;IAC7D,MAAM,CAAC,EAAY,YAAY,GAAG,MAAM,CAAA;IACxC,sEAAsE;IACtE,WAAW,CAAC,EAAO,YAAY,GAAG,MAAM,CAAA;IACxC,8EAA8E;IAC9E,eAAe,CAAC,EAAG,YAAY,GAAG,MAAM,CAAA;IACxC,4EAA4E;IAC5E,MAAM,CAAC,EAAY,YAAY,GAAG,MAAM,CAAA;CACzC;AAED;;;;;;;;;;;;;;;GAeG;AACH,qBAAa,cAAe,SAAQ,WAAW;IAC7C,IAAI,QAAQ,WAA8B;IAC1C,MAAM,CAAC,mBAAmB,UAAQ;IAElC,IAAI,QAAQ,IAAI,YAAY,CAE3B;IAGD,MAAM,CAAC,YAAY,SAsEnB;IAEA,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA2E;IACnG,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAmE;gBAEhF,MAAM,GAAE,oBAAyB;IAiB7C,eAAe;IACf,gBAAgB;IAChB,WAAW;IAGX,gBAAgB;;;;;;;;;IAOhB,WAAW,CAAC,GAAG,EAAE,cAAc,GAAG,MAAM;CAgBzC"}

package/dist/nodes/process/PrincipledHair.js

@@ -0,0 +1,137 @@
+import { ProcessNode } from '../../core/ProcessNode.js';
+/**
+ * Principled Hair BSDF — Blender "Principled Hair BSDF" node equivalent.
+ *
+ * Implements a Kajiya-Kay dual-lobe model suitable for real-time rendering:
+ *   • Diffuse:      sin(T, L)  — angle between tangent and light
+ *   • R lobe:       primary specular highlight (white, sharp, IOR-tinted)
+ *   • TRT lobe:     secondary specular (colored, broader, offset in opposite direction)
+ *   • Coat:         clear-coat gloss on top
+ *
+ * Connect HairInfo.TangentNormal to the internal `tangent` socket and
+ * HairInfo.Random to `random` for correct per-strand behavior.
+ *
+ * Inputs:  color, roughness, radialRoughness, coat, ior, offset,
+ *          randomColor, randomRoughness, random, tangent
+ * Outputs: BSDF (shader)
+ */
+export class PrincipledHair extends ProcessNode {
+    get nodeType() { return 'PrincipledHair'; }
+    get metadata() {
+        return { label: 'Principled Hair BSDF', category: 'Shader', color: '#5a3a1a', cost: 'medium' };
+    }
+    constructor(inputs = {}) {
+        super('PrincipledHair');
+        this._inputs = this.createInputs(inputs, {
+            color: ['color', inputs.color ?? '#8b6050'],
+            roughness: ['float', inputs.roughness ?? 0.3],
+            radialRoughness: ['float', inputs.radialRoughness ?? 0.5],
+            coat: ['float', inputs.coat ?? 0.2],
+            ior: ['float', inputs.ior ?? 1.55],
+            offset: ['float', inputs.offset ?? 0.04],
+            randomColor: ['float', inputs.randomColor ?? 0.1],
+            randomRoughness: ['float', inputs.randomRoughness ?? 0.0],
+            random: ['float', inputs.random ?? 0.0],
+            tangent: ['color', null],
+        });
+        this._outputs = this.createOutputs({ BSDF: 'shader' });
+    }
+    getInputSockets() { return this._inputs; }
+    getOutputSockets() { return this._outputs; }
+    compileDefs() { return PrincipledHair.glslFunction; }
+    // Ensure strandTangent is always available even without HairInfo in the graph
+    vertexInjections() {
+        return [
+            { attrName: 'strandTangent', attrType: 'vec3', varyingName: 'vStrandTangent' },
+            { attrName: 'strandRandom', attrType: 'float', varyingName: 'vStrandRandom' },
+        ];
+    }
+    compileCall(ctx) {
+        const color = ctx.resolveInput(this._inputs.color);
+        const roughness = ctx.resolveInput(this._inputs.roughness);
+        const radialRoughness = ctx.resolveInput(this._inputs.radialRoughness);
+        const coat = ctx.resolveInput(this._inputs.coat);
+        const ior = ctx.resolveInput(this._inputs.ior);
+        const offset = ctx.resolveInput(this._inputs.offset);
+        const randomColor = ctx.resolveInput(this._inputs.randomColor);
+        const randomRoughness = ctx.resolveInput(this._inputs.randomRoughness);
+        const random = ctx.resolveInput(this._inputs.random);
+        const tangent = this._inputs.tangent.isConnected()
+            ? ctx.outputVar(this._inputs.tangent.connection.node, this._inputs.tangent.connection.name)
+            : 'normalize(vStrandTangent)'; // fallback: read attribute directly if not connected
+        return `vec3 ${ctx.outputVar(this, 'BSDF')} = _st_principledHair(${color}, ${roughness}, ${radialRoughness}, ${coat}, ${ior}, ${offset}, ${randomColor}, ${randomRoughness}, ${random}, ${tangent});`;
+    }
+}
+PrincipledHair.instanceSpecificDef = false;
+// Light uniforms guarded by a #define so they survive alongside PrincipledBSDF in the same graph.
+PrincipledHair.glslFunction = `
+#ifndef _ST_HAIR_LIGHT_UNIFORMS
+#define _ST_HAIR_LIGHT_UNIFORMS
+uniform vec3 uSunDirection;
+uniform vec3 uSunColor;
+uniform vec3 uAmbientColor;
+#endif
+
+float _st_hairHash(float n) {
+  return fract(sin(n * 127.1 + 311.7) * 43758.5453);
+}
+
+// Kajiya-Kay dual-lobe hair BSDF.
+// T  = strand tangent (unit, world space)
+// R  = primary specular exponent = 1 / (roughness^2)
+// R2 = secondary specular exponent = 1 / (radialRoughness^2)
+vec3 _st_principledHair(
+  vec3  color,
+  float roughness,
+  float radialRoughness,
+  float coat,
+  float ior,
+  float offset,
+  float randomColor,
+  float randomRoughness,
+  float rnd,
+  vec3  T
+) {
+  // Per-strand variation
+  float rc = _st_hairHash(rnd * 1.3731 + 0.1);
+  float rr = _st_hairHash(rnd * 2.7183 + 0.2);
+  color     = mix(color, color * (0.6 + 0.8 * rc), randomColor);
+  roughness = clamp(roughness + (rr - 0.5) * randomRoughness * 0.5, 0.02, 1.0);
+
+  vec3  V   = normalize(cameraPosition - vPosition);
+  vec3  L   = normalize(uSunDirection);
+  vec3  H   = normalize(L + V);
+  vec3  N   = normalize(vNormal);
+
+  // Kajiya-Kay diffuse: sin(angle T, L)
+  float cosT  = dot(T, L);
+  float sinT  = sqrt(max(1.0 - cosT * cosT, 0.0));
+  float diff  = sinT * max(dot(N, L) * 0.5 + 0.5, 0.0);  // wrap diffuse
+
+  // R lobe — primary specular, shifted by +offset along normal
+  float f0    = pow(clamp((1.0 - ior) / (1.0 + ior), 0.0, 1.0), 2.0);
+  vec3  T1    = normalize(T + offset * N);
+  float cosTH1 = dot(T1, H);
+  float sinTH1 = sqrt(max(1.0 - cosTH1 * cosTH1, 0.0));
+  float exp1   = max(1.0 / max(roughness * roughness, 0.001), 1.0);
+  float spec1  = pow(sinTH1, exp1);
+  vec3  F1     = vec3(f0) + (vec3(1.0) - vec3(f0)) * pow(1.0 - max(dot(H, V), 0.0), 5.0);
+
+  // TRT lobe — secondary specular, shifted by -2*offset, colored
+  vec3  T2    = normalize(T - 2.0 * offset * N);
+  float cosTH2 = dot(T2, H);
+  float sinTH2 = sqrt(max(1.0 - cosTH2 * cosTH2, 0.0));
+  float rr2    = clamp(radialRoughness, 0.02, 1.0);
+  float exp2   = max(1.0 / max(rr2 * rr2, 0.001), 1.0);
+  float spec2  = pow(sinTH2, exp2) * 0.25;
+
+  // Coat gloss
+  float cosTHc  = dot(T, H);
+  float sinTHc  = sqrt(max(1.0 - cosTHc * cosTHc, 0.0));
+  float coatSpec = pow(sinTHc, 128.0) * coat;
+
+  vec3 diffuse  = color * (uSunColor * diff + uAmbientColor);
+  vec3 specular = uSunColor * (F1 * spec1 + vec3(coatSpec)) + color * uSunColor * spec2;
+
+  return diffuse + specular;
+}`;

package/dist/nodes/process/PrincipledVolume.d.ts

@@ -0,0 +1,37 @@
+import { ProcessNode } from '../../core/ProcessNode.js';
+import type { NodeMetadata } from '../../core/ShaderNode.js';
+import type { CompileContext } from '../../core/CompileContext.js';
+import type { OutputSocket } from '../../core/OutputSocket.js';
+export interface PrincipledVolumeInputs {
+    color?: OutputSocket | string;
+    density?: OutputSocket | number;
+    anisotropy?: OutputSocket | number;
+    absorptionColor?: OutputSocket | string;
+    emissionColor?: OutputSocket | string;
+    emissionStrength?: OutputSocket | number;
+    blackbodyIntensity?: OutputSocket | number;
+    temperature?: OutputSocket | number;
+}
+/**
+ * Principled Volume — Blender "Principled Volume" shader node.
+ * Combines scatter, absorption, and emission into a single volume shader.
+ * Connect to MaterialOutput.volume.
+ *
+ * Inputs:  color, density, anisotropy, absorptionColor, emissionColor,
+ *          emissionStrength, blackbodyIntensity, temperature
+ * Outputs: Volume (shader)
+ */
+export declare class PrincipledVolume extends ProcessNode {
+    get nodeType(): string;
+    static instanceSpecificDef: boolean;
+    get metadata(): NodeMetadata;
+    static glslFunction: string;
+    private readonly _inputs;
+    private readonly _outputs;
+    constructor(inputs?: PrincipledVolumeInputs);
+    getInputSockets(): Record<string, import("../../core/InputSocket.js").InputSocket<unknown>>;
+    getOutputSockets(): Record<string, OutputSocket>;
+    compileDefs(): string;
+    compileCall(ctx: CompileContext): string;
+}
+//# sourceMappingURL=PrincipledVolume.d.ts.map

package/dist/nodes/process/PrincipledVolume.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PrincipledVolume.d.ts","sourceRoot":"","sources":["../../../src/nodes/process/PrincipledVolume.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAA;AACvD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAA;AAC5D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAA;AAClE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAA;AAE9D,MAAM,WAAW,sBAAsB;IACrC,KAAK,CAAC,EAAc,YAAY,GAAG,MAAM,CAAA;IACzC,OAAO,CAAC,EAAY,YAAY,GAAG,MAAM,CAAA;IACzC,UAAU,CAAC,EAAS,YAAY,GAAG,MAAM,CAAA;IACzC,eAAe,CAAC,EAAI,YAAY,GAAG,MAAM,CAAA;IACzC,aAAa,CAAC,EAAM,YAAY,GAAG,MAAM,CAAA;IACzC,gBAAgB,CAAC,EAAG,YAAY,GAAG,MAAM,CAAA;IACzC,kBAAkB,CAAC,EAAE,YAAY,GAAG,MAAM,CAAA;IAC1C,WAAW,CAAC,EAAQ,YAAY,GAAG,MAAM,CAAA;CAC1C;AAED;;;;;;;;GAQG;AACH,qBAAa,gBAAiB,SAAQ,WAAW;IAC/C,IAAI,QAAQ,WAAgC;IAC5C,MAAM,CAAC,mBAAmB,UAAQ;IAElC,IAAI,QAAQ,IAAI,YAAY,CAE3B;IAED,MAAM,CAAC,YAAY,SAqBnB;IAEA,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA2E;IACnG,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAmE;gBAEhF,MAAM,GAAE,sBAA2B;IAe/C,eAAe;IACf,gBAAgB;IAChB,WAAW;IAEX,WAAW,CAAC,GAAG,EAAE,cAAc,GAAG,MAAM;CAWzC"}

package/dist/nodes/process/PrincipledVolume.js

@@ -0,0 +1,67 @@
+import { ProcessNode } from '../../core/ProcessNode.js';
+/**
+ * Principled Volume — Blender "Principled Volume" shader node.
+ * Combines scatter, absorption, and emission into a single volume shader.
+ * Connect to MaterialOutput.volume.
+ *
+ * Inputs:  color, density, anisotropy, absorptionColor, emissionColor,
+ *          emissionStrength, blackbodyIntensity, temperature
+ * Outputs: Volume (shader)
+ */
+export class PrincipledVolume extends ProcessNode {
+    get nodeType() { return 'PrincipledVolume'; }
+    get metadata() {
+        return { label: 'Principled Volume', category: 'Shader', color: '#1a6688', cost: 'high' };
+    }
+    constructor(inputs = {}) {
+        super('PrincipledVolume');
+        this._inputs = this.createInputs(inputs, {
+            color: ['color', '#ffffff'],
+            density: ['float', inputs.density ?? 1.0],
+            anisotropy: ['float', inputs.anisotropy ?? 0.0],
+            absorptionColor: ['color', '#000000'],
+            emissionColor: ['color', '#000000'],
+            emissionStrength: ['float', inputs.emissionStrength ?? 0.0],
+            blackbodyIntensity: ['float', inputs.blackbodyIntensity ?? 0.0],
+            temperature: ['float', inputs.temperature ?? 1000.0],
+        });
+        this._outputs = this.createOutputs({ Volume: 'shader' });
+    }
+    getInputSockets() { return this._inputs; }
+    getOutputSockets() { return this._outputs; }
+    compileDefs() { return PrincipledVolume.glslFunction; }
+    compileCall(ctx) {
+        const color = ctx.resolveInput(this._inputs.color);
+        const density = ctx.resolveInput(this._inputs.density);
+        const anisotropy = ctx.resolveInput(this._inputs.anisotropy);
+        const absorptionColor = ctx.resolveInput(this._inputs.absorptionColor);
+        const emissionColor = ctx.resolveInput(this._inputs.emissionColor);
+        const emissionStrength = ctx.resolveInput(this._inputs.emissionStrength);
+        const blackbodyIntensity = ctx.resolveInput(this._inputs.blackbodyIntensity);
+        const temperature = ctx.resolveInput(this._inputs.temperature);
+        return `vec3 ${ctx.outputVar(this, 'Volume')} = _st_principledVolume(${color}, ${density}, ${anisotropy}, ${absorptionColor}, ${emissionColor}, ${emissionStrength}, ${blackbodyIntensity}, ${temperature});`;
+    }
+}
+PrincipledVolume.instanceSpecificDef = false;
+PrincipledVolume.glslFunction = `
+vec3 _st_principledVolume(
+  vec3  scatterColor,   float density,
+  float anisotropy,     vec3  absorptionColor,
+  vec3  emissionColor,  float emissionStrength,
+  float blackbodyIntensity, float temperature
+) {
+  float g  = clamp(anisotropy, -0.9999, 0.9999);
+  float g2 = g * g;
+  float phase = (1.0 - g2) / pow(1.0 + g2, 1.5);
+
+  vec3 scatter    = scatterColor * density * phase;
+  vec3 absorption = absorptionColor * density;
+  vec3 emission   = emissionColor * emissionStrength;
+
+  // Simplified blackbody tint: blend toward hot white at high temperature
+  float tNorm = clamp((temperature - 800.0) / 4200.0, 0.0, 1.0);
+  vec3  bb    = mix(vec3(1.0, 0.2, 0.0), vec3(1.0, 0.95, 0.8), tNorm);
+  emission   += bb * blackbodyIntensity * density;
+
+  return scatter + emission - absorption * 0.5;
+}`;

package/dist/nodes/process/RGBCurves.d.ts

@@ -0,0 +1,45 @@
+import { ProcessNode } from '../../core/ProcessNode.js';
+import type { NodeMetadata } from '../../core/ShaderNode.js';
+import type { CompileContext } from '../../core/CompileContext.js';
+import type { OutputSocket } from '../../core/OutputSocket.js';
+/** A curve point [x, y] where both x and y are in [0, 1]. */
+export type CurvePoint = [number, number];
+export interface RGBCurvesInputs {
+    color?: OutputSocket | string;
+    fac?: OutputSocket | number;
+    /**
+     * Per-channel piecewise linear curve as [[x,y], ...] control points.
+     * Points are sorted by x automatically. Default = identity [[0,0],[1,1]].
+     */
+    rPoints?: CurvePoint[];
+    gPoints?: CurvePoint[];
+    bPoints?: CurvePoint[];
+    /** Master curve applied after per-channel curves. Default = identity. */
+    masterPoints?: CurvePoint[];
+}
+/**
+ * RGB Curves — Blender "RGB Curves" node equivalent.
+ * Full piecewise linear curve per channel (R, G, B) plus a master curve.
+ * Matches Blender's RGB Curves node exactly — arbitrary control points,
+ * piecewise linear interpolation between them.
+ *
+ * Inputs:  color, fac
+ * Outputs: Color (color)
+ */
+export declare class RGBCurves extends ProcessNode {
+    get nodeType(): string;
+    static instanceSpecificDef: boolean;
+    get metadata(): NodeMetadata;
+    private readonly rPts;
+    private readonly gPts;
+    private readonly bPts;
+    private readonly mPts;
+    private readonly _inputs;
+    private readonly _outputs;
+    constructor(inputs?: RGBCurvesInputs);
+    getInputSockets(): Record<string, import("../../core/InputSocket.js").InputSocket<unknown>>;
+    getOutputSockets(): Record<string, OutputSocket>;
+    compileDefs(): string;
+    compileCall(ctx: CompileContext): string;
+}
+//# sourceMappingURL=RGBCurves.d.ts.map

package/dist/nodes/process/RGBCurves.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RGBCurves.d.ts","sourceRoot":"","sources":["../../../src/nodes/process/RGBCurves.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAA;AACvD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAA;AAC5D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAA;AAClE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAA;AAE9D,6DAA6D;AAC7D,MAAM,MAAM,UAAU,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;AAEzC,MAAM,WAAW,eAAe;IAC9B,KAAK,CAAC,EAAG,YAAY,GAAG,MAAM,CAAA;IAC9B,GAAG,CAAC,EAAK,YAAY,GAAG,MAAM,CAAA;IAC9B;;;OAGG;IACH,OAAO,CAAC,EAAE,UAAU,EAAE,CAAA;IACtB,OAAO,CAAC,EAAE,UAAU,EAAE,CAAA;IACtB,OAAO,CAAC,EAAE,UAAU,EAAE,CAAA;IACtB,yEAAyE;IACzE,YAAY,CAAC,EAAE,UAAU,EAAE,CAAA;CAC5B;AAED;;;;;;;;GAQG;AACH,qBAAa,SAAU,SAAQ,WAAW;IACxC,IAAI,QAAQ,WAAyB;IACrC,MAAM,CAAC,mBAAmB,UAAO;IAEjC,IAAI,QAAQ,IAAI,YAAY,CAE3B;IAED,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAc;IACnC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAc;IACnC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAc;IACnC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAc;IACnC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA2E;IACnG,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAmE;gBAEhF,MAAM,GAAE,eAAoB;IAcxC,eAAe;IACf,gBAAgB;IAEhB,WAAW,IAAI,MAAM;IAUrB,WAAW,CAAC,GAAG,EAAE,cAAc,GAAG,MAAM;CAkBzC"}

package/dist/nodes/process/RGBCurves.js

@@ -0,0 +1,81 @@
+import { ProcessNode } from '../../core/ProcessNode.js';
+/**
+ * RGB Curves — Blender "RGB Curves" node equivalent.
+ * Full piecewise linear curve per channel (R, G, B) plus a master curve.
+ * Matches Blender's RGB Curves node exactly — arbitrary control points,
+ * piecewise linear interpolation between them.
+ *
+ * Inputs:  color, fac
+ * Outputs: Color (color)
+ */
+export class RGBCurves extends ProcessNode {
+    get nodeType() { return 'RGBCurves'; }
+    get metadata() {
+        return { label: 'RGB Curves', category: 'Color', color: '#633060', cost: 'low' };
+    }
+    constructor(inputs = {}) {
+        super('RGBCurves');
+        const identity = [[0, 0], [1, 1]];
+        this.rPts = sortPoints(inputs.rPoints ?? identity);
+        this.gPts = sortPoints(inputs.gPoints ?? identity);
+        this.bPts = sortPoints(inputs.bPoints ?? identity);
+        this.mPts = sortPoints(inputs.masterPoints ?? identity);
+        this._inputs = this.createInputs(inputs, {
+            color: ['color', '#ffffff'],
+            fac: ['float', inputs.fac ?? 1.0],
+        });
+        this._outputs = this.createOutputs({ Color: 'color' });
+    }
+    getInputSockets() { return this._inputs; }
+    getOutputSockets() { return this._outputs; }
+    compileDefs() {
+        // Emit one piecewise linear evaluator function per curve per instance
+        return [
+            buildCurveFn(`_rc_r_${this.id}`, this.rPts),
+            buildCurveFn(`_rc_g_${this.id}`, this.gPts),
+            buildCurveFn(`_rc_b_${this.id}`, this.bPts),
+            buildCurveFn(`_rc_m_${this.id}`, this.mPts),
+        ].join('\n');
+    }
+    compileCall(ctx) {
+        const col = ctx.resolveInput(this._inputs.color);
+        const fac = ctx.resolveInput(this._inputs.fac);
+        const id = this.id;
+        const out = ctx.outputVar(this, 'Color');
+        return [
+            `vec3 _rc_${id} = ${col};`,
+            // Per-channel curves
+            `_rc_${id}.r = _rc_r_${id}(_rc_${id}.r);`,
+            `_rc_${id}.g = _rc_g_${id}(_rc_${id}.g);`,
+            `_rc_${id}.b = _rc_b_${id}(_rc_${id}.b);`,
+            // Master curve applied to each channel
+            `_rc_${id}.r = _rc_m_${id}(_rc_${id}.r);`,
+            `_rc_${id}.g = _rc_m_${id}(_rc_${id}.g);`,
+            `_rc_${id}.b = _rc_m_${id}(_rc_${id}.b);`,
+            `vec3 ${out} = mix(${col}, clamp(_rc_${id}, 0.0, 1.0), clamp(${fac}, 0.0, 1.0));`,
+        ].join('\n  ');
+    }
+}
+RGBCurves.instanceSpecificDef = true;
+// ── helpers ───────────────────────────────────────────────────────────────────
+function sortPoints(pts) {
+    return [...pts].sort((a, b) => a[0] - b[0]);
+}
+function buildCurveFn(name, pts) {
+    // No array initializers — GLSL ES 1.00 doesn't support float[n](...) syntax.
+    // Generate a fully unrolled if/else chain with all values baked as literals.
+    const f = (n) => n.toFixed(5);
+    const clamps = `
+  if (t <= ${f(pts[0][0])}) return ${f(pts[0][1])};
+  if (t >= ${f(pts[pts.length - 1][0])}) return ${f(pts[pts.length - 1][1])};`;
+    const segments = pts.slice(0, -1).map((p, i) => {
+        const x0 = f(p[0]), y0 = f(p[1]);
+        const x1 = f(pts[i + 1][0]), y1 = f(pts[i + 1][1]);
+        return `  if (t <= ${x1}) return mix(${y0}, ${y1}, (t - ${x0}) / (${x1} - ${x0}));`;
+    }).join('\n');
+    return `
+float ${name}(float t) {${clamps}
+${segments}
+  return ${f(pts[pts.length - 1][1])};
+}`;
+}

package/dist/nodes/process/RGBtoBW.d.ts

@@ -0,0 +1,28 @@
+import { ProcessNode } from '../../core/ProcessNode.js';
+import type { NodeMetadata } from '../../core/ShaderNode.js';
+import type { CompileContext } from '../../core/CompileContext.js';
+import type { OutputSocket } from '../../core/OutputSocket.js';
+export interface RGBtoBWInputs {
+    color?: OutputSocket | string;
+}
+/**
+ * RGB to BW — Blender "RGB to BW" node equivalent.
+ * Converts a colour to a greyscale float using luminance weights.
+ *
+ * Inputs:  color (color)
+ * Outputs: Val (float) — luminance value [0-1]
+ */
+export declare class RGBtoBW extends ProcessNode {
+    get nodeType(): string;
+    static instanceSpecificDef: boolean;
+    get metadata(): NodeMetadata;
+    static glslFunction: string;
+    private readonly _inputs;
+    private readonly _outputs;
+    constructor(inputs?: RGBtoBWInputs);
+    getInputSockets(): Record<string, import("../../core/InputSocket.js").InputSocket<unknown>>;
+    getOutputSockets(): Record<string, OutputSocket>;
+    compileDefs(): string;
+    compileCall(ctx: CompileContext): string;
+}
+//# sourceMappingURL=RGBtoBW.d.ts.map

package/dist/nodes/process/RGBtoBW.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RGBtoBW.d.ts","sourceRoot":"","sources":["../../../src/nodes/process/RGBtoBW.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAA;AACvD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAA;AAC5D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAA;AAClE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAA;AAE9D,MAAM,WAAW,aAAa;IAC5B,KAAK,CAAC,EAAE,YAAY,GAAG,MAAM,CAAA;CAC9B;AAED;;;;;;GAMG;AACH,qBAAa,OAAQ,SAAQ,WAAW;IACtC,IAAI,QAAQ,WAAuB;IACnC,MAAM,CAAC,mBAAmB,UAAQ;IAElC,IAAI,QAAQ,IAAI,YAAY,CAE3B;IAED,MAAM,CAAC,YAAY,SAGnB;IAEA,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA2E;IACnG,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAmE;gBAEhF,MAAM,GAAE,aAAkB;IAMtC,eAAe;IACf,gBAAgB;IAChB,WAAW;IAEX,WAAW,CAAC,GAAG,EAAE,cAAc,GAAG,MAAM;CAIzC"}

package/dist/nodes/process/RGBtoBW.js

@@ -0,0 +1,31 @@
+import { ProcessNode } from '../../core/ProcessNode.js';
+/**
+ * RGB to BW — Blender "RGB to BW" node equivalent.
+ * Converts a colour to a greyscale float using luminance weights.
+ *
+ * Inputs:  color (color)
+ * Outputs: Val (float) — luminance value [0-1]
+ */
+export class RGBtoBW extends ProcessNode {
+    get nodeType() { return 'RGBtoBW'; }
+    get metadata() {
+        return { label: 'RGB to BW', category: 'Converter', color: '#4a3a6a', cost: 'low' };
+    }
+    constructor(inputs = {}) {
+        super('RGBtoBW');
+        this._inputs = this.createInputs(inputs, { color: ['color', '#ffffff'] });
+        this._outputs = this.createOutputs({ Val: 'float' });
+    }
+    getInputSockets() { return this._inputs; }
+    getOutputSockets() { return this._outputs; }
+    compileDefs() { return RGBtoBW.glslFunction; }
+    compileCall(ctx) {
+        const col = ctx.resolveInput(this._inputs.color);
+        return `float ${ctx.outputVar(this, 'Val')} = _st_rgbToBw(${col});`;
+    }
+}
+RGBtoBW.instanceSpecificDef = false;
+RGBtoBW.glslFunction = `
+float _st_rgbToBw(vec3 col) {
+  return dot(col, vec3(0.2126, 0.7152, 0.0722));
+}`;

package/dist/nodes/process/RefractionBSDF.d.ts

@@ -0,0 +1,32 @@
+import { ProcessNode } from '../../core/ProcessNode.js';
+import type { NodeMetadata } from '../../core/ShaderNode.js';
+import type { CompileContext } from '../../core/CompileContext.js';
+import type { OutputSocket } from '../../core/OutputSocket.js';
+export interface RefractionBSDFInputs {
+    color?: OutputSocket | string;
+    roughness?: OutputSocket | number;
+    ior?: OutputSocket | number;
+    normal?: OutputSocket;
+}
+/**
+ * Refraction BSDF — Blender "Refraction BSDF" node equivalent.
+ * Simulates light bending through a transparent medium.
+ * Approximated in real-time using a tinted transmission colour.
+ *
+ * Inputs:  color, roughness, ior, normal
+ * Outputs: BSDF (shader)
+ */
+export declare class RefractionBSDF extends ProcessNode {
+    get nodeType(): string;
+    static instanceSpecificDef: boolean;
+    get metadata(): NodeMetadata;
+    static glslFunction: string;
+    private readonly _inputs;
+    private readonly _outputs;
+    constructor(inputs?: RefractionBSDFInputs);
+    getInputSockets(): Record<string, import("../../core/InputSocket.js").InputSocket<unknown>>;
+    getOutputSockets(): Record<string, OutputSocket>;
+    compileDefs(): string;
+    compileCall(ctx: CompileContext): string;
+}
+//# sourceMappingURL=RefractionBSDF.d.ts.map

package/dist/nodes/process/RefractionBSDF.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RefractionBSDF.d.ts","sourceRoot":"","sources":["../../../src/nodes/process/RefractionBSDF.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAA;AACvD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAA;AAC5D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAA;AAClE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAA;AAE9D,MAAM,WAAW,oBAAoB;IACnC,KAAK,CAAC,EAAM,YAAY,GAAG,MAAM,CAAA;IACjC,SAAS,CAAC,EAAE,YAAY,GAAG,MAAM,CAAA;IACjC,GAAG,CAAC,EAAQ,YAAY,GAAG,MAAM,CAAA;IACjC,MAAM,CAAC,EAAK,YAAY,CAAA;CACzB;AAED;;;;;;;GAOG;AACH,qBAAa,cAAe,SAAQ,WAAW;IAC7C,IAAI,QAAQ,WAA8B;IAC1C,MAAM,CAAC,mBAAmB,UAAQ;IAElC,IAAI,QAAQ,IAAI,YAAY,CAE3B;IAED,MAAM,CAAC,YAAY,SAOnB;IAEA,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA2E;IACnG,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAmE;gBAEhF,MAAM,GAAE,oBAAyB;IAW7C,eAAe;IACf,gBAAgB;IAChB,WAAW;IAEX,WAAW,CAAC,GAAG,EAAE,cAAc,GAAG,MAAM;CASzC"}