@triforge/shader-core 0.1.0

package/dist/nodes/process/VolumeScatter.js

@@ -0,0 +1,42 @@
+import { ProcessNode } from '../../core/ProcessNode.js';
+/**
+ * Volume Scatter — Blender "Volume Scatter" shader node.
+ * Scatters light inside the volume with Henyey-Greenstein phase function.
+ * Connect to MaterialOutput.volume.
+ *
+ * Inputs:  color (color), density (float), anisotropy (float, -1..1)
+ * Outputs: Volume (shader)
+ */
+export class VolumeScatter extends ProcessNode {
+    get nodeType() { return 'VolumeScatter'; }
+    get metadata() {
+        return { label: 'Volume Scatter', category: 'Shader', color: '#3388cc', cost: 'medium' };
+    }
+    constructor(inputs = {}) {
+        super('VolumeScatter');
+        this._inputs = this.createInputs(inputs, {
+            color: ['color', '#ffffff'],
+            density: ['float', inputs.density ?? 1.0],
+            anisotropy: ['float', inputs.anisotropy ?? 0.0],
+        });
+        this._outputs = this.createOutputs({ Volume: 'shader' });
+    }
+    getInputSockets() { return this._inputs; }
+    getOutputSockets() { return this._outputs; }
+    compileDefs() { return VolumeScatter.glslFunction; }
+    compileCall(ctx) {
+        const color = ctx.resolveInput(this._inputs.color);
+        const density = ctx.resolveInput(this._inputs.density);
+        const anisotropy = ctx.resolveInput(this._inputs.anisotropy);
+        return `vec3 ${ctx.outputVar(this, 'Volume')} = _st_volumeScatter(${color}, ${density}, ${anisotropy});`;
+    }
+}
+VolumeScatter.instanceSpecificDef = false;
+VolumeScatter.glslFunction = `
+vec3 _st_volumeScatter(vec3 color, float density, float anisotropy) {
+  float g  = clamp(anisotropy, -0.9999, 0.9999);
+  float g2 = g * g;
+  // HG phase at cosTheta=0 (isotropic approximation for surface shading context)
+  float phase = (1.0 - g2) / pow(1.0 + g2, 1.5);
+  return color * density * phase;
+}`;

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

@@ -0,0 +1,38 @@
+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 VoronoiFeature = 'F1' | 'F2' | 'SMOOTH_F1' | 'DISTANCE_TO_EDGE';
+export interface VoronoiTextureInputs {
+    vector?: OutputSocket;
+    scale?: number | OutputSocket;
+    smoothness?: number | OutputSocket;
+    feature?: VoronoiFeature;
+}
+/**
+ * Voronoi Texture — Blender "Voronoi Texture" node equivalent.
+ * Full implementation matching all four Blender feature modes:
+ *
+ *   F1              — distance to nearest cell center (classic Voronoi)
+ *   F2              — distance to second-nearest cell center
+ *   SMOOTH_F1       — smooth minimum of F1 across cells (softens cell edges)
+ *   DISTANCE_TO_EDGE — distance to the Voronoi cell boundary
+ *
+ * Inputs:  vector, scale (float), smoothness (float, used by SMOOTH_F1)
+ * Outputs: Distance (float), Color (color)
+ */
+export declare class VoronoiTexture extends ProcessNode {
+    get nodeType(): string;
+    static instanceSpecificDef: boolean;
+    get metadata(): NodeMetadata;
+    static glslFunction: string;
+    private readonly feature;
+    private readonly _inputs;
+    private readonly _outputs;
+    constructor(inputs?: VoronoiTextureInputs);
+    getInputSockets(): Record<string, import("../../core/InputSocket.js").InputSocket<unknown>>;
+    getOutputSockets(): Record<string, OutputSocket>;
+    compileDefs(): string;
+    compileCall(ctx: CompileContext): string;
+}
+//# sourceMappingURL=VoronoiTexture.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"VoronoiTexture.d.ts","sourceRoot":"","sources":["../../../src/nodes/process/VoronoiTexture.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,cAAc,GAAG,IAAI,GAAG,IAAI,GAAG,WAAW,GAAG,kBAAkB,CAAA;AAE3E,MAAM,WAAW,oBAAoB;IACnC,MAAM,CAAC,EAAM,YAAY,CAAA;IACzB,KAAK,CAAC,EAAO,MAAM,GAAG,YAAY,CAAA;IAClC,UAAU,CAAC,EAAE,MAAM,GAAG,YAAY,CAAA;IAClC,OAAO,CAAC,EAAK,cAAc,CAAA;CAC5B;AAED;;;;;;;;;;;GAWG;AACH,qBAAa,cAAe,SAAQ,WAAW;IAC7C,IAAI,QAAQ,WAA8B;IAC1C,MAAM,CAAC,mBAAmB,UAAQ;IAElC,IAAI,QAAQ,IAAI,YAAY,CAQ3B;IAED,MAAM,CAAC,YAAY,SAgDnB;IAEA,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAgB;IACxC,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;CAuCzC"}

