@triforge/shader-core 0.1.0

package/dist/nodes/process/TranslucentBSDF.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 TranslucentBSDFInputs {
+    color?: OutputSocket | string;
+    normal?: OutputSocket;
+}
+/**
+ * Translucent BSDF — Blender "Translucent BSDF" node equivalent.
+ * Allows light silhouettes through the back of thin objects — leaves, paper, fabric.
+ *
+ * Inputs:  color, normal
+ * Outputs: BSDF (shader)
+ */
+export declare class TranslucentBSDF extends ProcessNode {
+    get nodeType(): string;
+    static instanceSpecificDef: boolean;
+    get metadata(): NodeMetadata;
+    static glslFunction: string;
+    private readonly _inputs;
+    private readonly _outputs;
+    constructor(inputs?: TranslucentBSDFInputs);
+    getInputSockets(): Record<string, import("../../core/InputSocket.js").InputSocket<unknown>>;
+    getOutputSockets(): Record<string, OutputSocket>;
+    compileDefs(): string;
+    compileCall(ctx: CompileContext): string;
+}
+//# sourceMappingURL=TranslucentBSDF.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"TranslucentBSDF.d.ts","sourceRoot":"","sources":["../../../src/nodes/process/TranslucentBSDF.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,qBAAqB;IACpC,KAAK,CAAC,EAAG,YAAY,GAAG,MAAM,CAAA;IAC9B,MAAM,CAAC,EAAE,YAAY,CAAA;CACtB;AAED;;;;;;GAMG;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,SAKnB;IAEA,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA2E;IACnG,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAmE;gBAEhF,MAAM,GAAE,qBAA0B;IAS9C,eAAe;IACf,gBAAgB;IAChB,WAAW;IAEX,WAAW,CAAC,GAAG,EAAE,cAAc,GAAG,MAAM;CAOzC"}

package/dist/nodes/process/TranslucentBSDF.js

@@ -0,0 +1,39 @@
+import { ProcessNode } from '../../core/ProcessNode.js';
+/**
+ * Translucent BSDF — Blender "Translucent BSDF" node equivalent.
+ * Allows light silhouettes through the back of thin objects — leaves, paper, fabric.
+ *
+ * Inputs:  color, normal
+ * Outputs: BSDF (shader)
+ */
+export class TranslucentBSDF extends ProcessNode {
+    get nodeType() { return 'TranslucentBSDF'; }
+    get metadata() {
+        return { label: 'Translucent BSDF', category: 'Shader', color: '#336699', cost: 'low' };
+    }
+    constructor(inputs = {}) {
+        super('TranslucentBSDF');
+        this._inputs = this.createInputs(inputs, {
+            color: ['color', '#ffffff'],
+            normal: ['color', null],
+        });
+        this._outputs = this.createOutputs({ BSDF: 'shader' });
+    }
+    getInputSockets() { return this._inputs; }
+    getOutputSockets() { return this._outputs; }
+    compileDefs() { return TranslucentBSDF.glslFunction; }
+    compileCall(ctx) {
+        const color = ctx.resolveInput(this._inputs.color);
+        const normal = this._inputs.normal.isConnected()
+            ? ctx.outputVar(this._inputs.normal.connection.node, this._inputs.normal.connection.name)
+            : 'normalize(vNormal)';
+        return `vec3 ${ctx.outputVar(this, 'BSDF')} = _st_translucentBSDF(${color}, ${normal});`;
+    }
+}
+TranslucentBSDF.instanceSpecificDef = false;
+TranslucentBSDF.glslFunction = `
+vec3 _st_translucentBSDF(vec3 color, vec3 N) {
+  vec3  L       = normalize(vec3(1.0, 2.0, 1.0));
+  float backDot = max(dot(-N, L), 0.0);
+  return color * backDot / 3.14159265 + color * 0.02;
+}`;

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

