@triforge/shader-core 0.1.0

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

@@ -0,0 +1,36 @@
+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 FresnelInputs {
+    ior?: number | OutputSocket;
+    normal?: OutputSocket;
+}
+/**
+ * Fresnel — outputs reflectance based on viewing angle.
+ * Equivalent to Blender's "Fresnel" input node.
+ *
+ * At grazing angles (looking across the surface) → value near 1.0 (reflects sky)
+ * Looking straight down at the surface           → value near 0.0 (sees through)
+ *
+ * Inputs:
+ *   ior    (float)  — index of refraction   default: 1.45
+ *   normal (vector) — surface normal override, defaults to geometry normal
+ *
+ * Outputs:
+ *   Fac (float) — fresnel reflectance [0-1]
+ */
+export declare class Fresnel extends ProcessNode {
+    get nodeType(): string;
+    static instanceSpecificDef: boolean;
+    get metadata(): NodeMetadata;
+    static glslFunction: string;
+    private readonly _inputs;
+    private readonly _outputs;
+    constructor(inputs?: FresnelInputs);
+    getInputSockets(): Record<string, import("../../core/InputSocket.js").InputSocket<unknown>>;
+    getOutputSockets(): Record<string, OutputSocket>;
+    compileDefs(): string;
+    compileCall(ctx: CompileContext): string;
+}
+//# sourceMappingURL=Fresnel.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Fresnel.d.ts","sourceRoot":"","sources":["../../../src/nodes/process/Fresnel.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,GAAG,CAAC,EAAK,MAAM,GAAG,YAAY,CAAA;IAC9B,MAAM,CAAC,EAAE,YAAY,CAAA;CACtB;AAED;;;;;;;;;;;;;GAaG;AACH,qBAAa,OAAQ,SAAQ,WAAW;IACtC,IAAI,QAAQ,WAAuB;IACnC,MAAM,CAAC,mBAAmB,UAAQ;IAElC,IAAI,QAAQ,IAAI,YAAY,CAO3B;IAED,MAAM,CAAC,YAAY,SAMnB;IAEA,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA2E;IACnG,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAmE;gBAEhF,MAAM,GAAE,aAAkB;IAStC,eAAe;IACf,gBAAgB;IAChB,WAAW;IAEX,WAAW,CAAC,GAAG,EAAE,cAAc,GAAG,MAAM;CAQzC"}

package/dist/nodes/process/Fresnel.js

@@ -0,0 +1,53 @@
+import { ProcessNode } from '../../core/ProcessNode.js';
+/**
+ * Fresnel — outputs reflectance based on viewing angle.
+ * Equivalent to Blender's "Fresnel" input node.
+ *
+ * At grazing angles (looking across the surface) → value near 1.0 (reflects sky)
+ * Looking straight down at the surface           → value near 0.0 (sees through)
+ *
+ * Inputs:
+ *   ior    (float)  — index of refraction   default: 1.45
+ *   normal (vector) — surface normal override, defaults to geometry normal
+ *
+ * Outputs:
+ *   Fac (float) — fresnel reflectance [0-1]
+ */
+export class Fresnel extends ProcessNode {
+    get nodeType() { return 'Fresnel'; }
+    get metadata() {
+        return {
+            label: 'Fresnel',
+            category: 'Input',
+            color: '#3d6b96',
+            cost: 'low',
+        };
+    }
+    constructor(inputs = {}) {
+        super('Fresnel');
+        this._inputs = this.createInputs(inputs, {
+            ior: ['float', inputs.ior ?? 1.33],
+            normal: ['color', null],
+        });
+        this._outputs = this.createOutputs({ Fac: 'float' });
+    }
+    getInputSockets() { return this._inputs; }
+    getOutputSockets() { return this._outputs; }
+    compileDefs() { return Fresnel.glslFunction; }
+    compileCall(ctx) {
+        const ior = ctx.resolveInput(this._inputs.ior);
+        const normal = this._inputs.normal.isConnected()
+            ? ctx.outputVar(this._inputs.normal.connection.node, this._inputs.normal.connection.name)
+            : 'normalize(vNormal)';
+        const outVar = ctx.outputVar(this, 'Fac');
+        return `float ${outVar} = _st_fresnel(${ior}, ${normal});`;
+    }
+}
+Fresnel.instanceSpecificDef = false;
+Fresnel.glslFunction = `
+float _st_fresnel(float ior, vec3 N) {
+  vec3  V  = normalize(cameraPosition - vPosition);
+  float F0 = pow((1.0 - ior) / (1.0 + ior), 2.0);
+  float c  = max(dot(V, N), 0.0);
+  return F0 + (1.0 - F0) * pow(1.0 - c, 5.0);
+}`;

