@triforge/shader-core 0.1.0

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

@@ -0,0 +1 @@
+{"version":3,"file":"ColorRamp.d.ts","sourceRoot":"","sources":["../../../src/nodes/process/ColorRamp.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAA;AACvD,OAAO,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAA;AAC7D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAA;AAC5D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAA;AAE9D,MAAM,WAAW,eAAe;IAC9B,GAAG,CAAC,EAAI,YAAY,GAAG,MAAM,CAAA;IAC7B,KAAK,CAAC,EAAE,MAAM,EAAE,CAAA;CACjB;AAED;;;;;GAKG;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,KAAK,CAAa;IACnC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA2E;IACnG,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAmE;gBAEhF,MAAM,GAAE,eAAoB;IASxC,eAAe;IACf,gBAAgB;IAEhB,WAAW,IAAI,MAAM;IAwBrB,WAAW,CAAC,GAAG,EAAE,cAAc,GAAG,MAAM;CAGzC"}

package/dist/nodes/process/ColorRamp.js

@@ -0,0 +1,49 @@
+import { ProcessNode } from '../../core/ProcessNode.js';
+import { CompileContext } from '../../core/CompileContext.js';
+/**
+ * Color Ramp — Blender "ColorRamp" node equivalent.
+ *
+ * Inputs:  fac (float)
+ * Outputs: Color (color)
+ */
+export class ColorRamp extends ProcessNode {
+    get nodeType() { return 'ColorRamp'; }
+    get metadata() {
+        return { label: 'Color Ramp', category: 'Converter', color: '#633060', cost: 'low' };
+    }
+    constructor(inputs = {}) {
+        super('ColorRamp');
+        this.stops = inputs.stops ?? ['#000000', '#ffffff'];
+        this._inputs = this.createInputs(inputs, {
+            fac: ['float', 0.5],
+        });
+        this._outputs = this.createOutputs({ Color: 'color' });
+    }
+    getInputSockets() { return this._inputs; }
+    getOutputSockets() { return this._outputs; }
+    compileDefs() {
+        const fn = `_st_colorRamp_${this.id}`;
+        const cs = this.stops.map(CompileContext.hexToVec3);
+        const n = cs.length;
+        if (n === 1) {
+            return `\nvec3 ${fn}(float t) { return ${cs[0]}; }`;
+        }
+        // if-else chain with baked-in constants — GLSL ES 1.00 compatible.
+        // Avoids vec3[] array initialisation and dynamic indexing which require ES 3.00.
+        const segs = n - 1;
+        const lines = [`\nvec3 ${fn}(float t) {`, `  float s = clamp(t, 0.0, 1.0);`];
+        for (let i = 0; i < segs; i++) {
+            const posA = (i / segs).toFixed(6);
+            const posB = ((i + 1) / segs).toFixed(6);
+            const frac = `((s - ${posA}) * ${segs}.0)`;
+            const stmt = `return mix(${cs[i]}, ${cs[i + 1]}, clamp(${frac}, 0.0, 1.0));`;
+            lines.push(i < segs - 1 ? `  if (s < ${posB}) ${stmt}` : `  ${stmt}`);
+        }
+        lines.push('}');
+        return lines.join('\n');
+    }
+    compileCall(ctx) {
+        return `vec3 ${ctx.outputVar(this, 'Color')} = _st_colorRamp_${this.id}(${ctx.resolveInput(this._inputs.fac)});`;
+    }
+}
+ColorRamp.instanceSpecificDef = true;

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

@@ -0,0 +1,34 @@
+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 type CombineColorMode = 'RGB' | 'HSV' | 'HSL';
+export interface CombineColorInputs {
+    red?: OutputSocket | number;
+    green?: OutputSocket | number;
+    blue?: OutputSocket | number;
+    mode?: CombineColorMode;
+}
+/**
+ * Combine Color — Blender 3.4+ "Combine Color" node equivalent.
+ * Combines three float channels into a color using RGB, HSV, or HSL mode.
+ * Replaces the older CombineRGB node and adds HSV/HSL support.
+ *
+ * Inputs:  red/green/blue (float) — semantics depend on mode
+ * Outputs: Color (color)
+ */
+export declare class CombineColor extends ProcessNode {
+    get nodeType(): string;
+    static instanceSpecificDef: boolean;
+    get metadata(): NodeMetadata;
+    static glslFunction: string;
+    private readonly mode;
+    private readonly _inputs;
+    private readonly _outputs;
+    constructor(inputs?: CombineColorInputs);
+    getInputSockets(): Record<string, import("../../core/InputSocket.js").InputSocket<unknown>>;
+    getOutputSockets(): Record<string, OutputSocket>;
+    compileDefs(): string;
+    compileCall(ctx: CompileContext): string;
+}
+//# sourceMappingURL=CombineColor.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"CombineColor.d.ts","sourceRoot":"","sources":["../../../src/nodes/process/CombineColor.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,MAAM,gBAAgB,GAAG,KAAK,GAAG,KAAK,GAAG,KAAK,CAAA;AAEpD,MAAM,WAAW,kBAAkB;IACjC,GAAG,CAAC,EAAI,YAAY,GAAG,MAAM,CAAA;IAC7B,KAAK,CAAC,EAAE,YAAY,GAAG,MAAM,CAAA;IAC7B,IAAI,CAAC,EAAG,YAAY,GAAG,MAAM,CAAA;IAC7B,IAAI,CAAC,EAAG,gBAAgB,CAAA;CACzB;AAED;;;;;;;GAOG;AACH,qBAAa,YAAa,SAAQ,WAAW;IAC3C,IAAI,QAAQ,WAA4B;IACxC,MAAM,CAAC,mBAAmB,UAAQ;IAElC,IAAI,QAAQ,IAAI,YAAY,CAE3B;IAED,MAAM,CAAC,YAAY,SAyBnB;IAEA,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAqB;IAC1C,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA2E;IACnG,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAmE;gBAEhF,MAAM,GAAE,kBAAuB;IAW3C,eAAe;IACf,gBAAgB;IAChB,WAAW;IAEX,WAAW,CAAC,GAAG,EAAE,cAAc,GAAG,MAAM;CAezC"}

package/dist/nodes/process/CombineColor.js

@@ -0,0 +1,69 @@
+import { ProcessNode } from '../../core/ProcessNode.js';
+/**
+ * Combine Color — Blender 3.4+ "Combine Color" node equivalent.
+ * Combines three float channels into a color using RGB, HSV, or HSL mode.
+ * Replaces the older CombineRGB node and adds HSV/HSL support.
+ *
+ * Inputs:  red/green/blue (float) — semantics depend on mode
+ * Outputs: Color (color)
+ */
+export class CombineColor extends ProcessNode {
+    get nodeType() { return 'CombineColor'; }
+    get metadata() {
+        return { label: 'Combine Color', category: 'Converter', color: '#633060', cost: 'low' };
+    }
+    constructor(inputs = {}) {
+        super('CombineColor');
+        this.mode = inputs.mode ?? 'RGB';
+        this._inputs = this.createInputs(inputs, {
+            red: ['float', 0.0],
+            green: ['float', 0.0],
+            blue: ['float', 0.0],
+        });
+        this._outputs = this.createOutputs({ Color: 'color' });
+    }
+    getInputSockets() { return this._inputs; }
+    getOutputSockets() { return this._outputs; }
+    compileDefs() { return CombineColor.glslFunction; }
+    compileCall(ctx) {
+        const r = ctx.resolveInput(this._inputs.red);
+        const g = ctx.resolveInput(this._inputs.green);
+        const b = ctx.resolveInput(this._inputs.blue);
+        const cv = ctx.outputVar(this, 'Color');
+        switch (this.mode) {
+            case 'HSV':
+                return `vec3 ${cv} = _st_hsvToRgb(vec3(${r}, ${g}, ${b}));`;
+            case 'HSL':
+                return `vec3 ${cv} = _st_hslToRgb(vec3(${r}, ${g}, ${b}));`;
+            default:
+                return `vec3 ${cv} = vec3(${r}, ${g}, ${b});`;
+        }
+    }
+}
+CombineColor.instanceSpecificDef = false;
+CombineColor.glslFunction = `
+vec3 _st_hsvToRgb(vec3 c) {
+  vec4 K = vec4(1.0, 2.0/3.0, 1.0/3.0, 3.0);
+  vec3 p = abs(fract(c.xxx + K.xyz) * 6.0 - K.www);
+  return c.z * mix(K.xxx, clamp(p - K.xxx, 0.0, 1.0), c.y);
+}
+vec3 _st_hslToRgb(vec3 c) {
+  float h = c.x, s = c.y, l = c.z;
+  float q = l < 0.5 ? l * (1.0 + s) : l + s - l * s;
+  float p = 2.0 * l - q;
+  vec3 t = vec3(h + 1.0/3.0, h, h - 1.0/3.0);
+  t = fract(t);
+  vec3 rgb;
+  for (int i = 0; i < 3; i++) {
+    float ti = (i == 0) ? t.x : (i == 1) ? t.y : t.z;
+    float v;
+    if (ti < 1.0/6.0)      v = p + (q - p) * 6.0 * ti;
+    else if (ti < 0.5)     v = q;
+    else if (ti < 2.0/3.0) v = p + (q - p) * (2.0/3.0 - ti) * 6.0;
+    else                   v = p;
+    if (i == 0) rgb.r = v;
+    else if (i == 1) rgb.g = v;
+    else rgb.b = v;
+  }
+  return rgb;
+}`;

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

@@ -0,0 +1,29 @@
+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 CombineRGBInputs {
+    r?: OutputSocket | number;
+    g?: OutputSocket | number;
+    b?: OutputSocket | number;
+}
+/**
+ * Combine RGB — Blender "Combine Color" node equivalent.
+ * Combines three float channels into a colour.
+ *
+ * Inputs:  R (float), G (float), B (float)
+ * Outputs: Color (color)
+ */
+export declare class CombineRGB extends ProcessNode {
+    get nodeType(): string;
+    static instanceSpecificDef: boolean;
+    get metadata(): NodeMetadata;
+    private readonly _inputs;
+    private readonly _outputs;
+    constructor(inputs?: CombineRGBInputs);
+    getInputSockets(): Record<string, import("../../core/InputSocket.js").InputSocket<unknown>>;
+    getOutputSockets(): Record<string, OutputSocket>;
+    compileDefs(): string;
+    compileCall(ctx: CompileContext): string;
+}
+//# sourceMappingURL=CombineRGB.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"CombineRGB.d.ts","sourceRoot":"","sources":["../../../src/nodes/process/CombineRGB.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,gBAAgB;IAC/B,CAAC,CAAC,EAAE,YAAY,GAAG,MAAM,CAAA;IACzB,CAAC,CAAC,EAAE,YAAY,GAAG,MAAM,CAAA;IACzB,CAAC,CAAC,EAAE,YAAY,GAAG,MAAM,CAAA;CAC1B;AAED;;;;;;GAMG;AACH,qBAAa,UAAW,SAAQ,WAAW;IACzC,IAAI,QAAQ,WAA0B;IACtC,MAAM,CAAC,mBAAmB,UAAQ;IAElC,IAAI,QAAQ,IAAI,YAAY,CAE3B;IAED,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA2E;IACnG,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAmE;gBAEhF,MAAM,GAAE,gBAAqB;IAUzC,eAAe;IACf,gBAAgB;IAChB,WAAW;IAEX,WAAW,CAAC,GAAG,EAAE,cAAc,GAAG,MAAM;CAMzC"}

package/dist/nodes/process/CombineRGB.js

@@ -0,0 +1,33 @@
+import { ProcessNode } from '../../core/ProcessNode.js';
+/**
+ * Combine RGB — Blender "Combine Color" node equivalent.
+ * Combines three float channels into a colour.
+ *
+ * Inputs:  R (float), G (float), B (float)
+ * Outputs: Color (color)
+ */
+export class CombineRGB extends ProcessNode {
+    get nodeType() { return 'CombineRGB'; }
+    get metadata() {
+        return { label: 'Combine RGB', category: 'Converter', color: '#4a3a6a', cost: 'low' };
+    }
+    constructor(inputs = {}) {
+        super('CombineRGB');
+        this._inputs = this.createInputs(inputs, {
+            r: ['float', inputs.r ?? 0.0],
+            g: ['float', inputs.g ?? 0.0],
+            b: ['float', inputs.b ?? 0.0],
+        });
+        this._outputs = this.createOutputs({ Color: 'color' });
+    }
+    getInputSockets() { return this._inputs; }
+    getOutputSockets() { return this._outputs; }
+    compileDefs() { return ''; }
+    compileCall(ctx) {
+        const r = ctx.resolveInput(this._inputs.r);
+        const g = ctx.resolveInput(this._inputs.g);
+        const b = ctx.resolveInput(this._inputs.b);
+        return `vec3 ${ctx.outputVar(this, 'Color')} = vec3(${r}, ${g}, ${b});`;
+    }
+}
+CombineRGB.instanceSpecificDef = false;

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

@@ -0,0 +1,29 @@
+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 CombineXYZInputs {
+    x?: OutputSocket | number;
+    y?: OutputSocket | number;
+    z?: OutputSocket | number;
+}
+/**
+ * Combine XYZ — Blender "Combine XYZ" node equivalent.
+ * Combines three floats into a vector.
+ *
+ * Inputs:  X (float), Y (float), Z (float)
+ * Outputs: Vector (color/vec3)
+ */
+export declare class CombineXYZ extends ProcessNode {
+    get nodeType(): string;
+    static instanceSpecificDef: boolean;
+    get metadata(): NodeMetadata;
+    private readonly _inputs;
+    private readonly _outputs;
+    constructor(inputs?: CombineXYZInputs);
+    getInputSockets(): Record<string, import("../../core/InputSocket.js").InputSocket<unknown>>;
+    getOutputSockets(): Record<string, OutputSocket>;
+    compileDefs(): string;
+    compileCall(ctx: CompileContext): string;
+}
+//# sourceMappingURL=CombineXYZ.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"CombineXYZ.d.ts","sourceRoot":"","sources":["../../../src/nodes/process/CombineXYZ.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,gBAAgB;IAC/B,CAAC,CAAC,EAAE,YAAY,GAAG,MAAM,CAAA;IACzB,CAAC,CAAC,EAAE,YAAY,GAAG,MAAM,CAAA;IACzB,CAAC,CAAC,EAAE,YAAY,GAAG,MAAM,CAAA;CAC1B;AAED;;;;;;GAMG;AACH,qBAAa,UAAW,SAAQ,WAAW;IACzC,IAAI,QAAQ,WAA0B;IACtC,MAAM,CAAC,mBAAmB,UAAQ;IAElC,IAAI,QAAQ,IAAI,YAAY,CAE3B;IAED,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA2E;IACnG,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAmE;gBAEhF,MAAM,GAAE,gBAAqB;IAUzC,eAAe;IACf,gBAAgB;IAChB,WAAW;IAEX,WAAW,CAAC,GAAG,EAAE,cAAc,GAAG,MAAM;CAMzC"}

package/dist/nodes/process/CombineXYZ.js

@@ -0,0 +1,33 @@
+import { ProcessNode } from '../../core/ProcessNode.js';
+/**
+ * Combine XYZ — Blender "Combine XYZ" node equivalent.
+ * Combines three floats into a vector.
+ *
+ * Inputs:  X (float), Y (float), Z (float)
+ * Outputs: Vector (color/vec3)
+ */
+export class CombineXYZ extends ProcessNode {
+    get nodeType() { return 'CombineXYZ'; }
+    get metadata() {
+        return { label: 'Combine XYZ', category: 'Converter', color: '#4a3a6a', cost: 'low' };
+    }
+    constructor(inputs = {}) {
+        super('CombineXYZ');
+        this._inputs = this.createInputs(inputs, {
+            x: ['float', inputs.x ?? 0.0],
+            y: ['float', inputs.y ?? 0.0],
+            z: ['float', inputs.z ?? 0.0],
+        });
+        this._outputs = this.createOutputs({ Vector: 'color' });
+    }
+    getInputSockets() { return this._inputs; }
+    getOutputSockets() { return this._outputs; }
+    compileDefs() { return ''; }
+    compileCall(ctx) {
+        const x = ctx.resolveInput(this._inputs.x);
+        const y = ctx.resolveInput(this._inputs.y);
+        const z = ctx.resolveInput(this._inputs.z);
+        return `vec3 ${ctx.outputVar(this, 'Vector')} = vec3(${x}, ${y}, ${z});`;
+    }
+}
+CombineXYZ.instanceSpecificDef = false;

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

@@ -0,0 +1,30 @@
+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 DiffuseBSDFInputs {
+    color?: OutputSocket | string;
+    roughness?: OutputSocket | number;
+    normal?: OutputSocket;
+}
+/**
+ * Diffuse BSDF — Blender "Diffuse BSDF" node equivalent.
+ * Pure Lambertian diffuse surface — flat matte, no specular highlights.
+ *
+ * Inputs:  color, roughness, normal
+ * Outputs: BSDF (shader)
+ */
+export declare class DiffuseBSDF extends ProcessNode {
+    get nodeType(): string;
+    static instanceSpecificDef: boolean;
+    get metadata(): NodeMetadata;
+    static glslFunction: string;
+    private readonly _inputs;
+    private readonly _outputs;
+    constructor(inputs?: DiffuseBSDFInputs);
+    getInputSockets(): Record<string, import("../../core/InputSocket.js").InputSocket<unknown>>;
+    getOutputSockets(): Record<string, OutputSocket>;
+    compileDefs(): string;
+    compileCall(ctx: CompileContext): string;
+}
+//# sourceMappingURL=DiffuseBSDF.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"DiffuseBSDF.d.ts","sourceRoot":"","sources":["../../../src/nodes/process/DiffuseBSDF.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,iBAAiB;IAChC,KAAK,CAAC,EAAK,YAAY,GAAG,MAAM,CAAA;IAChC,SAAS,CAAC,EAAE,YAAY,GAAG,MAAM,CAAA;IACjC,MAAM,CAAC,EAAI,YAAY,CAAA;CACxB;AAED;;;;;;GAMG;AACH,qBAAa,WAAY,SAAQ,WAAW;IAC1C,IAAI,QAAQ,WAA2B;IACvC,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,iBAAsB;IAU1C,eAAe;IACf,gBAAgB;IAChB,WAAW;IAEX,WAAW,CAAC,GAAG,EAAE,cAAc,GAAG,MAAM;CAQzC"}

package/dist/nodes/process/DiffuseBSDF.js

@@ -0,0 +1,43 @@
+import { ProcessNode } from '../../core/ProcessNode.js';
+/**
+ * Diffuse BSDF — Blender "Diffuse BSDF" node equivalent.
+ * Pure Lambertian diffuse surface — flat matte, no specular highlights.
+ *
+ * Inputs:  color, roughness, normal
+ * Outputs: BSDF (shader)
+ */
+export class DiffuseBSDF extends ProcessNode {
+    get nodeType() { return 'DiffuseBSDF'; }
+    get metadata() {
+        return { label: 'Diffuse BSDF', category: 'Shader', color: '#336699', cost: 'low' };
+    }
+    constructor(inputs = {}) {
+        super('DiffuseBSDF');
+        this._inputs = this.createInputs(inputs, {
+            color: ['color', '#ffffff'],
+            roughness: ['float', inputs.roughness ?? 0.0],
+            normal: ['color', null],
+        });
+        this._outputs = this.createOutputs({ BSDF: 'shader' });
+    }
+    getInputSockets() { return this._inputs; }
+    getOutputSockets() { return this._outputs; }
+    compileDefs() { return DiffuseBSDF.glslFunction; }
+    compileCall(ctx) {
+        const color = ctx.resolveInput(this._inputs.color);
+        const roughness = ctx.resolveInput(this._inputs.roughness);
+        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_diffuseBSDF(${color}, ${roughness}, ${normal});`;
+    }
+}
+DiffuseBSDF.instanceSpecificDef = false;
+DiffuseBSDF.glslFunction = `
+vec3 _st_diffuseBSDF(vec3 color, float roughness, vec3 N) {
+  vec3  L       = normalize(vec3(1.0, 2.0, 1.0));
+  float NdotL   = max(dot(N, L), 0.0);
+  float diffuse = NdotL / 3.14159265;
+  vec3  ambient = color * 0.15;
+  return ambient + color * (diffuse * (1.0 - roughness * 0.5));
+}`;

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

@@ -0,0 +1,30 @@
+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 EmissionInputs {
+    color?: OutputSocket | string;
+    strength?: OutputSocket | number;
+}
+/**
+ * Emission — Blender "Emission" shader node equivalent.
+ * Produces a self-illuminating surface — unaffected by scene lighting.
+ * Use with MixShader to add glow on top of a surface material.
+ *
+ * Inputs:  color (color), strength (float)
+ * Outputs: BSDF (shader)
+ */
+export declare class Emission extends ProcessNode {
+    get nodeType(): string;
+    static instanceSpecificDef: boolean;
+    get metadata(): NodeMetadata;
+    static glslFunction: string;
+    private readonly _inputs;
+    private readonly _outputs;
+    constructor(inputs?: EmissionInputs);
+    getInputSockets(): Record<string, import("../../core/InputSocket.js").InputSocket<unknown>>;
+    getOutputSockets(): Record<string, OutputSocket>;
+    compileDefs(): string;
+    compileCall(ctx: CompileContext): string;
+}
+//# sourceMappingURL=Emission.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Emission.d.ts","sourceRoot":"","sources":["../../../src/nodes/process/Emission.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,cAAc;IAC7B,KAAK,CAAC,EAAK,YAAY,GAAG,MAAM,CAAA;IAChC,QAAQ,CAAC,EAAE,YAAY,GAAG,MAAM,CAAA;CACjC;AAED;;;;;;;GAOG;AACH,qBAAa,QAAS,SAAQ,WAAW;IACvC,IAAI,QAAQ,WAAwB;IACpC,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,cAAmB;IASvC,eAAe;IACf,gBAAgB;IAChB,WAAW;IAEX,WAAW,CAAC,GAAG,EAAE,cAAc,GAAG,MAAM;CAKzC"}

package/dist/nodes/process/Emission.js

@@ -0,0 +1,36 @@
+import { ProcessNode } from '../../core/ProcessNode.js';
+/**
+ * Emission — Blender "Emission" shader node equivalent.
+ * Produces a self-illuminating surface — unaffected by scene lighting.
+ * Use with MixShader to add glow on top of a surface material.
+ *
+ * Inputs:  color (color), strength (float)
+ * Outputs: BSDF (shader)
+ */
+export class Emission extends ProcessNode {
+    get nodeType() { return 'Emission'; }
+    get metadata() {
+        return { label: 'Emission', category: 'Shader', color: '#336699', cost: 'low' };
+    }
+    constructor(inputs = {}) {
+        super('Emission');
+        this._inputs = this.createInputs(inputs, {
+            color: ['color', '#ffffff'],
+            strength: ['float', inputs.strength ?? 1.0],
+        });
+        this._outputs = this.createOutputs({ BSDF: 'shader' });
+    }
+    getInputSockets() { return this._inputs; }
+    getOutputSockets() { return this._outputs; }
+    compileDefs() { return Emission.glslFunction; }
+    compileCall(ctx) {
+        const color = ctx.resolveInput(this._inputs.color);
+        const strength = ctx.resolveInput(this._inputs.strength);
+        return `vec3 ${ctx.outputVar(this, 'BSDF')} = _st_emission(${color}, ${strength});`;
+    }
+}
+Emission.instanceSpecificDef = false;
+Emission.glslFunction = `
+vec3 _st_emission(vec3 color, float strength) {
+  return color * strength;
+}`;

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

@@ -0,0 +1,41 @@
+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 EnvironmentTextureInputs {
+    /** Output socket providing a direction vector (color type = vec3). Defaults to reflected view direction. */
+    vector?: OutputSocket;
+    /** Name of the samplerCube uniform on the ShaderMaterial. */
+    uniformName: string;
+    /** Mip level to sample (0 = sharpest, higher = blurrier/rougher). Default 0. */
+    roughness?: number | OutputSocket;
+}
+/**
+ * Environment Texture — Blender "Environment Texture" node equivalent.
+ * Samples a cubemap (THREE.CubeTexture or THREE.WebGLCubeRenderTarget) via a samplerCube uniform.
+ *
+ * Usage:
+ *   const node = new EnvironmentTexture({ uniformName: 'uEnv' })
+ *   // After mat.compile():
+ *   mat.material.uniforms.uEnv = { value: new THREE.CubeTextureLoader().load([...]) }
+ *
+ * Default vector: reflected view direction — perfect for reflections.
+ * Connect a Normal node output for environment-mapped normals.
+ *
+ * Inputs:  vector (direction, color), roughness (float), uniformName (string)
+ * Outputs: Color (color)
+ */
+export declare class EnvironmentTexture extends ProcessNode {
+    get nodeType(): string;
+    static instanceSpecificDef: boolean;
+    get metadata(): NodeMetadata;
+    private readonly _uniformName;
+    private readonly _inputs;
+    private readonly _outputs;
+    constructor(inputs: EnvironmentTextureInputs);
+    getInputSockets(): Record<string, import("../../core/InputSocket.js").InputSocket<unknown>>;
+    getOutputSockets(): Record<string, OutputSocket>;
+    compileDefs(): string;
+    compileCall(ctx: CompileContext): string;
+}
+//# sourceMappingURL=EnvironmentTexture.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"EnvironmentTexture.d.ts","sourceRoot":"","sources":["../../../src/nodes/process/EnvironmentTexture.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAA;AAGvD,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,wBAAwB;IACvC,4GAA4G;IAC5G,MAAM,CAAC,EAAO,YAAY,CAAA;IAC1B,6DAA6D;IAC7D,WAAW,EAAG,MAAM,CAAA;IACpB,gFAAgF;IAChF,SAAS,CAAC,EAAI,MAAM,GAAG,YAAY,CAAA;CACpC;AAED;;;;;;;;;;;;;;GAcG;AACH,qBAAa,kBAAmB,SAAQ,WAAW;IACjD,IAAI,QAAQ,WAAkC;IAC9C,MAAM,CAAC,mBAAmB,UAAO;IAEjC,IAAI,QAAQ,IAAI,YAAY,CAE3B;IAED,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAQ;IACrC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA2E;IACnG,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAmE;gBAEhF,MAAM,EAAE,wBAAwB;IAoB5C,eAAe;IACf,gBAAgB;IAEhB,WAAW,IAAI,MAAM;IAIrB,WAAW,CAAC,GAAG,EAAE,cAAc,GAAG,MAAM;CAmBzC"}

package/dist/nodes/process/EnvironmentTexture.js

@@ -0,0 +1,65 @@
+import { ProcessNode } from '../../core/ProcessNode.js';
+import { ShaderNodeError } from '../../core/ShaderNodeError.js';
+import { ShaderConfig } from '../../core/ShaderConfig.js';
+/**
+ * Environment Texture — Blender "Environment Texture" node equivalent.
+ * Samples a cubemap (THREE.CubeTexture or THREE.WebGLCubeRenderTarget) via a samplerCube uniform.
+ *
+ * Usage:
+ *   const node = new EnvironmentTexture({ uniformName: 'uEnv' })
+ *   // After mat.compile():
+ *   mat.material.uniforms.uEnv = { value: new THREE.CubeTextureLoader().load([...]) }
+ *
+ * Default vector: reflected view direction — perfect for reflections.
+ * Connect a Normal node output for environment-mapped normals.
+ *
+ * Inputs:  vector (direction, color), roughness (float), uniformName (string)
+ * Outputs: Color (color)
+ */
+export class EnvironmentTexture extends ProcessNode {
+    get nodeType() { return 'EnvironmentTexture'; }
+    get metadata() {
+        return { label: 'Environment Texture', category: 'Texture', color: '#3a5a6b', cost: 'medium' };
+    }
+    constructor(inputs) {
+        super('EnvironmentTexture');
+        if (ShaderConfig.errorLevel !== 'off' && !inputs.uniformName) {
+            ShaderNodeError.throw({
+                nodeType: 'EnvironmentTexture',
+                nodeId: this.id,
+                problem: 'uniformName is required.',
+                fix: 'new EnvironmentTexture({ uniformName: "uEnv" })\n  After compile(): mat.material.uniforms.uEnv = { value: cubeTexture }',
+            });
+        }
+        this._uniformName = inputs.uniformName;
+        this._inputs = this.createInputs(inputs, {
+            vector: ['color', null],
+            roughness: ['float', 0.0],
+        });
+        this._outputs = this.createOutputs({ Color: 'color' });
+    }
+    getInputSockets() { return this._inputs; }
+    getOutputSockets() { return this._outputs; }
+    compileDefs() {
+        return `uniform samplerCube ${this._uniformName};`;
+    }
+    compileCall(ctx) {
+        const roughness = ctx.resolveInput(this._inputs.roughness);
+        const cv = ctx.outputVar(this, 'Color');
+        // If a direction vector is connected, use it; otherwise use the reflected view direction
+        let dir;
+        if (this._inputs.vector.isConnected()) {
+            dir = ctx.resolveInput(this._inputs.vector);
+        }
+        else {
+            // Compute reflected view direction in world space
+            dir = `reflect(normalize(vPosition - cameraPosition), vNormal)`;
+        }
+        return [
+            `vec3 _env_dir_${this.id} = ${dir};`,
+            `vec4 _env_samp_${this.id} = textureCube(${this._uniformName}, _env_dir_${this.id}, ${roughness} * 8.0);`,
+            `vec3 ${cv} = _env_samp_${this.id}.rgb;`,
+        ].join('\n  ');
+    }
+}
+EnvironmentTexture.instanceSpecificDef = true;

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

@@ -0,0 +1,34 @@
+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 control point: [x, y] both in [0,1] */
+type CurvePoint = [number, number];
+export interface FloatCurveInputs {
+    value?: OutputSocket | number;
+    fac?: OutputSocket | number;
+    /** Array of [x, y] control points — at least 2, sorted by x. */
+    points?: CurvePoint[];
+}
+/**
+ * Float Curve — Blender "Float Curve" converter node equivalent.
+ * Remaps a float value using a custom piecewise-linear curve.
+ *
+ * Inputs:  value [0-1], fac [0-1], points (control points)
+ * Outputs: Value (float)
+ */
+export declare class FloatCurve extends ProcessNode {
+    get nodeType(): string;
+    static instanceSpecificDef: boolean;
+    get metadata(): NodeMetadata;
+    private readonly points;
+    private readonly _inputs;
+    private readonly _outputs;
+    constructor(inputs?: FloatCurveInputs);
+    getInputSockets(): Record<string, import("../../core/InputSocket.js").InputSocket<unknown>>;
+    getOutputSockets(): Record<string, OutputSocket>;
+    compileDefs(): string;
+    compileCall(ctx: CompileContext): string;
+}
+export {};
+//# sourceMappingURL=FloatCurve.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"FloatCurve.d.ts","sourceRoot":"","sources":["../../../src/nodes/process/FloatCurve.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,4CAA4C;AAC5C,KAAK,UAAU,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;AAElC,MAAM,WAAW,gBAAgB;IAC/B,KAAK,CAAC,EAAG,YAAY,GAAG,MAAM,CAAA;IAC9B,GAAG,CAAC,EAAK,YAAY,GAAG,MAAM,CAAA;IAC9B,gEAAgE;IAChE,MAAM,CAAC,EAAE,UAAU,EAAE,CAAA;CACtB;AAED;;;;;;GAMG;AACH,qBAAa,UAAW,SAAQ,WAAW;IACzC,IAAI,QAAQ,WAA0B;IACtC,MAAM,CAAC,mBAAmB,UAAO;IAEjC,IAAI,QAAQ,IAAI,YAAY,CAE3B;IAED,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAc;IACrC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA2E;IACnG,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAmE;gBAEhF,MAAM,GAAE,gBAAqB;IAUzC,eAAe;IACf,gBAAgB;IAChB,WAAW;IAEX,WAAW,CAAC,GAAG,EAAE,cAAc,GAAG,MAAM;CAsBzC"}

package/dist/nodes/process/FloatCurve.js

@@ -0,0 +1,46 @@
+import { ProcessNode } from '../../core/ProcessNode.js';
+/**
+ * Float Curve — Blender "Float Curve" converter node equivalent.
+ * Remaps a float value using a custom piecewise-linear curve.
+ *
+ * Inputs:  value [0-1], fac [0-1], points (control points)
+ * Outputs: Value (float)
+ */
+export class FloatCurve extends ProcessNode {
+    get nodeType() { return 'FloatCurve'; }
+    get metadata() {
+        return { label: 'Float Curve', category: 'Converter', color: '#4a3a6a', cost: 'low' };
+    }
+    constructor(inputs = {}) {
+        super('FloatCurve');
+        this.points = inputs.points ?? [[0, 0], [1, 1]];
+        this._inputs = this.createInputs(inputs, {
+            value: ['float', inputs.value ?? 0.5],
+            fac: ['float', inputs.fac ?? 1.0],
+        });
+        this._outputs = this.createOutputs({ Value: 'float' });
+    }
+    getInputSockets() { return this._inputs; }
+    getOutputSockets() { return this._outputs; }
+    compileDefs() { return ''; }
+    compileCall(ctx) {
+        const val = ctx.resolveInput(this._inputs.value);
+        const fac = ctx.resolveInput(this._inputs.fac);
+        const n = this.points.length;
+        const out = ctx.outputVar(this, 'Value');
+        // Build piecewise linear lookup from control points
+        const lines = [
+            `float _fc_v_${this.id} = clamp(${val}, 0.0, 1.0);`,
+            `float _fc_r_${this.id} = ${this.points[n - 1][1].toFixed(4)};`,
+        ];
+        for (let i = 0; i < n - 1; i++) {
+            const [x0, y0] = this.points[i];
+            const [x1, y1] = this.points[i + 1];
+            const t = `clamp((_fc_v_${this.id} - ${x0.toFixed(4)}) / max(${(x1 - x0).toFixed(4)}, 0.0001), 0.0, 1.0)`;
+            lines.push(`if (_fc_v_${this.id} <= ${x1.toFixed(4)}) _fc_r_${this.id} = mix(${y0.toFixed(4)}, ${y1.toFixed(4)}, ${t});`);
+        }
+        lines.push(`float ${out} = mix(_fc_v_${this.id}, _fc_r_${this.id}, clamp(${fac}, 0.0, 1.0));`);
+        return lines.join('\n  ');
+    }
+}
+FloatCurve.instanceSpecificDef = true;