@triforge/shader-core 0.1.0

package/dist/nodes/input/LightPath.js

@@ -0,0 +1,112 @@
+import { InputNode } from '../../core/InputNode.js';
+/**
+ * Light Path — Blender "Light Path" input node equivalent.
+ *
+ * Outputs the ray type currently being rendered, driven by externally-set
+ * uniforms. In rasterizer mode the uniforms default to camera-ray values
+ * (Is Camera Ray = 1, all others = 0).
+ *
+ * To drive a full multi-pass render where shadow/bounce contributions are
+ * separated, use LightPathController from @st-pathtracer-core, which sets
+ * these uniforms before each render pass.
+ *
+ * Uniform names are available on LightPath.U for external use.
+ *
+ * Outputs (all float):
+ *   Is Camera Ray, Is Shadow Ray, Is Diffuse Ray, Is Glossy Ray,
+ *   Is Singular Ray, Is Reflection Ray, Is Transmission Ray,
+ *   Ray Length, Ray Depth, Diffuse Depth, Glossy Depth,
+ *   Shadow Depth, Transparent Depth, Transmission Depth
+ */
+export class LightPath extends InputNode {
+    get nodeType() { return 'LightPath'; }
+    get metadata() {
+        return { label: 'Light Path', category: 'Input', color: '#5a3d7a', cost: 'low' };
+    }
+    constructor() {
+        super('LightPath');
+        this.parameters = {};
+        this._outputs = this.createOutputs({
+            'Is Camera Ray': 'float',
+            'Is Shadow Ray': 'float',
+            'Is Diffuse Ray': 'float',
+            'Is Glossy Ray': 'float',
+            'Is Singular Ray': 'float',
+            'Is Reflection Ray': 'float',
+            'Is Transmission Ray': 'float',
+            'Ray Length': 'float',
+            'Ray Depth': 'float',
+            'Diffuse Depth': 'float',
+            'Glossy Depth': 'float',
+            'Shadow Depth': 'float',
+            'Transparent Depth': 'float',
+            'Transmission Depth': 'float',
+        });
+    }
+    getOutputSockets() { return this._outputs; }
+    /**
+     * Register all LightPath uniforms with their rasterizer defaults.
+     * CompileContext picks these up and includes them in the compiled
+     * material's uniforms object so LightPathController can set them.
+     * Default: Is Camera Ray = 1.0, all others = 0.0.
+     */
+    extraUniforms() {
+        const U = LightPath.U;
+        return {
+            [U.isCamera]: 1.0,
+            [U.isShadow]: 0.0,
+            [U.isDiffuse]: 0.0,
+            [U.isGlossy]: 0.0,
+            [U.isSingular]: 0.0,
+            [U.isReflection]: 0.0,
+            [U.isTransmission]: 0.0,
+            [U.rayLength]: 0.0,
+            [U.rayDepth]: 0.0,
+            [U.diffuseDepth]: 0.0,
+            [U.glossyDepth]: 0.0,
+            [U.shadowDepth]: 0.0,
+            [U.transparentDepth]: 0.0,
+            [U.transmissionDepth]: 0.0,
+        };
+    }
+    compileDefs() { return ''; }
+    compileCall(ctx) {
+        const U = LightPath.U;
+        return [
+            `float ${ctx.outputVar(this, 'Is Camera Ray')}       = ${U.isCamera};`,
+            `float ${ctx.outputVar(this, 'Is Shadow Ray')}       = ${U.isShadow};`,
+            `float ${ctx.outputVar(this, 'Is Diffuse Ray')}      = ${U.isDiffuse};`,
+            `float ${ctx.outputVar(this, 'Is Glossy Ray')}       = ${U.isGlossy};`,
+            `float ${ctx.outputVar(this, 'Is Singular Ray')}     = ${U.isSingular};`,
+            `float ${ctx.outputVar(this, 'Is Reflection Ray')}   = ${U.isReflection};`,
+            `float ${ctx.outputVar(this, 'Is Transmission Ray')} = ${U.isTransmission};`,
+            `float ${ctx.outputVar(this, 'Ray Length')}          = ${U.rayLength};`,
+            `float ${ctx.outputVar(this, 'Ray Depth')}           = ${U.rayDepth};`,
+            `float ${ctx.outputVar(this, 'Diffuse Depth')}       = ${U.diffuseDepth};`,
+            `float ${ctx.outputVar(this, 'Glossy Depth')}        = ${U.glossyDepth};`,
+            `float ${ctx.outputVar(this, 'Shadow Depth')}        = ${U.shadowDepth};`,
+            `float ${ctx.outputVar(this, 'Transparent Depth')}   = ${U.transparentDepth};`,
+            `float ${ctx.outputVar(this, 'Transmission Depth')}  = ${U.transmissionDepth};`,
+        ].join('\n  ');
+    }
+}
+/**
+ * Canonical uniform names used by LightPath.
+ * LightPathController sets these on the compiled ShaderMaterial.
+ */
+LightPath.U = {
+    isCamera: 'u_st_lp_isCamera',
+    isShadow: 'u_st_lp_isShadow',
+    isDiffuse: 'u_st_lp_isDiffuse',
+    isGlossy: 'u_st_lp_isGlossy',
+    isSingular: 'u_st_lp_isSingular',
+    isReflection: 'u_st_lp_isReflection',
+    isTransmission: 'u_st_lp_isTransmission',
+    rayLength: 'u_st_lp_rayLength',
+    rayDepth: 'u_st_lp_rayDepth',
+    diffuseDepth: 'u_st_lp_diffuseDepth',
+    glossyDepth: 'u_st_lp_glossyDepth',
+    shadowDepth: 'u_st_lp_shadowDepth',
+    transparentDepth: 'u_st_lp_transparentDepth',
+    transmissionDepth: 'u_st_lp_transmissionDepth',
+};

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