package/dist/nodes/process/Gamma.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 GammaInputs {
+    color?: OutputSocket | string;
+    gamma?: OutputSocket | number;
+}
+/**
+ * Gamma — Blender "Gamma" node equivalent.
+ * Applies exponential gamma correction to a colour.
+ *
+ * Inputs:  color, gamma (float — 1.0 = no change, <1 = lighten, >1 = darken)
+ * Outputs: Color (color)
+ */
+export declare class Gamma extends ProcessNode {
+    get nodeType(): string;
+    static instanceSpecificDef: boolean;
+    get metadata(): NodeMetadata;
+    static glslFunction: string;
+    private readonly _inputs;
+    private readonly _outputs;
+    constructor(inputs?: GammaInputs);
+    getInputSockets(): Record<string, import("../../core/InputSocket.js").InputSocket<unknown>>;
+    getOutputSockets(): Record<string, OutputSocket>;
+    compileDefs(): string;
+    compileCall(ctx: CompileContext): string;
+}
+//# sourceMappingURL=Gamma.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Gamma.d.ts","sourceRoot":"","sources":["../../../src/nodes/process/Gamma.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,WAAW;IAC1B,KAAK,CAAC,EAAE,YAAY,GAAG,MAAM,CAAA;IAC7B,KAAK,CAAC,EAAE,YAAY,GAAG,MAAM,CAAA;CAC9B;AAED;;;;;;GAMG;AACH,qBAAa,KAAM,SAAQ,WAAW;IACpC,IAAI,QAAQ,WAAqB;IACjC,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,WAAgB;IASpC,eAAe;IACf,gBAAgB;IAChB,WAAW;IAEX,WAAW,CAAC,GAAG,EAAE,cAAc,GAAG,MAAM;CAKzC"}

package/dist/nodes/process/Gamma.js

@@ -0,0 +1,35 @@
+import { ProcessNode } from '../../core/ProcessNode.js';
+/**
+ * Gamma — Blender "Gamma" node equivalent.
+ * Applies exponential gamma correction to a colour.
+ *
+ * Inputs:  color, gamma (float — 1.0 = no change, <1 = lighten, >1 = darken)
+ * Outputs: Color (color)
+ */
+export class Gamma extends ProcessNode {
+    get nodeType() { return 'Gamma'; }
+    get metadata() {
+        return { label: 'Gamma', category: 'Color', color: '#633060', cost: 'low' };
+    }
+    constructor(inputs = {}) {
+        super('Gamma');
+        this._inputs = this.createInputs(inputs, {
+            color: ['color', '#ffffff'],
+            gamma: ['float', inputs.gamma ?? 1.0],
+        });
+        this._outputs = this.createOutputs({ Color: 'color' });
+    }
+    getInputSockets() { return this._inputs; }
+    getOutputSockets() { return this._outputs; }
+    compileDefs() { return Gamma.glslFunction; }
+    compileCall(ctx) {
+        const col = ctx.resolveInput(this._inputs.color);
+        const gamma = ctx.resolveInput(this._inputs.gamma);
+        return `vec3 ${ctx.outputVar(this, 'Color')} = _st_gamma(${col}, ${gamma});`;
+    }
+}
+Gamma.instanceSpecificDef = false;
+Gamma.glslFunction = `
+vec3 _st_gamma(vec3 col, float gamma) {
+  return pow(max(col, vec3(0.0)), vec3(gamma));
+}`;

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

