@triforge/shader-core 0.1.0

package/dist/nodes/process/MixRGB.js

@@ -0,0 +1,63 @@
+import { ProcessNode } from '../../core/ProcessNode.js';
+/**
+ * Mix RGB — Blender "Mix" color node equivalent.
+ * Blends two colours using a mode selector.
+ *
+ * Inputs:  fac [0-1], colorA, colorB
+ * Outputs: Color (color)
+ */
+export class MixRGB extends ProcessNode {
+    get nodeType() { return 'MixRGB'; }
+    get metadata() {
+        return { label: 'Mix RGB', category: 'Color', color: '#633060', cost: 'low' };
+    }
+    constructor(inputs = {}) {
+        super('MixRGB');
+        this.mode = inputs.mode ?? 'MIX';
+        this.clamp = inputs.clamp ?? false;
+        this._inputs = this.createInputs(inputs, {
+            fac: ['float', inputs.fac ?? 0.5],
+            colorA: ['color', '#000000'],
+            colorB: ['color', '#ffffff'],
+        });
+        this._outputs = this.createOutputs({ Color: 'color' });
+    }
+    getInputSockets() { return this._inputs; }
+    getOutputSockets() { return this._outputs; }
+    compileDefs() { return MixRGB.glslFunction; }
+    compileCall(ctx) {
+        const modeIndex = [
+            'MIX', 'DARKEN', 'MULTIPLY', 'BURN', 'LIGHTEN', 'SCREEN', 'DODGE', 'ADD',
+            'OVERLAY', 'SOFT_LIGHT', 'LINEAR_LIGHT', 'DIFFERENCE', 'EXCLUSION', 'SUBTRACT', 'DIVIDE',
+        ].indexOf(this.mode);
+        const idx = modeIndex === -1 ? 0 : modeIndex;
+        const fac = ctx.resolveInput(this._inputs.fac);
+        const colorA = ctx.resolveInput(this._inputs.colorA);
+        const colorB = ctx.resolveInput(this._inputs.colorB);
+        const out = ctx.outputVar(this, 'Color');
+        const expr = `_st_mixRGB(${idx}, ${fac}, ${colorA}, ${colorB})`;
+        return `vec3 ${out} = ${this.clamp ? `clamp(${expr}, 0.0, 1.0)` : expr};`;
+    }
+}
+MixRGB.instanceSpecificDef = false;
+MixRGB.glslFunction = `
+vec3 _st_mixRGB(int mode, float fac, vec3 a, vec3 b) {
+  fac = clamp(fac, 0.0, 1.0);
+  vec3 col = a;
+  if      (mode == 0)  col = mix(a, b, fac);
+  else if (mode == 1)  col = mix(a, min(a, b), fac);
+  else if (mode == 2)  col = mix(a, a * b, fac);
+  else if (mode == 3)  col = mix(a, vec3(1.0) - (vec3(1.0) - a) * (vec3(1.0) - b) / max(vec3(1.0) - a, vec3(0.001)), fac);
+  else if (mode == 4)  col = mix(a, max(a, b), fac);
+  else if (mode == 5)  col = mix(a, vec3(1.0) - (vec3(1.0) - a) * (vec3(1.0) - b), fac);
+  else if (mode == 6)  col = mix(a, a / max(vec3(1.0) - b, vec3(0.001)), fac);
+  else if (mode == 7)  col = mix(a, clamp(a + b, 0.0, 1.0), fac);
+  else if (mode == 8)  col = mix(a, mix(2.0*a*b, vec3(1.0)-2.0*(vec3(1.0)-a)*(vec3(1.0)-b), step(vec3(0.5), a)), fac);
+  else if (mode == 9)  col = mix(a, mix(2.0*a*b + a*a*(1.0-2.0*b), sqrt(max(a,vec3(0.0)))*(2.0*b-1.0)+2.0*a*(1.0-b), step(vec3(0.5), b)), fac);
+  else if (mode == 10) col = mix(a, clamp(2.0*a*b - 1.0 + 2.0*(vec3(1.0)-a)*(b-0.5), 0.0, 1.0), fac);
+  else if (mode == 11) col = mix(a, abs(a - b), fac);
+  else if (mode == 12) col = mix(a, a + b - 2.0*a*b, fac);
+  else if (mode == 13) col = mix(a, clamp(a - b, 0.0, 1.0), fac);
+  else if (mode == 14) col = mix(a, a / max(b, vec3(0.0001)), fac);
+  return col;
+}`;

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