@@ -0,0 +1,42 @@
+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';
+/** A curve point [x, y]. */
+export type VectorCurvePoint = [number, number];
+export interface VectorCurvesInputs {
+    vector?: OutputSocket;
+    fac?: OutputSocket | number;
+    /**
+     * Per-axis piecewise linear curve as [[x,y], ...] control points.
+     * Default = identity [[−1,−1],[1,1]] (maps full float range through unchanged).
+     */
+    xPoints?: VectorCurvePoint[];
+    yPoints?: VectorCurvePoint[];
+    zPoints?: VectorCurvePoint[];
+}
+/**
+ * Vector Curves — Blender "Vector Curves" node equivalent.
+ * Full piecewise linear curve per axis (X, Y, Z).
+ * Matches Blender's Vector Curves node exactly — arbitrary control points,
+ * piecewise linear interpolation. Input range is typically [−1, 1] for vectors.
+ *
+ * Inputs:  vector, fac
+ * Outputs: Vector (color/vec3)
+ */
+export declare class VectorCurves extends ProcessNode {
+    get nodeType(): string;
+    static instanceSpecificDef: boolean;
+    get metadata(): NodeMetadata;
+    private readonly xPts;
+    private readonly yPts;
+    private readonly zPts;
+    private readonly _inputs;
+    private readonly _outputs;
+    constructor(inputs?: VectorCurvesInputs);
+    getInputSockets(): Record<string, import("../../core/InputSocket.js").InputSocket<unknown>>;
+    getOutputSockets(): Record<string, OutputSocket>;
+    compileDefs(): string;
+    compileCall(ctx: CompileContext): string;
+}
+//# sourceMappingURL=VectorCurves.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"VectorCurves.d.ts","sourceRoot":"","sources":["../../../src/nodes/process/VectorCurves.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,4BAA4B;AAC5B,MAAM,MAAM,gBAAgB,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;AAE/C,MAAM,WAAW,kBAAkB;IACjC,MAAM,CAAC,EAAG,YAAY,CAAA;IACtB,GAAG,CAAC,EAAM,YAAY,GAAG,MAAM,CAAA;IAC/B;;;OAGG;IACH,OAAO,CAAC,EAAE,gBAAgB,EAAE,CAAA;IAC5B,OAAO,CAAC,EAAE,gBAAgB,EAAE,CAAA;IAC5B,OAAO,CAAC,EAAE,gBAAgB,EAAE,CAAA;CAC7B;AAED;;;;;;;;GAQG;AACH,qBAAa,YAAa,SAAQ,WAAW;IAC3C,IAAI,QAAQ,WAA4B;IACxC,MAAM,CAAC,mBAAmB,UAAO;IAEjC,IAAI,QAAQ,IAAI,YAAY,CAE3B;IAED,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAoB;IACzC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAoB;IACzC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAoB;IACzC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA2E;IACnG,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAmE;gBAEhF,MAAM,GAAE,kBAAuB;IAc3C,eAAe;IACf,gBAAgB;IAEhB,WAAW,IAAI,MAAM;IAQrB,WAAW,CAAC,GAAG,EAAE,cAAc,GAAG,MAAM;CAWzC"}

package/dist/nodes/process/VectorCurves.js

@@ -0,0 +1,71 @@
+import { ProcessNode } from '../../core/ProcessNode.js';
+/**
+ * Vector Curves — Blender "Vector Curves" node equivalent.
+ * Full piecewise linear curve per axis (X, Y, Z).
+ * Matches Blender's Vector Curves node exactly — arbitrary control points,
+ * piecewise linear interpolation. Input range is typically [−1, 1] for vectors.
+ *
+ * Inputs:  vector, fac
+ * Outputs: Vector (color/vec3)
+ */
+export class VectorCurves extends ProcessNode {
+    get nodeType() { return 'VectorCurves'; }
+    get metadata() {
+        return { label: 'Vector Curves', category: 'Vector', color: '#4a3a8a', cost: 'low' };
+    }
+    constructor(inputs = {}) {
+        super('VectorCurves');
+        // Default identity spans [−1, 1] to match Blender's vector curve range
+        const identity = [[-1, -1], [1, 1]];
+        this.xPts = sortPoints(inputs.xPoints ?? identity);
+        this.yPts = sortPoints(inputs.yPoints ?? identity);
+        this.zPts = sortPoints(inputs.zPoints ?? identity);
+        this._inputs = this.createInputs(inputs, {
+            vector: ['color', null],
+            fac: ['float', inputs.fac ?? 1.0],
+        });
+        this._outputs = this.createOutputs({ Vector: 'color' });
+    }
+    getInputSockets() { return this._inputs; }
+    getOutputSockets() { return this._outputs; }
+    compileDefs() {
+        return [
+            buildCurveFn(`_vc_x_${this.id}`, this.xPts),
+            buildCurveFn(`_vc_y_${this.id}`, this.yPts),
+            buildCurveFn(`_vc_z_${this.id}`, this.zPts),
+        ].join('\n');
+    }
+    compileCall(ctx) {
+        const vec = ctx.resolveInput(this._inputs.vector);
+        const fac = ctx.resolveInput(this._inputs.fac);
+        const id = this.id;
+        const out = ctx.outputVar(this, 'Vector');
+        return [
+            `vec3 _vc_${id} = ${vec};`,
+            `vec3 _vc_${id}_r = vec3(_vc_x_${id}(_vc_${id}.x), _vc_y_${id}(_vc_${id}.y), _vc_z_${id}(_vc_${id}.z));`,
+            `vec3 ${out} = mix(${vec}, _vc_${id}_r, clamp(${fac}, 0.0, 1.0));`,
+        ].join('\n  ');
+    }
+}
+VectorCurves.instanceSpecificDef = true;
+// ── helpers ───────────────────────────────────────────────────────────────────
+function sortPoints(pts) {
+    return [...pts].sort((a, b) => a[0] - b[0]);
+}
+function buildCurveFn(name, pts) {
+    // No array initializers — GLSL ES 1.00 doesn't support float[n](...) syntax.
+    const f = (n) => n.toFixed(5);
+    const clamps = `
+  if (t <= ${f(pts[0][0])}) return ${f(pts[0][1])};
+  if (t >= ${f(pts[pts.length - 1][0])}) return ${f(pts[pts.length - 1][1])};`;
+    const segments = pts.slice(0, -1).map((p, i) => {
+        const x0 = f(p[0]), y0 = f(p[1]);
+        const x1 = f(pts[i + 1][0]), y1 = f(pts[i + 1][1]);
+        return `  if (t <= ${x1}) return mix(${y0}, ${y1}, (t - ${x0}) / (${x1} - ${x0}));`;
+    }).join('\n');
+    return `
+float ${name}(float t) {${clamps}
+${segments}
+  return ${f(pts[pts.length - 1][1])};
+}`;
+}

