@triforge/shader-core 0.1.0

package/dist/nodes/process/AnimatedNoiseTexture.js

@@ -0,0 +1,93 @@
+import { ProcessNode } from '../../core/ProcessNode.js';
+/**
+ * Animated Noise Texture — time-animated extension of NoiseTexture.
+ * Uses four scrolling noise layers for realistic wave-like movement.
+ * Injects a `time` uniform into the compiled ShaderMaterial automatically.
+ *
+ * Inputs:  vector, scale, detail, roughness, distortion, speed
+ * Outputs: Fac (float), Color (color)
+ *
+ * Usage:
+ *   const noise = new AnimatedNoiseTexture({ scale: 5.0, speed: 1.0 })
+ *   // After mat.compile(), time updates via: mat.material.uniforms.time.value = t
+ */
+export class AnimatedNoiseTexture extends ProcessNode {
+    get nodeType() { return 'AnimatedNoiseTexture'; }
+    get metadata() {
+        return {
+            label: 'Animated Noise Texture',
+            category: 'Texture',
+            color: '#3a6b3a',
+            cost: 'high',
+            costNote: 'Four noise layers per fragment. Limit to 2 instances per material.',
+        };
+    }
+    constructor(inputs = {}) {
+        super('AnimatedNoiseTexture');
+        this.speed = inputs.speed ?? 1.0;
+        this._inputs = this.createInputs(inputs, {
+            vector: ['color', null],
+            scale: ['float', inputs.scale ?? 5.0],
+            detail: ['float', inputs.detail ?? 2.0],
+            roughness: ['float', inputs.roughness ?? 0.5],
+            distortion: ['float', inputs.distortion ?? 0.0],
+        });
+        this._outputs = this.createOutputs({ Fac: 'float', Color: 'color' });
+    }
+    getInputSockets() { return this._inputs; }
+    getOutputSockets() { return this._outputs; }
+    compileDefs() { return AnimatedNoiseTexture.glslFunction; }
+    compileCall(ctx) {
+        const p3 = this._inputs.vector.isConnected()
+            ? ctx.outputVar(this._inputs.vector.connection.node, this._inputs.vector.connection.name)
+            : 'vPosition';
+        const scale = ctx.resolveInput(this._inputs.scale);
+        const fv = ctx.outputVar(this, 'Fac');
+        const cv = ctx.outputVar(this, 'Color');
+        return [
+            `float ${fv} = _st_animatedNoise(${p3}, ${scale}, ${this.speed.toFixed(4)});`,
+            `vec3  ${cv} = vec3(${fv});`,
+        ].join('\n  ');
+    }
+}
+AnimatedNoiseTexture.instanceSpecificDef = false;
+AnimatedNoiseTexture.glslFunction = `
+uniform float time;
+
+float _st_an_hash(vec3 p) {
+  return fract(sin(dot(p, vec3(127.1, 311.7, 74.7))) * 43758.5453);
+}
+vec3 _st_an_grad(vec3 p) {
+  float h = _st_an_hash(floor(p));
+  return normalize(vec3(h, fract(h * 34.0), fract(h * 89.0)) * 2.0 - 1.0);
+}
+float _st_an_perlin(vec3 p) {
+  vec3 pi = floor(p), pf = p - pi, u = pf * pf * (3.0 - 2.0 * pf);
+  float v000 = dot(_st_an_grad(pi+vec3(0,0,0)), pf-vec3(0,0,0));
+  float v100 = dot(_st_an_grad(pi+vec3(1,0,0)), pf-vec3(1,0,0));
+  float v010 = dot(_st_an_grad(pi+vec3(0,1,0)), pf-vec3(0,1,0));
+  float v110 = dot(_st_an_grad(pi+vec3(1,1,0)), pf-vec3(1,1,0));
+  float v001 = dot(_st_an_grad(pi+vec3(0,0,1)), pf-vec3(0,0,1));
+  float v101 = dot(_st_an_grad(pi+vec3(1,0,1)), pf-vec3(1,0,1));
+  float v011 = dot(_st_an_grad(pi+vec3(0,1,1)), pf-vec3(0,1,1));
+  float v111 = dot(_st_an_grad(pi+vec3(1,1,1)), pf-vec3(1,1,1));
+  return mix(
+    mix(mix(v000,v100,u.x), mix(v010,v110,u.x), u.y),
+    mix(mix(v001,v101,u.x), mix(v011,v111,u.x), u.y), u.z
+  ) * 0.5 + 0.5;
+}
+
+float _st_animatedNoise(vec3 pos, float scale, float speed) {
+  vec2 worldXZ = pos.xz;
+  vec2 wp = worldXZ * 0.008 * scale;
+  float t = time * speed;
+  vec2 uv0 = wp        + vec2( t / 17.0,  t / 29.0);
+  vec2 uv1 = wp        + vec2(-t / 19.0,  t / 31.0);
+  vec2 uv2 = wp * 2.1  + vec2( t / 41.0,  t / 53.0);
+  vec2 uv3 = wp * 2.1  + vec2(-t / 37.0, -t / 61.0);
+  float n = _st_an_perlin(vec3(uv0, 0.0))
+          + _st_an_perlin(vec3(uv1, 0.0))
+          + _st_an_perlin(vec3(uv2, 0.0))
+          + _st_an_perlin(vec3(uv3, 0.0));
+  return n * 0.25;
+}`;

