@triforge/shader-core 0.1.0

package/dist/nodes/process/ImageTexture.js

@@ -0,0 +1,53 @@
+import { ProcessNode } from '../../core/ProcessNode.js';
+import { ShaderNodeError } from '../../core/ShaderNodeError.js';
+import { ShaderConfig } from '../../core/ShaderConfig.js';
+/**
+ * Image Texture — Blender "Image Texture" node equivalent.
+ * Samples an external texture via a sampler2D uniform.
+ *
+ * Usage:
+ *   const node = new ImageTexture({ uniformName: 'uAlbedo' })
+ *   // After mat.compile():
+ *   mat.material.uniforms.uAlbedo = { value: new THREE.TextureLoader().load('path.jpg') }
+ *
+ * Inputs:  vector (UV), uniformName (string — name of sampler2D uniform)
+ * Outputs: Color (color), Alpha (float)
+ */
+export class ImageTexture extends ProcessNode {
+    get nodeType() { return 'ImageTexture'; }
+    get metadata() {
+        return { label: 'Image Texture', category: 'Texture', color: '#3a6b3a', cost: 'medium' };
+    }
+    constructor(inputs) {
+        super('ImageTexture');
+        if (ShaderConfig.errorLevel !== 'off' && !inputs.uniformName) {
+            ShaderNodeError.throw({
+                nodeType: 'ImageTexture',
+                nodeId: this.id,
+                problem: 'uniformName is required.',
+                fix: 'new ImageTexture({ uniformName: "uMyTexture" })\n  After compile(): mat.material.uniforms.uMyTexture = { value: texture }',
+            });
+        }
+        this.uniformName = inputs.uniformName;
+        this._inputs = this.createInputs(inputs, { vector: ['vector', null] });
+        this._outputs = this.createOutputs({ Color: 'color', Alpha: 'float' });
+    }
+    getInputSockets() { return this._inputs; }
+    getOutputSockets() { return this._outputs; }
+    compileDefs() {
+        return `uniform sampler2D ${this.uniformName};`;
+    }
+    compileCall(ctx) {
+        const uv = this._inputs.vector.isConnected()
+            ? ctx.outputVar(this._inputs.vector.connection.node, this._inputs.vector.connection.name)
+            : 'vUv';
+        const cv = ctx.outputVar(this, 'Color');
+        const av = ctx.outputVar(this, 'Alpha');
+        return [
+            `vec4 _it_${this.id} = texture2D(${this.uniformName}, ${uv});`,
+            `vec3  ${cv} = _it_${this.id}.rgb;`,
+            `float ${av} = _it_${this.id}.a;`,
+        ].join('\n  ');
+    }
+}
+ImageTexture.instanceSpecificDef = true;

package/dist/nodes/process/InvertColor.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 InvertColorInputs {
+    color?: OutputSocket | string;
+    fac?: OutputSocket | number;
+}
+/**
+ * Invert Color — Blender "Invert Color" node equivalent.
+ * Produces the negative of a colour, blended by fac.
+ *
+ * Inputs:  color, fac [0-1] (0 = original, 1 = fully inverted)
+ * Outputs: Color (color)
+ */
+export declare class InvertColor extends ProcessNode {
+    get nodeType(): string;
+    static instanceSpecificDef: boolean;
+    get metadata(): NodeMetadata;
+    static glslFunction: string;
+    private readonly _inputs;
+    private readonly _outputs;
+    constructor(inputs?: InvertColorInputs);
+    getInputSockets(): Record<string, import("../../core/InputSocket.js").InputSocket<unknown>>;
+    getOutputSockets(): Record<string, OutputSocket>;
+    compileDefs(): string;
+    compileCall(ctx: CompileContext): string;
+}
+//# sourceMappingURL=InvertColor.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"InvertColor.d.ts","sourceRoot":"","sources":["../../../src/nodes/process/InvertColor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAA;AACvD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAA;AAC5D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAA;AAClE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAA;AAE9D,MAAM,WAAW,iBAAiB;IAChC,KAAK,CAAC,EAAE,YAAY,GAAG,MAAM,CAAA;IAC7B,GAAG,CAAC,EAAI,YAAY,GAAG,MAAM,CAAA;CAC9B;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,SAGnB;IAEA,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA2E;IACnG,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAmE;gBAEhF,MAAM,GAAE,iBAAsB;IAS1C,eAAe;IACf,gBAAgB;IAChB,WAAW;IAEX,WAAW,CAAC,GAAG,EAAE,cAAc,GAAG,MAAM;CAKzC"}