@@ -0,0 +1,31 @@
+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 GlassBSDFInputs {
+    color?: OutputSocket | string;
+    roughness?: OutputSocket | number;
+    ior?: OutputSocket | number;
+    normal?: OutputSocket;
+}
+/**
+ * Glass BSDF — Blender "Glass BSDF" node equivalent.
+ * Combines specular reflection and refraction — physically-based glass.
+ *
+ * Inputs:  color, roughness, ior, normal
+ * Outputs: BSDF (shader)
+ */
+export declare class GlassBSDF extends ProcessNode {
+    get nodeType(): string;
+    static instanceSpecificDef: boolean;
+    get metadata(): NodeMetadata;
+    static glslFunction: string;
+    private readonly _inputs;
+    private readonly _outputs;
+    constructor(inputs?: GlassBSDFInputs);
+    getInputSockets(): Record<string, import("../../core/InputSocket.js").InputSocket<unknown>>;
+    getOutputSockets(): Record<string, OutputSocket>;
+    compileDefs(): string;
+    compileCall(ctx: CompileContext): string;
+}
+//# sourceMappingURL=GlassBSDF.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"GlassBSDF.d.ts","sourceRoot":"","sources":["../../../src/nodes/process/GlassBSDF.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,eAAe;IAC9B,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;;;;;;GAMG;AACH,qBAAa,SAAU,SAAQ,WAAW;IACxC,IAAI,QAAQ,WAAyB;IACrC,MAAM,CAAC,mBAAmB,UAAQ;IAElC,IAAI,QAAQ,IAAI,YAAY,CAE3B;IAED,MAAM,CAAC,YAAY,SAanB;IAEA,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA2E;IACnG,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAmE;gBAEhF,MAAM,GAAE,eAAoB;IAWxC,eAAe;IACf,gBAAgB;IAChB,WAAW;IAEX,WAAW,CAAC,GAAG,EAAE,cAAc,GAAG,MAAM;CASzC"}

package/dist/nodes/process/GlassBSDF.js