package/dist/nodes/process/Blackbody.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 BlackbodyInputs {
+    temperature?: OutputSocket | number;
+}
+/**
+ * Blackbody — Blender "Blackbody" node equivalent.
+ * Converts temperature in Kelvin to an emission colour.
+ * 1000K = deep red, 6500K = white, 10000K = blue-white.
+ *
+ * Inputs:  temperature (float, Kelvin)
+ * Outputs: Color (color)
+ */
+export declare class Blackbody extends ProcessNode {
+    get nodeType(): string;
+    static instanceSpecificDef: boolean;
+    get metadata(): NodeMetadata;
+    static glslFunction: string;
+    private readonly _inputs;
+    private readonly _outputs;
+    constructor(inputs?: BlackbodyInputs);
+    getInputSockets(): Record<string, import("../../core/InputSocket.js").InputSocket<unknown>>;
+    getOutputSockets(): Record<string, OutputSocket>;
+    compileDefs(): string;
+    compileCall(ctx: CompileContext): string;
+}
+//# sourceMappingURL=Blackbody.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Blackbody.d.ts","sourceRoot":"","sources":["../../../src/nodes/process/Blackbody.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,WAAW,CAAC,EAAE,YAAY,GAAG,MAAM,CAAA;CACpC;AAED;;;;;;;GAOG;AACH,qBAAa,SAAU,SAAQ,WAAW;IACxC,IAAI,QAAQ,WAAyB;IACrC,MAAM,CAAC,mBAAmB,UAAQ;IAElC,IAAI,QAAQ,IAAI,YAAY,CAE3B;IAED,MAAM,CAAC,YAAY,SAmBnB;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;CAIzC"}

package/dist/nodes/process/Blackbody.js

@@ -0,0 +1,50 @@
+import { ProcessNode } from '../../core/ProcessNode.js';
+/**
+ * Blackbody — Blender "Blackbody" node equivalent.
+ * Converts temperature in Kelvin to an emission colour.
+ * 1000K = deep red, 6500K = white, 10000K = blue-white.
+ *
+ * Inputs:  temperature (float, Kelvin)
+ * Outputs: Color (color)
+ */
+export class Blackbody extends ProcessNode {
+    get nodeType() { return 'Blackbody'; }
+    get metadata() {
+        return { label: 'Blackbody', category: 'Color', color: '#633060', cost: 'low' };
+    }
+    constructor(inputs = {}) {
+        super('Blackbody');
+        this._inputs = this.createInputs(inputs, {
+            temperature: ['float', inputs.temperature ?? 3200.0],
+        });
+        this._outputs = this.createOutputs({ Color: 'color' });
+    }
+    getInputSockets() { return this._inputs; }
+    getOutputSockets() { return this._outputs; }
+    compileDefs() { return Blackbody.glslFunction; }
+    compileCall(ctx) {
+        const temp = ctx.resolveInput(this._inputs.temperature);
+        return `vec3 ${ctx.outputVar(this, 'Color')} = _st_blackbody(${temp});`;
+    }
+}
+Blackbody.instanceSpecificDef = false;
+Blackbody.glslFunction = `
+vec3 _st_blackbody(float t) {
+  t = clamp(t, 800.0, 40000.0) / 100.0;
+  float r, g, b;
+  if (t <= 66.0) {
+    r = 1.0;
+    g = clamp((99.4708025861 * log(t) - 161.1195681661) / 255.0, 0.0, 1.0);
+  } else {
+    r = clamp((329.698727446 * pow(t - 60.0, -0.1332047592)) / 255.0, 0.0, 1.0);
+    g = clamp((288.1221695283 * pow(t - 60.0, -0.0755148492)) / 255.0, 0.0, 1.0);
+  }
+  if (t >= 66.0) {
+    b = 1.0;
+  } else if (t <= 19.0) {
+    b = 0.0;
+  } else {
+    b = clamp((138.5177312231 * log(t - 10.0) - 305.0447927307) / 255.0, 0.0, 1.0);
+  }
+  return vec3(r, g, b);
+}`;