package/dist/nodes/process/InvertColor.js

@@ -0,0 +1,35 @@
+import { ProcessNode } from '../../core/ProcessNode.js';
+/**
+ * Invert Color — Blender "Invert Color" node equivalent.
+ * Produces the negative of a colour, blended by fac.
+ *
+ * Inputs:  color, fac [0-1] (0 = original, 1 = fully inverted)
+ * Outputs: Color (color)
+ */
+export class InvertColor extends ProcessNode {
+    get nodeType() { return 'InvertColor'; }
+    get metadata() {
+        return { label: 'Invert Color', category: 'Color', color: '#633060', cost: 'low' };
+    }
+    constructor(inputs = {}) {
+        super('InvertColor');
+        this._inputs = this.createInputs(inputs, {
+            color: ['color', '#ffffff'],
+            fac: ['float', inputs.fac ?? 1.0],
+        });
+        this._outputs = this.createOutputs({ Color: 'color' });
+    }
+    getInputSockets() { return this._inputs; }
+    getOutputSockets() { return this._outputs; }
+    compileDefs() { return InvertColor.glslFunction; }
+    compileCall(ctx) {
+        const col = ctx.resolveInput(this._inputs.color);
+        const fac = ctx.resolveInput(this._inputs.fac);
+        return `vec3 ${ctx.outputVar(this, 'Color')} = _st_invertColor(${col}, ${fac});`;
+    }
+}
+InvertColor.instanceSpecificDef = false;
+InvertColor.glslFunction = `
+vec3 _st_invertColor(vec3 col, float fac) {
+  return mix(col, 1.0 - col, clamp(fac, 0.0, 1.0));
+}`;

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

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

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

package/dist/nodes/process/MagicTexture.js

@@ -0,0 +1,54 @@
+import { ProcessNode } from '../../core/ProcessNode.js';
+/**
+ * Magic Texture — Blender "Magic Texture" node equivalent.
+ * Swirling psychedelic colour pattern from sine wave interference.
+ *
+ * Outputs: Color (color), Fac (float)
+ */
+export class MagicTexture extends ProcessNode {
+    get nodeType() { return 'MagicTexture'; }
+    get metadata() {
+        return { label: 'Magic Texture', category: 'Texture', color: '#3a6b3a', cost: 'low' };
+    }
+    constructor(inputs = {}) {
+        super('MagicTexture');
+        this._inputs = this.createInputs(inputs, {
+            vector: ['color', null],
+            scale: ['float', inputs.scale ?? 5.0],
+            distortion: ['float', inputs.distortion ?? 1.0],
+        });
+        this._outputs = this.createOutputs({ Color: 'color', Fac: 'float' });
+    }
+    getInputSockets() { return this._inputs; }
+    getOutputSockets() { return this._outputs; }
+    compileDefs() { return MagicTexture.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 sc = ctx.resolveInput(this._inputs.scale);
+        const di = ctx.resolveInput(this._inputs.distortion);
+        const cv = ctx.outputVar(this, 'Color');
+        const fv = ctx.outputVar(this, 'Fac');
+        return [
+            `vec4 _mg_${this.id} = _st_magicTexture(${vec}, ${sc}, ${di});`,
+            `vec3  ${cv} = _mg_${this.id}.rgb;`,
+            `float ${fv} = _mg_${this.id}.a;`,
+        ].join('\n  ');
+    }
+}
+MagicTexture.instanceSpecificDef = false;
+MagicTexture.glslFunction = `
+vec4 _st_magicTexture(vec3 p, float scale, float distortion) {
+  p *= scale;
+  float x = sin((p.x + p.y + p.z) * distortion);
+  float y = cos((-p.x + p.y - p.z) * distortion);
+  float z = -cos((-p.x - p.y + p.z) * distortion);
+  vec3 col = (vec3(x, y, z) + 1.0) * 0.5;
+  col = vec3(
+    sin((col.x + col.y) * 6.28318),
+    sin((col.y + col.z) * 6.28318),
+    sin((col.z + col.x) * 6.28318)
+  ) * 0.5 + 0.5;
+  return vec4(col, (col.r + col.g + col.b) / 3.0);
+}`;