package/dist/nodes/process/VectorMath.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 VectorMathMode = 'ADD' | 'SUBTRACT' | 'MULTIPLY' | 'DIVIDE' | 'SCALE' | 'LENGTH' | 'NORMALIZE' | 'DOT_PRODUCT' | 'CROSS_PRODUCT' | 'REFLECT' | 'REFRACT' | 'ABSOLUTE' | 'MINIMUM' | 'MAXIMUM' | 'FLOOR' | 'CEIL' | 'FRACTION' | 'MODULO' | 'SNAP' | 'SINE' | 'COSINE' | 'TANGENT' | 'DISTANCE';
+export interface VectorMathInputs {
+    mode: VectorMathMode;
+    vector?: OutputSocket | [number, number, number];
+    vectorB?: OutputSocket | [number, number, number];
+    scale?: OutputSocket | number;
+}
+/**
+ * Vector Math — Blender "Vector Math" node equivalent.
+ * Operates on vec3 values with a mode selector.
+ *
+ * Inputs:  vector, vectorB, scale
+ * Outputs: Vector (vector/color), Value (float — for scalar results)
+ *
+ * @example
+ * new VectorMath({ mode: 'NORMALIZE', vector: normal.output('Normal') })
+ * new VectorMath({ mode: 'DOT_PRODUCT', vector: a.output('Normal'), vectorB: b.output('Normal') })
+ */
+export declare class VectorMath extends ProcessNode {
+    get nodeType(): string;
+    static instanceSpecificDef: boolean;
+    get metadata(): NodeMetadata;
+    private readonly mode;
+    private readonly _inputs;
+    private readonly _outputs;
+    constructor(inputs: VectorMathInputs);
+    getInputSockets(): Record<string, import("../../core/InputSocket.js").InputSocket<unknown>>;
+    getOutputSockets(): Record<string, OutputSocket>;
+    compileDefs(): string;
+    compileCall(ctx: CompileContext): string;
+    private buildVector;
+    private buildScalar;
+}
+//# sourceMappingURL=VectorMath.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"VectorMath.d.ts","sourceRoot":"","sources":["../../../src/nodes/process/VectorMath.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,cAAc,GACtB,KAAK,GAAG,UAAU,GAAG,UAAU,GAAG,QAAQ,GAC1C,OAAO,GAAG,QAAQ,GAAG,WAAW,GAChC,aAAa,GAAG,eAAe,GAC/B,SAAS,GAAG,SAAS,GACrB,UAAU,GAAG,SAAS,GAAG,SAAS,GAClC,OAAO,GAAG,MAAM,GAAG,UAAU,GAAG,QAAQ,GAAG,MAAM,GACjD,MAAM,GAAG,QAAQ,GAAG,SAAS,GAC7B,UAAU,CAAA;AAEd,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAK,cAAc,CAAA;IACvB,MAAM,CAAC,EAAE,YAAY,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;IAChD,OAAO,CAAC,EAAE,YAAY,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;IACjD,KAAK,CAAC,EAAG,YAAY,GAAG,MAAM,CAAA;CAC/B;AAED;;;;;;;;;;GAUG;AACH,qBAAa,UAAW,SAAQ,WAAW;IACzC,IAAI,QAAQ,WAA0B;IACtC,MAAM,CAAC,mBAAmB,UAAO;IAEjC,IAAI,QAAQ,IAAI,YAAY,CAO3B;IAED,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAgB;IACrC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA2E;IACnG,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAmE;gBAEhF,MAAM,EAAE,gBAAgB;IA6BpC,eAAe;IACf,gBAAgB;IAChB,WAAW;IAEX,WAAW,CAAC,GAAG,EAAE,cAAc,GAAG,MAAM;IAuBxC,OAAO,CAAC,WAAW;IA0BnB,OAAO,CAAC,WAAW;CAQpB"}