package/dist/nodes/process/BrickTexture.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 BrickTextureInputs {
+    vector?: OutputSocket;
+    color1?: OutputSocket | string;
+    color2?: OutputSocket | string;
+    mortar?: OutputSocket | string;
+    scale?: number | OutputSocket;
+    mortarSize?: number | OutputSocket;
+    mortarSmooth?: number | OutputSocket;
+    bias?: number | OutputSocket;
+    brickWidth?: number | OutputSocket;
+    rowHeight?: number | OutputSocket;
+}
+/**
+ * Brick Texture — Blender "Brick Texture" node equivalent.
+ * Procedural brick/tile pattern with mortar lines.
+ *
+ * Outputs: Color (color), Fac (float — 1.0 on mortar, 0.0 on brick)
+ */
+export declare class BrickTexture extends ProcessNode {
+    get nodeType(): string;
+    static instanceSpecificDef: boolean;
+    get metadata(): NodeMetadata;
+    static glslFunction: string;
+    private readonly _inputs;
+    private readonly _outputs;
+    constructor(inputs?: BrickTextureInputs);
+    getInputSockets(): Record<string, import("../../core/InputSocket.js").InputSocket<unknown>>;
+    getOutputSockets(): Record<string, OutputSocket>;
+    compileDefs(): string;
+    compileCall(ctx: CompileContext): string;
+}
+//# sourceMappingURL=BrickTexture.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"BrickTexture.d.ts","sourceRoot":"","sources":["../../../src/nodes/process/BrickTexture.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,kBAAkB;IACjC,MAAM,CAAC,EAAQ,YAAY,CAAA;IAC3B,MAAM,CAAC,EAAQ,YAAY,GAAG,MAAM,CAAA;IACpC,MAAM,CAAC,EAAQ,YAAY,GAAG,MAAM,CAAA;IACpC,MAAM,CAAC,EAAQ,YAAY,GAAG,MAAM,CAAA;IACpC,KAAK,CAAC,EAAS,MAAM,GAAG,YAAY,CAAA;IACpC,UAAU,CAAC,EAAI,MAAM,GAAG,YAAY,CAAA;IACpC,YAAY,CAAC,EAAE,MAAM,GAAG,YAAY,CAAA;IACpC,IAAI,CAAC,EAAU,MAAM,GAAG,YAAY,CAAA;IACpC,UAAU,CAAC,EAAI,MAAM,GAAG,YAAY,CAAA;IACpC,SAAS,CAAC,EAAK,MAAM,GAAG,YAAY,CAAA;CACrC;AAED;;;;;GAKG;AACH,qBAAa,YAAa,SAAQ,WAAW;IAC3C,IAAI,QAAQ,WAA4B;IACxC,MAAM,CAAC,mBAAmB,UAAQ;IAElC,IAAI,QAAQ,IAAI,YAAY,CAE3B;IAED,MAAM,CAAC,YAAY,SAgBnB;IAEA,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA2E;IACnG,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAmE;gBAEhF,MAAM,GAAE,kBAAuB;IAiB3C,eAAe;IACf,gBAAgB;IAChB,WAAW;IAEX,WAAW,CAAC,GAAG,EAAE,cAAc,GAAG,MAAM;CAqBzC"}