package/dist/nodes/process/MapRange.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 MapRangeMode = 'LINEAR' | 'STEPPED' | 'SMOOTHSTEP' | 'SMOOTHERSTEP';
+export interface MapRangeInputs {
+    value?: OutputSocket | number;
+    fromMin?: OutputSocket | number;
+    fromMax?: OutputSocket | number;
+    toMin?: OutputSocket | number;
+    toMax?: OutputSocket | number;
+    steps?: OutputSocket | number;
+    mode?: MapRangeMode;
+    clamp?: boolean;
+}
+/**
+ * Map Range — Blender "Map Range" converter node equivalent.
+ * Remaps a value from one range to another.
+ *
+ * Inputs:  value, fromMin, fromMax, toMin, toMax, steps, mode, clamp
+ * Outputs: Result (float)
+ */
+export declare class MapRange extends ProcessNode {
+    get nodeType(): string;
+    static instanceSpecificDef: boolean;
+    get metadata(): NodeMetadata;
+    static glslFunction: string;
+    private readonly mode;
+    private readonly doClamp;
+    private readonly _inputs;
+    private readonly _outputs;
+    constructor(inputs?: MapRangeInputs);
+    getInputSockets(): Record<string, import("../../core/InputSocket.js").InputSocket<unknown>>;
+    getOutputSockets(): Record<string, OutputSocket>;
+    compileDefs(): string;
+    compileCall(ctx: CompileContext): string;
+}
+//# sourceMappingURL=MapRange.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"MapRange.d.ts","sourceRoot":"","sources":["../../../src/nodes/process/MapRange.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAA;AACvD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAA;AAC5D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAA;AAClE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAA;AAE9D,MAAM,MAAM,YAAY,GAAG,QAAQ,GAAG,SAAS,GAAG,YAAY,GAAG,cAAc,CAAA;AAE/E,MAAM,WAAW,cAAc;IAC7B,KAAK,CAAC,EAAK,YAAY,GAAG,MAAM,CAAA;IAChC,OAAO,CAAC,EAAG,YAAY,GAAG,MAAM,CAAA;IAChC,OAAO,CAAC,EAAG,YAAY,GAAG,MAAM,CAAA;IAChC,KAAK,CAAC,EAAK,YAAY,GAAG,MAAM,CAAA;IAChC,KAAK,CAAC,EAAK,YAAY,GAAG,MAAM,CAAA;IAChC,KAAK,CAAC,EAAK,YAAY,GAAG,MAAM,CAAA;IAChC,IAAI,CAAC,EAAM,YAAY,CAAA;IACvB,KAAK,CAAC,EAAK,OAAO,CAAA;CACnB;AAED;;;;;;GAMG;AACH,qBAAa,QAAS,SAAQ,WAAW;IACvC,IAAI,QAAQ,WAAwB;IACpC,MAAM,CAAC,mBAAmB,UAAQ;IAElC,IAAI,QAAQ,IAAI,YAAY,CAE3B;IAED,MAAM,CAAC,YAAY,SASnB;IAEA,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAe;IACpC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;IACjC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA2E;IACnG,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAmE;gBAEhF,MAAM,GAAE,cAAmB;IAevC,eAAe;IACf,gBAAgB;IAChB,WAAW;IAEX,WAAW,CAAC,GAAG,EAAE,cAAc,GAAG,MAAM;CAUzC"}

package/dist/nodes/process/MapRange.js