@@ -0,0 +1,22 @@
+import { InputNode } from '../../core/InputNode.js';
+import type { NodeMetadata } from '../../core/ShaderNode.js';
+import type { CompileContext } from '../../core/CompileContext.js';
+/**
+ * Object Info — Blender "Object Info" node equivalent.
+ * Provides per-object random and index values for procedural variation across instances.
+ *
+ * Outputs: Random (float), ObjectIndex (float), MaterialIndex (float)
+ *
+ * Random is seeded per-node-instance so two ObjectInfo nodes in the same graph
+ * produce independent random values — useful for layering variation.
+ */
+export declare class ObjectInfo extends InputNode {
+    get nodeType(): string;
+    get metadata(): NodeMetadata;
+    private readonly _outputs;
+    private readonly _seed;
+    constructor();
+    getOutputSockets(): Record<string, import("../../core/OutputSocket.js").OutputSocket>;
+    compileCall(ctx: CompileContext): string;
+}
+//# sourceMappingURL=ObjectInfo.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ObjectInfo.d.ts","sourceRoot":"","sources":["../../../src/nodes/input/ObjectInfo.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;;;;;;;;GAQG;AACH,qBAAa,UAAW,SAAQ,SAAS;IACvC,IAAI,QAAQ,WAA0B;IAEtC,IAAI,QAAQ,IAAI,YAAY,CAE3B;IAED,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAmE;IAC5F,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAW;;IAcjC,gBAAgB;IAEhB,WAAW,CAAC,GAAG,EAAE,cAAc,GAAG,MAAM;CAazC"}

package/dist/nodes/input/ObjectInfo.js