package/dist/nodes/process/BrickTexture.js

@@ -0,0 +1,71 @@
+import { ProcessNode } from '../../core/ProcessNode.js';
+/**
+ * Brick Texture — Blender "Brick Texture" node equivalent.
+ * Procedural brick/tile pattern with mortar lines.
+ *
+ * Outputs: Color (color), Fac (float — 1.0 on mortar, 0.0 on brick)
+ */
+export class BrickTexture extends ProcessNode {
+    get nodeType() { return 'BrickTexture'; }
+    get metadata() {
+        return { label: 'Brick Texture', category: 'Texture', color: '#3a6b3a', cost: 'low' };
+    }
+    constructor(inputs = {}) {
+        super('BrickTexture');
+        this._inputs = this.createInputs(inputs, {
+            vector: ['color', null],
+            color1: ['color', inputs.color1 ?? '#cc8855'],
+            color2: ['color', inputs.color2 ?? '#aa6633'],
+            mortar: ['color', inputs.mortar ?? '#222222'],
+            scale: ['float', inputs.scale ?? 5.0],
+            mortarSize: ['float', inputs.mortarSize ?? 0.02],
+            mortarSmooth: ['float', inputs.mortarSmooth ?? 0.1],
+            bias: ['float', inputs.bias ?? 0.0],
+            brickWidth: ['float', inputs.brickWidth ?? 0.5],
+            rowHeight: ['float', inputs.rowHeight ?? 0.25],
+        });
+        this._outputs = this.createOutputs({ Color: 'color', Fac: 'float' });
+    }
+    getInputSockets() { return this._inputs; }
+    getOutputSockets() { return this._outputs; }
+    compileDefs() { return BrickTexture.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 c1 = ctx.resolveInput(this._inputs.color1);
+        const c2 = ctx.resolveInput(this._inputs.color2);
+        const mo = ctx.resolveInput(this._inputs.mortar);
+        const sc = ctx.resolveInput(this._inputs.scale);
+        const ms = ctx.resolveInput(this._inputs.mortarSize);
+        const mm = ctx.resolveInput(this._inputs.mortarSmooth);
+        const bi = ctx.resolveInput(this._inputs.bias);
+        const bw = ctx.resolveInput(this._inputs.brickWidth);
+        const rh = ctx.resolveInput(this._inputs.rowHeight);
+        const cv = ctx.outputVar(this, 'Color');
+        const fv = ctx.outputVar(this, 'Fac');
+        return [
+            `vec4 _br_${this.id} = _st_brickTexture(${vec}, ${c1}, ${c2}, ${mo}, ${sc}, ${ms}, ${mm}, ${bi}, ${bw}, ${rh});`,
+            `vec3  ${cv} = _br_${this.id}.rgb;`,
+            `float ${fv} = _br_${this.id}.a;`,
+        ].join('\n  ');
+    }
+}
+BrickTexture.instanceSpecificDef = false;
+BrickTexture.glslFunction = `
+vec4 _st_brickTexture(vec3 p, vec3 c1, vec3 c2, vec3 mortar, float scale,
+    float mortarSize, float mortarSmooth, float bias, float brickW, float rowH) {
+  p *= scale;
+  float rowNum  = floor(p.y / rowH);
+  float offset  = mod(rowNum, 2.0) * brickW * 0.5;
+  float brickX  = mod(p.x + offset, brickW);
+  float brickY  = mod(p.y, rowH);
+  float mx      = smoothstep(mortarSize - mortarSmooth, mortarSize + mortarSmooth, brickX);
+  float my      = smoothstep(mortarSize - mortarSmooth, mortarSize + mortarSmooth, brickY);
+  mx *= smoothstep(mortarSize - mortarSmooth, mortarSize + mortarSmooth, brickW - brickX);
+  my *= smoothstep(mortarSize - mortarSmooth, mortarSize + mortarSmooth, rowH - brickY);
+  float isMortar = 1.0 - mx * my;
+  float b = clamp(bias, -1.0, 1.0);
+  vec3  col = mix(mix(c1, c2, step(0.5 + b * 0.5, fract(rowNum * 0.5 + brickX / brickW))), mortar, isMortar);
+  return vec4(col, isMortar);
+}`;