@@ -0,0 +1,52 @@
+import { ProcessNode } from '../../core/ProcessNode.js';
+/**
+ * Map Range — Blender "Map Range" converter node equivalent.
+ * Remaps a value from one range to another.
+ *
+ * Inputs:  value, fromMin, fromMax, toMin, toMax, steps, mode, clamp
+ * Outputs: Result (float)
+ */
+export class MapRange extends ProcessNode {
+    get nodeType() { return 'MapRange'; }
+    get metadata() {
+        return { label: 'Map Range', category: 'Converter', color: '#4a3a6a', cost: 'low' };
+    }
+    constructor(inputs = {}) {
+        super('MapRange');
+        this.mode = inputs.mode ?? 'LINEAR';
+        this.doClamp = inputs.clamp ?? false;
+        this._inputs = this.createInputs(inputs, {
+            value: ['float', inputs.value ?? 0.5],
+            fromMin: ['float', inputs.fromMin ?? 0.0],
+            fromMax: ['float', inputs.fromMax ?? 1.0],
+            toMin: ['float', inputs.toMin ?? 0.0],
+            toMax: ['float', inputs.toMax ?? 1.0],
+            steps: ['float', inputs.steps ?? 4.0],
+        });
+        this._outputs = this.createOutputs({ Result: 'float' });
+    }
+    getInputSockets() { return this._inputs; }
+    getOutputSockets() { return this._outputs; }
+    compileDefs() { return MapRange.glslFunction; }
+    compileCall(ctx) {
+        const modeIdx = { LINEAR: 0, STEPPED: 1, SMOOTHSTEP: 2, SMOOTHERSTEP: 3 }[this.mode];
+        const v = ctx.resolveInput(this._inputs.value);
+        const f0 = ctx.resolveInput(this._inputs.fromMin);
+        const f1 = ctx.resolveInput(this._inputs.fromMax);
+        const t0 = ctx.resolveInput(this._inputs.toMin);
+        const t1 = ctx.resolveInput(this._inputs.toMax);
+        const st = ctx.resolveInput(this._inputs.steps);
+        return `float ${ctx.outputVar(this, 'Result')} = _st_mapRange(${v}, ${f0}, ${f1}, ${t0}, ${t1}, ${st}, ${modeIdx}, ${this.doClamp});`;
+    }
+}
+MapRange.instanceSpecificDef = false;
+MapRange.glslFunction = `
+float _st_mapRange(float v, float fMin, float fMax, float tMin, float tMax, float steps, int mode, bool doClamp) {
+  float range  = fMax - fMin;
+  float t      = range == 0.0 ? 0.0 : (v - fMin) / range;
+  if      (mode == 1) t = (steps > 0.0) ? floor(t * steps + 0.5) / steps : t;
+  else if (mode == 2) t = t * t * (3.0 - 2.0 * t);
+  else if (mode == 3) t = t * t * t * (t * (t * 6.0 - 15.0) + 10.0);
+  if (doClamp) t = clamp(t, 0.0, 1.0);
+  return tMin + t * (tMax - tMin);
+}`;

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

@@ -0,0 +1,37 @@
+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 MappingMode = 'TEXTURE' | 'POINT' | 'VECTOR' | 'NORMAL';
+export interface MappingInputs {
+    mode?: MappingMode;
+    vector?: OutputSocket;
+    location?: [number, number, number];
+    rotation?: [number, number, number];
+    scale?: [number, number, number];
+}
+/**
+ * Mapping — Blender "Mapping" node equivalent.
+ * Transforms UV/vector coordinates: translate, rotate, scale.
+ *
+ * Inputs:  vector, location, rotation (degrees), scale
+ * Outputs: Vector (vector/color)
+ */
+export declare class Mapping extends ProcessNode {
+    get nodeType(): string;
+    static instanceSpecificDef: boolean;
+    get metadata(): NodeMetadata;
+    static glslFunction: string;
+    private readonly loc;
+    private readonly rot;
+    private readonly scl;
+    private readonly mode;
+    private readonly _inputs;
+    private readonly _outputs;
+    constructor(inputs?: MappingInputs);
+    getInputSockets(): Record<string, import("../../core/InputSocket.js").InputSocket<unknown>>;
+    getOutputSockets(): Record<string, OutputSocket>;
+    compileDefs(): string;
+    compileCall(ctx: CompileContext): string;
+}
+//# sourceMappingURL=Mapping.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Mapping.d.ts","sourceRoot":"","sources":["../../../src/nodes/process/Mapping.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,WAAW,GAAG,SAAS,GAAG,OAAO,GAAG,QAAQ,GAAG,QAAQ,CAAA;AAEnE,MAAM,WAAW,aAAa;IAC5B,IAAI,CAAC,EAAM,WAAW,CAAA;IACtB,MAAM,CAAC,EAAI,YAAY,CAAA;IACvB,QAAQ,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;IACnC,QAAQ,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;IACnC,KAAK,CAAC,EAAK,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;CACpC;AAED;;;;;;GAMG;AACH,qBAAa,OAAQ,SAAQ,WAAW;IACtC,IAAI,QAAQ,WAAuB;IACnC,MAAM,CAAC,mBAAmB,UAAQ;IAElC,IAAI,QAAQ,IAAI,YAAY,CAE3B;IAED,MAAM,CAAC,YAAY,SAYnB;IAEA,OAAO,CAAC,QAAQ,CAAC,GAAG,CAA0B;IAC9C,OAAO,CAAC,QAAQ,CAAC,GAAG,CAA0B;IAC9C,OAAO,CAAC,QAAQ,CAAC,GAAG,CAA0B;IAC9C,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAa;IAClC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA2E;IACnG,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAmE;gBAEhF,MAAM,GAAE,aAAkB;IAUtC,eAAe;IACf,gBAAgB;IAChB,WAAW;IAEX,WAAW,CAAC,GAAG,EAAE,cAAc,GAAG,MAAM;CAkBzC"}