@@ -0,0 +1,41 @@
+import { InputNode } from '../../core/InputNode.js';
+/**
+ * Object Info — Blender "Object Info" node equivalent.
+ * Provides per-object random and index values for procedural variation across instances.
+ *
+ * Outputs: Random (float), ObjectIndex (float), MaterialIndex (float)
+ *
+ * Random is seeded per-node-instance so two ObjectInfo nodes in the same graph
+ * produce independent random values — useful for layering variation.
+ */
+export class ObjectInfo extends InputNode {
+    get nodeType() { return 'ObjectInfo'; }
+    get metadata() {
+        return { label: 'Object Info', category: 'Input', color: '#3d6b96', cost: 'low' };
+    }
+    constructor() {
+        super('ObjectInfo');
+        // Each instance gets a unique seed so multiple ObjectInfo nodes in one graph
+        // produce independent random outputs
+        this._seed = Math.random();
+        this._outputs = this.createOutputs({
+            Random: 'float',
+            ObjectIndex: 'float',
+            MaterialIndex: 'float',
+        });
+    }
+    getOutputSockets() { return this._outputs; }
+    compileCall(ctx) {
+        const rv = ctx.outputVar(this, 'Random');
+        const oiv = ctx.outputVar(this, 'ObjectIndex');
+        const miv = ctx.outputVar(this, 'MaterialIndex');
+        // Hash world position to produce a stable per-object random value.
+        // floor() snaps to object origin so all fragments of the same object get the same value.
+        return [
+            `vec3  _oi_origin_${this.id} = floor(vPosition * 0.01) * 100.0;`,
+            `float ${rv}  = fract(sin(dot(_oi_origin_${this.id}, vec3(127.1, 311.7, 74.7)) + ${this._seed.toFixed(6)}) * 43758.5453);`,
+            `float ${oiv} = floor(${rv} * 255.0);`,
+            `float ${miv} = floor(fract(${rv} * 17.0) * 255.0);`,
+        ].join('\n  ');
+    }
+}

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

@@ -0,0 +1,32 @@
+import { InputNode } from '../../core/InputNode.js';
+import type { NodeMetadata } from '../../core/ShaderNode.js';
+import type { CompileContext } from '../../core/CompileContext.js';
+/**
+ * Ocean Attribute — Blender "Attribute" node reading the "Ocean" foam data layer.
+ *
+ * Reads the `foam` Float32BufferAttribute written by OceanModifier and passes it
+ * from the vertex shader to the fragment shader via a varying.
+ *
+ * Outputs:
+ *   Fac   (float) — raw foam value [0, 1]. 0 = calm water, 1 = breaking wave.
+ *   Color (color) — vec3(fac, fac, fac) for use in color/emission nodes.
+ *
+ * Usage matches Blender's Attribute node with Data Layer set to "Ocean":
+ *   const ocean = new OceanAttribute()
+ *   const ramp  = new ColorRamp({ fac: ocean.output('Fac'), stops: ['#000000', '#ffffff'] })
+ *   // white where foam, dark where calm
+ */
+export declare class OceanAttribute extends InputNode {
+    get nodeType(): string;
+    get metadata(): NodeMetadata;
+    private readonly _outputs;
+    constructor();
+    getOutputSockets(): Record<string, import("../../core/OutputSocket.js").OutputSocket>;
+    vertexInjections(): {
+        attrName: string;
+        attrType: "float";
+        varyingName: string;
+    }[];
+    compileCall(ctx: CompileContext): string;
+}
+//# sourceMappingURL=OceanAttribute.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"OceanAttribute.d.ts","sourceRoot":"","sources":["../../../src/nodes/input/OceanAttribute.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;;;;;;;;;;;;;;GAcG;AACH,qBAAa,cAAe,SAAQ,SAAS;IAC3C,IAAI,QAAQ,WAA8B;IAE1C,IAAI,QAAQ,IAAI,YAAY,CAE3B;IAED,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAmE;;IAO5F,gBAAgB;IAEhB,gBAAgB;;;;;IAIhB,WAAW,CAAC,GAAG,EAAE,cAAc,GAAG,MAAM;CAQzC"}

package/dist/nodes/input/OceanAttribute.js