package/dist/nodes/process/VectorMath.js

@@ -0,0 +1,105 @@
+import { ProcessNode } from '../../core/ProcessNode.js';
+import { ShaderNodeError } from '../../core/ShaderNodeError.js';
+import { ShaderConfig } from '../../core/ShaderConfig.js';
+/**
+ * Vector Math — Blender "Vector Math" node equivalent.
+ * Operates on vec3 values with a mode selector.
+ *
+ * Inputs:  vector, vectorB, scale
+ * Outputs: Vector (vector/color), Value (float — for scalar results)
+ *
+ * @example
+ * new VectorMath({ mode: 'NORMALIZE', vector: normal.output('Normal') })
+ * new VectorMath({ mode: 'DOT_PRODUCT', vector: a.output('Normal'), vectorB: b.output('Normal') })
+ */
+export class VectorMath extends ProcessNode {
+    get nodeType() { return 'VectorMath'; }
+    get metadata() {
+        return {
+            label: 'Vector Math',
+            category: 'Converter',
+            color: '#4a3a6a',
+            cost: 'low',
+        };
+    }
+    constructor(inputs) {
+        super('VectorMath');
+        if (ShaderConfig.errorLevel !== 'off' && !inputs.mode) {
+            ShaderNodeError.throw({
+                nodeType: 'VectorMath',
+                nodeId: this.id,
+                problem: 'mode is required.',
+                fix: 'new VectorMath({ mode: "NORMALIZE", vector: ... })',
+            });
+        }
+        this.mode = inputs.mode;
+        const vecDefault = inputs.vector instanceof Array ? inputs.vector : [0, 0, 0];
+        const vecBDefault = inputs.vectorB instanceof Array ? inputs.vectorB : [0, 0, 0];
+        this._inputs = this.createInputs(inputs, {
+            vector: ['color', vecDefault],
+            vectorB: ['color', vecBDefault],
+            scale: ['float', inputs.scale ?? 1.0],
+        });
+        if (inputs.vector && !(inputs.vector instanceof Array))
+            this._inputs.vector.connection = inputs.vector;
+        if (inputs.vectorB && !(inputs.vectorB instanceof Array))
+            this._inputs.vectorB.connection = inputs.vectorB;
+        this._outputs = this.createOutputs({ Vector: 'color', Value: 'float' });
+    }
+    getInputSockets() { return this._inputs; }
+    getOutputSockets() { return this._outputs; }
+    compileDefs() { return ''; }
+    compileCall(ctx) {
+        const v = ctx.resolveInput(this._inputs.vector);
+        const vb = ctx.resolveInput(this._inputs.vectorB);
+        const s = ctx.resolveInput(this._inputs.scale);
+        const vOut = ctx.outputVar(this, 'Vector');
+        const fOut = ctx.outputVar(this, 'Value');
+        const scalarModes = ['DOT_PRODUCT', 'LENGTH', 'DISTANCE'];
+        const isScalar = scalarModes.includes(this.mode);
+        const lines = [];
+        if (isScalar) {
+            lines.push(`float ${fOut} = ${this.buildScalar(v, vb, s)};`);
+            lines.push(`vec3  ${vOut} = vec3(${fOut});`);
+        }
+        else {
+            lines.push(`vec3  ${vOut} = ${this.buildVector(v, vb, s)};`);
+            lines.push(`float ${fOut} = length(${vOut});`);
+        }
+        return lines.join('\n  ');
+    }
+    buildVector(v, vb, s) {
+        switch (this.mode) {
+            case 'ADD': return `(${v} + ${vb})`;
+            case 'SUBTRACT': return `(${v} - ${vb})`;
+            case 'MULTIPLY': return `(${v} * ${vb})`;
+            case 'DIVIDE': return `(vec3(${vb}.x != 0.0 ? ${v}.x / ${vb}.x : 0.0, ${vb}.y != 0.0 ? ${v}.y / ${vb}.y : 0.0, ${vb}.z != 0.0 ? ${v}.z / ${vb}.z : 0.0))`;
+            case 'SCALE': return `(${v} * ${s})`;
+            case 'NORMALIZE': return `normalize(${v})`;
+            case 'REFLECT': return `reflect(${v}, normalize(${vb}))`;
+            case 'REFRACT': return `refract(normalize(${v}), normalize(${vb}), ${s})`;
+            case 'CROSS_PRODUCT': return `cross(${v}, ${vb})`;
+            case 'ABSOLUTE': return `abs(${v})`;
+            case 'MINIMUM': return `min(${v}, ${vb})`;
+            case 'MAXIMUM': return `max(${v}, ${vb})`;
+            case 'FLOOR': return `floor(${v})`;
+            case 'CEIL': return `ceil(${v})`;
+            case 'FRACTION': return `fract(${v})`;
+            case 'MODULO': return `mod(${v}, ${vb})`;
+            case 'SNAP': return `(floor(${v} / ${vb}) * ${vb})`;
+            case 'SINE': return `sin(${v})`;
+            case 'COSINE': return `cos(${v})`;
+            case 'TANGENT': return `tan(${v})`;
+            default: return v;
+        }
+    }
+    buildScalar(v, vb, _s) {
+        switch (this.mode) {
+            case 'DOT_PRODUCT': return `dot(${v}, ${vb})`;
+            case 'LENGTH': return `length(${v})`;
+            case 'DISTANCE': return `distance(${v}, ${vb})`;
+            default: return '0.0';
+        }
+    }
+}
+VectorMath.instanceSpecificDef = true;