@@ -0,0 +1,35 @@
+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 MixShaderInputs {
+    fac?: OutputSocket | number;
+    shader1?: OutputSocket;
+    shader2?: OutputSocket;
+}
+/**
+ * Mix Shader — Blender "Mix Shader" node equivalent.
+ * Blends two BSDF shader outputs by a factor.
+ *
+ * Inputs:
+ *   fac     (float)  — blend factor [0-1]   0 = full shader1, 1 = full shader2
+ *   shader1 (shader) — first BSDF
+ *   shader2 (shader) — second BSDF
+ *
+ * Outputs:
+ *   BSDF (shader) — blended result
+ */
+export declare class MixShader extends ProcessNode {
+    get nodeType(): string;
+    static instanceSpecificDef: boolean;
+    get metadata(): NodeMetadata;
+    static glslFunction: string;
+    private readonly _inputs;
+    private readonly _outputs;
+    constructor(inputs?: MixShaderInputs);
+    getInputSockets(): Record<string, import("../../core/InputSocket.js").InputSocket<unknown>>;
+    getOutputSockets(): Record<string, OutputSocket>;
+    compileDefs(): string;
+    compileCall(ctx: CompileContext): string;
+}
+//# sourceMappingURL=MixShader.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"MixShader.d.ts","sourceRoot":"","sources":["../../../src/nodes/process/MixShader.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,GAAG,CAAC,EAAM,YAAY,GAAG,MAAM,CAAA;IAC/B,OAAO,CAAC,EAAE,YAAY,CAAA;IACtB,OAAO,CAAC,EAAE,YAAY,CAAA;CACvB;AAED;;;;;;;;;;;GAWG;AACH,qBAAa,SAAU,SAAQ,WAAW;IACxC,IAAI,QAAQ,WAAyB;IACrC,MAAM,CAAC,mBAAmB,UAAQ;IAElC,IAAI,QAAQ,IAAI,YAAY,CAO3B;IAED,MAAM,CAAC,YAAY,SAGnB;IAEA,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA2E;IACnG,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAmE;gBAEhF,MAAM,GAAE,eAAoB;IAUxC,eAAe;IACf,gBAAgB;IAChB,WAAW;IAEX,WAAW,CAAC,GAAG,EAAE,cAAc,GAAG,MAAM;CAMzC"}

package/dist/nodes/process/MixShader.js

@@ -0,0 +1,47 @@
+import { ProcessNode } from '../../core/ProcessNode.js';
+/**
+ * Mix Shader — Blender "Mix Shader" node equivalent.
+ * Blends two BSDF shader outputs by a factor.
+ *
+ * Inputs:
+ *   fac     (float)  — blend factor [0-1]   0 = full shader1, 1 = full shader2
+ *   shader1 (shader) — first BSDF
+ *   shader2 (shader) — second BSDF
+ *
+ * Outputs:
+ *   BSDF (shader) — blended result
+ */
+export class MixShader extends ProcessNode {
+    get nodeType() { return 'MixShader'; }
+    get metadata() {
+        return {
+            label: 'Mix Shader',
+            category: 'Shader',
+            color: '#336699',
+            cost: 'low',
+        };
+    }
+    constructor(inputs = {}) {
+        super('MixShader');
+        this._inputs = this.createInputs(inputs, {
+            fac: ['float', 0.5],
+            shader1: ['shader', null],
+            shader2: ['shader', null],
+        });
+        this._outputs = this.createOutputs({ BSDF: 'shader' });
+    }
+    getInputSockets() { return this._inputs; }
+    getOutputSockets() { return this._outputs; }
+    compileDefs() { return MixShader.glslFunction; }
+    compileCall(ctx) {
+        const fac = ctx.resolveInput(this._inputs.fac);
+        const shader1 = ctx.resolveInput(this._inputs.shader1);
+        const shader2 = ctx.resolveInput(this._inputs.shader2);
+        return `vec3 ${ctx.outputVar(this, 'BSDF')} = _st_mixShader(${fac}, ${shader1}, ${shader2});`;
+    }
+}
+MixShader.instanceSpecificDef = false;
+MixShader.glslFunction = `
+vec3 _st_mixShader(float fac, vec3 a, vec3 b) {
+  return mix(a, b, clamp(fac, 0.0, 1.0));
+}`;