package/dist/nodes/process/Mapping.js

@@ -0,0 +1,57 @@
+import { ProcessNode } from '../../core/ProcessNode.js';
+/**
+ * Mapping — Blender "Mapping" node equivalent.
+ * Transforms UV/vector coordinates: translate, rotate, scale.
+ *
+ * Inputs:  vector, location, rotation (degrees), scale
+ * Outputs: Vector (vector/color)
+ */
+export class Mapping extends ProcessNode {
+    get nodeType() { return 'Mapping'; }
+    get metadata() {
+        return { label: 'Mapping', category: 'Vector', color: '#4a3a8a', cost: 'low' };
+    }
+    constructor(inputs = {}) {
+        super('Mapping');
+        this.mode = inputs.mode ?? 'TEXTURE';
+        this.loc = inputs.location ?? [0, 0, 0];
+        this.rot = inputs.rotation ?? [0, 0, 0];
+        this.scl = inputs.scale ?? [1, 1, 1];
+        this._inputs = this.createInputs(inputs, { vector: ['color', null] });
+        this._outputs = this.createOutputs({ Vector: 'color' });
+    }
+    getInputSockets() { return this._inputs; }
+    getOutputSockets() { return this._outputs; }
+    compileDefs() { return Mapping.glslFunction; }
+    compileCall(ctx) {
+        const v = ctx.resolveInput(this._inputs.vector);
+        const out = ctx.outputVar(this, 'Vector');
+        const toRad = (d) => (d * Math.PI / 180).toFixed(6);
+        const [lx, ly, lz] = this.loc;
+        const [rx, ry, rz] = this.rot.map(Number);
+        const [sx, sy, sz] = this.scl;
+        return [
+            `vec3 _mp_v_${this.id} = ${v};`,
+            `_mp_v_${this.id} = _mp_v_${this.id} - vec3(${lx.toFixed(4)}, ${ly.toFixed(4)}, ${lz.toFixed(4)});`,
+            `_mp_v_${this.id} = _st_rotateX(_mp_v_${this.id}, ${toRad(rx)});`,
+            `_mp_v_${this.id} = _st_rotateY(_mp_v_${this.id}, ${toRad(ry)});`,
+            `_mp_v_${this.id} = _st_rotateZ(_mp_v_${this.id}, ${toRad(rz)});`,
+            `_mp_v_${this.id} = _mp_v_${this.id} * vec3(${sx.toFixed(4)}, ${sy.toFixed(4)}, ${sz.toFixed(4)});`,
+            `vec3 ${out} = _mp_v_${this.id};`,
+        ].join('\n  ');
+    }
+}
+Mapping.instanceSpecificDef = false;
+Mapping.glslFunction = `
+vec3 _st_rotateX(vec3 v, float a) {
+  float c = cos(a), s = sin(a);
+  return vec3(v.x, c * v.y - s * v.z, s * v.y + c * v.z);
+}
+vec3 _st_rotateY(vec3 v, float a) {
+  float c = cos(a), s = sin(a);
+  return vec3(c * v.x + s * v.z, v.y, -s * v.x + c * v.z);
+}
+vec3 _st_rotateZ(vec3 v, float a) {
+  float c = cos(a), s = sin(a);
+  return vec3(c * v.x - s * v.y, s * v.x + c * v.y, v.z);
+}`;

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