@@ -0,0 +1,38 @@
+import { InputNode } from '../../core/InputNode.js';
+/**
+ * Ocean Attribute — Blender "Attribute" node reading the "Ocean" foam data layer.
+ *
+ * Reads the `foam` Float32BufferAttribute written by OceanModifier and passes it
+ * from the vertex shader to the fragment shader via a varying.
+ *
+ * Outputs:
+ *   Fac   (float) — raw foam value [0, 1]. 0 = calm water, 1 = breaking wave.
+ *   Color (color) — vec3(fac, fac, fac) for use in color/emission nodes.
+ *
+ * Usage matches Blender's Attribute node with Data Layer set to "Ocean":
+ *   const ocean = new OceanAttribute()
+ *   const ramp  = new ColorRamp({ fac: ocean.output('Fac'), stops: ['#000000', '#ffffff'] })
+ *   // white where foam, dark where calm
+ */
+export class OceanAttribute extends InputNode {
+    get nodeType() { return 'OceanAttribute'; }
+    get metadata() {
+        return { label: 'Ocean Attribute', category: 'Input', color: '#1a4a6b', cost: 'low' };
+    }
+    constructor() {
+        super('OceanAttribute');
+        this._outputs = this.createOutputs({ Fac: 'float', Color: 'color' });
+    }
+    getOutputSockets() { return this._outputs; }
+    vertexInjections() {
+        return [{ attrName: 'foam', attrType: 'float', varyingName: 'vFoam' }];
+    }
+    compileCall(ctx) {
+        const fv = ctx.outputVar(this, 'Fac');
+        const cv = ctx.outputVar(this, 'Color');
+        return [
+            `float ${fv} = clamp(vFoam, 0.0, 1.0);`,
+            `vec3  ${cv} = vec3(${fv});`,
+        ].join('\n  ');
+    }
+}

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

@@ -0,0 +1,31 @@
+import { InputNode } from '../../core/InputNode.js';
+import type { NodeMetadata } from '../../core/ShaderNode.js';
+import type { CompileContext } from '../../core/CompileContext.js';
+/**
+ * Particle Info — Blender "Particle Info" input node equivalent.
+ * Reads per-particle data written into vertex attributes by particle renderers.
+ *
+ * Geometry requirements (from st-particle-core BillboardRenderer / InstanceRenderer):
+ *   attribute float particleIndex   — particle index in pool [0, N)
+ *   attribute float particleAge     — normalised age [0, 1]
+ *   attribute float particleRandom  — per-particle stable random value [0, 1]
+ *
+ * Outputs:
+ *   Index  (float) — particle index (normalised to [0, 1] via index/count)
+ *   Age    (float) — normalised lifetime: 0 = just born, 1 = about to die
+ *   Random (float) — per-particle stable random value in [0, 1]
+ */
+export declare class ParticleInfo extends InputNode {
+    get nodeType(): string;
+    get metadata(): NodeMetadata;
+    private readonly _outputs;
+    constructor();
+    getOutputSockets(): Record<string, import("../../core/OutputSocket.js").OutputSocket>;
+    vertexInjections(): {
+        attrName: string;
+        attrType: "float";
+        varyingName: string;
+    }[];
+    compileCall(ctx: CompileContext): string;
+}
+//# sourceMappingURL=ParticleInfo.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ParticleInfo.d.ts","sourceRoot":"","sources":["../../../src/nodes/input/ParticleInfo.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;;;;;;;;;;;;;GAaG;AACH,qBAAa,YAAa,SAAQ,SAAS;IACzC,IAAI,QAAQ,WAA4B;IAExC,IAAI,QAAQ,IAAI,YAAY,CAE3B;IAED,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAmE;;IAW5F,gBAAgB;IAEhB,gBAAgB;;;;;IAQhB,WAAW,CAAC,GAAG,EAAE,cAAc,GAAG,MAAM;CAOzC"}

package/dist/nodes/input/ParticleInfo.js