package/dist/nodes/process/MusgraveTexture.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 type MusgraveType = 'FBM' | 'MULTIFRACTAL' | 'HYBRID_MULTIFRACTAL' | 'RIDGED_MULTIFRACTAL' | 'HETERO_TERRAIN';
+export interface MusgraveTextureInputs {
+    vector?: OutputSocket;
+    scale?: number | OutputSocket;
+    detail?: number | OutputSocket;
+    dimension?: number | OutputSocket;
+    lacunarity?: number | OutputSocket;
+    offset?: number | OutputSocket;
+    gain?: number | OutputSocket;
+    type?: MusgraveType;
+}
+/**
+ * Musgrave Texture — Blender "Musgrave Texture" node equivalent.
+ * Complex fractal noise — terrain, clouds, organic surfaces.
+ *
+ * Outputs: Fac (float), Color (color)
+ */
+export declare class MusgraveTexture extends ProcessNode {
+    get nodeType(): string;
+    static instanceSpecificDef: boolean;
+    get metadata(): NodeMetadata;
+    static glslFunction: string;
+    private readonly musType;
+    private readonly _inputs;
+    private readonly _outputs;
+    constructor(inputs?: MusgraveTextureInputs);
+    getInputSockets(): Record<string, import("../../core/InputSocket.js").InputSocket<unknown>>;
+    getOutputSockets(): Record<string, OutputSocket>;
+    compileDefs(): string;
+    compileCall(ctx: CompileContext): string;
+}
+//# sourceMappingURL=MusgraveTexture.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"MusgraveTexture.d.ts","sourceRoot":"","sources":["../../../src/nodes/process/MusgraveTexture.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,KAAK,GAAG,cAAc,GAAG,qBAAqB,GAAG,qBAAqB,GAAG,gBAAgB,CAAA;AAEpH,MAAM,WAAW,qBAAqB;IACpC,MAAM,CAAC,EAAM,YAAY,CAAA;IACzB,KAAK,CAAC,EAAO,MAAM,GAAG,YAAY,CAAA;IAClC,MAAM,CAAC,EAAM,MAAM,GAAG,YAAY,CAAA;IAClC,SAAS,CAAC,EAAG,MAAM,GAAG,YAAY,CAAA;IAClC,UAAU,CAAC,EAAE,MAAM,GAAG,YAAY,CAAA;IAClC,MAAM,CAAC,EAAM,MAAM,GAAG,YAAY,CAAA;IAClC,IAAI,CAAC,EAAQ,MAAM,GAAG,YAAY,CAAA;IAClC,IAAI,CAAC,EAAQ,YAAY,CAAA;CAC1B;AAED;;;;;GAKG;AACH,qBAAa,eAAgB,SAAQ,WAAW;IAC9C,IAAI,QAAQ,WAA+B;IAC3C,MAAM,CAAC,mBAAmB,UAAQ;IAElC,IAAI,QAAQ,IAAI,YAAY,CAE3B;IAED,MAAM,CAAC,YAAY,SA0BnB;IAEA,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAc;IACtC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA2E;IACnG,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAmE;gBAEhF,MAAM,GAAE,qBAA0B;IAe9C,eAAe;IACf,gBAAgB;IAChB,WAAW;IAEX,WAAW,CAAC,GAAG,EAAE,cAAc,GAAG,MAAM;CAYzC"}

package/dist/nodes/process/MusgraveTexture.js