package/dist/nodes/process/VoronoiTexture.js

@@ -0,0 +1,123 @@
+import { ProcessNode } from '../../core/ProcessNode.js';
+/**
+ * Voronoi Texture — Blender "Voronoi Texture" node equivalent.
+ * Full implementation matching all four Blender feature modes:
+ *
+ *   F1              — distance to nearest cell center (classic Voronoi)
+ *   F2              — distance to second-nearest cell center
+ *   SMOOTH_F1       — smooth minimum of F1 across cells (softens cell edges)
+ *   DISTANCE_TO_EDGE — distance to the Voronoi cell boundary
+ *
+ * Inputs:  vector, scale (float), smoothness (float, used by SMOOTH_F1)
+ * Outputs: Distance (float), Color (color)
+ */
+export class VoronoiTexture extends ProcessNode {
+    get nodeType() { return 'VoronoiTexture'; }
+    get metadata() {
+        return {
+            label: 'Voronoi Texture',
+            category: 'Texture',
+            color: '#3a6b3a',
+            cost: 'high',
+            costNote: '3×3×3 cell loop per fragment — avoid stacking.',
+        };
+    }
+    constructor(inputs = {}) {
+        super('VoronoiTexture');
+        this.feature = inputs.feature ?? 'F1';
+        this._inputs = this.createInputs(inputs, {
+            vector: ['color', null],
+            scale: ['float', inputs.scale ?? 5.0],
+            smoothness: ['float', inputs.smoothness ?? 1.0],
+        });
+        this._outputs = this.createOutputs({ Distance: 'float', Color: 'color' });
+    }
+    getInputSockets() { return this._inputs; }
+    getOutputSockets() { return this._outputs; }
+    compileDefs() { return VoronoiTexture.glslFunction; }
+    compileCall(ctx) {
+        const p = this._inputs.vector.isConnected()
+            ? `(${ctx.outputVar(this._inputs.vector.connection.node, this._inputs.vector.connection.name)} * ${ctx.resolveInput(this._inputs.scale)})`
+            : `(vec3(vUv, 0.0) * ${ctx.resolveInput(this._inputs.scale)})`;
+        const smooth = ctx.resolveInput(this._inputs.smoothness);
+        const dv = ctx.outputVar(this, 'Distance');
+        const cv = ctx.outputVar(this, 'Color');
+        const tmp = `_vor_${this.id}`;
+        switch (this.feature) {
+            case 'F2':
+                return [
+                    `vec3  ${tmp}_col = vec3(0.0);`,
+                    `vec2  ${tmp}_f   = _st_vorF1F2(${p}, ${tmp}_col);`,
+                    `float ${dv} = ${tmp}_f.y;`,
+                    `vec3  ${cv} = ${tmp}_col;`,
+                ].join('\n  ');
+            case 'SMOOTH_F1':
+                return [
+                    `float ${dv} = _st_vorSmoothF1(${p}, ${smooth});`,
+                    `vec3  ${cv} = vec3(${dv});`,
+                ].join('\n  ');
+            case 'DISTANCE_TO_EDGE':
+                return [
+                    `float ${dv} = _st_vorDistToEdge(${p});`,
+                    `vec3  ${cv} = vec3(${dv});`,
+                ].join('\n  ');
+            default: // F1
+                return [
+                    `vec3  ${tmp}_col = vec3(0.0);`,
+                    `vec2  ${tmp}_f   = _st_vorF1F2(${p}, ${tmp}_col);`,
+                    `float ${dv} = ${tmp}_f.x;`,
+                    `vec3  ${cv} = ${tmp}_col;`,
+                ].join('\n  ');
+        }
+    }
+}
+VoronoiTexture.instanceSpecificDef = false;
+VoronoiTexture.glslFunction = `
+vec3 _st_vorHash(vec3 cell) {
+  return fract(sin(vec3(
+    dot(cell, vec3(127.1, 311.7,  74.7)),
+    dot(cell, vec3(269.5, 183.3, 246.1)),
+    dot(cell, vec3(113.5, 271.9, 124.6))
+  )) * 43758.5453);
+}
+
+// Returns vec3(f1_dist, f2_dist, 0) and outputs cell color via out param
+vec2 _st_vorF1F2(vec3 p, out vec3 cellColor) {
+  vec3  pi = floor(p), pf = fract(p);
+  float d1 = 8.0, d2 = 8.0;
+  vec3  c1 = vec3(0.0);
+  for (int x = -1; x <= 1; x++)
+  for (int y = -1; y <= 1; y++)
+  for (int z = -1; z <= 1; z++) {
+    vec3  nb   = vec3(float(x), float(y), float(z));
+    vec3  pt   = _st_vorHash(pi + nb);
+    float dist = length(nb + pt - pf);
+    if (dist < d1) { d2 = d1; d1 = dist; c1 = pt; }
+    else if (dist < d2) { d2 = dist; }
+  }
+  cellColor = c1;
+  return vec2(d1, d2);
+}
+
+float _st_vorSmoothF1(vec3 p, float smoothness) {
+  vec3  pi = floor(p), pf = fract(p);
+  float res = 0.0;
+  float k   = max(smoothness, 0.0001);
+  for (int x = -1; x <= 1; x++)
+  for (int y = -1; y <= 1; y++)
+  for (int z = -1; z <= 1; z++) {
+    vec3  nb   = vec3(float(x), float(y), float(z));
+    vec3  pt   = _st_vorHash(pi + nb);
+    float dist = length(nb + pt - pf);
+    res += exp(-32.0 * dist / k);
+  }
+  return -(k / 32.0) * log(res);
+}
+
+float _st_vorDistToEdge(vec3 p) {
+  // Approximate distance to cell edge as (F2 - F1) * 0.5.
+  // Avoids the 5x5x5 loop that exceeds WebGL1 loop-unroll limits.
+  vec3  col = vec3(0.0);
+  vec2  f   = _st_vorF1F2(p, col);
+  return (f.y - f.x) * 0.5;
+}`;

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