@@ -0,0 +1,51 @@
+import { ProcessNode } from '../../core/ProcessNode.js';
+/**
+ * Glass BSDF — Blender "Glass BSDF" node equivalent.
+ * Combines specular reflection and refraction — physically-based glass.
+ *
+ * Inputs:  color, roughness, ior, normal
+ * Outputs: BSDF (shader)
+ */
+export class GlassBSDF extends ProcessNode {
+    get nodeType() { return 'GlassBSDF'; }
+    get metadata() {
+        return { label: 'Glass BSDF', category: 'Shader', color: '#336699', cost: 'medium' };
+    }
+    constructor(inputs = {}) {
+        super('GlassBSDF');
+        this._inputs = this.createInputs(inputs, {
+            color: ['color', '#ffffff'],
+            roughness: ['float', inputs.roughness ?? 0.0],
+            ior: ['float', inputs.ior ?? 1.45],
+            normal: ['color', null],
+        });
+        this._outputs = this.createOutputs({ BSDF: 'shader' });
+    }
+    getInputSockets() { return this._inputs; }
+    getOutputSockets() { return this._outputs; }
+    compileDefs() { return GlassBSDF.glslFunction; }
+    compileCall(ctx) {
+        const color = ctx.resolveInput(this._inputs.color);
+        const roughness = ctx.resolveInput(this._inputs.roughness);
+        const ior = ctx.resolveInput(this._inputs.ior);
+        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_glassBSDF(${color}, ${roughness}, ${ior}, ${normal});`;
+    }
+}
+GlassBSDF.instanceSpecificDef = false;
+GlassBSDF.glslFunction = `
+vec3 _st_glassBSDF(vec3 color, float roughness, float ior, vec3 N) {
+  vec3  V       = normalize(cameraPosition - vPosition);
+  vec3  L       = normalize(vec3(1.0, 2.0, 1.0));
+  vec3  H       = normalize(L + V);
+  float F0      = pow((1.0 - ior) / (1.0 + ior), 2.0);
+  float fresnel = F0 + (1.0 - F0) * pow(1.0 - max(dot(V, N), 0.0), 5.0);
+  float NdotH   = max(dot(N, H), 0.0);
+  float a2      = roughness * roughness * roughness * roughness;
+  float D       = a2 / max(3.14159 * pow(NdotH * NdotH * (a2 - 1.0) + 1.0, 2.0), 0.0001);
+  vec3  spec    = vec3(1.0) * D * fresnel;
+  vec3  refr    = color * (1.0 - fresnel) * (1.0 - roughness * 0.3);
+  return spec + refr;
+}`;

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"GlossyBSDF.d.ts","sourceRoot":"","sources":["../../../src/nodes/process/GlossyBSDF.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,KAAK,CAAC,EAAM,YAAY,GAAG,MAAM,CAAA;IACjC,SAAS,CAAC,EAAE,YAAY,GAAG,MAAM,CAAA;IACjC,MAAM,CAAC,EAAK,YAAY,CAAA;CACzB;AAED;;;;;;GAMG;AACH,qBAAa,UAAW,SAAQ,WAAW;IACzC,IAAI,QAAQ,WAA0B;IACtC,MAAM,CAAC,mBAAmB,UAAQ;IAElC,IAAI,QAAQ,IAAI,YAAY,CAE3B;IAED,MAAM,CAAC,YAAY,SAcnB;IAEA,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;CAQzC"}

package/dist/nodes/process/GlossyBSDF.js

@@ -0,0 +1,50 @@
+import { ProcessNode } from '../../core/ProcessNode.js';
+/**
+ * Glossy BSDF — Blender "Glossy BSDF" node equivalent.
+ * Pure specular/mirror surface — no diffuse.
+ *
+ * Inputs:  color, roughness [0-1], normal
+ * Outputs: BSDF (shader)
+ */
+export class GlossyBSDF extends ProcessNode {
+    get nodeType() { return 'GlossyBSDF'; }
+    get metadata() {
+        return { label: 'Glossy BSDF', category: 'Shader', color: '#336699', cost: 'medium' };
+    }
+    constructor(inputs = {}) {
+        super('GlossyBSDF');
+        this._inputs = this.createInputs(inputs, {
+            color: ['color', '#ffffff'],
+            roughness: ['float', inputs.roughness ?? 0.5],
+            normal: ['color', null],
+        });
+        this._outputs = this.createOutputs({ BSDF: 'shader' });
+    }
+    getInputSockets() { return this._inputs; }
+    getOutputSockets() { return this._outputs; }
+    compileDefs() { return GlossyBSDF.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_glossyBSDF(${color}, ${roughness}, ${normal});`;
+    }
+}
+GlossyBSDF.instanceSpecificDef = false;
+GlossyBSDF.glslFunction = `
+vec3 _st_glossyBSDF(vec3 color, float roughness, vec3 N) {
+  vec3  L     = normalize(vec3(1.0, 2.0, 1.0));
+  vec3  V     = normalize(cameraPosition - vPosition);
+  vec3  H     = normalize(L + V);
+  float a     = roughness * roughness;
+  float a2    = a * a;
+  float NdotH = max(dot(N, H), 0.0);
+  float D     = a2 / max(3.14159265 * pow(NdotH * NdotH * (a2 - 1.0) + 1.0, 2.0), 0.0001);
+  float NdotL = max(dot(N, L), 0.0);
+  float NdotV = max(dot(N, V), 0.0001);
+  float k     = (roughness + 1.0) * (roughness + 1.0) / 8.0;
+  float G     = (NdotL / (NdotL * (1.0 - k) + k)) * (NdotV / (NdotV * (1.0 - k) + k));
+  return color * D * G / max(4.0 * NdotL * NdotV, 0.0001) * NdotL;
+}`;

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