@@ -0,0 +1,70 @@
+import { ProcessNode } from '../../core/ProcessNode.js';
+/**
+ * Musgrave Texture — Blender "Musgrave Texture" node equivalent.
+ * Complex fractal noise — terrain, clouds, organic surfaces.
+ *
+ * Outputs: Fac (float), Color (color)
+ */
+export class MusgraveTexture extends ProcessNode {
+    get nodeType() { return 'MusgraveTexture'; }
+    get metadata() {
+        return { label: 'Musgrave Texture', category: 'Texture', color: '#3a6b3a', cost: 'high', costNote: 'Fractal octave loop — limit detail to <=8.' };
+    }
+    constructor(inputs = {}) {
+        super('MusgraveTexture');
+        this.musType = inputs.type ?? 'FBM';
+        this._inputs = this.createInputs(inputs, {
+            vector: ['color', null],
+            scale: ['float', inputs.scale ?? 5.0],
+            detail: ['float', inputs.detail ?? 8.0],
+            dimension: ['float', inputs.dimension ?? 2.0],
+            lacunarity: ['float', inputs.lacunarity ?? 2.0],
+            offset: ['float', inputs.offset ?? 0.0],
+            gain: ['float', inputs.gain ?? 1.0],
+        });
+        this._outputs = this.createOutputs({ Fac: 'float', Color: 'color' });
+    }
+    getInputSockets() { return this._inputs; }
+    getOutputSockets() { return this._outputs; }
+    compileDefs() { return MusgraveTexture.glslFunction; }
+    compileCall(ctx) {
+        const typeMap = { FBM: 0, MULTIFRACTAL: 1, HYBRID_MULTIFRACTAL: 2, RIDGED_MULTIFRACTAL: 3, HETERO_TERRAIN: 3 };
+        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, 'Fac');
+        const cv = ctx.outputVar(this, 'Color');
+        return [
+            `float ${fv} = _st_musgrave(${vec}, ${ctx.resolveInput(this._inputs.scale)}, ${ctx.resolveInput(this._inputs.detail)}, ${ctx.resolveInput(this._inputs.dimension)}, ${ctx.resolveInput(this._inputs.lacunarity)}, ${ctx.resolveInput(this._inputs.offset)}, ${ctx.resolveInput(this._inputs.gain)}, ${typeMap[this.musType]});`,
+            `vec3  ${cv} = vec3(${fv});`,
+        ].join('\n  ');
+    }
+}
+MusgraveTexture.instanceSpecificDef = false;
+MusgraveTexture.glslFunction = `
+float _st_mhash(vec3 p) { return fract(sin(dot(p, vec3(127.1, 311.7, 74.7))) * 43758.5453); }
+vec3  _st_mgrad(vec3 p)  { float h = _st_mhash(floor(p)); return normalize(vec3(h, fract(h*34.), fract(h*89.))*2.-1.); }
+float _st_mperlin(vec3 p) {
+  vec3 pi=floor(p), pf=p-pi, u=pf*pf*(3.-2.*pf);
+  return mix(mix(mix(dot(_st_mgrad(pi+vec3(0,0,0)),pf-vec3(0,0,0)),dot(_st_mgrad(pi+vec3(1,0,0)),pf-vec3(1,0,0)),u.x),
+                 mix(dot(_st_mgrad(pi+vec3(0,1,0)),pf-vec3(0,1,0)),dot(_st_mgrad(pi+vec3(1,1,0)),pf-vec3(1,1,0)),u.x),u.y),
+             mix(mix(dot(_st_mgrad(pi+vec3(0,0,1)),pf-vec3(0,0,1)),dot(_st_mgrad(pi+vec3(1,0,1)),pf-vec3(1,0,1)),u.x),
+                 mix(dot(_st_mgrad(pi+vec3(0,1,1)),pf-vec3(0,1,1)),dot(_st_mgrad(pi+vec3(1,1,1)),pf-vec3(1,1,1)),u.x),u.y),u.z);
+}
+float _st_musgrave(vec3 p, float scale, float detail, float dimension, float lacunarity, float offset, float gain, int mtype) {
+  p *= scale;
+  float value = 0.0, amp = 1.0, freq = 1.0, weight = 1.0;
+  int   oct   = int(clamp(detail, 1.0, 16.0));
+  float H     = max(dimension, 0.0001);
+  for (int i = 0; i < 16; i++) {
+    if (i >= oct) break;
+    float n = _st_mperlin(p * freq);
+    if (mtype == 0) { value += amp * n; }
+    else if (mtype == 1) { value += amp * abs(n); }
+    else if (mtype == 2) { float signal = abs(n) + offset; weight = clamp(signal * gain, 0.0, 1.0); value += weight * signal * amp; }
+    else if (mtype == 3) { float signal = offset - abs(n); signal *= signal; value += weight * signal * amp; weight = clamp(signal * gain, 0.0, 1.0); }
+    amp  *= pow(freq, -H);
+    freq *= lacunarity;
+  }
+  return value * 0.5 + 0.5;
+}`;

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"NoiseTexture.d.ts","sourceRoot":"","sources":["../../../src/nodes/process/NoiseTexture.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,EAAM,YAAY,CAAA;IACzB,KAAK,CAAC,EAAO,MAAM,GAAG,YAAY,CAAA;IAClC,MAAM,CAAC,EAAM,MAAM,GAAG,YAAY,CAAA;IAClC,SAAS,CAAC,EAAG,MAAM,GAAG,YAAY,CAAA;IAClC,UAAU,CAAC,EAAE,MAAM,GAAG,YAAY,CAAA;CACnC;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,SAsCnB;IAEA,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA2E;IACnG,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAmE;gBAEhF,MAAM,GAAE,kBAAuB;IAY3C,eAAe;IACf,gBAAgB;IAChB,WAAW;IAEX,WAAW,CAAC,GAAG,EAAE,cAAc,GAAG,MAAM;CAWzC"}