package/dist/nodes/process/BrightContrast.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 BrightContrastInputs {
+    color?: OutputSocket | string;
+    bright?: OutputSocket | number;
+    contrast?: OutputSocket | number;
+}
+/**
+ * Bright Contrast — Blender "Bright/Contrast" node equivalent.
+ * Adjusts brightness and contrast of a colour.
+ *
+ * Inputs:  color, bright [-100 to 100], contrast [-100 to 100]
+ * Outputs: Color (color)
+ */
+export declare class BrightContrast extends ProcessNode {
+    get nodeType(): string;
+    static instanceSpecificDef: boolean;
+    get metadata(): NodeMetadata;
+    static glslFunction: string;
+    private readonly _inputs;
+    private readonly _outputs;
+    constructor(inputs?: BrightContrastInputs);
+    getInputSockets(): Record<string, import("../../core/InputSocket.js").InputSocket<unknown>>;
+    getOutputSockets(): Record<string, OutputSocket>;
+    compileDefs(): string;
+    compileCall(ctx: CompileContext): string;
+}
+//# sourceMappingURL=BrightContrast.d.ts.map

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

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

package/dist/nodes/process/BrightContrast.js

@@ -0,0 +1,41 @@
+import { ProcessNode } from '../../core/ProcessNode.js';
+/**
+ * Bright Contrast — Blender "Bright/Contrast" node equivalent.
+ * Adjusts brightness and contrast of a colour.
+ *
+ * Inputs:  color, bright [-100 to 100], contrast [-100 to 100]
+ * Outputs: Color (color)
+ */
+export class BrightContrast extends ProcessNode {
+    get nodeType() { return 'BrightContrast'; }
+    get metadata() {
+        return { label: 'Bright/Contrast', category: 'Color', color: '#633060', cost: 'low' };
+    }
+    constructor(inputs = {}) {
+        super('BrightContrast');
+        this._inputs = this.createInputs(inputs, {
+            color: ['color', '#ffffff'],
+            bright: ['float', inputs.bright ?? 0.0],
+            contrast: ['float', inputs.contrast ?? 0.0],
+        });
+        this._outputs = this.createOutputs({ Color: 'color' });
+    }
+    getInputSockets() { return this._inputs; }
+    getOutputSockets() { return this._outputs; }
+    compileDefs() { return BrightContrast.glslFunction; }
+    compileCall(ctx) {
+        const col = ctx.resolveInput(this._inputs.color);
+        const bright = ctx.resolveInput(this._inputs.bright);
+        const contrast = ctx.resolveInput(this._inputs.contrast);
+        return `vec3 ${ctx.outputVar(this, 'Color')} = _st_brightContrast(${col}, ${bright}, ${contrast});`;
+    }
+}
+BrightContrast.instanceSpecificDef = false;
+BrightContrast.glslFunction = `
+vec3 _st_brightContrast(vec3 col, float bright, float contrast) {
+  float b = bright / 100.0;
+  float c = contrast / 100.0;
+  float a = 1.0 + c;
+  float o = b - c * 0.5;
+  return clamp(col * a + vec3(o), 0.0, 1.0);
+}`;

