@triforge/shader-core 0.1.0

package/dist/nodes/input/Value.d.ts

@@ -0,0 +1,19 @@
+import { InputNode } from '../../core/InputNode.js';
+import type { NodeMetadata } from '../../core/ShaderNode.js';
+import type { CompileContext } from '../../core/CompileContext.js';
+/**
+ * Value — Blender "Value" input node equivalent.
+ * Outputs a single constant float.
+ *
+ * Outputs: Value (float)
+ */
+export declare class Value extends InputNode {
+    get nodeType(): string;
+    get metadata(): NodeMetadata;
+    private readonly val;
+    private readonly _outputs;
+    constructor(value?: number);
+    getOutputSockets(): Record<string, import("../../core/OutputSocket.js").OutputSocket>;
+    compileCall(ctx: CompileContext): string;
+}
+//# sourceMappingURL=Value.d.ts.map

package/dist/nodes/input/Value.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Value.d.ts","sourceRoot":"","sources":["../../../src/nodes/input/Value.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAA;AACnD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAA;AAC5D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAA;AAElE;;;;;GAKG;AACH,qBAAa,KAAM,SAAQ,SAAS;IAClC,IAAI,QAAQ,WAAqB;IAEjC,IAAI,QAAQ,IAAI,YAAY,CAE3B;IAED,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAQ;IAC5B,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAmE;gBAEhF,KAAK,GAAE,MAAY;IAM/B,gBAAgB;IAEhB,WAAW,CAAC,GAAG,EAAE,cAAc,GAAG,MAAM;CAGzC"}

package/dist/nodes/input/Value.js

@@ -0,0 +1,22 @@
+import { InputNode } from '../../core/InputNode.js';
+/**
+ * Value — Blender "Value" input node equivalent.
+ * Outputs a single constant float.
+ *
+ * Outputs: Value (float)
+ */
+export class Value extends InputNode {
+    get nodeType() { return 'Value'; }
+    get metadata() {
+        return { label: 'Value', category: 'Input', color: '#3d6b96', cost: 'low' };
+    }
+    constructor(value = 0.5) {
+        super('Value');
+        this.val = value;
+        this._outputs = this.createOutputs({ Value: 'float' });
+    }
+    getOutputSockets() { return this._outputs; }
+    compileCall(ctx) {
+        return `float ${ctx.outputVar(this, 'Value')} = ${this.val.toFixed(4)};`;
+    }
+}

package/dist/nodes/input/Wireframe.d.ts

@@ -0,0 +1,25 @@
+import { InputNode } from '../../core/InputNode.js';
+import type { NodeMetadata } from '../../core/ShaderNode.js';
+import type { CompileContext } from '../../core/CompileContext.js';
+/**
+ * Wireframe — Blender "Wireframe" input node equivalent.
+ * Produces a greyscale mask highlighting polygon edges.
+ * Uses screen-space derivatives for edge detection.
+ *
+ * Outputs:
+ *   Fac (float) — 1.0 on edges, 0.0 on face interior
+ */
+export declare class Wireframe extends InputNode {
+    get nodeType(): string;
+    get metadata(): NodeMetadata;
+    parameters: {
+        thickness: number;
+    };
+    private readonly _outputs;
+    constructor(inputs?: {
+        thickness?: number;
+    } | number);
+    getOutputSockets(): Record<string, import("../../core/OutputSocket.js").OutputSocket>;
+    compileCall(ctx: CompileContext): string;
+}
+//# sourceMappingURL=Wireframe.d.ts.map

package/dist/nodes/input/Wireframe.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Wireframe.d.ts","sourceRoot":"","sources":["../../../src/nodes/input/Wireframe.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAA;AACnD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAA;AAC5D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAA;AAElE;;;;;;;GAOG;AACH,qBAAa,SAAU,SAAQ,SAAS;IACtC,IAAI,QAAQ,WAAyB;IAErC,IAAI,QAAQ,IAAI,YAAY,CAE3B;IAED,UAAU,EAAE;QAAE,SAAS,EAAE,MAAM,CAAA;KAAE,CAAA;IACjC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAmE;gBAEhF,MAAM,GAAE;QAAE,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,MAAW;IAOxD,gBAAgB;IAEhB,WAAW,CAAC,GAAG,EAAE,cAAc,GAAG,MAAM;CAQzC"}