@@ -0,0 +1,39 @@
+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 WaveType = 'BANDS' | 'RINGS';
+export type WaveProfile = 'SINE' | 'SAW' | 'TRIANGLE';
+export interface WaveTextureInputs {
+    vector?: OutputSocket;
+    scale?: number | OutputSocket;
+    distortion?: number | OutputSocket;
+    detail?: number | OutputSocket;
+    detailScale?: number | OutputSocket;
+    detailRoughness?: number | OutputSocket;
+    waveType?: WaveType;
+    profile?: WaveProfile;
+}
+/**
+ * Wave Texture — Blender "Wave Texture" node equivalent.
+ * Generates stripe/ring patterns with optional noise distortion.
+ *
+ * Inputs:  vector, scale, distortion, detail, detailScale, detailRoughness
+ * Outputs: Color (color), Fac (float)
+ */
+export declare class WaveTexture extends ProcessNode {
+    get nodeType(): string;
+    static instanceSpecificDef: boolean;
+    get metadata(): NodeMetadata;
+    static glslFunction: string;
+    private readonly waveType;
+    private readonly profile;
+    private readonly _inputs;
+    private readonly _outputs;
+    constructor(inputs?: WaveTextureInputs);
+    getInputSockets(): Record<string, import("../../core/InputSocket.js").InputSocket<unknown>>;
+    getOutputSockets(): Record<string, OutputSocket>;
+    compileDefs(): string;
+    compileCall(ctx: CompileContext): string;
+}
+//# sourceMappingURL=WaveTexture.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"WaveTexture.d.ts","sourceRoot":"","sources":["../../../src/nodes/process/WaveTexture.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,QAAQ,GAAK,OAAO,GAAG,OAAO,CAAA;AAC1C,MAAM,MAAM,WAAW,GAAG,MAAM,GAAG,KAAK,GAAG,UAAU,CAAA;AAErD,MAAM,WAAW,iBAAiB;IAChC,MAAM,CAAC,EAAO,YAAY,CAAA;IAC1B,KAAK,CAAC,EAAQ,MAAM,GAAG,YAAY,CAAA;IACnC,UAAU,CAAC,EAAG,MAAM,GAAG,YAAY,CAAA;IACnC,MAAM,CAAC,EAAO,MAAM,GAAG,YAAY,CAAA;IACnC,WAAW,CAAC,EAAE,MAAM,GAAG,YAAY,CAAA;IACnC,eAAe,CAAC,EAAE,MAAM,GAAG,YAAY,CAAA;IACvC,QAAQ,CAAC,EAAK,QAAQ,CAAA;IACtB,OAAO,CAAC,EAAM,WAAW,CAAA;CAC1B;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,SA0BnB;IAEA,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAU;IACnC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAc;IACtC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA2E;IACnG,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAmE;gBAEhF,MAAM,GAAE,iBAAsB;IAe1C,eAAe;IACf,gBAAgB;IAChB,WAAW;IAEX,WAAW,CAAC,GAAG,EAAE,cAAc,GAAG,MAAM;CAkBzC"}