package/dist/nodes/process/Bump.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 BumpInputs {
+    strength?: OutputSocket | number;
+    distance?: OutputSocket | number;
+    height?: OutputSocket;
+    normal?: OutputSocket;
+}
+/**
+ * Bump — Blender "Bump" node equivalent.
+ * Converts a height map into a perturbed surface normal using screen-space derivatives.
+ *
+ * Inputs:  strength [0-1], distance, height (float), normal (optional override)
+ * Outputs: Normal (color/vec3)
+ */
+export declare class Bump extends ProcessNode {
+    get nodeType(): string;
+    static instanceSpecificDef: boolean;
+    get metadata(): NodeMetadata;
+    static glslFunction: string;
+    private readonly _inputs;
+    private readonly _outputs;
+    constructor(inputs?: BumpInputs);
+    getInputSockets(): Record<string, import("../../core/InputSocket.js").InputSocket<unknown>>;
+    getOutputSockets(): Record<string, OutputSocket>;
+    compileDefs(): string;
+    compileCall(ctx: CompileContext): string;
+}
+//# sourceMappingURL=Bump.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Bump.d.ts","sourceRoot":"","sources":["../../../src/nodes/process/Bump.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,UAAU;IACzB,QAAQ,CAAC,EAAE,YAAY,GAAG,MAAM,CAAA;IAChC,QAAQ,CAAC,EAAE,YAAY,GAAG,MAAM,CAAA;IAChC,MAAM,CAAC,EAAI,YAAY,CAAA;IACvB,MAAM,CAAC,EAAI,YAAY,CAAA;CACxB;AAED;;;;;;GAMG;AACH,qBAAa,IAAK,SAAQ,WAAW;IACnC,IAAI,QAAQ,WAAoB;IAChC,MAAM,CAAC,mBAAmB,UAAQ;IAElC,IAAI,QAAQ,IAAI,YAAY,CAE3B;IAED,MAAM,CAAC,YAAY,SA2BnB;IAEA,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA2E;IACnG,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAmE;gBAEhF,MAAM,GAAE,UAAe;IAWnC,eAAe;IACf,gBAAgB;IAChB,WAAW;IAEX,WAAW,CAAC,GAAG,EAAE,cAAc,GAAG,MAAM;CASzC"}

package/dist/nodes/process/Bump.js