@@ -0,0 +1,44 @@
+import { InputNode } from '../../core/InputNode.js';
+/**
+ * Particle Info — Blender "Particle Info" input node equivalent.
+ * Reads per-particle data written into vertex attributes by particle renderers.
+ *
+ * Geometry requirements (from st-particle-core BillboardRenderer / InstanceRenderer):
+ *   attribute float particleIndex   — particle index in pool [0, N)
+ *   attribute float particleAge     — normalised age [0, 1]
+ *   attribute float particleRandom  — per-particle stable random value [0, 1]
+ *
+ * Outputs:
+ *   Index  (float) — particle index (normalised to [0, 1] via index/count)
+ *   Age    (float) — normalised lifetime: 0 = just born, 1 = about to die
+ *   Random (float) — per-particle stable random value in [0, 1]
+ */
+export class ParticleInfo extends InputNode {
+    get nodeType() { return 'ParticleInfo'; }
+    get metadata() {
+        return { label: 'Particle Info', category: 'Input', color: '#3b5c3b', cost: 'low' };
+    }
+    constructor() {
+        super('ParticleInfo');
+        this._outputs = this.createOutputs({
+            Index: 'float',
+            Age: 'float',
+            Random: 'float',
+        });
+    }
+    getOutputSockets() { return this._outputs; }
+    vertexInjections() {
+        return [
+            { attrName: 'particleIndex', attrType: 'float', varyingName: 'vParticleIndex' },
+            { attrName: 'particleAge', attrType: 'float', varyingName: 'vParticleAge' },
+            { attrName: 'particleRandom', attrType: 'float', varyingName: 'vParticleRandom' },
+        ];
+    }
+    compileCall(ctx) {
+        return [
+            `float ${ctx.outputVar(this, 'Index')}  = vParticleIndex;`,
+            `float ${ctx.outputVar(this, 'Age')}    = vParticleAge;`,
+            `float ${ctx.outputVar(this, 'Random')} = vParticleRandom;`,
+        ].join('\n  ');
+    }
+}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"RGB.d.ts","sourceRoot":"","sources":["../../../src/nodes/input/RGB.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAA;AACnD,OAAO,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAA;AAC7D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAA;AAE5D;;;;;GAKG;AACH,qBAAa,GAAI,SAAQ,SAAS;IAChC,IAAI,QAAQ,WAAmB;IAE/B,IAAI,QAAQ,IAAI,YAAY,CAE3B;IAED,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAQ;IAC5B,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAmE;gBAEhF,KAAK,GAAE,MAAkB;IAMrC,gBAAgB;IAEhB,WAAW,CAAC,GAAG,EAAE,cAAc,GAAG,MAAM;CAGzC"}

package/dist/nodes/input/RGB.js

@@ -0,0 +1,23 @@
+import { InputNode } from '../../core/InputNode.js';
+import { CompileContext } from '../../core/CompileContext.js';
+/**
+ * RGB — Blender "RGB" input node equivalent.
+ * Outputs a single constant colour.
+ *
+ * Outputs: Color (color)
+ */
+export class RGB extends InputNode {
+    get nodeType() { return 'RGB'; }
+    get metadata() {
+        return { label: 'RGB', category: 'Input', color: '#3d6b96', cost: 'low' };
+    }
+    constructor(color = '#ffffff') {
+        super('RGB');
+        this.hex = color;
+        this._outputs = this.createOutputs({ Color: 'color' });
+    }
+    getOutputSockets() { return this._outputs; }
+    compileCall(ctx) {
+        return `vec3 ${ctx.outputVar(this, 'Color')} = ${CompileContext.hexToVec3(this.hex)};`;
+    }
+}

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