package/dist/nodes/input/Wireframe.js

@@ -0,0 +1,30 @@
+import { InputNode } from '../../core/InputNode.js';
+/**
+ * Wireframe — Blender "Wireframe" input node equivalent.
+ * Produces a greyscale mask highlighting polygon edges.
+ * Uses screen-space derivatives for edge detection.
+ *
+ * Outputs:
+ *   Fac (float) — 1.0 on edges, 0.0 on face interior
+ */
+export class Wireframe extends InputNode {
+    get nodeType() { return 'Wireframe'; }
+    get metadata() {
+        return { label: 'Wireframe', category: 'Input', color: '#3d6b96', cost: 'medium' };
+    }
+    constructor(inputs = {}) {
+        super('Wireframe');
+        const thickness = typeof inputs === 'number' ? inputs : (inputs.thickness ?? 0.01);
+        this.parameters = { thickness };
+        this._outputs = this.createOutputs({ Fac: 'float' });
+    }
+    getOutputSockets() { return this._outputs; }
+    compileCall(ctx) {
+        const t = this.parameters.thickness.toFixed(4);
+        return [
+            `vec3  _wf_bc_${this.id}  = vec3(vUv, 1.0 - vUv.x - vUv.y);`,
+            `float _wf_min_${this.id} = min(_wf_bc_${this.id}.x, min(_wf_bc_${this.id}.y, _wf_bc_${this.id}.z));`,
+            `float ${ctx.outputVar(this, 'Fac')} = 1.0 - smoothstep(${t} - 0.002, ${t} + 0.002, _wf_min_${this.id});`,
+        ].join('\n  ');
+    }
+}

package/dist/nodes/output/Displacement.d.ts

@@ -0,0 +1,28 @@
+import { OutputNode } from '../../core/OutputNode.js';
+import type { NodeMetadata } from '../../core/ShaderNode.js';
+import type { CompileContext } from '../../core/CompileContext.js';
+import type { OutputSocket } from '../../core/OutputSocket.js';
+import { InputSocket } from '../../core/InputSocket.js';
+export interface DisplacementInputs {
+    height?: OutputSocket;
+    midlevel?: OutputSocket | number;
+    scale?: OutputSocket | number;
+    normal?: OutputSocket;
+}
+/**
+ * Displacement — Blender "Displacement" vector output node.
+ * Feeds into MaterialOutput.displacement to control vertex offset.
+ * In real-time WebGL, displacement is baked into the vertex shader via normal perturbation.
+ *
+ * Inputs:  height (float), midlevel, scale, normal
+ * Outputs: Displacement (color/vec3)
+ */
+export declare class Displacement extends OutputNode {
+    get nodeType(): string;
+    get metadata(): NodeMetadata;
+    private readonly _inputs;
+    constructor(inputs?: DisplacementInputs);
+    getInputSockets(): Record<string, InputSocket<unknown>>;
+    compileCall(ctx: CompileContext): string;
+}
+//# sourceMappingURL=Displacement.d.ts.map

package/dist/nodes/output/Displacement.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Displacement.d.ts","sourceRoot":"","sources":["../../../src/nodes/output/Displacement.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAA;AACrD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAA;AAC5D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAA;AAClE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAA;AAC9D,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAA;AAEvD,MAAM,WAAW,kBAAkB;IACjC,MAAM,CAAC,EAAI,YAAY,CAAA;IACvB,QAAQ,CAAC,EAAE,YAAY,GAAG,MAAM,CAAA;IAChC,KAAK,CAAC,EAAK,YAAY,GAAG,MAAM,CAAA;IAChC,MAAM,CAAC,EAAI,YAAY,CAAA;CACxB;AAED;;;;;;;GAOG;AACH,qBAAa,YAAa,SAAQ,UAAU;IAC1C,IAAI,QAAQ,WAA4B;IAExC,IAAI,QAAQ,IAAI,YAAY,CAE3B;IAED,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAuC;gBAEnD,MAAM,GAAE,kBAAuB;IAU3C,eAAe;IAEf,WAAW,CAAC,GAAG,EAAE,cAAc,GAAG,MAAM;CASzC"}