package/dist/nodes/process/NoiseTexture.js

@@ -0,0 +1,78 @@
+import { ProcessNode } from '../../core/ProcessNode.js';
+/**
+ * Noise Texture — Blender "Noise Texture" node equivalent.
+ *
+ * Inputs:  vector, scale, detail, roughness, distortion
+ * Outputs: Fac (float), Color (color)
+ */
+export class NoiseTexture extends ProcessNode {
+    get nodeType() { return 'NoiseTexture'; }
+    get metadata() {
+        return { label: 'Noise Texture', category: 'Texture', color: '#3a6b3a', cost: 'medium', costNote: 'Keep detail <= 4 on mobile.' };
+    }
+    constructor(inputs = {}) {
+        super('NoiseTexture');
+        this._inputs = this.createInputs(inputs, {
+            vector: ['color', null],
+            scale: ['float', 5.0],
+            detail: ['float', 2.0],
+            roughness: ['float', 0.5],
+            distortion: ['float', 0.0],
+        });
+        this._outputs = this.createOutputs({ Fac: 'float', Color: 'color' });
+    }
+    getInputSockets() { return this._inputs; }
+    getOutputSockets() { return this._outputs; }
+    compileDefs() { return this.glslFunction ?? NoiseTexture.glslFunction; }
+    compileCall(ctx) {
+        const p3 = this._inputs.vector.isConnected()
+            ? ctx.outputVar(this._inputs.vector.connection.node, this._inputs.vector.connection.name)
+            : 'vPosition';
+        const fv = ctx.outputVar(this, 'Fac');
+        const cv = ctx.outputVar(this, 'Color');
+        return [
+            `float ${fv} = _st_noiseTexture(${p3}, ${ctx.resolveInput(this._inputs.scale)}, ${ctx.resolveInput(this._inputs.detail)}, ${ctx.resolveInput(this._inputs.roughness)}, ${ctx.resolveInput(this._inputs.distortion)});`,
+            `vec3  ${cv} = vec3(${fv});`,
+        ].join('\n  ');
+    }
+}
+NoiseTexture.instanceSpecificDef = false;
+NoiseTexture.glslFunction = `
+float _st_phash(vec3 p) {
+  return fract(sin(dot(p, vec3(127.1, 311.7, 74.7))) * 43758.5453);
+}
+vec3 _st_pgrad(vec3 p) {
+  float h = _st_phash(floor(p));
+  return normalize(vec3(h, fract(h * 34.0), fract(h * 89.0)) * 2.0 - 1.0);
+}
+float _st_perlin(vec3 p) {
+  vec3 pi = floor(p), pf = p - pi, u = pf * pf * (3.0 - 2.0 * pf);
+  float v000 = dot(_st_pgrad(pi+vec3(0,0,0)), pf-vec3(0,0,0));
+  float v100 = dot(_st_pgrad(pi+vec3(1,0,0)), pf-vec3(1,0,0));
+  float v010 = dot(_st_pgrad(pi+vec3(0,1,0)), pf-vec3(0,1,0));
+  float v110 = dot(_st_pgrad(pi+vec3(1,1,0)), pf-vec3(1,1,0));
+  float v001 = dot(_st_pgrad(pi+vec3(0,0,1)), pf-vec3(0,0,1));
+  float v101 = dot(_st_pgrad(pi+vec3(1,0,1)), pf-vec3(1,0,1));
+  float v011 = dot(_st_pgrad(pi+vec3(0,1,1)), pf-vec3(0,1,1));
+  float v111 = dot(_st_pgrad(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_noiseTexture(vec3 p3, float scale, float detail, float roughness, float distortion) {
+  vec3 p = p3 * scale;
+  if (distortion > 0.0) {
+    p.x += distortion * _st_perlin(p + vec3(1.7, 9.2, 3.4));
+    p.y += distortion * _st_perlin(p + vec3(8.3, 2.8, 5.1));
+    p.z += distortion * _st_perlin(p + vec3(4.1, 6.5, 1.9));
+  }
+  float value = 0.0, amplitude = 1.0, frequency = 1.0, maxAmp = 0.0;
+  int octaves = int(clamp(detail, 1.0, 8.0));
+  for (int i = 0; i < 8; i++) {
+    if (i >= octaves) break;
+    value += amplitude * _st_perlin(p * frequency);
+    maxAmp += amplitude; amplitude *= roughness; frequency *= 2.0;
+  }
+  return value / maxAmp;
+}`;