package/dist/nodes/process/WaveTexture.js

@@ -0,0 +1,77 @@
+import { ProcessNode } from '../../core/ProcessNode.js';
+/**
+ * Wave Texture — Blender "Wave Texture" node equivalent.
+ * Generates stripe/ring patterns with optional noise distortion.
+ *
+ * Inputs:  vector, scale, distortion, detail, detailScale, detailRoughness
+ * Outputs: Color (color), Fac (float)
+ */
+export class WaveTexture extends ProcessNode {
+    get nodeType() { return 'WaveTexture'; }
+    get metadata() {
+        return { label: 'Wave Texture', category: 'Texture', color: '#3a6b3a', cost: 'medium' };
+    }
+    constructor(inputs = {}) {
+        super('WaveTexture');
+        this.waveType = inputs.waveType ?? 'BANDS';
+        this.profile = inputs.profile ?? 'SINE';
+        this._inputs = this.createInputs(inputs, {
+            vector: ['color', null],
+            scale: ['float', inputs.scale ?? 5.0],
+            distortion: ['float', inputs.distortion ?? 0.0],
+            detail: ['float', inputs.detail ?? 2.0],
+            detailScale: ['float', inputs.detailScale ?? 1.0],
+            detailRoughness: ['float', inputs.detailRoughness ?? 0.5],
+        });
+        this._outputs = this.createOutputs({ Color: 'color', Fac: 'float' });
+    }
+    getInputSockets() { return this._inputs; }
+    getOutputSockets() { return this._outputs; }
+    compileDefs() { return WaveTexture.glslFunction; }
+    compileCall(ctx) {
+        const vec = this._inputs.vector.isConnected()
+            ? `vec3(${ctx.outputVar(this._inputs.vector.connection.node, this._inputs.vector.connection.name)})`
+            : 'vec3(vUv, 0.0)';
+        const s = ctx.resolveInput(this._inputs.scale);
+        const d = ctx.resolveInput(this._inputs.distortion);
+        const det = ctx.resolveInput(this._inputs.detail);
+        const ds = ctx.resolveInput(this._inputs.detailScale);
+        const dr = ctx.resolveInput(this._inputs.detailRoughness);
+        const wt = this.waveType === 'BANDS' ? 0 : 1;
+        const pf = this.profile === 'SINE' ? 0 : this.profile === 'SAW' ? 1 : 2;
+        const fv = ctx.outputVar(this, 'Fac');
+        const cv = ctx.outputVar(this, 'Color');
+        return [
+            `float ${fv} = _st_waveTexture(${vec}, ${s}, ${d}, ${det}, ${ds}, ${dr}, ${wt}, ${pf});`,
+            `vec3  ${cv} = vec3(${fv});`,
+        ].join('\n  ');
+    }
+}
+WaveTexture.instanceSpecificDef = false;
+WaveTexture.glslFunction = `
+float _st_waveHash(vec3 p) {
+  return fract(sin(dot(p, vec3(127.1, 311.7, 74.7))) * 43758.5453);
+}
+float _st_waveNoise(vec3 p) {
+  vec3 pi = floor(p), pf = p - pi, u = pf * pf * (3.0 - 2.0 * pf);
+  return mix(mix(mix(_st_waveHash(pi),              _st_waveHash(pi+vec3(1,0,0)), u.x),
+                 mix(_st_waveHash(pi+vec3(0,1,0)),  _st_waveHash(pi+vec3(1,1,0)), u.x), u.y),
+             mix(mix(_st_waveHash(pi+vec3(0,0,1)),  _st_waveHash(pi+vec3(1,0,1)), u.x),
+                 mix(_st_waveHash(pi+vec3(0,1,1)),  _st_waveHash(pi+vec3(1,1,1)), u.x), u.y), u.z);
+}
+float _st_waveTexture(vec3 p, float scale, float distortion, float detail, float dScale, float dRough, int waveType, int profile) {
+  p *= scale;
+  float dist = (waveType == 0) ? p.x + p.y + p.z : length(p);
+  float n = 0.0, amp = 1.0, freq = 1.0, maxAmp = 0.0;
+  int oct = int(clamp(detail, 0.0, 8.0));
+  for (int i = 0; i < 8; i++) {
+    if (i >= oct) break;
+    n += amp * _st_waveNoise(p * freq * dScale);
+    maxAmp += amp; amp *= dRough; freq *= 2.0;
+  }
+  dist += distortion * (maxAmp > 0.0 ? n / maxAmp : 0.0);
+  float wave = 0.5 + 0.5 * sin(dist * 6.28318);
+  if (profile == 1) wave = fract(dist / 6.28318);
+  if (profile == 2) wave = abs(2.0 * fract(dist / 6.28318) - 1.0);
+  return wave;
+}`;