package/dist/nodes/output/Displacement.js

@@ -0,0 +1,34 @@
+import { OutputNode } from '../../core/OutputNode.js';
+/**
+ * Displacement — Blender "Displacement" vector output node.
+ * Feeds into MaterialOutput.displacement to control vertex offset.
+ * In real-time WebGL, displacement is baked into the vertex shader via normal perturbation.
+ *
+ * Inputs:  height (float), midlevel, scale, normal
+ * Outputs: Displacement (color/vec3)
+ */
+export class Displacement extends OutputNode {
+    get nodeType() { return 'Displacement'; }
+    get metadata() {
+        return { label: 'Displacement', category: 'Vector', color: '#4a3a8a', cost: 'low' };
+    }
+    constructor(inputs = {}) {
+        super('Displacement');
+        this._inputs = this.createInputs(inputs, {
+            height: ['float', 0.0],
+            midlevel: ['float', inputs.midlevel ?? 0.5],
+            scale: ['float', inputs.scale ?? 1.0],
+            normal: ['color', null],
+        });
+    }
+    getInputSockets() { return this._inputs; }
+    compileCall(ctx) {
+        const height = ctx.resolveInput(this._inputs.height);
+        const midlevel = ctx.resolveInput(this._inputs.midlevel);
+        const scale = ctx.resolveInput(this._inputs.scale);
+        const normal = this._inputs.normal.isConnected()
+            ? ctx.outputVar(this._inputs.normal.connection.node, this._inputs.normal.connection.name)
+            : 'normalize(vNormal)';
+        return `vec3 _disp_${this.id} = ${normal} * (${height} - ${midlevel}) * ${scale};`;
+    }
+}

package/dist/nodes/output/MaterialOutput.d.ts

@@ -0,0 +1,43 @@
+import { OutputNode } from '../../core/OutputNode.js';
+import { MeshPhysicalMaterial, Texture } from 'three';
+import type { NodeMetadata } from '../../core/ShaderNode.js';
+import type { CompileContext } from '../../core/CompileContext.js';
+import type { OutputSocket } from '../../core/OutputSocket.js';
+export interface MaterialOutputInputs {
+    surface?: OutputSocket;
+    volume?: OutputSocket;
+    displacement?: OutputSocket;
+    thickness?: OutputSocket;
+}
+/**
+ * Material Output — Blender "Material Output" node equivalent.
+ * Terminal node. Call compile() to produce the final shader.
+ *
+ * Inputs:  surface (required), volume, displacement, thickness
+ */
+export declare class MaterialOutput extends OutputNode {
+    get nodeType(): string;
+    get metadata(): NodeMetadata;
+    private readonly _inputs;
+    constructor(inputs?: MaterialOutputInputs);
+    getInputSockets(): Record<string, import("../../core/InputSocket.js").InputSocket<unknown>>;
+    /**
+     * Converts the node graph to a THREE.MeshPhysicalMaterial for use with
+     * path-tracer renderers (three-gpu-pathtracer).
+     *
+     * Walks upstream from MaterialOutput.surface looking for a PrincipledBSDF
+     * (or Emission) node and maps its live parameters to MeshPhysicalMaterial
+     * properties. ImageTexture nodes connected to baseColor are wired as .map.
+     *
+     * For custom GLSL-heavy materials with no compatible BSDF root, the method
+     * returns a neutral grey MeshPhysicalMaterial as a fallback.
+     *
+     * @example
+     * const mat = new MaterialOutput({ surface: bsdf.output('BSDF') })
+     * mat.compile()                      // rasterizer ShaderMaterial
+     * const ptMat = mat.toPhysicalMaterial()  // path-tracer MeshPhysicalMaterial
+     */
+    toPhysicalMaterial(extraUniforms?: Record<string, Texture>): MeshPhysicalMaterial;
+    compileCall(ctx: CompileContext): string;
+}
+//# sourceMappingURL=MaterialOutput.d.ts.map