@@ -0,0 +1,37 @@
+import { InputNode } from '../../core/InputNode.js';
+import type { NodeMetadata } from '../../core/ShaderNode.js';
+import type { CompileContext } from '../../core/CompileContext.js';
+/**
+ * ScreenCamera — provides per-pixel ray direction and camera position
+ * for screen-space / ray-marching shaders.
+ *
+ * Used with ScreenOutput, which injects the camera uniforms automatically.
+ * Call `screenOut.updateCamera(camera, w, h)` once per frame.
+ *
+ * Outputs:
+ *   RayPos (color/vec3) — camera world-space position
+ *   RayDir (color/vec3) — normalised ray direction for this pixel
+ *
+ * @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 ScreenCamera extends InputNode {
+    get nodeType(): string;
+    get metadata(): NodeMetadata;
+    private readonly _outputs;
+    constructor();
+    getOutputSockets(): Record<string, import("../../core/OutputSocket.js").OutputSocket>;
+    /**
+     * Declare the camera uniforms that ScreenOutput will inject.
+     * They are vec2/vec3/float types that live outside the standard
+     * float/vec3 uniform registry — declared here so the GLSL is valid.
+     */
+    compileDefs(): string;
+    compileCall(ctx: CompileContext): string;
+}
+//# sourceMappingURL=ScreenCamera.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ScreenCamera.d.ts","sourceRoot":"","sources":["../../../src/nodes/input/ScreenCamera.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;;;;;;;;;;;;;;;;;;GAkBG;AACH,qBAAa,YAAa,SAAQ,SAAS;IACzC,IAAI,QAAQ,WAA4B;IAExC,IAAI,QAAQ,IAAI,YAAY,CAE3B;IAED,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAmE;;IAO5F,gBAAgB;IAEhB;;;;OAIG;IACH,WAAW,IAAI,MAAM;IAWrB,WAAW,CAAC,GAAG,EAAE,cAAc,GAAG,MAAM;CAazC"}

package/dist/nodes/input/ScreenCamera.js

@@ -0,0 +1,59 @@
+import { InputNode } from '../../core/InputNode.js';
+/**
+ * ScreenCamera — provides per-pixel ray direction and camera position
+ * for screen-space / ray-marching shaders.
+ *
+ * Used with ScreenOutput, which injects the camera uniforms automatically.
+ * Call `screenOut.updateCamera(camera, w, h)` once per frame.
+ *
+ * Outputs:
+ *   RayPos (color/vec3) — camera world-space position
+ *   RayDir (color/vec3) — normalised ray direction for this pixel
+ *
+ * @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 ScreenCamera extends InputNode {
+    get nodeType() { return 'ScreenCamera'; }
+    get metadata() {
+        return { label: 'Screen Camera', category: 'Input', color: '#3d6b96', cost: 'low' };
+    }
+    constructor() {
+        super('ScreenCamera');
+        this._outputs = this.createOutputs({ RayPos: 'color', RayDir: 'color' });
+    }
+    getOutputSockets() { return this._outputs; }
+    /**
+     * Declare the camera uniforms that ScreenOutput will inject.
+     * They are vec2/vec3/float types that live outside the standard
+     * float/vec3 uniform registry — declared here so the GLSL is valid.
+     */
+    compileDefs() {
+        return [
+            `uniform vec2  uSCResolution;`,
+            `uniform vec3  uSCCamPos;`,
+            `uniform vec3  uSCCamRight;`,
+            `uniform vec3  uSCCamUp;`,
+            `uniform vec3  uSCCamFwd;`,
+            `uniform float uSCFov;`,
+        ].join('\n');
+    }
+    compileCall(ctx) {
+        const id = this.id;
+        return [
+            `vec2  _scUV_${id} = (gl_FragCoord.xy / uSCResolution - 0.5);`,
+            `_scUV_${id}.x *= uSCResolution.x / uSCResolution.y;`,
+            `vec3 ${ctx.outputVar(this, 'RayPos')} = uSCCamPos;`,
+            `vec3 ${ctx.outputVar(this, 'RayDir')} = normalize(`,
+            `  uSCCamRight * _scUV_${id}.x * uSCFov +`,
+            `  uSCCamUp    * _scUV_${id}.y * uSCFov +`,
+            `  uSCCamFwd`,
+            `);`,
+        ].join('\n  ');
+    }
+}

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