package/dist/nodes/process/Normal.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 NormalInputs {
+    normal?: OutputSocket;
+    direction?: [number, number, number];
+}
+/**
+ * Normal — Blender "Normal" vector node equivalent.
+ * Outputs a static customisable direction vector.
+ * Also computes a dot product of the surface normal against that direction.
+ *
+ * Inputs:  normal (override), direction ([x,y,z] — default: [0,0,1])
+ * Outputs: Normal (color/vec3), Dot (float)
+ */
+export declare class Normal extends ProcessNode {
+    get nodeType(): string;
+    static instanceSpecificDef: boolean;
+    get metadata(): NodeMetadata;
+    private readonly direction;
+    private readonly _inputs;
+    private readonly _outputs;
+    constructor(inputs?: NormalInputs);
+    getInputSockets(): Record<string, import("../../core/InputSocket.js").InputSocket<unknown>>;
+    getOutputSockets(): Record<string, OutputSocket>;
+    compileDefs(): string;
+    compileCall(ctx: CompileContext): string;
+}
+//# sourceMappingURL=Normal.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Normal.d.ts","sourceRoot":"","sources":["../../../src/nodes/process/Normal.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,YAAY;IAC3B,MAAM,CAAC,EAAE,YAAY,CAAA;IACrB,SAAS,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;CACrC;AAED;;;;;;;GAOG;AACH,qBAAa,MAAO,SAAQ,WAAW;IACrC,IAAI,QAAQ,WAAsB;IAClC,MAAM,CAAC,mBAAmB,UAAO;IAEjC,IAAI,QAAQ,IAAI,YAAY,CAE3B;IAED,OAAO,CAAC,QAAQ,CAAC,SAAS,CAA0B;IACpD,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA2E;IACnG,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAmE;gBAEhF,MAAM,GAAE,YAAiB;IAOrC,eAAe;IACf,gBAAgB;IAChB,WAAW;IAEX,WAAW,CAAC,GAAG,EAAE,cAAc,GAAG,MAAM;CAazC"}

package/dist/nodes/process/Normal.js