package/dist/nodes/output/MaterialOutput.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MaterialOutput.d.ts","sourceRoot":"","sources":["../../../src/nodes/output/MaterialOutput.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAA;AAGrD,OAAO,EAAE,oBAAoB,EAAS,OAAO,EAAE,MAAM,OAAO,CAAA;AAC5D,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,OAAO,CAAC,EAAO,YAAY,CAAA;IAC3B,MAAM,CAAC,EAAQ,YAAY,CAAA;IAC3B,YAAY,CAAC,EAAE,YAAY,CAAA;IAC3B,SAAS,CAAC,EAAK,YAAY,CAAA;CAC5B;AAED;;;;;GAKG;AACH,qBAAa,cAAe,SAAQ,UAAU;IAC5C,IAAI,QAAQ,WAA8B;IAE1C,IAAI,QAAQ,IAAI,YAAY,CAE3B;IAED,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA0E;gBAEtF,MAAM,GAAE,oBAAyB;IAoB7C,eAAe;IAEf;;;;;;;;;;;;;;;OAeG;IACH,kBAAkB,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,oBAAoB;IAmEjF,WAAW,CAAC,GAAG,EAAE,cAAc,GAAG,MAAM;CAMzC"}

package/dist/nodes/output/MaterialOutput.js

@@ -0,0 +1,118 @@
+import { OutputNode } from '../../core/OutputNode.js';
+import { ShaderNodeError } from '../../core/ShaderNodeError.js';
+import { ShaderConfig } from '../../core/ShaderConfig.js';
+import { MeshPhysicalMaterial, Color, Texture } from 'three';
+/**
+ * Material Output — Blender "Material Output" node equivalent.
+ * Terminal node. Call compile() to produce the final shader.
+ *
+ * Inputs:  surface (required), volume, displacement, thickness
+ */
+export class MaterialOutput extends OutputNode {
+    get nodeType() { return 'MaterialOutput'; }
+    get metadata() {
+        return { label: 'Material Output', category: 'Output', color: '#a06030', cost: 'low' };
+    }
+    constructor(inputs = {}) {
+        super('MaterialOutput');
+        this._inputs = this.createInputs(inputs, {
+            surface: ['shader', null, true],
+            volume: ['shader', null],
+            displacement: ['vector', null],
+            thickness: ['float', 0.0],
+        });
+        if (ShaderConfig.errorLevel !== 'off' && !this._inputs.surface.isConnected()) {
+            ShaderNodeError.throw({
+                nodeType: this.nodeType,
+                nodeId: this.id,
+                inputName: 'surface',
+                problem: 'Required input "surface" has no connection.',
+                fix: 'new MaterialOutput({ surface: bsdf.output("BSDF") })',
+            });
+        }
+    }
+    getInputSockets() { return this._inputs; }
+    /**
+     * Converts the node graph to a THREE.MeshPhysicalMaterial for use with
+     * path-tracer renderers (three-gpu-pathtracer).
+     *
+     * Walks upstream from MaterialOutput.surface looking for a PrincipledBSDF
+     * (or Emission) node and maps its live parameters to MeshPhysicalMaterial
+     * properties. ImageTexture nodes connected to baseColor are wired as .map.
+     *
+     * For custom GLSL-heavy materials with no compatible BSDF root, the method
+     * returns a neutral grey MeshPhysicalMaterial as a fallback.
+     *
+     * @example
+     * const mat = new MaterialOutput({ surface: bsdf.output('BSDF') })
+     * mat.compile()                      // rasterizer ShaderMaterial
+     * const ptMat = mat.toPhysicalMaterial()  // path-tracer MeshPhysicalMaterial
+     */
+    toPhysicalMaterial(extraUniforms) {
+        const surfaceSocket = this._inputs.surface;
+        if (!surfaceSocket.isConnected()) {
+            return new MeshPhysicalMaterial({ color: 0x888888, roughness: 0.5 });
+        }
+        const bsdfNode = surfaceSocket.connection.node;
+        const nodeType = bsdfNode.nodeType;
+        const p = bsdfNode.parameters;
+        // Helper: extract a Color from a parameter (may be [r,g,b] or a hex number)
+        const toColor = (key, fallback = '#ffffff') => {
+            const v = p[key];
+            if (Array.isArray(v))
+                return new Color(v[0], v[1], v[2]);
+            if (typeof v === 'number')
+                return new Color(v, v, v);
+            return new Color(fallback);
+        };
+        const toFloat = (key, fallback) => {
+            const v = p[key];
+            return typeof v === 'number' ? v : fallback;
+        };
+        // Check if baseColor input is wired to an ImageTexture
+        const bsdfInputs = bsdfNode.getInputSockets();
+        let map = null;
+        if (bsdfInputs.baseColor?.isConnected()) {
+            const upstream = bsdfInputs.baseColor.connection.node;
+            if (upstream.nodeType === 'ImageTexture') {
+                const uniformName = upstream.uniformName;
+                if (extraUniforms?.[uniformName] instanceof Texture) {
+                    map = extraUniforms[uniformName];
+                }
+            }
+        }
+        if (nodeType === 'Emission') {
+            return new MeshPhysicalMaterial({
+                emissive: toColor('color'),
+                emissiveIntensity: toFloat('strength', 1.0),
+                roughness: 1.0,
+                metalness: 0.0,
+            });
+        }
+        // PrincipledBSDF, GlossyBSDF, DiffuseBSDF, GlassBSDF, RefractionBSDF
+        const isGlass = nodeType === 'GlassBSDF' || nodeType === 'RefractionBSDF';
+        const alpha = toFloat('alpha', 1.0);
+        const matParams = {
+            color: map ? 0xffffff : toColor('baseColor'),
+            metalness: toFloat('metallic', 0.0),
+            roughness: toFloat('roughness', 0.5),
+            ior: toFloat('ior', 1.5),
+            opacity: alpha,
+            transparent: alpha < 1.0 || isGlass,
+        };
+        if (map)
+            matParams.map = map;
+        const mat = new MeshPhysicalMaterial(matParams);
+        if (nodeType === 'GlassBSDF' || nodeType === 'RefractionBSDF') {
+            mat.transmission = 1.0;
+            mat.thickness = 0.5;
+        }
+        return mat;
+    }
+    compileCall(ctx) {
+        const sv = this._inputs.surface.isConnected()
+            ? ctx.outputVar(this._inputs.surface.connection.node, this._inputs.surface.connection.name)
+            : 'vec3(0.8)';
+        return `gl_FragColor = vec4(${sv}, 1.0);`;
+    }
+}