@@ -0,0 +1,21 @@
+import { InputNode } from '../../core/InputNode.js';
+import type { NodeMetadata } from '../../core/ShaderNode.js';
+import type { CompileContext } from '../../core/CompileContext.js';
+/**
+ * Tangent — Blender "Tangent" input node equivalent.
+ * Provides tangent and bitangent vectors for anisotropic shading.
+ * Derived from screen-space position derivatives in the absence of a tangent attribute.
+ *
+ * Outputs:
+ *   Tangent   (color/vec3) — surface tangent direction
+ *   Bitangent (color/vec3) — surface bitangent direction
+ */
+export declare class Tangent extends InputNode {
+    get nodeType(): string;
+    get metadata(): NodeMetadata;
+    private readonly _outputs;
+    constructor();
+    getOutputSockets(): Record<string, import("../../core/OutputSocket.js").OutputSocket>;
+    compileCall(ctx: CompileContext): string;
+}
+//# sourceMappingURL=Tangent.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Tangent.d.ts","sourceRoot":"","sources":["../../../src/nodes/input/Tangent.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;;;;;;;;GAQG;AACH,qBAAa,OAAQ,SAAQ,SAAS;IACpC,IAAI,QAAQ,WAAuB;IAEnC,IAAI,QAAQ,IAAI,YAAY,CAE3B;IAED,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAmE;;IAO5F,gBAAgB;IAEhB,WAAW,CAAC,GAAG,EAAE,cAAc,GAAG,MAAM;CASzC"}

package/dist/nodes/input/Tangent.js

@@ -0,0 +1,30 @@
+import { InputNode } from '../../core/InputNode.js';
+/**
+ * Tangent — Blender "Tangent" input node equivalent.
+ * Provides tangent and bitangent vectors for anisotropic shading.
+ * Derived from screen-space position derivatives in the absence of a tangent attribute.
+ *
+ * Outputs:
+ *   Tangent   (color/vec3) — surface tangent direction
+ *   Bitangent (color/vec3) — surface bitangent direction
+ */
+export class Tangent extends InputNode {
+    get nodeType() { return 'Tangent'; }
+    get metadata() {
+        return { label: 'Tangent', category: 'Input', color: '#3d6b96', cost: 'low' };
+    }
+    constructor() {
+        super('Tangent');
+        this._outputs = this.createOutputs({ Tangent: 'color', Bitangent: 'color' });
+    }
+    getOutputSockets() { return this._outputs; }
+    compileCall(ctx) {
+        return [
+            `vec3  _tg_N_${this.id}  = normalize(vNormal);`,
+            `vec3  _tg_dp1_${this.id} = dFdx(vPosition);`,
+            `vec3  _tg_dp2_${this.id} = dFdy(vPosition);`,
+            `vec3  ${ctx.outputVar(this, 'Tangent')}   = normalize(_tg_dp1_${this.id} - _tg_N_${this.id} * dot(_tg_dp1_${this.id}, _tg_N_${this.id}));`,
+            `vec3  ${ctx.outputVar(this, 'Bitangent')} = cross(_tg_N_${this.id}, ${ctx.outputVar(this, 'Tangent')});`,
+        ].join('\n  ');
+    }
+}

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

@@ -0,0 +1,17 @@
+import { InputNode } from '../../core/InputNode.js';
+import type { NodeMetadata } from '../../core/ShaderNode.js';
+import type { CompileContext } from '../../core/CompileContext.js';
+/**
+ * Texture Coordinate — Blender "Texture Coordinate" node equivalent.
+ *
+ * Outputs: UV (vector/vec2), Generated (color/vec3 object-space position), Normal (color/vec3)
+ */
+export declare class TextureCoordinate extends InputNode {
+    get nodeType(): string;
+    get metadata(): NodeMetadata;
+    private readonly _outputs;
+    constructor();
+    getOutputSockets(): Record<string, import("../../core/OutputSocket.js").OutputSocket>;
+    compileCall(ctx: CompileContext): string;
+}
+//# sourceMappingURL=TextureCoordinate.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"TextureCoordinate.d.ts","sourceRoot":"","sources":["../../../src/nodes/input/TextureCoordinate.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;;;;GAIG;AACH,qBAAa,iBAAkB,SAAQ,SAAS;IAC9C,IAAI,QAAQ,WAAiC;IAE7C,IAAI,QAAQ,IAAI,YAAY,CAE3B;IAED,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAmE;;IAO5F,gBAAgB;IAEhB,WAAW,CAAC,GAAG,EAAE,cAAc,GAAG,MAAM;CAOzC"}