@@ -0,0 +1,31 @@
+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 GradientType = 'LINEAR' | 'QUADRATIC' | 'EASING' | 'DIAGONAL' | 'RADIAL' | 'QUADRATIC_SPHERE' | 'SPHERICAL';
+export interface GradientTextureInputs {
+    vector?: OutputSocket;
+    type?: GradientType;
+}
+/**
+ * Gradient Texture — Blender "Gradient Texture" node equivalent.
+ * Generates gradient patterns from a vector input.
+ *
+ * Inputs:  vector, type
+ * Outputs: Color (color), Fac (float)
+ */
+export declare class GradientTexture extends ProcessNode {
+    get nodeType(): string;
+    static instanceSpecificDef: boolean;
+    get metadata(): NodeMetadata;
+    private readonly type;
+    private readonly _inputs;
+    private readonly _outputs;
+    constructor(inputs?: GradientTextureInputs);
+    getInputSockets(): Record<string, import("../../core/InputSocket.js").InputSocket<unknown>>;
+    getOutputSockets(): Record<string, OutputSocket>;
+    compileDefs(): string;
+    compileCall(ctx: CompileContext): string;
+    private buildExpr;
+}
+//# sourceMappingURL=GradientTexture.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"GradientTexture.d.ts","sourceRoot":"","sources":["../../../src/nodes/process/GradientTexture.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,YAAY,GAAG,QAAQ,GAAG,WAAW,GAAG,QAAQ,GAAG,UAAU,GAAG,QAAQ,GAAG,kBAAkB,GAAG,WAAW,CAAA;AAEvH,MAAM,WAAW,qBAAqB;IACpC,MAAM,CAAC,EAAE,YAAY,CAAA;IACrB,IAAI,CAAC,EAAI,YAAY,CAAA;CACtB;AAED;;;;;;GAMG;AACH,qBAAa,eAAgB,SAAQ,WAAW;IAC9C,IAAI,QAAQ,WAA+B;IAC3C,MAAM,CAAC,mBAAmB,UAAO;IAEjC,IAAI,QAAQ,IAAI,YAAY,CAE3B;IAED,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAc;IACnC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA2E;IACnG,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAmE;gBAEhF,MAAM,GAAE,qBAA0B;IAO9C,eAAe;IACf,gBAAgB;IAChB,WAAW;IAEX,WAAW,CAAC,GAAG,EAAE,cAAc,GAAG,MAAM;IAWxC,OAAO,CAAC,SAAS;CAelB"}

package/dist/nodes/process/GradientTexture.js

@@ -0,0 +1,49 @@
+import { ProcessNode } from '../../core/ProcessNode.js';
+/**
+ * Gradient Texture — Blender "Gradient Texture" node equivalent.
+ * Generates gradient patterns from a vector input.
+ *
+ * Inputs:  vector, type
+ * Outputs: Color (color), Fac (float)
+ */
+export class GradientTexture extends ProcessNode {
+    get nodeType() { return 'GradientTexture'; }
+    get metadata() {
+        return { label: 'Gradient Texture', category: 'Texture', color: '#3a6b3a', cost: 'low' };
+    }
+    constructor(inputs = {}) {
+        super('GradientTexture');
+        this.type = inputs.type ?? 'LINEAR';
+        this._inputs = this.createInputs(inputs, { vector: ['color', null] });
+        this._outputs = this.createOutputs({ Color: 'color', Fac: 'float' });
+    }
+    getInputSockets() { return this._inputs; }
+    getOutputSockets() { return this._outputs; }
+    compileDefs() { return ''; }
+    compileCall(ctx) {
+        const v = ctx.resolveInput(this._inputs.vector);
+        const fv = ctx.outputVar(this, 'Fac');
+        const cv = ctx.outputVar(this, 'Color');
+        const expr = this.buildExpr(v);
+        return [
+            `float ${fv} = clamp(${expr}, 0.0, 1.0);`,
+            `vec3  ${cv} = vec3(${fv});`,
+        ].join('\n  ');
+    }
+    buildExpr(v) {
+        switch (this.type) {
+            case 'LINEAR': return `(${v}).x`;
+            case 'QUADRATIC': return `pow(max((${v}).x, 0.0), 2.0)`;
+            case 'EASING': {
+                const t = `(${v}).x`;
+                return `(${t} * ${t} * (3.0 - 2.0 * ${t}))`;
+            }
+            case 'DIAGONAL': return `((${v}).x + (${v}).y) * 0.5`;
+            case 'RADIAL': return `(atan((${v}).y, (${v}).x) / 6.28318 + 0.5)`;
+            case 'SPHERICAL': return `max(1.0 - length(${v}), 0.0)`;
+            case 'QUADRATIC_SPHERE': return `max(1.0 - pow(length(${v}), 2.0), 0.0)`;
+            default: return `(${v}).x`;
+        }
+    }
+}
+GradientTexture.instanceSpecificDef = true;