@@ -0,0 +1,40 @@
+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 MathMode = 'ADD' | 'SUBTRACT' | 'MULTIPLY' | 'DIVIDE' | 'POWER' | 'LOGARITHM' | 'SQRT' | 'INV_SQRT' | 'ABSOLUTE' | 'ROUND' | 'FLOOR' | 'CEIL' | 'TRUNCATE' | 'FRACTION' | 'MINIMUM' | 'MAXIMUM' | 'LESS_THAN' | 'GREATER_THAN' | 'CLAMP' | 'SNAP' | 'SINE' | 'COSINE' | 'TANGENT' | 'ARCSINE' | 'ARCCOSINE' | 'ARCTANGENT' | 'ARCTAN2' | 'MODULO' | 'WRAP' | 'PINGPONG' | 'SMOOTH_MIN' | 'SMOOTH_MAX';
+export interface MathInputs {
+    mode: MathMode;
+    a?: OutputSocket | number;
+    b?: OutputSocket | number;
+    c?: OutputSocket | number;
+    clamp?: boolean;
+}
+/**
+ * Math — Blender "Math" node equivalent.
+ * Single node with mode selector covering all arithmetic, trig, and comparison ops.
+ *
+ * Inputs:  a, b (floats or connected sockets), c for ternary ops
+ * Outputs: Value (float)
+ *
+ * @example
+ * new Math({ mode: 'ADD',   a: noise.output('Fac'), b: 0.5 })
+ * new Math({ mode: 'CLAMP', a: noise.output('Fac') })
+ * new Math({ mode: 'SINE',  a: noise.output('Fac') })
+ */
+export declare class Math extends ProcessNode {
+    get nodeType(): string;
+    static instanceSpecificDef: boolean;
+    get metadata(): NodeMetadata;
+    private readonly mode;
+    private readonly clamp;
+    private readonly _inputs;
+    private readonly _outputs;
+    constructor(inputs: MathInputs);
+    getInputSockets(): Record<string, import("../../core/InputSocket.js").InputSocket<unknown>>;
+    getOutputSockets(): Record<string, OutputSocket>;
+    compileDefs(): string;
+    compileCall(ctx: CompileContext): string;
+    private buildExpr;
+}
+//# sourceMappingURL=Math.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Math.d.ts","sourceRoot":"","sources":["../../../src/nodes/process/Math.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAA;AAGvD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAA;AAC5D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAA;AAClE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAA;AAE9D,MAAM,MAAM,QAAQ,GAEhB,KAAK,GAAG,UAAU,GAAG,UAAU,GAAG,QAAQ,GAC1C,OAAO,GAAG,WAAW,GAAG,MAAM,GAAG,UAAU,GAAG,UAAU,GAExD,OAAO,GAAG,OAAO,GAAG,MAAM,GAAG,UAAU,GAAG,UAAU,GAEpD,SAAS,GAAG,SAAS,GAAG,WAAW,GAAG,cAAc,GAAG,OAAO,GAAG,MAAM,GAEvE,MAAM,GAAG,QAAQ,GAAG,SAAS,GAAG,SAAS,GAAG,WAAW,GAAG,YAAY,GAAG,SAAS,GAElF,QAAQ,GAAG,MAAM,GAAG,UAAU,GAAG,YAAY,GAAG,YAAY,CAAA;AAEhE,MAAM,WAAW,UAAU;IACzB,IAAI,EAAI,QAAQ,CAAA;IAChB,CAAC,CAAC,EAAM,YAAY,GAAG,MAAM,CAAA;IAC7B,CAAC,CAAC,EAAM,YAAY,GAAG,MAAM,CAAA;IAC7B,CAAC,CAAC,EAAM,YAAY,GAAG,MAAM,CAAA;IAC7B,KAAK,CAAC,EAAE,OAAO,CAAA;CAChB;AAED;;;;;;;;;;;GAWG;AACH,qBAAa,IAAK,SAAQ,WAAW;IACnC,IAAI,QAAQ,WAAoB;IAChC,MAAM,CAAC,mBAAmB,UAAO;IAEjC,IAAI,QAAQ,IAAI,YAAY,CAO3B;IAED,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAW;IAChC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAS;IAC/B,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA2E;IACnG,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAmE;gBAEhF,MAAM,EAAE,UAAU;IAuB9B,eAAe;IACf,gBAAgB;IAEhB,WAAW,IAAI,MAAM;IAErB,WAAW,CAAC,GAAG,EAAE,cAAc,GAAG,MAAM;IAWxC,OAAO,CAAC,SAAS;CA0ClB"}

package/dist/nodes/process/Math.js