package/dist/nodes/input/TextureCoordinate.js

@@ -0,0 +1,24 @@
+import { InputNode } from '../../core/InputNode.js';
+/**
+ * Texture Coordinate — Blender "Texture Coordinate" node equivalent.
+ *
+ * Outputs: UV (vector/vec2), Generated (color/vec3 object-space position), Normal (color/vec3)
+ */
+export class TextureCoordinate extends InputNode {
+    get nodeType() { return 'TextureCoordinate'; }
+    get metadata() {
+        return { label: 'Texture Coordinate', category: 'Input', color: '#3d6b96', cost: 'low' };
+    }
+    constructor() {
+        super('TextureCoordinate');
+        this._outputs = this.createOutputs({ UV: 'vector', Generated: 'color', Normal: 'color' });
+    }
+    getOutputSockets() { return this._outputs; }
+    compileCall(ctx) {
+        return [
+            `vec2 ${ctx.outputVar(this, 'UV')}        = vUv;`,
+            `vec3 ${ctx.outputVar(this, 'Generated')} = vPosition;`,
+            `vec3 ${ctx.outputVar(this, 'Normal')}    = normalize(vNormal);`,
+        ].join('\n  ');
+    }
+}

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

@@ -0,0 +1,20 @@
+import { InputNode } from '../../core/InputNode.js';
+import type { NodeMetadata } from '../../core/ShaderNode.js';
+import type { CompileContext } from '../../core/CompileContext.js';
+/**
+ * UV Map — Blender "UV Map" input node equivalent.
+ * Outputs the mesh UV coordinates.
+ * In Three.js all geometries use a single UV channel exposed as vUv.
+ *
+ * Outputs:
+ *   UV (vector/vec2) — UV coordinates [0,1]
+ */
+export declare class UVMap extends InputNode {
+    get nodeType(): string;
+    get metadata(): NodeMetadata;
+    private readonly _outputs;
+    constructor();
+    getOutputSockets(): Record<string, import("../../core/OutputSocket.js").OutputSocket>;
+    compileCall(ctx: CompileContext): string;
+}
+//# sourceMappingURL=UVMap.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"UVMap.d.ts","sourceRoot":"","sources":["../../../src/nodes/input/UVMap.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,KAAM,SAAQ,SAAS;IAClC,IAAI,QAAQ,WAAqB;IAEjC,IAAI,QAAQ,IAAI,YAAY,CAE3B;IAED,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAmE;;IAO5F,gBAAgB;IAEhB,WAAW,CAAC,GAAG,EAAE,cAAc,GAAG,MAAM;CAGzC"}

package/dist/nodes/input/UVMap.js

@@ -0,0 +1,23 @@
+import { InputNode } from '../../core/InputNode.js';
+/**
+ * UV Map — Blender "UV Map" input node equivalent.
+ * Outputs the mesh UV coordinates.
+ * In Three.js all geometries use a single UV channel exposed as vUv.
+ *
+ * Outputs:
+ *   UV (vector/vec2) — UV coordinates [0,1]
+ */
+export class UVMap extends InputNode {
+    get nodeType() { return 'UVMap'; }
+    get metadata() {
+        return { label: 'UV Map', category: 'Input', color: '#3d6b96', cost: 'low' };
+    }
+    constructor() {
+        super('UVMap');
+        this._outputs = this.createOutputs({ UV: 'vector' });
+    }
+    getOutputSockets() { return this._outputs; }
+    compileCall(ctx) {
+        return `vec2 ${ctx.outputVar(this, 'UV')} = vUv;`;
+    }
+}