package/dist/nodes/process/VectorRotate.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 type VectorRotateMode = 'AXIS_ANGLE' | 'X_AXIS' | 'Y_AXIS' | 'Z_AXIS' | 'EULER_XYZ';
+export interface VectorRotateInputs {
+    vector?: OutputSocket;
+    center?: OutputSocket | [number, number, number];
+    axis?: OutputSocket | [number, number, number];
+    angle?: OutputSocket | number;
+    mode?: VectorRotateMode;
+}
+/**
+ * Vector Rotate — Blender "Vector Rotate" node equivalent.
+ * Rotates a vector around an axis or by Euler angles.
+ *
+ * Inputs:  vector, center, axis, angle (radians)
+ * Outputs: Vector (color/vec3)
+ */
+export declare class VectorRotate extends ProcessNode {
+    get nodeType(): string;
+    static instanceSpecificDef: boolean;
+    get metadata(): NodeMetadata;
+    static glslFunction: string;
+    private readonly mode;
+    private readonly _inputs;
+    private readonly _outputs;
+    constructor(inputs?: VectorRotateInputs);
+    getInputSockets(): Record<string, import("../../core/InputSocket.js").InputSocket<unknown>>;
+    getOutputSockets(): Record<string, OutputSocket>;
+    compileDefs(): string;
+    compileCall(ctx: CompileContext): string;
+}
+//# sourceMappingURL=VectorRotate.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"VectorRotate.d.ts","sourceRoot":"","sources":["../../../src/nodes/process/VectorRotate.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,gBAAgB,GAAG,YAAY,GAAG,QAAQ,GAAG,QAAQ,GAAG,QAAQ,GAAG,WAAW,CAAA;AAE1F,MAAM,WAAW,kBAAkB;IACjC,MAAM,CAAC,EAAE,YAAY,CAAA;IACrB,MAAM,CAAC,EAAE,YAAY,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;IAChD,IAAI,CAAC,EAAI,YAAY,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;IAChD,KAAK,CAAC,EAAG,YAAY,GAAG,MAAM,CAAA;IAC9B,IAAI,CAAC,EAAI,gBAAgB,CAAA;CAC1B;AAED;;;;;;GAMG;AACH,qBAAa,YAAa,SAAQ,WAAW;IAC3C,IAAI,QAAQ,WAA4B;IACxC,MAAM,CAAC,mBAAmB,UAAQ;IAElC,IAAI,QAAQ,IAAI,YAAY,CAE3B;IAED,MAAM,CAAC,YAAY,SAKnB;IAEA,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAkB;IACvC,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;CAkBzC"}