package/dist/nodes/process/Wavelength.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 WavelengthInputs {
+    wavelength?: OutputSocket | number;
+}
+/**
+ * Wavelength — Blender "Wavelength" node equivalent.
+ * Converts a visible light wavelength (380–780 nm) into an RGB colour.
+ *
+ * Inputs:  wavelength (float, nanometres — 380 to 780)
+ * Outputs: Color (color)
+ */
+export declare class Wavelength extends ProcessNode {
+    get nodeType(): string;
+    static instanceSpecificDef: boolean;
+    get metadata(): NodeMetadata;
+    static glslFunction: string;
+    private readonly _inputs;
+    private readonly _outputs;
+    constructor(inputs?: WavelengthInputs);
+    getInputSockets(): Record<string, import("../../core/InputSocket.js").InputSocket<unknown>>;
+    getOutputSockets(): Record<string, OutputSocket>;
+    compileDefs(): string;
+    compileCall(ctx: CompileContext): string;
+}
+//# sourceMappingURL=Wavelength.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Wavelength.d.ts","sourceRoot":"","sources":["../../../src/nodes/process/Wavelength.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,UAAU,CAAC,EAAE,YAAY,GAAG,MAAM,CAAA;CACnC;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,SAanB;IAEA,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA2E;IACnG,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAmE;gBAEhF,MAAM,GAAE,gBAAqB;IAQzC,eAAe;IACf,gBAAgB;IAChB,WAAW;IAEX,WAAW,CAAC,GAAG,EAAE,cAAc,GAAG,MAAM;CAIzC"}

package/dist/nodes/process/Wavelength.js

@@ -0,0 +1,43 @@
+import { ProcessNode } from '../../core/ProcessNode.js';
+/**
+ * Wavelength — Blender "Wavelength" node equivalent.
+ * Converts a visible light wavelength (380–780 nm) into an RGB colour.
+ *
+ * Inputs:  wavelength (float, nanometres — 380 to 780)
+ * Outputs: Color (color)
+ */
+export class Wavelength extends ProcessNode {
+    get nodeType() { return 'Wavelength'; }
+    get metadata() {
+        return { label: 'Wavelength', category: 'Color', color: '#633060', cost: 'low' };
+    }
+    constructor(inputs = {}) {
+        super('Wavelength');
+        this._inputs = this.createInputs(inputs, {
+            wavelength: ['float', inputs.wavelength ?? 550.0],
+        });
+        this._outputs = this.createOutputs({ Color: 'color' });
+    }
+    getInputSockets() { return this._inputs; }
+    getOutputSockets() { return this._outputs; }
+    compileDefs() { return Wavelength.glslFunction; }
+    compileCall(ctx) {
+        const w = ctx.resolveInput(this._inputs.wavelength);
+        return `vec3 ${ctx.outputVar(this, 'Color')} = _st_wavelength(${w});`;
+    }
+}
+Wavelength.instanceSpecificDef = false;
+Wavelength.glslFunction = `
+vec3 _st_wavelength(float w) {
+  w = clamp(w, 380.0, 780.0);
+  float r = 0.0, g = 0.0, b = 0.0;
+  if      (w < 440.0) { r = (440.0 - w) / 60.0; b = 1.0; }
+  else if (w < 490.0) { g = (w - 440.0) / 50.0; b = 1.0; }
+  else if (w < 510.0) { g = 1.0; b = (510.0 - w) / 20.0; }
+  else if (w < 580.0) { r = (w - 510.0) / 70.0; g = 1.0; }
+  else if (w < 645.0) { r = 1.0; g = (645.0 - w) / 65.0; }
+  else                { r = 1.0; }
+  float factor = (w < 420.0) ? 0.3 + 0.7 * (w - 380.0) / 40.0
+               : (w > 700.0) ? 0.3 + 0.7 * (780.0 - w) / 80.0 : 1.0;
+  return pow(vec3(r, g, b) * factor, vec3(0.8));
+}`;

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