@@ -0,0 +1,38 @@
+import { ProcessNode } from '../../core/ProcessNode.js';
+/**
+ * Normal — Blender "Normal" vector node equivalent.
+ * Outputs a static customisable direction vector.
+ * Also computes a dot product of the surface normal against that direction.
+ *
+ * Inputs:  normal (override), direction ([x,y,z] — default: [0,0,1])
+ * Outputs: Normal (color/vec3), Dot (float)
+ */
+export class Normal extends ProcessNode {
+    get nodeType() { return 'Normal'; }
+    get metadata() {
+        return { label: 'Normal', category: 'Vector', color: '#4a3a8a', cost: 'low' };
+    }
+    constructor(inputs = {}) {
+        super('Normal');
+        this.direction = inputs.direction ?? [0, 0, 1];
+        this._inputs = this.createInputs(inputs, { normal: ['color', null] });
+        this._outputs = this.createOutputs({ Normal: 'color', Dot: 'float' });
+    }
+    getInputSockets() { return this._inputs; }
+    getOutputSockets() { return this._outputs; }
+    compileDefs() { return ''; }
+    compileCall(ctx) {
+        const [x, y, z] = this.direction;
+        const N = this._inputs.normal.isConnected()
+            ? ctx.outputVar(this._inputs.normal.connection.node, this._inputs.normal.connection.name)
+            : 'normalize(vNormal)';
+        const nv = ctx.outputVar(this, 'Normal');
+        const dv = ctx.outputVar(this, 'Dot');
+        const dir = `vec3(${x.toFixed(4)}, ${y.toFixed(4)}, ${z.toFixed(4)})`;
+        return [
+            `vec3  ${nv} = normalize(${dir});`,
+            `float ${dv} = dot(${N}, ${nv});`,
+        ].join('\n  ');
+    }
+}
+Normal.instanceSpecificDef = true;

package/dist/nodes/process/NormalMap.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 NormalMapInputs {
+    fac?: OutputSocket;
+    strength?: number | OutputSocket;
+}
+/**
+ * Normal Map — converts a float noise value into a surface normal.
+ * Derives normals via numerical gradient of the input Fac value.
+ * Connect to PrincipledBSDF.normal input for surface detail lighting.
+ *
+ * Inputs:
+ *   fac      (float)  — greyscale height value, typically from NoiseTexture.Fac
+ *   strength (float)  — normal intensity [0-10]  default: 1.0
+ *
+ * Outputs:
+ *   Normal (vector) — perturbed surface normal, ready for PrincipledBSDF.normal
+ */
+export declare class NormalMap extends ProcessNode {
+    get nodeType(): string;
+    static instanceSpecificDef: boolean;
+    get metadata(): NodeMetadata;
+    static glslFunction: string;
+    private readonly _inputs;
+    private readonly _outputs;
+    constructor(inputs?: NormalMapInputs);
+    getInputSockets(): Record<string, import("../../core/InputSocket.js").InputSocket<unknown>>;
+    getOutputSockets(): Record<string, OutputSocket>;
+    compileDefs(): string;
+    compileCall(ctx: CompileContext): string;
+}
+//# sourceMappingURL=NormalMap.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"NormalMap.d.ts","sourceRoot":"","sources":["../../../src/nodes/process/NormalMap.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,GAAG,CAAC,EAAO,YAAY,CAAA;IACvB,QAAQ,CAAC,EAAE,MAAM,GAAG,YAAY,CAAA;CACjC;AAED;;;;;;;;;;;GAWG;AACH,qBAAa,SAAU,SAAQ,WAAW;IACxC,IAAI,QAAQ,WAAyB;IACrC,MAAM,CAAC,mBAAmB,UAAQ;IAElC,IAAI,QAAQ,IAAI,YAAY,CAQ3B;IAED,MAAM,CAAC,YAAY,SAGnB;IAEA,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA2E;IACnG,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAmE;gBAEhF,MAAM,GAAE,eAAoB;IASxC,eAAe;IACf,gBAAgB;IAChB,WAAW;IAEX,WAAW,CAAC,GAAG,EAAE,cAAc,GAAG,MAAM;CAezC"}

package/dist/nodes/process/NormalMap.js