package/dist/nodes/process/HashValue.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 HashValueInputs {
+    value?: OutputSocket | number;
+}
+/**
+ * Hash Value — Blender "Hash Value" node equivalent.
+ * Hashes any input float to a pseudo-random float in [0, 1].
+ * Deterministic: same input always produces the same output.
+ * Useful for per-element procedural randomness without textures.
+ *
+ * Inputs:  value (float)
+ * Outputs: Value (float)
+ */
+export declare class HashValue extends ProcessNode {
+    get nodeType(): string;
+    static instanceSpecificDef: boolean;
+    get metadata(): NodeMetadata;
+    static glslFunction: string;
+    private readonly _inputs;
+    private readonly _outputs;
+    constructor(inputs?: HashValueInputs);
+    getInputSockets(): Record<string, import("../../core/InputSocket.js").InputSocket<unknown>>;
+    getOutputSockets(): Record<string, OutputSocket>;
+    compileDefs(): string;
+    compileCall(ctx: CompileContext): string;
+}
+//# sourceMappingURL=HashValue.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"HashValue.d.ts","sourceRoot":"","sources":["../../../src/nodes/process/HashValue.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,eAAe;IAC9B,KAAK,CAAC,EAAE,YAAY,GAAG,MAAM,CAAA;CAC9B;AAED;;;;;;;;GAQG;AACH,qBAAa,SAAU,SAAQ,WAAW;IACxC,IAAI,QAAQ,WAAyB;IACrC,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,eAAoB;IAQxC,eAAe;IACf,gBAAgB;IAChB,WAAW;IAEX,WAAW,CAAC,GAAG,EAAE,cAAc,GAAG,MAAM;CAGzC"}

package/dist/nodes/process/HashValue.js

@@ -0,0 +1,34 @@
+import { ProcessNode } from '../../core/ProcessNode.js';
+/**
+ * Hash Value — Blender "Hash Value" node equivalent.
+ * Hashes any input float to a pseudo-random float in [0, 1].
+ * Deterministic: same input always produces the same output.
+ * Useful for per-element procedural randomness without textures.
+ *
+ * Inputs:  value (float)
+ * Outputs: Value (float)
+ */
+export class HashValue extends ProcessNode {
+    get nodeType() { return 'HashValue'; }
+    get metadata() {
+        return { label: 'Hash Value', category: 'Converter', color: '#4a7a4a', cost: 'low' };
+    }
+    constructor(inputs = {}) {
+        super('HashValue');
+        this._inputs = this.createInputs(inputs, {
+            value: ['float', 0.0],
+        });
+        this._outputs = this.createOutputs({ Value: 'float' });
+    }
+    getInputSockets() { return this._inputs; }
+    getOutputSockets() { return this._outputs; }
+    compileDefs() { return HashValue.glslFunction; }
+    compileCall(ctx) {
+        return `float ${ctx.outputVar(this, 'Value')} = _st_hashValue(${ctx.resolveInput(this._inputs.value)});`;
+    }
+}
+HashValue.instanceSpecificDef = false;
+HashValue.glslFunction = `
+float _st_hashValue(float v) {
+  return fract(sin(v * 127.1 + 311.7) * 43758.5453);
+}`;