@@ -0,0 +1,100 @@
+import { ProcessNode } from '../../core/ProcessNode.js';
+import { ShaderNodeError } from '../../core/ShaderNodeError.js';
+import { ShaderConfig } from '../../core/ShaderConfig.js';
+/**
+ * Math — Blender "Math" node equivalent.
+ * Single node with mode selector covering all arithmetic, trig, and comparison ops.
+ *
+ * Inputs:  a, b (floats or connected sockets), c for ternary ops
+ * Outputs: Value (float)
+ *
+ * @example
+ * new Math({ mode: 'ADD',   a: noise.output('Fac'), b: 0.5 })
+ * new Math({ mode: 'CLAMP', a: noise.output('Fac') })
+ * new Math({ mode: 'SINE',  a: noise.output('Fac') })
+ */
+export class Math extends ProcessNode {
+    get nodeType() { return 'Math'; }
+    get metadata() {
+        return {
+            label: 'Math',
+            category: 'Converter',
+            color: '#4a3a6a',
+            cost: 'low',
+        };
+    }
+    constructor(inputs) {
+        super('Math');
+        if (ShaderConfig.errorLevel !== 'off' && !inputs.mode) {
+            ShaderNodeError.throw({
+                nodeType: 'Math',
+                nodeId: this.id,
+                problem: 'mode is required.',
+                fix: 'new Math({ mode: "ADD", a: ..., b: ... })',
+            });
+        }
+        this.mode = inputs.mode;
+        this.clamp = inputs.clamp ?? false;
+        this._inputs = this.createInputs(inputs, {
+            a: ['float', inputs.a ?? 0.0],
+            b: ['float', inputs.b ?? 0.0],
+            c: ['float', inputs.c ?? 0.5],
+        });
+        this._outputs = this.createOutputs({ Value: 'float' });
+    }
+    getInputSockets() { return this._inputs; }
+    getOutputSockets() { return this._outputs; }
+    compileDefs() { return ''; }
+    compileCall(ctx) {
+        const a = ctx.resolveInput(this._inputs.a);
+        const b = ctx.resolveInput(this._inputs.b);
+        const c = ctx.resolveInput(this._inputs.c);
+        const out = ctx.outputVar(this, 'Value');
+        const expr = this.buildExpr(a, b, c);
+        const final = this.clamp ? `clamp(${expr}, 0.0, 1.0)` : expr;
+        return `float ${out} = ${final};`;
+    }
+    buildExpr(a, b, c) {
+        switch (this.mode) {
+            // Basic
+            case 'ADD': return `(${a} + ${b})`;
+            case 'SUBTRACT': return `(${a} - ${b})`;
+            case 'MULTIPLY': return `(${a} * ${b})`;
+            case 'DIVIDE': return `(${b} != 0.0 ? ${a} / ${b} : 0.0)`;
+            case 'POWER': return `pow(max(${a}, 0.0), ${b})`;
+            case 'LOGARITHM': return `(${a} > 0.0 && ${b} > 0.0 ? log(${a}) / log(${b}) : 0.0)`;
+            case 'SQRT': return `sqrt(max(${a}, 0.0))`;
+            case 'INV_SQRT': return `(${a} > 0.0 ? 1.0 / sqrt(${a}) : 0.0)`;
+            case 'ABSOLUTE': return `abs(${a})`;
+            // Rounding
+            case 'ROUND': return `floor(${a} + 0.5)`;
+            case 'FLOOR': return `floor(${a})`;
+            case 'CEIL': return `ceil(${a})`;
+            case 'TRUNCATE': return `trunc(${a})`;
+            case 'FRACTION': return `fract(${a})`;
+            // Comparison
+            case 'MINIMUM': return `min(${a}, ${b})`;
+            case 'MAXIMUM': return `max(${a}, ${b})`;
+            case 'LESS_THAN': return `(${a} < ${b} ? 1.0 : 0.0)`;
+            case 'GREATER_THAN': return `(${a} > ${b} ? 1.0 : 0.0)`;
+            case 'CLAMP': return `clamp(${a}, ${b}, ${c})`;
+            case 'SNAP': return `(${b} != 0.0 ? floor(${a} / ${b}) * ${b} : 0.0)`;
+            // Trig
+            case 'SINE': return `sin(${a})`;
+            case 'COSINE': return `cos(${a})`;
+            case 'TANGENT': return `tan(${a})`;
+            case 'ARCSINE': return `asin(clamp(${a}, -1.0, 1.0))`;
+            case 'ARCCOSINE': return `acos(clamp(${a}, -1.0, 1.0))`;
+            case 'ARCTANGENT': return `atan(${a})`;
+            case 'ARCTAN2': return `atan(${a}, ${b})`;
+            // Special
+            case 'MODULO': return `(${b} != 0.0 ? mod(${a}, ${b}) : 0.0)`;
+            case 'WRAP': return `(${c} != 0.0 ? mod(${a} - ${b}, ${c} - ${b}) + ${b} : ${b})`;
+            case 'PINGPONG': return `(${b} != 0.0 ? abs(fract((${a} - ${b}) / (${b} * 2.0)) * ${b} * 2.0 - ${b}) : 0.0)`;
+            case 'SMOOTH_MIN': return `(exp(-${c} * ${a}) + exp(-${c} * ${b}) > 0.0 ? -log(exp(-${c} * ${a}) + exp(-${c} * ${b})) / max(${c}, 0.0001) : min(${a}, ${b}))`;
+            case 'SMOOTH_MAX': return `(exp(${c} * ${a}) + exp(${c} * ${b}) > 0.0 ? log(exp(${c} * ${a}) + exp(${c} * ${b})) / max(${c}, 0.0001) : max(${a}, ${b}))`;
+            default: return `${a}`;
+        }
+    }
+}
+Math.instanceSpecificDef = true; // each instance emits its own operation