@@ -0,0 +1,54 @@
+import { ProcessNode } from '../../core/ProcessNode.js';
+/**
+ * Normal Map — converts a float noise value into a surface normal.
+ * Derives normals via numerical gradient of the input Fac value.
+ * Connect to PrincipledBSDF.normal input for surface detail lighting.
+ *
+ * Inputs:
+ *   fac      (float)  — greyscale height value, typically from NoiseTexture.Fac
+ *   strength (float)  — normal intensity [0-10]  default: 1.0
+ *
+ * Outputs:
+ *   Normal (vector) — perturbed surface normal, ready for PrincipledBSDF.normal
+ */
+export class NormalMap extends ProcessNode {
+    get nodeType() { return 'NormalMap'; }
+    get metadata() {
+        return {
+            label: 'Normal Map',
+            category: 'Vector',
+            color: '#4a3a8a',
+            cost: 'medium',
+            costNote: 'Samples input Fac four times for gradient computation.',
+        };
+    }
+    constructor(inputs = {}) {
+        super('NormalMap');
+        this._inputs = this.createInputs(inputs, {
+            fac: ['float', 0.5],
+            strength: ['float', inputs.strength ?? 1.0],
+        });
+        this._outputs = this.createOutputs({ Normal: 'color' });
+    }
+    getInputSockets() { return this._inputs; }
+    getOutputSockets() { return this._outputs; }
+    compileDefs() { return ''; }
+    compileCall(ctx) {
+        const facVar = this._inputs.fac.isConnected()
+            ? ctx.outputVar(this._inputs.fac.connection.node, this._inputs.fac.connection.name)
+            : ctx.resolveInput(this._inputs.fac);
+        const strength = ctx.resolveInput(this._inputs.strength);
+        const normalVar = ctx.outputVar(this, 'Normal');
+        // Numerical gradient — samples fac variable neighbour delta via world position
+        return [
+            `float _nm_nx_${this.id} = dFdx(${facVar});`,
+            `float _nm_ny_${this.id} = dFdy(${facVar});`,
+            `vec3  ${normalVar} = normalize(vec3(-_nm_nx_${this.id} * ${strength}, 1.0, -_nm_ny_${this.id} * ${strength}));`,
+        ].join('\n  ');
+    }
+}
+NormalMap.instanceSpecificDef = false;
+NormalMap.glslFunction = `
+vec3 _st_normalMap(float fac, float strength) {
+  return vec3(0.0, 1.0, 0.0);
+}`;

package/dist/nodes/process/PrincipledBSDF.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 PrincipledBSDFInputs {
+    baseColor?: OutputSocket | string;
+    metallic?: OutputSocket | number;
+    roughness?: OutputSocket | number;
+    ior?: OutputSocket | number;
+    alpha?: OutputSocket | number;
+    normal?: OutputSocket;
+}
+/**
+ * Principled BSDF — Blender "Principled BSDF" node equivalent.
+ *
+ * Inputs:  baseColor, metallic, roughness, ior, alpha, normal
+ * Outputs: BSDF (shader)
+ */
+export declare class PrincipledBSDF extends ProcessNode {
+    get nodeType(): string;
+    static instanceSpecificDef: boolean;
+    get metadata(): NodeMetadata;
+    static glslFunction: string;
+    private readonly _inputs;
+    private readonly _outputs;
+    constructor(inputs?: PrincipledBSDFInputs);
+    getInputSockets(): Record<string, import("../../core/InputSocket.js").InputSocket<unknown>>;
+    getOutputSockets(): Record<string, OutputSocket>;
+    compileDefs(): string;
+    compileCall(ctx: CompileContext): string;
+}
+//# sourceMappingURL=PrincipledBSDF.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"PrincipledBSDF.d.ts","sourceRoot":"","sources":["../../../src/nodes/process/PrincipledBSDF.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,SAAS,CAAC,EAAE,YAAY,GAAG,MAAM,CAAA;IACjC,QAAQ,CAAC,EAAG,YAAY,GAAG,MAAM,CAAA;IACjC,SAAS,CAAC,EAAE,YAAY,GAAG,MAAM,CAAA;IACjC,GAAG,CAAC,EAAQ,YAAY,GAAG,MAAM,CAAA;IACjC,KAAK,CAAC,EAAM,YAAY,GAAG,MAAM,CAAA;IACjC,MAAM,CAAC,EAAK,YAAY,CAAA;CACzB;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,SAuCnB;IAEA,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA2E;IACnG,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAmE;gBAEhF,MAAM,GAAE,oBAAyB;IAa7C,eAAe;IACf,gBAAgB;IAChB,WAAW;IAEX,WAAW,CAAC,GAAG,EAAE,cAAc,GAAG,MAAM;CAMzC"}