package/dist/nodes/output/ScreenOutput.d.ts

@@ -0,0 +1,38 @@
+import { OutputNode } from '../../core/OutputNode.js';
+import { CompileContext } from '../../core/CompileContext.js';
+import { ShaderMaterial, Mesh } from 'three';
+import type { PerspectiveCamera } from 'three';
+import type { OutputSocket } from '../../core/OutputSocket.js';
+import type { NodeMetadata } from '../../core/ShaderNode.js';
+/**
+ * ScreenOutput — renders a node graph to a fullscreen quad.
+ *
+ * After compile():
+ *   scene.add(out.mesh)                          — add to scene
+ *   out.updateCamera(camera, w, h)               — call each frame
+ *   renderer.render(scene, camera)               — renders the shader
+ *
+ * @example
+ * const cam   = new ScreenCamera()
+ * const march = new SchwarzschildMarch({ rayPos: cam.output('RayPos'), rayDir: cam.output('RayDir') })
+ * const out   = new ScreenOutput({ color: march.output('Color') })
+ * out.compile()
+ * scene.add(out.mesh)
+ * // in loop: out.updateCamera(camera, innerWidth, innerHeight)
+ */
+export declare class ScreenOutput extends OutputNode {
+    get nodeType(): string;
+    get metadata(): NodeMetadata;
+    mesh: Mesh | null;
+    private readonly _inputs;
+    constructor(inputs?: {
+        color?: OutputSocket;
+    });
+    getInputSockets(): Record<string, import("../../core/InputSocket.js").InputSocket<unknown>>;
+    compileDefs(): string;
+    compileCall(ctx: CompileContext): string;
+    compile(): ShaderMaterial;
+    /** Sync Three.js camera → shader uniforms. Call once per frame. */
+    updateCamera(camera: PerspectiveCamera, width: number, height: number): void;
+}
+//# sourceMappingURL=ScreenOutput.d.ts.map