@@ -0,0 +1,27 @@
+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 WhiteNoiseInputs {
+    vector?: OutputSocket;
+}
+/**
+ * White Noise — Blender "White Noise" texture node equivalent.
+ * Pure pixel-perfect random values — no spatial correlation.
+ *
+ * Outputs: Value (float), Color (color)
+ */
+export declare class WhiteNoise extends ProcessNode {
+    get nodeType(): string;
+    static instanceSpecificDef: boolean;
+    get metadata(): NodeMetadata;
+    static glslFunction: string;
+    private readonly _inputs;
+    private readonly _outputs;
+    constructor(inputs?: WhiteNoiseInputs);
+    getInputSockets(): Record<string, import("../../core/InputSocket.js").InputSocket<unknown>>;
+    getOutputSockets(): Record<string, OutputSocket>;
+    compileDefs(): string;
+    compileCall(ctx: CompileContext): string;
+}
+//# sourceMappingURL=WhiteNoise.d.ts.map

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

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

package/dist/nodes/process/WhiteNoise.js

@@ -0,0 +1,44 @@
+import { ProcessNode } from '../../core/ProcessNode.js';
+/**
+ * White Noise — Blender "White Noise" texture node equivalent.
+ * Pure pixel-perfect random values — no spatial correlation.
+ *
+ * Outputs: Value (float), Color (color)
+ */
+export class WhiteNoise extends ProcessNode {
+    get nodeType() { return 'WhiteNoise'; }
+    get metadata() {
+        return { label: 'White Noise', category: 'Texture', color: '#3a6b3a', cost: 'low' };
+    }
+    constructor(inputs = {}) {
+        super('WhiteNoise');
+        this._inputs = this.createInputs(inputs, { vector: ['color', null] });
+        this._outputs = this.createOutputs({ Value: 'float', Color: 'color' });
+    }
+    getInputSockets() { return this._inputs; }
+    getOutputSockets() { return this._outputs; }
+    compileDefs() { return WhiteNoise.glslFunction; }
+    compileCall(ctx) {
+        const vec = this._inputs.vector.isConnected()
+            ? `vec3(${ctx.outputVar(this._inputs.vector.connection.node, this._inputs.vector.connection.name)})`
+            : 'vec3(vUv, 0.0)';
+        const fv = ctx.outputVar(this, 'Value');
+        const cv = ctx.outputVar(this, 'Color');
+        return [
+            `float ${fv} = _st_whiteNoise1(${vec});`,
+            `vec3  ${cv} = _st_whiteNoise3(${vec});`,
+        ].join('\n  ');
+    }
+}
+WhiteNoise.instanceSpecificDef = false;
+WhiteNoise.glslFunction = `
+float _st_whiteNoise1(vec3 p) {
+  return fract(sin(dot(p, vec3(127.1, 311.7, 74.7))) * 43758.5453);
+}
+vec3 _st_whiteNoise3(vec3 p) {
+  return vec3(
+    fract(sin(dot(p, vec3(127.1, 311.7, 74.7))) * 43758.5453),
+    fract(sin(dot(p, vec3(269.5, 183.3, 246.1))) * 43758.5453),
+    fract(sin(dot(p, vec3(113.5, 271.9, 124.6))) * 43758.5453)
+  );
+}`;

package/dist/nodes/shader/AmbientOcclusion.d.ts