package/dist/nodes/process/HueSaturationValue.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 HueSaturationValueInputs {
+    hue?: OutputSocket | number;
+    saturation?: OutputSocket | number;
+    value?: OutputSocket | number;
+    fac?: OutputSocket | number;
+    color?: OutputSocket | string;
+}
+/**
+ * Hue Saturation Value — Blender "Hue/Saturation/Value" node equivalent.
+ * Adjusts the HSV components of a colour.
+ *
+ * Inputs:  hue [0-1], saturation [0-2], value [0-2], fac [0-1], color
+ * Outputs: Color (color)
+ */
+export declare class HueSaturationValue extends ProcessNode {
+    get nodeType(): string;
+    static instanceSpecificDef: boolean;
+    get metadata(): NodeMetadata;
+    static glslFunction: string;
+    private readonly _inputs;
+    private readonly _outputs;
+    constructor(inputs?: HueSaturationValueInputs);
+    getInputSockets(): Record<string, import("../../core/InputSocket.js").InputSocket<unknown>>;
+    getOutputSockets(): Record<string, OutputSocket>;
+    compileDefs(): string;
+    compileCall(ctx: CompileContext): string;
+}
+//# sourceMappingURL=HueSaturationValue.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"HueSaturationValue.d.ts","sourceRoot":"","sources":["../../../src/nodes/process/HueSaturationValue.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,wBAAwB;IACvC,GAAG,CAAC,EAAS,YAAY,GAAG,MAAM,CAAA;IAClC,UAAU,CAAC,EAAE,YAAY,GAAG,MAAM,CAAA;IAClC,KAAK,CAAC,EAAO,YAAY,GAAG,MAAM,CAAA;IAClC,GAAG,CAAC,EAAS,YAAY,GAAG,MAAM,CAAA;IAClC,KAAK,CAAC,EAAO,YAAY,GAAG,MAAM,CAAA;CACnC;AAED;;;;;;GAMG;AACH,qBAAa,kBAAmB,SAAQ,WAAW;IACjD,IAAI,QAAQ,WAAkC;IAC9C,MAAM,CAAC,mBAAmB,UAAQ;IAElC,IAAI,QAAQ,IAAI,YAAY,CAE3B;IAED,MAAM,CAAC,YAAY,SAoBnB;IAEA,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA2E;IACnG,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAmE;gBAEhF,MAAM,GAAE,wBAA6B;IAYjD,eAAe;IACf,gBAAgB;IAChB,WAAW;IAEX,WAAW,CAAC,GAAG,EAAE,cAAc,GAAG,MAAM;CAQzC"}

package/dist/nodes/process/HueSaturationValue.js