package/dist/nodes/output/ScreenOutput.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ScreenOutput.d.ts","sourceRoot":"","sources":["../../../src/nodes/output/ScreenOutput.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAS,0BAA0B,CAAA;AACxD,OAAO,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAA;AAC7D,OAAO,EAAE,cAAc,EAAE,IAAI,EAAmC,MAAM,OAAO,CAAA;AAC7E,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,OAAO,CAAA;AAC9C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAW,4BAA4B,CAAA;AACnE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAW,0BAA0B,CAAA;AAEjE;;;;;;;;;;;;;;;GAeG;AACH,qBAAa,YAAa,SAAQ,UAAU;IAC1C,IAAI,QAAQ,WAA4B;IAExC,IAAI,QAAQ,IAAI,YAAY,CAE3B;IAED,IAAI,EAAE,IAAI,GAAG,IAAI,CAAO;IAExB,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA0E;gBAEtF,MAAM,GAAE;QAAE,KAAK,CAAC,EAAE,YAAY,CAAA;KAAO;IAOjD,eAAe;IACf,WAAW,IAAO,MAAM;IAExB,WAAW,CAAC,GAAG,EAAE,cAAc,GAAG,MAAM;IAOxC,OAAO,IAAI,cAAc;IA4CzB,mEAAmE;IACnE,YAAY,CAAC,MAAM,EAAE,iBAAiB,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI;CAW7E"}

package/dist/nodes/output/ScreenOutput.js