@@ -0,0 +1,47 @@
+import { InputNode } from '../../core/InputNode.js';
+import type { NodeMetadata } from '../../core/ShaderNode.js';
+import type { CompileContext } from '../../core/CompileContext.js';
+import type { OutputSocket } from '../../core/OutputSocket.js';
+import type { InputSocket } from '../../core/InputSocket.js';
+export interface AmbientOcclusionInputs {
+    color?: OutputSocket | [number, number, number] | string;
+}
+/**
+ * Ambient Occlusion — Blender "Ambient Occlusion" input node equivalent.
+ *
+ * Approximates SSAO using a fixed hemisphere sample kernel evaluated against
+ * neighboring surface normals. Because no depth buffer is available in a
+ * forward-rendered fragment shader, the implementation samples offset
+ * positions in view space and estimates occlusion from the surface normal
+ * divergence between the central fragment and each sample.
+ *
+ * Parameters:
+ *   samples  (number) — hemisphere sample count [1–16], default 8
+ *   distance (number) — sampling radius in world units, default 0.5
+ *   inside   (number) — 0 = exterior AO (default), 1 = invert for interior surfaces
+ *
+ * Inputs:
+ *   Color (color) — base color to attenuate by the AO factor
+ *
+ * Outputs:
+ *   Color (color) — input color darkened by AO
+ *   AO    (float) — raw ambient occlusion factor [0–1]
+ */
+export declare class AmbientOcclusion extends InputNode {
+    get nodeType(): string;
+    static instanceSpecificDef: boolean;
+    get metadata(): NodeMetadata;
+    parameters: {
+        samples: number;
+        distance: number;
+        inside: number;
+    };
+    private readonly _inputs;
+    private readonly _outputs;
+    constructor(inputs?: AmbientOcclusionInputs);
+    getInputSockets(): Record<string, InputSocket<unknown>>;
+    getOutputSockets(): Record<string, OutputSocket>;
+    compileDefs(): string;
+    compileCall(ctx: CompileContext): string;
+}
+//# sourceMappingURL=AmbientOcclusion.d.ts.map

package/dist/nodes/shader/AmbientOcclusion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AmbientOcclusion.d.ts","sourceRoot":"","sources":["../../../src/nodes/shader/AmbientOcclusion.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAA;AACnD,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;AAC9D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAA;AAE5D,MAAM,WAAW,sBAAsB;IACrC,KAAK,CAAC,EAAG,YAAY,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,GAAG,MAAM,CAAA;CAC1D;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,qBAAa,gBAAiB,SAAQ,SAAS;IAC7C,IAAI,QAAQ,WAAgC;IAC5C,MAAM,CAAC,mBAAmB,UAAQ;IAElC,IAAI,QAAQ,IAAI,YAAY,CAE3B;IAEQ,UAAU,EAAE;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAIzE;IAED,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAuC;IAC/D,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAA8B;gBAE3C,MAAM,GAAE,sBAA2B;IAQ/C,eAAe;IACf,gBAAgB;IAEhB,WAAW,IAAI,MAAM;IAsErB,WAAW,CAAC,GAAG,EAAE,cAAc,GAAG,MAAM;CAkBzC"}

package/dist/nodes/shader/AmbientOcclusion.js