package/dist/nodes/process/VectorRotate.js

@@ -0,0 +1,52 @@
+import { ProcessNode } from '../../core/ProcessNode.js';
+/**
+ * Vector Rotate — Blender "Vector Rotate" node equivalent.
+ * Rotates a vector around an axis or by Euler angles.
+ *
+ * Inputs:  vector, center, axis, angle (radians)
+ * Outputs: Vector (color/vec3)
+ */
+export class VectorRotate extends ProcessNode {
+    get nodeType() { return 'VectorRotate'; }
+    get metadata() {
+        return { label: 'Vector Rotate', category: 'Vector', color: '#4a3a8a', cost: 'low' };
+    }
+    constructor(inputs = {}) {
+        super('VectorRotate');
+        this.mode = inputs.mode ?? 'AXIS_ANGLE';
+        this._inputs = this.createInputs(inputs, {
+            vector: ['color', null],
+            center: ['color', null],
+            axis: ['color', null],
+            angle: ['float', inputs.angle ?? 0.0],
+        });
+        this._outputs = this.createOutputs({ Vector: 'color' });
+    }
+    getInputSockets() { return this._inputs; }
+    getOutputSockets() { return this._outputs; }
+    compileDefs() { return VectorRotate.glslFunction; }
+    compileCall(ctx) {
+        const vec = ctx.resolveInput(this._inputs.vector);
+        const angle = ctx.resolveInput(this._inputs.angle);
+        const out = ctx.outputVar(this, 'Vector');
+        switch (this.mode) {
+            case 'X_AXIS':
+                return `vec3 ${out} = _st_rotateAxisAngle(${vec}, vec3(1,0,0), ${angle});`;
+            case 'Y_AXIS':
+                return `vec3 ${out} = _st_rotateAxisAngle(${vec}, vec3(0,1,0), ${angle});`;
+            case 'Z_AXIS':
+                return `vec3 ${out} = _st_rotateAxisAngle(${vec}, vec3(0,0,1), ${angle});`;
+            default: {
+                const axis = ctx.resolveInput(this._inputs.axis);
+                return `vec3 ${out} = _st_rotateAxisAngle(${vec}, ${axis}, ${angle});`;
+            }
+        }
+    }
+}
+VectorRotate.instanceSpecificDef = false;
+VectorRotate.glslFunction = `
+vec3 _st_rotateAxisAngle(vec3 v, vec3 axis, float angle) {
+  float c = cos(angle), s = sin(angle);
+  axis = normalize(axis);
+  return v * c + cross(axis, v) * s + axis * dot(axis, v) * (1.0 - c);
+}`;

package/dist/nodes/process/VectorTransform.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 VectorTransformSpace = 'WORLD' | 'OBJECT' | 'CAMERA';
+export type VectorTransformType = 'VECTOR' | 'POINT' | 'NORMAL';
+export interface VectorTransformInputs {
+    vector?: OutputSocket;
+    fromSpace?: VectorTransformSpace;
+    toSpace?: VectorTransformSpace;
+    type?: VectorTransformType;
+}
+/**
+ * Vector Transform — Blender "Vector Transform" node equivalent.
+ * Transforms coordinates between World, Object, and Camera spaces.
+ *
+ * Inputs:  vector, fromSpace, toSpace, type
+ * Outputs: Vector (color/vec3)
+ */
+export declare class VectorTransform extends ProcessNode {
+    get nodeType(): string;
+    static instanceSpecificDef: boolean;
+    get metadata(): NodeMetadata;
+    static glslFunction: string;
+    private readonly fromSpace;
+    private readonly toSpace;
+    private readonly vtype;
+    private readonly _inputs;
+    private readonly _outputs;
+    constructor(inputs?: VectorTransformInputs);
+    getInputSockets(): Record<string, import("../../core/InputSocket.js").InputSocket<unknown>>;
+    getOutputSockets(): Record<string, OutputSocket>;
+    compileDefs(): string;
+    compileCall(ctx: CompileContext): string;
+}
+//# sourceMappingURL=VectorTransform.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"VectorTransform.d.ts","sourceRoot":"","sources":["../../../src/nodes/process/VectorTransform.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,oBAAoB,GAAG,OAAO,GAAG,QAAQ,GAAG,QAAQ,CAAA;AAChE,MAAM,MAAM,mBAAmB,GAAI,QAAQ,GAAG,OAAO,GAAG,QAAQ,CAAA;AAEhE,MAAM,WAAW,qBAAqB;IACpC,MAAM,CAAC,EAAI,YAAY,CAAA;IACvB,SAAS,CAAC,EAAE,oBAAoB,CAAA;IAChC,OAAO,CAAC,EAAI,oBAAoB,CAAA;IAChC,IAAI,CAAC,EAAO,mBAAmB,CAAA;CAChC;AAED;;;;;;GAMG;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,SAenB;IAEA,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAsB;IAChD,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAwB;IAChD,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAyB;IAC/C,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA4E;IACpG,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAoE;gBAEjF,MAAM,GAAE,qBAA0B;IAS9C,eAAe;IACf,gBAAgB;IAChB,WAAW;IAEX,WAAW,CAAC,GAAG,EAAE,cAAc,GAAG,MAAM;CAMzC"}