@@ -0,0 +1,88 @@
+import { OutputNode } from '../../core/OutputNode.js';
+import { CompileContext } from '../../core/CompileContext.js';
+import { ShaderMaterial, Mesh, PlaneGeometry, Vector2, Vector3 } from 'three';
+/**
+ * ScreenOutput — renders a node graph to a fullscreen quad.
+ *
+ * After compile():
+ *   scene.add(out.mesh)                          — add to scene
+ *   out.updateCamera(camera, w, h)               — call each frame
+ *   renderer.render(scene, camera)               — renders the shader
+ *
+ * @example
+ * const cam   = new ScreenCamera()
+ * const march = new SchwarzschildMarch({ rayPos: cam.output('RayPos'), rayDir: cam.output('RayDir') })
+ * const out   = new ScreenOutput({ color: march.output('Color') })
+ * out.compile()
+ * scene.add(out.mesh)
+ * // in loop: out.updateCamera(camera, innerWidth, innerHeight)
+ */
+export class ScreenOutput extends OutputNode {
+    get nodeType() { return 'ScreenOutput'; }
+    get metadata() {
+        return { label: 'Screen Output', category: 'Output', color: '#a06030', cost: 'low' };
+    }
+    constructor(inputs = {}) {
+        super('ScreenOutput');
+        this.mesh = null;
+        this._inputs = this.createInputs(inputs, {
+            color: ['color', null, true],
+        });
+    }
+    getInputSockets() { return this._inputs; }
+    compileDefs() { return ''; }
+    compileCall(ctx) {
+        const cv = this._inputs.color.isConnected()
+            ? ctx.outputVar(this._inputs.color.connection.node, this._inputs.color.connection.name)
+            : 'vec3(0.5)';
+        return `gl_FragColor = vec4(${cv}, 1.0);`;
+    }
+    compile() {
+        const ctx = new CompileContext();
+        const compiled = ctx.compile(this);
+        const vertexShader = `
+varying vec2 vUv;
+varying vec3 vNormal;
+varying vec3 vPosition;
+void main() {
+  vUv       = uv;
+  vNormal   = normal;
+  vPosition = position;
+  gl_Position = vec4(position, 1.0);
+}`.trim();
+        const camUniforms = {
+            uSCResolution: { value: new Vector2(typeof innerWidth !== 'undefined' ? innerWidth : 800, typeof innerHeight !== 'undefined' ? innerHeight : 600) },
+            uSCCamPos: { value: new Vector3() },
+            uSCCamRight: { value: new Vector3(1, 0, 0) },
+            uSCCamUp: { value: new Vector3(0, 1, 0) },
+            uSCCamFwd: { value: new Vector3(0, 0, -1) },
+            uSCFov: { value: 1.0 },
+        };
+        this.material = new ShaderMaterial({
+            vertexShader,
+            fragmentShader: compiled.fragmentShader,
+            uniforms: { ...compiled.uniforms, ...camUniforms },
+            depthTest: false,
+            depthWrite: false,
+        });
+        for (const node of compiled.nodes)
+            node._wireParameters(this.material.uniforms);
+        this.mesh = new Mesh(new PlaneGeometry(2, 2), this.material);
+        this.mesh.frustumCulled = false;
+        this.mesh.renderOrder = -1;
+        return this.material;
+    }
+    /** Sync Three.js camera → shader uniforms. Call once per frame. */
+    updateCamera(camera, width, height) {
+        if (!this.material)
+            return;
+        const m = camera.matrixWorld;
+        const u = this.material.uniforms;
+        u.uSCResolution.value.set(width, height);
+        u.uSCCamPos.value.setFromMatrixPosition(m);
+        u.uSCCamRight.value.setFromMatrixColumn(m, 0);
+        u.uSCCamUp.value.setFromMatrixColumn(m, 1);
+        u.uSCCamFwd.value.setFromMatrixColumn(m, 2).negate();
+        u.uSCFov.value = Math.tan((camera.fov * Math.PI / 180) / 2);
+    }
+}

package/dist/nodes/process/AddShader.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 AddShaderInputs {
+    shader1?: OutputSocket;
+    shader2?: OutputSocket;
+}
+/**
+ * Add Shader — Blender "Add Shader" node equivalent.
+ * Adds two shader outputs together (unlike MixShader which blends).
+ * Useful for combining emission on top of a surface shader.
+ *
+ * Inputs:  shader1 (shader), shader2 (shader)
+ * Outputs: BSDF (shader)
+ */
+export declare class AddShader extends ProcessNode {
+    get nodeType(): string;
+    static instanceSpecificDef: boolean;
+    get metadata(): NodeMetadata;
+    static glslFunction: string;
+    private readonly _inputs;
+    private readonly _outputs;
+    constructor(inputs?: AddShaderInputs);
+    getInputSockets(): Record<string, import("../../core/InputSocket.js").InputSocket<unknown>>;
+    getOutputSockets(): Record<string, OutputSocket>;
+    compileDefs(): string;
+    compileCall(ctx: CompileContext): string;
+}
+//# sourceMappingURL=AddShader.d.ts.map

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

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

package/dist/nodes/process/AddShader.js