@@ -0,0 +1,128 @@
+import { InputNode } from '../../core/InputNode.js';
+/**
+ * Ambient Occlusion — Blender "Ambient Occlusion" input node equivalent.
+ *
+ * Approximates SSAO using a fixed hemisphere sample kernel evaluated against
+ * neighboring surface normals. Because no depth buffer is available in a
+ * forward-rendered fragment shader, the implementation samples offset
+ * positions in view space and estimates occlusion from the surface normal
+ * divergence between the central fragment and each sample.
+ *
+ * Parameters:
+ *   samples  (number) — hemisphere sample count [1–16], default 8
+ *   distance (number) — sampling radius in world units, default 0.5
+ *   inside   (number) — 0 = exterior AO (default), 1 = invert for interior surfaces
+ *
+ * Inputs:
+ *   Color (color) — base color to attenuate by the AO factor
+ *
+ * Outputs:
+ *   Color (color) — input color darkened by AO
+ *   AO    (float) — raw ambient occlusion factor [0–1]
+ */
+export class AmbientOcclusion extends InputNode {
+    get nodeType() { return 'AmbientOcclusion'; }
+    get metadata() {
+        return { label: 'Ambient Occlusion', category: 'Input', color: '#3d6b96', cost: 'high', costNote: 'multi-sample hemisphere loop' };
+    }
+    constructor(inputs = {}) {
+        super('AmbientOcclusion');
+        this.parameters = {
+            samples: 8,
+            distance: 0.5,
+            inside: 0,
+        };
+        this._inputs = this.createInputs(inputs, {
+            color: ['color', inputs.color ?? '#ffffff'],
+        });
+        this._outputs = this.createOutputs({ Color: 'color', AO: 'float' });
+    }
+    getInputSockets() { return this._inputs; }
+    getOutputSockets() { return this._outputs; }
+    compileDefs() {
+        // Fixed-size hemisphere kernel (16 directions) — cap prevents unbounded loops.
+        // Hash-based pseudo-random rotation avoids a texture lookup.
+        // SECURITY: loop is bounded by compile-time constant 16.
+        return `
+float _st_ao_hash(vec2 p) {
+  p = fract(p * vec2(234.34, 435.345));
+  p += dot(p, p + 34.23);
+  return fract(p.x * p.y);
+}
+
+float _st_ambientOcclusion(vec3 pos, vec3 N, float dist, int samples, bool inside) {
+  // 16-element hemisphere kernel (fixed compile-time size)
+  vec3 kernel[16];
+  kernel[0]  = vec3( 0.5381,  0.1856, -0.4319);
+  kernel[1]  = vec3( 0.1379,  0.2486,  0.4430);
+  kernel[2]  = vec3( 0.3371,  0.5679, -0.0057);
+  kernel[3]  = vec3(-0.6999, -0.0451, -0.0019);
+  kernel[4]  = vec3( 0.0689, -0.1598, -0.8547);
+  kernel[5]  = vec3( 0.0560,  0.0069, -0.1843);
+  kernel[6]  = vec3(-0.0146,  0.1402,  0.0762);
+  kernel[7]  = vec3( 0.0100, -0.1924, -0.0344);
+  kernel[8]  = vec3(-0.3577, -0.5301, -0.4358);
+  kernel[9]  = vec3(-0.3169,  0.1063,  0.0158);
+  kernel[10] = vec3( 0.0103, -0.5869,  0.0046);
+  kernel[11] = vec3(-0.0897, -0.4940,  0.3287);
+  kernel[12] = vec3( 0.7119, -0.0154, -0.0918);
+  kernel[13] = vec3(-0.0533,  0.0596, -0.5411);
+  kernel[14] = vec3( 0.0352, -0.0631,  0.5460);
+  kernel[15] = vec3(-0.4776,  0.2847, -0.0271);
+
+  float occlusion = 0.0;
+  float noise     = _st_ao_hash(pos.xy + pos.z);
+  float c = cos(noise * 6.2832);
+  float s = sin(noise * 6.2832);
+
+  // Build tangent frame from normal
+  vec3 up      = abs(N.y) < 0.999 ? vec3(0.0, 1.0, 0.0) : vec3(1.0, 0.0, 0.0);
+  vec3 tangent = normalize(cross(up, N));
+  vec3 bitan   = cross(N, tangent);
+  mat3 tbn     = mat3(tangent, bitan, N);
+
+  int clampedSamples = clamp(samples, 1, 16);
+  for (int i = 0; i < 16; i++) {
+    if (i >= clampedSamples) break;
+
+    // Rotate sample by noise to reduce banding
+    vec3 ks = kernel[i];
+    vec3 rotated = vec3(
+      c * ks.x - s * ks.y,
+      s * ks.x + c * ks.y,
+      ks.z
+    );
+    // Flip to hemisphere
+    if (dot(rotated, N) < 0.0) rotated = -rotated;
+    vec3 samplePos = pos + tbn * rotated * dist;
+
+    // Estimate occlusion: if sample is "behind" the surface normal, it is occluded
+    vec3  dir     = samplePos - pos;
+    float contrib = max(dot(normalize(dir), N), 0.0);
+    float decay   = 1.0 - clamp(length(dir) / dist, 0.0, 1.0);
+    occlusion += contrib * decay;
+  }
+
+  occlusion = 1.0 - (occlusion / float(clampedSamples));
+  return inside ? 1.0 - occlusion : occlusion;
+}
+`;
+    }
+    compileCall(ctx) {
+        const colorIn = ctx.resolveInput(this._inputs.color);
+        const outColor = ctx.outputVar(this, 'Color');
+        const outAO = ctx.outputVar(this, 'AO');
+        // SECURITY: validate samples is a finite positive integer before GLSL
+        const rawSamples = this.parameters.samples;
+        const safeSamples = (Number.isFinite(rawSamples) && rawSamples >= 1)
+            ? Math.min(Math.floor(rawSamples), 16)
+            : 8;
+        const inside = this.parameters.inside !== 0 ? 'true' : 'false';
+        const dist = Number.isFinite(this.parameters.distance) ? this.parameters.distance.toFixed(4) : '0.5000';
+        return [
+            `float ${outAO}    = _st_ambientOcclusion(vPosition, normalize(vNormal), ${dist}, ${safeSamples}, ${inside});`,
+            `vec3  ${outColor} = ${colorIn} * ${outAO};`,
+        ].join('\n  ');
+    }
+}
+AmbientOcclusion.instanceSpecificDef = false;