package/dist/nodes/process/VectorTransform.js

@@ -0,0 +1,48 @@
+import { ProcessNode } from '../../core/ProcessNode.js';
+/**
+ * Vector Transform — Blender "Vector Transform" node equivalent.
+ * Transforms coordinates between World, Object, and Camera spaces.
+ *
+ * Inputs:  vector, fromSpace, toSpace, type
+ * Outputs: Vector (color/vec3)
+ */
+export class VectorTransform extends ProcessNode {
+    get nodeType() { return 'VectorTransform'; }
+    get metadata() {
+        return { label: 'Vector Transform', category: 'Vector', color: '#4a3a8a', cost: 'low' };
+    }
+    constructor(inputs = {}) {
+        super('VectorTransform');
+        this.fromSpace = inputs.fromSpace ?? 'WORLD';
+        this.toSpace = inputs.toSpace ?? 'OBJECT';
+        this.vtype = inputs.type ?? 'VECTOR';
+        this._inputs = this.createInputs(inputs, { vector: ['color', null] });
+        this._outputs = this.createOutputs({ Vector: 'color' });
+    }
+    getInputSockets() { return this._inputs; }
+    getOutputSockets() { return this._outputs; }
+    compileDefs() { return VectorTransform.glslFunction; }
+    compileCall(ctx) {
+        const spaceMap = { WORLD: 0, OBJECT: 1, CAMERA: 2 };
+        const typeMap = { VECTOR: 0, POINT: 1, NORMAL: 2 };
+        const vec = ctx.resolveInput(this._inputs.vector);
+        return `vec3 ${ctx.outputVar(this, 'Vector')} = _st_vectorTransform(${vec}, ${spaceMap[this.fromSpace]}, ${spaceMap[this.toSpace]}, ${typeMap[this.vtype]});`;
+    }
+}
+VectorTransform.instanceSpecificDef = false;
+VectorTransform.glslFunction = `
+vec3 _st_vectorTransform(vec3 v, int fromSpace, int toSpace, int vtype) {
+  vec3 result = v;
+  // World to Object: multiply by inverse model matrix (approximated)
+  if (fromSpace == 0 && toSpace == 1) {
+    result = (vec4(v, 0.0) * modelMatrix).xyz;
+  } else if (fromSpace == 1 && toSpace == 0) {
+    result = (modelMatrix * vec4(v, 0.0)).xyz;
+  } else if (toSpace == 2) {
+    result = (viewMatrix * vec4(result, 0.0)).xyz;
+  } else if (fromSpace == 2) {
+    result = (inverse(viewMatrix) * vec4(v, 0.0)).xyz;
+  }
+  if (vtype == 2) result = normalize(result);
+  return result;
+}`;

package/dist/nodes/process/VolumeAbsorption.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 VolumeAbsorptionInputs {
+    color?: OutputSocket | string;
+    density?: OutputSocket | number;
+}
+/**
+ * Volume Absorption — Blender "Volume Absorption" shader node.
+ * Absorbs light as it passes through the volume.
+ * Connect to MaterialOutput.volume.
+ *
+ * Inputs:  color (color), density (float)
+ * Outputs: Volume (shader)
+ */
+export declare class VolumeAbsorption extends ProcessNode {
+    get nodeType(): string;
+    static instanceSpecificDef: boolean;
+    get metadata(): NodeMetadata;
+    static glslFunction: string;
+    private readonly _inputs;
+    private readonly _outputs;
+    constructor(inputs?: VolumeAbsorptionInputs);
+    getInputSockets(): Record<string, import("../../core/InputSocket.js").InputSocket<unknown>>;
+    getOutputSockets(): Record<string, OutputSocket>;
+    compileDefs(): string;
+    compileCall(ctx: CompileContext): string;
+}
+//# sourceMappingURL=VolumeAbsorption.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"VolumeAbsorption.d.ts","sourceRoot":"","sources":["../../../src/nodes/process/VolumeAbsorption.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,sBAAsB;IACrC,KAAK,CAAC,EAAI,YAAY,GAAG,MAAM,CAAA;IAC/B,OAAO,CAAC,EAAE,YAAY,GAAG,MAAM,CAAA;CAChC;AAED;;;;;;;GAOG;AACH,qBAAa,gBAAiB,SAAQ,WAAW;IAC/C,IAAI,QAAQ,WAAgC;IAC5C,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,sBAA2B;IAS/C,eAAe;IACf,gBAAgB;IAChB,WAAW;IAEX,WAAW,CAAC,GAAG,EAAE,cAAc,GAAG,MAAM;CAKzC"}