package/dist/nodes/process/MixRGB.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 type MixRGBMode = 'MIX' | 'DARKEN' | 'MULTIPLY' | 'BURN' | 'LIGHTEN' | 'SCREEN' | 'DODGE' | 'ADD' | 'OVERLAY' | 'SOFT_LIGHT' | 'LINEAR_LIGHT' | 'DIFFERENCE' | 'EXCLUSION' | 'SUBTRACT' | 'DIVIDE' | 'HUE' | 'SATURATION' | 'COLOR' | 'LUMINOSITY';
+export interface MixRGBInputs {
+    mode?: MixRGBMode;
+    fac?: OutputSocket | number;
+    colorA?: OutputSocket | string;
+    colorB?: OutputSocket | string;
+    clamp?: boolean;
+}
+/**
+ * Mix RGB — Blender "Mix" color node equivalent.
+ * Blends two colours using a mode selector.
+ *
+ * Inputs:  fac [0-1], colorA, colorB
+ * Outputs: Color (color)
+ */
+export declare class MixRGB extends ProcessNode {
+    get nodeType(): string;
+    static instanceSpecificDef: boolean;
+    get metadata(): NodeMetadata;
+    static glslFunction: string;
+    private readonly mode;
+    private readonly clamp;
+    private readonly _inputs;
+    private readonly _outputs;
+    constructor(inputs?: MixRGBInputs);
+    getInputSockets(): Record<string, import("../../core/InputSocket.js").InputSocket<unknown>>;
+    getOutputSockets(): Record<string, OutputSocket>;
+    compileDefs(): string;
+    compileCall(ctx: CompileContext): string;
+}
+//# sourceMappingURL=MixRGB.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"MixRGB.d.ts","sourceRoot":"","sources":["../../../src/nodes/process/MixRGB.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,UAAU,GAClB,KAAK,GAAG,QAAQ,GAAG,UAAU,GAAG,MAAM,GACtC,SAAS,GAAG,QAAQ,GAAG,OAAO,GAAG,KAAK,GACtC,SAAS,GAAG,YAAY,GAAG,cAAc,GACzC,YAAY,GAAG,WAAW,GAAG,UAAU,GACvC,QAAQ,GAAG,KAAK,GAAG,YAAY,GAAG,OAAO,GAAG,YAAY,CAAA;AAE5D,MAAM,WAAW,YAAY;IAC3B,IAAI,CAAC,EAAI,UAAU,CAAA;IACnB,GAAG,CAAC,EAAK,YAAY,GAAG,MAAM,CAAA;IAC9B,MAAM,CAAC,EAAE,YAAY,GAAG,MAAM,CAAA;IAC9B,MAAM,CAAC,EAAE,YAAY,GAAG,MAAM,CAAA;IAC9B,KAAK,CAAC,EAAG,OAAO,CAAA;CACjB;AAED;;;;;;GAMG;AACH,qBAAa,MAAO,SAAQ,WAAW;IACrC,IAAI,QAAQ,WAAsB;IAClC,MAAM,CAAC,mBAAmB,UAAQ;IAElC,IAAI,QAAQ,IAAI,YAAY,CAE3B;IAED,MAAM,CAAC,YAAY,SAoBnB;IAEA,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAa;IAClC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAS;IAC/B,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA2E;IACnG,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAmE;gBAEhF,MAAM,GAAE,YAAiB;IAYrC,eAAe;IACf,gBAAgB;IAChB,WAAW;IAEX,WAAW,CAAC,GAAG,EAAE,cAAc,GAAG,MAAM;CAazC"}