@@ -0,0 +1,36 @@
+import { ProcessNode } from '../../core/ProcessNode.js';
+/**
+ * Add Shader — Blender "Add Shader" node equivalent.
+ * Adds two shader outputs together (unlike MixShader which blends).
+ * Useful for combining emission on top of a surface shader.
+ *
+ * Inputs:  shader1 (shader), shader2 (shader)
+ * Outputs: BSDF (shader)
+ */
+export class AddShader extends ProcessNode {
+    get nodeType() { return 'AddShader'; }
+    get metadata() {
+        return { label: 'Add Shader', category: 'Shader', color: '#336699', cost: 'low' };
+    }
+    constructor(inputs = {}) {
+        super('AddShader');
+        this._inputs = this.createInputs(inputs, {
+            shader1: ['shader', null],
+            shader2: ['shader', null],
+        });
+        this._outputs = this.createOutputs({ BSDF: 'shader' });
+    }
+    getInputSockets() { return this._inputs; }
+    getOutputSockets() { return this._outputs; }
+    compileDefs() { return AddShader.glslFunction; }
+    compileCall(ctx) {
+        const s1 = ctx.resolveInput(this._inputs.shader1);
+        const s2 = ctx.resolveInput(this._inputs.shader2);
+        return `vec3 ${ctx.outputVar(this, 'BSDF')} = _st_addShader(${s1}, ${s2});`;
+    }
+}
+AddShader.instanceSpecificDef = false;
+AddShader.glslFunction = `
+vec3 _st_addShader(vec3 a, vec3 b) {
+  return a + b;
+}`;

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

@@ -0,0 +1,39 @@
+import { ProcessNode } from '../../core/ProcessNode.js';
+import type { NodeMetadata } from '../../core/ShaderNode.js';
+import type { CompileContext } from '../../core/CompileContext.js';
+import type { OutputSocket } from '../../core/OutputSocket.js';
+export interface AnimatedNoiseTextureInputs {
+    vector?: OutputSocket;
+    scale?: number | OutputSocket;
+    detail?: number | OutputSocket;
+    roughness?: number | OutputSocket;
+    distortion?: number | OutputSocket;
+    speed?: number;
+}
+/**
+ * Animated Noise Texture — time-animated extension of NoiseTexture.
+ * Uses four scrolling noise layers for realistic wave-like movement.
+ * Injects a `time` uniform into the compiled ShaderMaterial automatically.
+ *
+ * Inputs:  vector, scale, detail, roughness, distortion, speed
+ * Outputs: Fac (float), Color (color)
+ *
+ * Usage:
+ *   const noise = new AnimatedNoiseTexture({ scale: 5.0, speed: 1.0 })
+ *   // After mat.compile(), time updates via: mat.material.uniforms.time.value = t
+ */
+export declare class AnimatedNoiseTexture extends ProcessNode {
+    get nodeType(): string;
+    static instanceSpecificDef: boolean;
+    get metadata(): NodeMetadata;
+    static glslFunction: string;
+    private readonly _inputs;
+    private readonly _outputs;
+    private readonly speed;
+    constructor(inputs?: AnimatedNoiseTextureInputs);
+    getInputSockets(): Record<string, import("../../core/InputSocket.js").InputSocket<unknown>>;
+    getOutputSockets(): Record<string, OutputSocket>;
+    compileDefs(): string;
+    compileCall(ctx: CompileContext): string;
+}
+//# sourceMappingURL=AnimatedNoiseTexture.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"AnimatedNoiseTexture.d.ts","sourceRoot":"","sources":["../../../src/nodes/process/AnimatedNoiseTexture.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,0BAA0B;IACzC,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,KAAK,CAAC,EAAO,MAAM,CAAA;CACpB;AAED;;;;;;;;;;;GAWG;AACH,qBAAa,oBAAqB,SAAQ,WAAW;IACnD,IAAI,QAAQ,WAAoC;IAChD,MAAM,CAAC,mBAAmB,UAAQ;IAElC,IAAI,QAAQ,IAAI,YAAY,CAQ3B;IAED,MAAM,CAAC,YAAY,SAuCnB;IAEA,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA2E;IACnG,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAmE;IAC5F,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAW;gBAErB,MAAM,GAAE,0BAA+B;IAanD,eAAe;IACf,gBAAgB;IAChB,WAAW;IAEX,WAAW,CAAC,GAAG,EAAE,cAAc,GAAG,MAAM;CAYzC"}