@@ -0,0 +1,65 @@
+import { ProcessNode } from '../../core/ProcessNode.js';
+/**
+ * Bump — Blender "Bump" node equivalent.
+ * Converts a height map into a perturbed surface normal using screen-space derivatives.
+ *
+ * Inputs:  strength [0-1], distance, height (float), normal (optional override)
+ * Outputs: Normal (color/vec3)
+ */
+export class Bump extends ProcessNode {
+    get nodeType() { return 'Bump'; }
+    get metadata() {
+        return { label: 'Bump', category: 'Vector', color: '#4a3a8a', cost: 'medium' };
+    }
+    constructor(inputs = {}) {
+        super('Bump');
+        this._inputs = this.createInputs(inputs, {
+            strength: ['float', inputs.strength ?? 1.0],
+            distance: ['float', inputs.distance ?? 1.0],
+            height: ['float', 0.5],
+            normal: ['color', null],
+        });
+        this._outputs = this.createOutputs({ Normal: 'color' });
+    }
+    getInputSockets() { return this._inputs; }
+    getOutputSockets() { return this._outputs; }
+    compileDefs() { return Bump.glslFunction; }
+    compileCall(ctx) {
+        const height = ctx.resolveInput(this._inputs.height);
+        const strength = ctx.resolveInput(this._inputs.strength);
+        const distance = ctx.resolveInput(this._inputs.distance);
+        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, 'Normal')} = _st_bump(${height}, ${strength}, ${distance}, ${normal});`;
+    }
+}
+Bump.instanceSpecificDef = false;
+Bump.glslFunction = `
+vec3 _st_bump(float height, float strength, float distance, vec3 N) {
+  // Cotangent frame bump — camera-independent.
+  // We derive world-space surface tangent T and bitangent B from the UV
+  // parameterisation (cotangent frame). This gives vectors that are fixed
+  // to the surface regardless of camera orientation.
+  // Then we express the height gradient in UV space (dh/du, dh/dv) which
+  // is also surface-fixed, eliminating the screen-space dependency.
+  vec3 dPdx = dFdx(vPosition);
+  vec3 dPdy = dFdy(vPosition);
+  vec2 dUdx = dFdx(vUv);
+  vec2 dUdy = dFdy(vUv);
+
+  float det    = dUdx.x * dUdy.y - dUdx.y * dUdy.x;
+  float sgn    = sign(det);
+  float invDet = sgn / max(abs(det), 1e-6);
+
+  // World-space tangent and bitangent from UV Jacobian (camera-independent)
+  vec3 T = normalize((dUdy.y * dPdx - dUdx.y * dPdy) * invDet);
+  vec3 B = normalize(cross(N, T)) * sgn;
+
+  // Height gradient in UV space (camera-independent)
+  float dhdu = (dUdy.y * dFdx(height) - dUdx.y * dFdy(height)) * invDet;
+  float dhdv = (dUdx.x * dFdy(height) - dUdy.x * dFdx(height)) * invDet;
+
+  float scale = strength * distance * 50.0;
+  return normalize(N - T * dhdu * scale - B * dhdv * scale);
+}`;

package/dist/nodes/process/CheckerTexture.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 CheckerTextureInputs {
+    vector?: OutputSocket;
+    color1?: OutputSocket | string;
+    color2?: OutputSocket | string;
+    scale?: number | OutputSocket;
+}
+/**
+ * Checker Texture — Blender "Checker Texture" node equivalent.
+ * Alternating square grid pattern.
+ *
+ * Outputs: Color (color), Fac (float — 0.0 or 1.0)
+ */
+export declare class CheckerTexture extends ProcessNode {
+    get nodeType(): string;
+    static instanceSpecificDef: boolean;
+    get metadata(): NodeMetadata;
+    static glslFunction: string;
+    private readonly _inputs;
+    private readonly _outputs;
+    constructor(inputs?: CheckerTextureInputs);
+    getInputSockets(): Record<string, import("../../core/InputSocket.js").InputSocket<unknown>>;
+    getOutputSockets(): Record<string, OutputSocket>;
+    compileDefs(): string;
+    compileCall(ctx: CompileContext): string;
+}
+//# sourceMappingURL=CheckerTexture.d.ts.map

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

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

package/dist/nodes/process/CheckerTexture.js

@@ -0,0 +1,48 @@
+import { ProcessNode } from '../../core/ProcessNode.js';
+/**
+ * Checker Texture — Blender "Checker Texture" node equivalent.
+ * Alternating square grid pattern.
+ *
+ * Outputs: Color (color), Fac (float — 0.0 or 1.0)
+ */
+export class CheckerTexture extends ProcessNode {
+    get nodeType() { return 'CheckerTexture'; }
+    get metadata() {
+        return { label: 'Checker Texture', category: 'Texture', color: '#3a6b3a', cost: 'low' };
+    }
+    constructor(inputs = {}) {
+        super('CheckerTexture');
+        this._inputs = this.createInputs(inputs, {
+            vector: ['color', null],
+            color1: ['color', inputs.color1 ?? '#ffffff'],
+            color2: ['color', inputs.color2 ?? '#000000'],
+            scale: ['float', inputs.scale ?? 5.0],
+        });
+        this._outputs = this.createOutputs({ Color: 'color', Fac: 'float' });
+    }
+    getInputSockets() { return this._inputs; }
+    getOutputSockets() { return this._outputs; }
+    compileDefs() { return CheckerTexture.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 c1 = ctx.resolveInput(this._inputs.color1);
+        const c2 = ctx.resolveInput(this._inputs.color2);
+        const sc = ctx.resolveInput(this._inputs.scale);
+        const cv = ctx.outputVar(this, 'Color');
+        const fv = ctx.outputVar(this, 'Fac');
+        return [
+            `vec4 _ck_${this.id} = _st_checkerTexture(${vec}, ${c1}, ${c2}, ${sc});`,
+            `vec3  ${cv} = _ck_${this.id}.rgb;`,
+            `float ${fv} = _ck_${this.id}.a;`,
+        ].join('\n  ');
+    }
+}
+CheckerTexture.instanceSpecificDef = false;
+CheckerTexture.glslFunction = `
+vec4 _st_checkerTexture(vec3 p, vec3 c1, vec3 c2, float scale) {
+  vec3  s   = floor(p * scale);
+  float fac = mod(s.x + s.y + s.z, 2.0);
+  return vec4(mix(c1, c2, fac), fac);
+}`;

package/dist/nodes/process/Clamp.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 type ClampMode = 'MINMAX' | 'RANGE';
+export interface ClampInputs {
+    value?: OutputSocket | number;
+    min?: OutputSocket | number;
+    max?: OutputSocket | number;
+    mode?: ClampMode;
+}
+/**
+ * Clamp — Blender "Clamp" converter node equivalent.
+ * Pins a float value between min and max.
+ *
+ * Inputs:  value, min, max
+ * Outputs: Result (float)
+ */
+export declare class Clamp extends ProcessNode {
+    get nodeType(): string;
+    static instanceSpecificDef: boolean;
+    get metadata(): NodeMetadata;
+    static glslFunction: string;
+    private readonly _inputs;
+    private readonly _outputs;
+    constructor(inputs?: ClampInputs);
+    getInputSockets(): Record<string, import("../../core/InputSocket.js").InputSocket<unknown>>;
+    getOutputSockets(): Record<string, OutputSocket>;
+    compileDefs(): string;
+    compileCall(ctx: CompileContext): string;
+}
+//# sourceMappingURL=Clamp.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Clamp.d.ts","sourceRoot":"","sources":["../../../src/nodes/process/Clamp.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,SAAS,GAAG,QAAQ,GAAG,OAAO,CAAA;AAE1C,MAAM,WAAW,WAAW;IAC1B,KAAK,CAAC,EAAE,YAAY,GAAG,MAAM,CAAA;IAC7B,GAAG,CAAC,EAAI,YAAY,GAAG,MAAM,CAAA;IAC7B,GAAG,CAAC,EAAI,YAAY,GAAG,MAAM,CAAA;IAC7B,IAAI,CAAC,EAAG,SAAS,CAAA;CAClB;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;IAUpC,eAAe;IACf,gBAAgB;IAChB,WAAW;IAEX,WAAW,CAAC,GAAG,EAAE,cAAc,GAAG,MAAM;CAMzC"}

package/dist/nodes/process/Clamp.js

@@ -0,0 +1,37 @@
+import { ProcessNode } from '../../core/ProcessNode.js';
+/**
+ * Clamp — Blender "Clamp" converter node equivalent.
+ * Pins a float value between min and max.
+ *
+ * Inputs:  value, min, max
+ * Outputs: Result (float)
+ */
+export class Clamp extends ProcessNode {
+    get nodeType() { return 'Clamp'; }
+    get metadata() {
+        return { label: 'Clamp', category: 'Converter', color: '#4a3a6a', cost: 'low' };
+    }
+    constructor(inputs = {}) {
+        super('Clamp');
+        this._inputs = this.createInputs(inputs, {
+            value: ['float', inputs.value ?? 0.5],
+            min: ['float', inputs.min ?? 0.0],
+            max: ['float', inputs.max ?? 1.0],
+        });
+        this._outputs = this.createOutputs({ Result: 'float' });
+    }
+    getInputSockets() { return this._inputs; }
+    getOutputSockets() { return this._outputs; }
+    compileDefs() { return Clamp.glslFunction; }
+    compileCall(ctx) {
+        const v = ctx.resolveInput(this._inputs.value);
+        const lo = ctx.resolveInput(this._inputs.min);
+        const hi = ctx.resolveInput(this._inputs.max);
+        return `float ${ctx.outputVar(this, 'Result')} = _st_clamp(${v}, ${lo}, ${hi});`;
+    }
+}
+Clamp.instanceSpecificDef = false;
+Clamp.glslFunction = `
+float _st_clamp(float v, float lo, float hi) {
+  return clamp(v, min(lo, hi), max(lo, hi));
+}`;

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

@@ -0,0 +1,28 @@
+import { ProcessNode } from '../../core/ProcessNode.js';
+import { CompileContext } from '../../core/CompileContext.js';
+import type { NodeMetadata } from '../../core/ShaderNode.js';
+import type { OutputSocket } from '../../core/OutputSocket.js';
+export interface ColorRampInputs {
+    fac?: OutputSocket | number;
+    stops?: string[];
+}
+/**
+ * Color Ramp — Blender "ColorRamp" node equivalent.
+ *
+ * Inputs:  fac (float)
+ * Outputs: Color (color)
+ */
+export declare class ColorRamp extends ProcessNode {
+    get nodeType(): string;
+    static instanceSpecificDef: boolean;
+    get metadata(): NodeMetadata;
+    private readonly stops;
+    private readonly _inputs;
+    private readonly _outputs;
+    constructor(inputs?: ColorRampInputs);
+    getInputSockets(): Record<string, import("../../core/InputSocket.js").InputSocket<unknown>>;
+    getOutputSockets(): Record<string, OutputSocket>;
+    compileDefs(): string;
+    compileCall(ctx: CompileContext): string;
+}
+//# sourceMappingURL=ColorRamp.d.ts.map