package/dist/nodes/process/VolumeAbsorption.js

@@ -0,0 +1,36 @@
+import { ProcessNode } from '../../core/ProcessNode.js';
+/**
+ * Volume Absorption — Blender "Volume Absorption" shader node.
+ * Absorbs light as it passes through the volume.
+ * Connect to MaterialOutput.volume.
+ *
+ * Inputs:  color (color), density (float)
+ * Outputs: Volume (shader)
+ */
+export class VolumeAbsorption extends ProcessNode {
+    get nodeType() { return 'VolumeAbsorption'; }
+    get metadata() {
+        return { label: 'Volume Absorption', category: 'Shader', color: '#2255aa', cost: 'low' };
+    }
+    constructor(inputs = {}) {
+        super('VolumeAbsorption');
+        this._inputs = this.createInputs(inputs, {
+            color: ['color', '#000000'],
+            density: ['float', inputs.density ?? 1.0],
+        });
+        this._outputs = this.createOutputs({ Volume: 'shader' });
+    }
+    getInputSockets() { return this._inputs; }
+    getOutputSockets() { return this._outputs; }
+    compileDefs() { return VolumeAbsorption.glslFunction; }
+    compileCall(ctx) {
+        const color = ctx.resolveInput(this._inputs.color);
+        const density = ctx.resolveInput(this._inputs.density);
+        return `vec3 ${ctx.outputVar(this, 'Volume')} = _st_volumeAbsorption(${color}, ${density});`;
+    }
+}
+VolumeAbsorption.instanceSpecificDef = false;
+VolumeAbsorption.glslFunction = `
+vec3 _st_volumeAbsorption(vec3 color, float density) {
+  return color * density;
+}`;

package/dist/nodes/process/VolumeScatter.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 VolumeScatterInputs {
+    color?: OutputSocket | string;
+    density?: OutputSocket | number;
+    anisotropy?: OutputSocket | number;
+}
+/**
+ * Volume Scatter — Blender "Volume Scatter" shader node.
+ * Scatters light inside the volume with Henyey-Greenstein phase function.
+ * Connect to MaterialOutput.volume.
+ *
+ * Inputs:  color (color), density (float), anisotropy (float, -1..1)
+ * Outputs: Volume (shader)
+ */
+export declare class VolumeScatter extends ProcessNode {
+    get nodeType(): string;
+    static instanceSpecificDef: boolean;
+    get metadata(): NodeMetadata;
+    static glslFunction: string;
+    private readonly _inputs;
+    private readonly _outputs;
+    constructor(inputs?: VolumeScatterInputs);
+    getInputSockets(): Record<string, import("../../core/InputSocket.js").InputSocket<unknown>>;
+    getOutputSockets(): Record<string, OutputSocket>;
+    compileDefs(): string;
+    compileCall(ctx: CompileContext): string;
+}
+//# sourceMappingURL=VolumeScatter.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"VolumeScatter.d.ts","sourceRoot":"","sources":["../../../src/nodes/process/VolumeScatter.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,mBAAmB;IAClC,KAAK,CAAC,EAAQ,YAAY,GAAG,MAAM,CAAA;IACnC,OAAO,CAAC,EAAM,YAAY,GAAG,MAAM,CAAA;IACnC,UAAU,CAAC,EAAG,YAAY,GAAG,MAAM,CAAA;CACpC;AAED;;;;;;;GAOG;AACH,qBAAa,aAAc,SAAQ,WAAW;IAC5C,IAAI,QAAQ,WAA6B;IACzC,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,mBAAwB;IAU5C,eAAe;IACf,gBAAgB;IAChB,WAAW;IAEX,WAAW,CAAC,GAAG,EAAE,cAAc,GAAG,MAAM;CAMzC"}