@@ -0,0 +1,58 @@
+import { ProcessNode } from '../../core/ProcessNode.js';
+/**
+ * Hue Saturation Value — Blender "Hue/Saturation/Value" node equivalent.
+ * Adjusts the HSV components of a colour.
+ *
+ * Inputs:  hue [0-1], saturation [0-2], value [0-2], fac [0-1], color
+ * Outputs: Color (color)
+ */
+export class HueSaturationValue extends ProcessNode {
+    get nodeType() { return 'HueSaturationValue'; }
+    get metadata() {
+        return { label: 'Hue Saturation Value', category: 'Color', color: '#633060', cost: 'low' };
+    }
+    constructor(inputs = {}) {
+        super('HueSaturationValue');
+        this._inputs = this.createInputs(inputs, {
+            hue: ['float', inputs.hue ?? 0.5],
+            saturation: ['float', inputs.saturation ?? 1.0],
+            value: ['float', inputs.value ?? 1.0],
+            fac: ['float', inputs.fac ?? 1.0],
+            color: ['color', '#ffffff'],
+        });
+        this._outputs = this.createOutputs({ Color: 'color' });
+    }
+    getInputSockets() { return this._inputs; }
+    getOutputSockets() { return this._outputs; }
+    compileDefs() { return HueSaturationValue.glslFunction; }
+    compileCall(ctx) {
+        const col = ctx.resolveInput(this._inputs.color);
+        const hue = ctx.resolveInput(this._inputs.hue);
+        const sat = ctx.resolveInput(this._inputs.saturation);
+        const val = ctx.resolveInput(this._inputs.value);
+        const fac = ctx.resolveInput(this._inputs.fac);
+        return `vec3 ${ctx.outputVar(this, 'Color')} = _st_hueSatVal(${col}, ${hue}, ${sat}, ${val}, ${fac});`;
+    }
+}
+HueSaturationValue.instanceSpecificDef = false;
+HueSaturationValue.glslFunction = `
+vec3 _st_rgbToHsv(vec3 c) {
+  vec4 K = vec4(0.0, -1.0/3.0, 2.0/3.0, -1.0);
+  vec4 p = mix(vec4(c.bg, K.wz), vec4(c.gb, K.xy), step(c.b, c.g));
+  vec4 q = mix(vec4(p.xyw, c.r), vec4(c.r, p.yzx), step(p.x, c.r));
+  float d = q.x - min(q.w, q.y);
+  float e = 1.0e-10;
+  return vec3(abs(q.z + (q.w - q.y) / (6.0 * d + e)), d / (q.x + e), q.x);
+}
+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_hueSatVal(vec3 col, float hue, float sat, float val, float fac) {
+  vec3 hsv = _st_rgbToHsv(col);
+  hsv.x = fract(hsv.x + hue - 0.5);
+  hsv.y = clamp(hsv.y * sat, 0.0, 1.0);
+  hsv.z = clamp(hsv.z * val, 0.0, 1.0);
+  return mix(col, _st_hsvToRgb(hsv), fac);
+}`;

package/dist/nodes/process/ImageTexture.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 interface ImageTextureInputs {
+    vector?: OutputSocket;
+    uniformName: string;
+}
+/**
+ * Image Texture — Blender "Image Texture" node equivalent.
+ * Samples an external texture via a sampler2D uniform.
+ *
+ * Usage:
+ *   const node = new ImageTexture({ uniformName: 'uAlbedo' })
+ *   // After mat.compile():
+ *   mat.material.uniforms.uAlbedo = { value: new THREE.TextureLoader().load('path.jpg') }
+ *
+ * Inputs:  vector (UV), uniformName (string — name of sampler2D uniform)
+ * Outputs: Color (color), Alpha (float)
+ */
+export declare class ImageTexture extends ProcessNode {
+    get nodeType(): string;
+    static instanceSpecificDef: boolean;
+    get metadata(): NodeMetadata;
+    private readonly uniformName;
+    private readonly _inputs;
+    private readonly _outputs;
+    constructor(inputs: ImageTextureInputs);
+    getInputSockets(): Record<string, import("../../core/InputSocket.js").InputSocket<unknown>>;
+    getOutputSockets(): Record<string, OutputSocket>;
+    compileDefs(): string;
+    compileCall(ctx: CompileContext): string;
+}
+//# sourceMappingURL=ImageTexture.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ImageTexture.d.ts","sourceRoot":"","sources":["../../../src/nodes/process/ImageTexture.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,kBAAkB;IACjC,MAAM,CAAC,EAAK,YAAY,CAAA;IACxB,WAAW,EAAE,MAAM,CAAA;CACpB;AAED;;;;;;;;;;;GAWG;AACH,qBAAa,YAAa,SAAQ,WAAW;IAC3C,IAAI,QAAQ,WAA4B;IACxC,MAAM,CAAC,mBAAmB,UAAO;IAEjC,IAAI,QAAQ,IAAI,YAAY,CAE3B;IAED,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAQ;IACpC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA2E;IACnG,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAmE;gBAEhF,MAAM,EAAE,kBAAkB;IAiBtC,eAAe;IACf,gBAAgB;IAEhB,WAAW,IAAI,MAAM;IAIrB,WAAW,CAAC,GAAG,EAAE,cAAc,GAAG,MAAM;CAYzC"}