@triforge/shader-core 0.1.0

package/dist/index.js

@@ -0,0 +1,108 @@
+// ── Config & Errors ───────────────────────────────────────────────────────────
+export { ShaderConfig } from './core/ShaderConfig.js';
+export { ShaderNodeError } from './core/ShaderNodeError.js';
+// ── Core abstracts ────────────────────────────────────────────────────────────
+export { ShaderNode } from './core/ShaderNode.js';
+export { InputNode } from './core/InputNode.js';
+export { OutputNode } from './core/OutputNode.js';
+export { ProcessNode } from './core/ProcessNode.js';
+// ── Sockets ───────────────────────────────────────────────────────────────────
+export { InputSocket } from './core/InputSocket.js';
+export { OutputSocket } from './core/OutputSocket.js';
+export { SOCKET_GLSL_TYPE } from './core/SocketType.js';
+// ── Compiler ──────────────────────────────────────────────────────────────────
+export { CompileContext } from './core/CompileContext.js';
+// ── Input nodes ───────────────────────────────────────────────────────────────
+export { TextureCoordinate } from './nodes/input/TextureCoordinate.js';
+export { Value } from './nodes/input/Value.js';
+export { RGB } from './nodes/input/RGB.js';
+export { Geometry } from './nodes/input/Geometry.js';
+export { LayerWeight } from './nodes/input/LayerWeight.js';
+export { CameraData } from './nodes/input/CameraData.js';
+export { UVMap } from './nodes/input/UVMap.js';
+export { Tangent } from './nodes/input/Tangent.js';
+export { ColorAttribute } from './nodes/input/ColorAttribute.js';
+export { Attribute } from './nodes/input/Attribute.js';
+export { Wireframe } from './nodes/input/Wireframe.js';
+export { ObjectInfo } from './nodes/input/ObjectInfo.js';
+export { OceanAttribute } from './nodes/input/OceanAttribute.js';
+export { HairInfo } from './nodes/input/HairInfo.js';
+export { ParticleInfo } from './nodes/input/ParticleInfo.js';
+export { LightPath } from './nodes/input/LightPath.js';
+// ── Output nodes ──────────────────────────────────────────────────────────────
+export { MaterialOutput } from './nodes/output/MaterialOutput.js';
+export { Displacement } from './nodes/output/Displacement.js';
+// ── Process nodes — Texture ───────────────────────────────────────────────────
+export { NoiseTexture } from './nodes/process/NoiseTexture.js';
+export { AnimatedNoiseTexture } from './nodes/process/AnimatedNoiseTexture.js';
+export { VoronoiTexture } from './nodes/process/VoronoiTexture.js';
+export { WaveTexture } from './nodes/process/WaveTexture.js';
+export { GradientTexture } from './nodes/process/GradientTexture.js';
+export { BrickTexture } from './nodes/process/BrickTexture.js';
+export { CheckerTexture } from './nodes/process/CheckerTexture.js';
+export { MagicTexture } from './nodes/process/MagicTexture.js';
+export { MusgraveTexture } from './nodes/process/MusgraveTexture.js';
+export { WhiteNoise } from './nodes/process/WhiteNoise.js';
+export { ImageTexture } from './nodes/process/ImageTexture.js';
+export { EnvironmentTexture } from './nodes/process/EnvironmentTexture.js';
+// ── Process nodes — Color ─────────────────────────────────────────────────────
+export { ColorRamp } from './nodes/process/ColorRamp.js';
+export { MixRGB } from './nodes/process/MixRGB.js';
+export { HueSaturationValue } from './nodes/process/HueSaturationValue.js';
+export { BrightContrast } from './nodes/process/BrightContrast.js';
+export { RGBtoBW } from './nodes/process/RGBtoBW.js';
+export { Blackbody } from './nodes/process/Blackbody.js';
+export { Gamma } from './nodes/process/Gamma.js';
+export { InvertColor } from './nodes/process/InvertColor.js';
+export { RGBCurves } from './nodes/process/RGBCurves.js';
+export { Wavelength } from './nodes/process/Wavelength.js';
+// ── Process nodes — Vector ────────────────────────────────────────────────────
+export { NormalMap } from './nodes/process/NormalMap.js';
+export { Bump } from './nodes/process/Bump.js';
+export { Mapping } from './nodes/process/Mapping.js';
+export { VectorMath } from './nodes/process/VectorMath.js';
+export { SeparateRGB } from './nodes/process/SeparateRGB.js';
+export { CombineRGB } from './nodes/process/CombineRGB.js';
+export { SeparateXYZ } from './nodes/process/SeparateXYZ.js';
+export { CombineXYZ } from './nodes/process/CombineXYZ.js';
+export { Normal } from './nodes/process/Normal.js';
+export { VectorRotate } from './nodes/process/VectorRotate.js';
+export { VectorTransform } from './nodes/process/VectorTransform.js';
+export { VectorCurves } from './nodes/process/VectorCurves.js';
+// ── Process nodes — Shader ────────────────────────────────────────────────────
+export { PrincipledBSDF } from './nodes/process/PrincipledBSDF.js';
+export { Emission } from './nodes/process/Emission.js';
+export { VolumeAbsorption } from './nodes/process/VolumeAbsorption.js';
+export { VolumeScatter } from './nodes/process/VolumeScatter.js';
+export { PrincipledVolume } from './nodes/process/PrincipledVolume.js';
+export { MixShader } from './nodes/process/MixShader.js';
+export { AddShader } from './nodes/process/AddShader.js';
+export { Fresnel } from './nodes/process/Fresnel.js';
+export { DiffuseBSDF } from './nodes/process/DiffuseBSDF.js';
+export { GlossyBSDF } from './nodes/process/GlossyBSDF.js';
+export { RefractionBSDF } from './nodes/process/RefractionBSDF.js';
+export { GlassBSDF } from './nodes/process/GlassBSDF.js';
+export { SheenBSDF } from './nodes/process/SheenBSDF.js';
+export { SubsurfaceScattering } from './nodes/process/SubsurfaceScattering.js';
+export { ToonBSDF } from './nodes/process/ToonBSDF.js';
+export { SpecularBSDF } from './nodes/process/SpecularBSDF.js';
+export { TranslucentBSDF } from './nodes/process/TranslucentBSDF.js';
+export { PrincipledHair } from './nodes/process/PrincipledHair.js';
+// ── Process nodes — Converter ─────────────────────────────────────────────────
+export { Math as ShaderMath } from './nodes/process/Math.js';
+export { Clamp } from './nodes/process/Clamp.js';
+export { MapRange } from './nodes/process/MapRange.js';
+export { FloatCurve } from './nodes/process/FloatCurve.js';
+export { ShaderToRGB } from './nodes/process/ShaderToRGB.js';
+export { CombineColor } from './nodes/process/CombineColor.js';
+export { SeparateColor } from './nodes/process/SeparateColor.js';
+export { HashValue } from './nodes/process/HashValue.js';
+// ── Script node — custom GLSL as a first-class graph node (OSL equivalent) ───
+export { ShaderScript } from './nodes/process/ShaderScript.js';
+// ── Screen-space / ray-marching nodes ────────────────────────────────────────
+export { ScreenCamera } from './nodes/input/ScreenCamera.js';
+export { SchwarzschildMarch } from './nodes/process/SchwarzschildMarch.js';
+export { ScreenOutput } from './nodes/output/ScreenOutput.js';
+// ── Shader nodes ──────────────────────────────────────────────────────────────
+export { AmbientOcclusion } from './nodes/shader/AmbientOcclusion.js';
+export { RayPortal } from './nodes/shader/RayPortal.js';

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

@@ -0,0 +1,45 @@
+import { InputNode } from '../../core/InputNode.js';
+import type { NodeMetadata } from '../../core/ShaderNode.js';
+import type { CompileContext } from '../../core/CompileContext.js';
+/**
+ * Attribute — Blender "Attribute" input node equivalent.
+ * Reads a named custom float or vector attribute from the geometry's BufferAttributes.
+ *
+ * The attribute must be present on the geometry as a BufferAttribute with the given name.
+ * For vec3 attributes: Vector = the attribute value, Fac = length of the vector.
+ * For float attributes: Fac = the attribute value, Vector = vec3(value, value, value).
+ *
+ * Parameters:
+ *   attributeType (number) — 0 = vec3, 1 = float (numeric for keyframe compat)
+ *
+ * Outputs:
+ *   Fac    (float)  — scalar representation of the attribute value
+ *   Vector (color)  — vec3 representation of the attribute value
+ */
+export declare class Attribute extends InputNode {
+    get nodeType(): string;
+    get metadata(): NodeMetadata;
+    /** The raw attribute name as it appears on the BufferGeometry. */
+    readonly attributeName: string;
+    /** 0 = vec3, 1 = float. Stored as number for keyframe/GSAP compat. */
+    parameters: {
+        attributeType: number;
+    };
+    private readonly _outputs;
+    /** Sanitized attribute name — only alphanumeric + underscore, used in GLSL. */
+    private readonly _safeAttrName;
+    constructor(attributeName: string, attributeType?: 'float' | 'vec3');
+    getOutputSockets(): Record<string, import("../../core/OutputSocket.js").OutputSocket>;
+    vertexInjections(): {
+        attrName: string;
+        attrType: "float";
+        varyingName: string;
+    }[] | {
+        attrName: string;
+        attrType: "vec3";
+        varyingName: string;
+    }[];
+    compileDefs(): string;
+    compileCall(ctx: CompileContext): string;
+}
+//# sourceMappingURL=Attribute.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Attribute.d.ts","sourceRoot":"","sources":["../../../src/nodes/input/Attribute.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,SAAU,SAAQ,SAAS;IACtC,IAAI,QAAQ,WAAyB;IAErC,IAAI,QAAQ,IAAI,YAAY,CAE3B;IAED,kEAAkE;IAClE,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAA;IAE9B,sEAAsE;IAC7D,UAAU,EAAE;QAAE,aAAa,EAAE,MAAM,CAAA;KAAE,CAAuB;IAErE,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAmE;IAE5F,+EAA+E;IAC/E,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAQ;gBAE1B,aAAa,EAAE,MAAM,EAAE,aAAa,GAAE,OAAO,GAAG,MAAe;IAW3E,gBAAgB;IAEhB,gBAAgB;;;;;;;;;IAUhB,WAAW,IAAI,MAAM;IAErB,WAAW,CAAC,GAAG,EAAE,cAAc,GAAG,MAAM;CAkBzC"}

package/dist/nodes/input/Attribute.js

@@ -0,0 +1,58 @@
+import { InputNode } from '../../core/InputNode.js';
+/**
+ * Attribute — Blender "Attribute" input node equivalent.
+ * Reads a named custom float or vector attribute from the geometry's BufferAttributes.
+ *
+ * The attribute must be present on the geometry as a BufferAttribute with the given name.
+ * For vec3 attributes: Vector = the attribute value, Fac = length of the vector.
+ * For float attributes: Fac = the attribute value, Vector = vec3(value, value, value).
+ *
+ * Parameters:
+ *   attributeType (number) — 0 = vec3, 1 = float (numeric for keyframe compat)
+ *
+ * Outputs:
+ *   Fac    (float)  — scalar representation of the attribute value
+ *   Vector (color)  — vec3 representation of the attribute value
+ */
+export class Attribute extends InputNode {
+    get nodeType() { return 'Attribute'; }
+    get metadata() {
+        return { label: 'Attribute', category: 'Input', color: '#3d6b96', cost: 'low' };
+    }
+    constructor(attributeName, attributeType = 'vec3') {
+        super('Attribute');
+        /** 0 = vec3, 1 = float. Stored as number for keyframe/GSAP compat. */
+        this.parameters = { attributeType: 0 };
+        // SECURITY: sanitize the attribute name for safe use in GLSL identifiers
+        this._safeAttrName = attributeName.replace(/[^a-zA-Z0-9_]/g, '_');
+        this.attributeName = attributeName;
+        this.parameters.attributeType = attributeType === 'float' ? 1 : 0;
+        this._outputs = this.createOutputs({ Fac: 'float', Vector: 'color' });
+    }
+    getOutputSockets() { return this._outputs; }
+    vertexInjections() {
+        const isFloat = this.parameters.attributeType === 1;
+        const varyingName = `vAttr_${this._safeAttrName}`;
+        if (isFloat) {
+            return [{ attrName: this.attributeName, attrType: 'float', varyingName }];
+        }
+        return [{ attrName: this.attributeName, attrType: 'vec3', varyingName }];
+    }
+    compileDefs() { return ''; }
+    compileCall(ctx) {
+        const isFloat = this.parameters.attributeType === 1;
+        const varyingName = `vAttr_${this._safeAttrName}`;
+        const outFac = ctx.outputVar(this, 'Fac');
+        const outVector = ctx.outputVar(this, 'Vector');
+        if (isFloat) {
+            return [
+                `float ${outFac}    = ${varyingName};`,
+                `vec3  ${outVector} = vec3(${varyingName}, ${varyingName}, ${varyingName});`,
+            ].join('\n  ');
+        }
+        return [
+            `vec3  ${outVector} = ${varyingName};`,
+            `float ${outFac}    = length(${varyingName});`,
+        ].join('\n  ');
+    }
+}

package/dist/nodes/input/CameraData.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';
+/**
+ * Camera Data — Blender "Camera Data" input node equivalent.
+ * Provides camera-relative metrics for the current surface point.
+ *
+ * Outputs:
+ *   ViewDistance (float)      — distance from surface to camera
+ *   ViewZDepth   (float)      — camera-space Z depth
+ *   ViewVector   (color/vec3) — normalised direction from surface to camera
+ */
+export declare class CameraData 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=CameraData.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"CameraData.d.ts","sourceRoot":"","sources":["../../../src/nodes/input/CameraData.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;;IAW5F,gBAAgB;IAEhB,WAAW,CAAC,GAAG,EAAE,cAAc,GAAG,MAAM;CAQzC"}

package/dist/nodes/input/CameraData.js

@@ -0,0 +1,33 @@
+import { InputNode } from '../../core/InputNode.js';
+/**
+ * Camera Data — Blender "Camera Data" input node equivalent.
+ * Provides camera-relative metrics for the current surface point.
+ *
+ * Outputs:
+ *   ViewDistance (float)      — distance from surface to camera
+ *   ViewZDepth   (float)      — camera-space Z depth
+ *   ViewVector   (color/vec3) — normalised direction from surface to camera
+ */
+export class CameraData extends InputNode {
+    get nodeType() { return 'CameraData'; }
+    get metadata() {
+        return { label: 'Camera Data', category: 'Input', color: '#3d6b96', cost: 'low' };
+    }
+    constructor() {
+        super('CameraData');
+        this._outputs = this.createOutputs({
+            ViewDistance: 'float',
+            ViewZDepth: 'float',
+            ViewVector: 'color',
+        });
+    }
+    getOutputSockets() { return this._outputs; }
+    compileCall(ctx) {
+        return [
+            `vec3  _cd_toCamera_${this.id} = cameraPosition - vPosition;`,
+            `float ${ctx.outputVar(this, 'ViewDistance')} = length(_cd_toCamera_${this.id});`,
+            `float ${ctx.outputVar(this, 'ViewZDepth')}   = -gl_FragCoord.z;`,
+            `vec3  ${ctx.outputVar(this, 'ViewVector')}   = normalize(_cd_toCamera_${this.id});`,
+        ].join('\n  ');
+    }
+}

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

@@ -0,0 +1,28 @@
+import { InputNode } from '../../core/InputNode.js';
+import type { NodeMetadata } from '../../core/ShaderNode.js';
+import type { CompileContext } from '../../core/CompileContext.js';
+/**
+ * Color Attribute — Blender "Color Attribute" input node equivalent.
+ * Reads vertex colour data painted onto the mesh.
+ * Requires the geometry to have a 'color' BufferAttribute.
+ * Falls back to white if the attribute is not present.
+ *
+ * Outputs:
+ *   Color  (color) — vertex colour RGB
+ *   Alpha  (float) — vertex colour alpha
+ */
+export declare class ColorAttribute extends InputNode {
+    get nodeType(): string;
+    get metadata(): NodeMetadata;
+    private readonly _outputs;
+    constructor();
+    getOutputSockets(): Record<string, import("../../core/OutputSocket.js").OutputSocket>;
+    vertexInjections(): {
+        attrName: string;
+        attrType: "vec3";
+        varyingName: string;
+    }[];
+    compileDefs(): string;
+    compileCall(ctx: CompileContext): string;
+}
+//# sourceMappingURL=ColorAttribute.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ColorAttribute.d.ts","sourceRoot":"","sources":["../../../src/nodes/input/ColorAttribute.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;;;;;;;;;GASG;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,IAAI,MAAM;IAErB,WAAW,CAAC,GAAG,EAAE,cAAc,GAAG,MAAM;CAMzC"}

package/dist/nodes/input/ColorAttribute.js

@@ -0,0 +1,32 @@
+import { InputNode } from '../../core/InputNode.js';
+/**
+ * Color Attribute — Blender "Color Attribute" input node equivalent.
+ * Reads vertex colour data painted onto the mesh.
+ * Requires the geometry to have a 'color' BufferAttribute.
+ * Falls back to white if the attribute is not present.
+ *
+ * Outputs:
+ *   Color  (color) — vertex colour RGB
+ *   Alpha  (float) — vertex colour alpha
+ */
+export class ColorAttribute extends InputNode {
+    get nodeType() { return 'ColorAttribute'; }
+    get metadata() {
+        return { label: 'Color Attribute', category: 'Input', color: '#3d6b96', cost: 'low' };
+    }
+    constructor() {
+        super('ColorAttribute');
+        this._outputs = this.createOutputs({ Color: 'color', Alpha: 'float' });
+    }
+    getOutputSockets() { return this._outputs; }
+    vertexInjections() {
+        return [{ attrName: 'color', attrType: 'vec3', varyingName: 'vColor' }];
+    }
+    compileDefs() { return ''; }
+    compileCall(ctx) {
+        return [
+            `vec3  ${ctx.outputVar(this, 'Color')} = vColor;`,
+            `float ${ctx.outputVar(this, 'Alpha')} = 1.0;`,
+        ].join('\n  ');
+    }
+}

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

@@ -0,0 +1,23 @@
+import { InputNode } from '../../core/InputNode.js';
+import type { NodeMetadata } from '../../core/ShaderNode.js';
+import type { CompileContext } from '../../core/CompileContext.js';
+/**
+ * Geometry — Blender "Geometry" input node equivalent.
+ * Provides raw geometric data about the current surface point.
+ *
+ * Outputs:
+ *   Position  (color/vec3) — world space position
+ *   Normal    (color/vec3) — interpolated surface normal
+ *   TrueNormal(color/vec3) — flat face normal
+ *   Incoming  (color/vec3) — direction from camera to surface
+ *   Backfacing(float)      — 1.0 if back face, 0.0 if front
+ */
+export declare class Geometry 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=Geometry.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Geometry.d.ts","sourceRoot":"","sources":["../../../src/nodes/input/Geometry.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;;;;;;;;;;GAUG;AACH,qBAAa,QAAS,SAAQ,SAAS;IACrC,IAAI,QAAQ,WAAwB;IAEpC,IAAI,QAAQ,IAAI,YAAY,CAE3B;IAED,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAmE;;IAa5F,gBAAgB;IAEhB,WAAW,CAAC,GAAG,EAAE,cAAc,GAAG,MAAM;CASzC"}

package/dist/nodes/input/Geometry.js

@@ -0,0 +1,38 @@
+import { InputNode } from '../../core/InputNode.js';
+/**
+ * Geometry — Blender "Geometry" input node equivalent.
+ * Provides raw geometric data about the current surface point.
+ *
+ * Outputs:
+ *   Position  (color/vec3) — world space position
+ *   Normal    (color/vec3) — interpolated surface normal
+ *   TrueNormal(color/vec3) — flat face normal
+ *   Incoming  (color/vec3) — direction from camera to surface
+ *   Backfacing(float)      — 1.0 if back face, 0.0 if front
+ */
+export class Geometry extends InputNode {
+    get nodeType() { return 'Geometry'; }
+    get metadata() {
+        return { label: 'Geometry', category: 'Input', color: '#3d6b96', cost: 'low' };
+    }
+    constructor() {
+        super('Geometry');
+        this._outputs = this.createOutputs({
+            Position: 'color',
+            Normal: 'color',
+            TrueNormal: 'color',
+            Incoming: 'color',
+            Backfacing: 'float',
+        });
+    }
+    getOutputSockets() { return this._outputs; }
+    compileCall(ctx) {
+        return [
+            `vec3  ${ctx.outputVar(this, 'Position')}   = vPosition;`,
+            `vec3  ${ctx.outputVar(this, 'Normal')}     = normalize(vNormal);`,
+            `vec3  ${ctx.outputVar(this, 'TrueNormal')} = normalize(cross(dFdx(vPosition), dFdy(vPosition)));`,
+            `vec3  ${ctx.outputVar(this, 'Incoming')}   = normalize(vPosition - cameraPosition);`,
+            `float ${ctx.outputVar(this, 'Backfacing')} = gl_FrontFacing ? 0.0 : 1.0;`,
+        ].join('\n  ');
+    }
+}

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

@@ -0,0 +1,38 @@
+import { InputNode } from '../../core/InputNode.js';
+import type { NodeMetadata } from '../../core/ShaderNode.js';
+import type { CompileContext } from '../../core/CompileContext.js';
+/**
+ * Hair Info — Blender "Hair Info" input node equivalent.
+ * Reads per-vertex strand data written by st-hair-core buildTubeGeometry /
+ * buildRibbonGeometry into the strandTangent and strandRandom attributes.
+ *
+ * Geometry requirements (tube or ribbon from st-hair-core):
+ *   attribute vec3  strandTangent — tangent along strand axis at this vertex
+ *   attribute float strandRandom  — per-strand uniform random value [0,1]
+ *   vUv.y                         — 0 at root, 1 at tip
+ *
+ * Outputs:
+ *   IsStrand      (float) — always 1.0 (use to mix with surface shader)
+ *   Intercept     (float) — 0.0 at root → 1.0 at tip
+ *   Length        (float) — 1.0 (normalised; actual length lives in the generator)
+ *   TangentNormal (color) — unit tangent direction along the strand
+ *   Random        (float) — per-strand random value in [0, 1]
+ */
+export declare class HairInfo extends InputNode {
+    get nodeType(): string;
+    get metadata(): NodeMetadata;
+    private readonly _outputs;
+    constructor();
+    getOutputSockets(): Record<string, import("../../core/OutputSocket.js").OutputSocket>;
+    vertexInjections(): ({
+        attrName: string;
+        attrType: "vec3";
+        varyingName: string;
+    } | {
+        attrName: string;
+        attrType: "float";
+        varyingName: string;
+    })[];
+    compileCall(ctx: CompileContext): string;
+}
+//# sourceMappingURL=HairInfo.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"HairInfo.d.ts","sourceRoot":"","sources":["../../../src/nodes/input/HairInfo.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;;;;;;;;;;;;;;;;GAgBG;AACH,qBAAa,QAAS,SAAQ,SAAS;IACrC,IAAI,QAAQ,WAAwB;IAEpC,IAAI,QAAQ,IAAI,YAAY,CAE3B;IAED,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAmE;;IAa5F,gBAAgB;IAEhB,gBAAgB;;;;;;;;;IAOhB,WAAW,CAAC,GAAG,EAAE,cAAc,GAAG,MAAM;CASzC"}

package/dist/nodes/input/HairInfo.js

@@ -0,0 +1,50 @@
+import { InputNode } from '../../core/InputNode.js';
+/**
+ * Hair Info — Blender "Hair Info" input node equivalent.
+ * Reads per-vertex strand data written by st-hair-core buildTubeGeometry /
+ * buildRibbonGeometry into the strandTangent and strandRandom attributes.
+ *
+ * Geometry requirements (tube or ribbon from st-hair-core):
+ *   attribute vec3  strandTangent — tangent along strand axis at this vertex
+ *   attribute float strandRandom  — per-strand uniform random value [0,1]
+ *   vUv.y                         — 0 at root, 1 at tip
+ *
+ * Outputs:
+ *   IsStrand      (float) — always 1.0 (use to mix with surface shader)
+ *   Intercept     (float) — 0.0 at root → 1.0 at tip
+ *   Length        (float) — 1.0 (normalised; actual length lives in the generator)
+ *   TangentNormal (color) — unit tangent direction along the strand
+ *   Random        (float) — per-strand random value in [0, 1]
+ */
+export class HairInfo extends InputNode {
+    get nodeType() { return 'HairInfo'; }
+    get metadata() {
+        return { label: 'Hair Info', category: 'Input', color: '#5a3a1a', cost: 'low' };
+    }
+    constructor() {
+        super('HairInfo');
+        this._outputs = this.createOutputs({
+            IsStrand: 'float',
+            Intercept: 'float',
+            Length: 'float',
+            TangentNormal: 'color',
+            Random: 'float',
+        });
+    }
+    getOutputSockets() { return this._outputs; }
+    vertexInjections() {
+        return [
+            { attrName: 'strandTangent', attrType: 'vec3', varyingName: 'vStrandTangent' },
+            { attrName: 'strandRandom', attrType: 'float', varyingName: 'vStrandRandom' },
+        ];
+    }
+    compileCall(ctx) {
+        return [
+            `float ${ctx.outputVar(this, 'IsStrand')}      = 1.0;`,
+            `float ${ctx.outputVar(this, 'Intercept')}     = vUv.y;`,
+            `float ${ctx.outputVar(this, 'Length')}        = 1.0;`,
+            `vec3  ${ctx.outputVar(this, 'TangentNormal')} = normalize(vStrandTangent);`,
+            `float ${ctx.outputVar(this, 'Random')}        = vStrandRandom;`,
+        ].join('\n  ');
+    }
+}

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

@@ -0,0 +1,26 @@
+import { InputNode } from '../../core/InputNode.js';
+import type { NodeMetadata } from '../../core/ShaderNode.js';
+import type { CompileContext } from '../../core/CompileContext.js';
+/**
+ * Layer Weight — Blender "Layer Weight" input node equivalent.
+ * Generates blend factors based on viewing angle.
+ * Useful for edge blending and layering materials.
+ *
+ * Outputs:
+ *   Fresnel (float) — physically-based Fresnel factor
+ *   Facing  (float) — 0.0 at grazing, 1.0 facing camera
+ */
+export declare class LayerWeight extends InputNode {
+    get nodeType(): string;
+    get metadata(): NodeMetadata;
+    parameters: {
+        blend: number;
+    };
+    private readonly _outputs;
+    constructor(inputs?: {
+        blend?: number;
+    } | number);
+    getOutputSockets(): Record<string, import("../../core/OutputSocket.js").OutputSocket>;
+    compileCall(ctx: CompileContext): string;
+}
+//# sourceMappingURL=LayerWeight.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"LayerWeight.d.ts","sourceRoot":"","sources":["../../../src/nodes/input/LayerWeight.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,WAAY,SAAQ,SAAS;IACxC,IAAI,QAAQ,WAA2B;IAEvC,IAAI,QAAQ,IAAI,YAAY,CAE3B;IAED,UAAU,EAAE;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,CAAA;IAC7B,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAmE;gBAEhF,MAAM,GAAE;QAAE,KAAK,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,MAAW;IAOpD,gBAAgB;IAEhB,WAAW,CAAC,GAAG,EAAE,cAAc,GAAG,MAAM;CAYzC"}

package/dist/nodes/input/LayerWeight.js

@@ -0,0 +1,35 @@
+import { InputNode } from '../../core/InputNode.js';
+/**
+ * Layer Weight — Blender "Layer Weight" input node equivalent.
+ * Generates blend factors based on viewing angle.
+ * Useful for edge blending and layering materials.
+ *
+ * Outputs:
+ *   Fresnel (float) — physically-based Fresnel factor
+ *   Facing  (float) — 0.0 at grazing, 1.0 facing camera
+ */
+export class LayerWeight extends InputNode {
+    get nodeType() { return 'LayerWeight'; }
+    get metadata() {
+        return { label: 'Layer Weight', category: 'Input', color: '#3d6b96', cost: 'low' };
+    }
+    constructor(inputs = {}) {
+        super('LayerWeight');
+        const blend = typeof inputs === 'number' ? inputs : (inputs.blend ?? 0.5);
+        this.parameters = { blend: Math.max(0.0001, blend) };
+        this._outputs = this.createOutputs({ Fresnel: 'float', Facing: 'float' });
+    }
+    getOutputSockets() { return this._outputs; }
+    compileCall(ctx) {
+        const b = this.parameters.blend.toFixed(4);
+        return [
+            `vec3  _lw_N_${this.id}  = normalize(vNormal);`,
+            `vec3  _lw_V_${this.id}  = normalize(cameraPosition - vPosition);`,
+            `float _lw_c_${this.id}  = max(dot(_lw_N_${this.id}, _lw_V_${this.id}), 0.0);`,
+            `float _lw_ior_${this.id} = 1.0 / max(1.0 - ${b}, 0.0001);`,
+            `float _lw_F0_${this.id} = pow((_lw_ior_${this.id} - 1.0) / (_lw_ior_${this.id} + 1.0), 2.0);`,
+            `float ${ctx.outputVar(this, 'Fresnel')} = _lw_F0_${this.id} + (1.0 - _lw_F0_${this.id}) * pow(1.0 - _lw_c_${this.id}, 5.0);`,
+            `float ${ctx.outputVar(this, 'Facing')}  = pow(1.0 - _lw_c_${this.id}, max(1.0 - ${b} + 0.0001, 0.0001));`,
+        ].join('\n  ');
+    }
+}

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

@@ -0,0 +1,60 @@
+import { InputNode } from '../../core/InputNode.js';
+import type { NodeMetadata } from '../../core/ShaderNode.js';
+import type { CompileContext } from '../../core/CompileContext.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 declare class LightPath extends InputNode {
+    get nodeType(): string;
+    get metadata(): NodeMetadata;
+    readonly parameters: Record<string, never>;
+    private readonly _outputs;
+    /**
+     * Canonical uniform names used by LightPath.
+     * LightPathController sets these on the compiled ShaderMaterial.
+     */
+    static readonly U: {
+        readonly isCamera: "u_st_lp_isCamera";
+        readonly isShadow: "u_st_lp_isShadow";
+        readonly isDiffuse: "u_st_lp_isDiffuse";
+        readonly isGlossy: "u_st_lp_isGlossy";
+        readonly isSingular: "u_st_lp_isSingular";
+        readonly isReflection: "u_st_lp_isReflection";
+        readonly isTransmission: "u_st_lp_isTransmission";
+        readonly rayLength: "u_st_lp_rayLength";
+        readonly rayDepth: "u_st_lp_rayDepth";
+        readonly diffuseDepth: "u_st_lp_diffuseDepth";
+        readonly glossyDepth: "u_st_lp_glossyDepth";
+        readonly shadowDepth: "u_st_lp_shadowDepth";
+        readonly transparentDepth: "u_st_lp_transparentDepth";
+        readonly transmissionDepth: "u_st_lp_transmissionDepth";
+    };
+    constructor();
+    getOutputSockets(): Record<string, import("../../core/OutputSocket.js").OutputSocket>;
+    /**
+     * 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(): Record<string, number>;
+    compileDefs(): string;
+    compileCall(ctx: CompileContext): string;
+}
+//# sourceMappingURL=LightPath.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"LightPath.d.ts","sourceRoot":"","sources":["../../../src/nodes/input/LightPath.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,SAAU,SAAQ,SAAS;IACtC,IAAI,QAAQ,WAAyB;IAErC,IAAI,QAAQ,IAAI,YAAY,CAE3B;IAED,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,CAAK;IAE/C,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAmE;IAE5F;;;OAGG;IACH,MAAM,CAAC,QAAQ,CAAC,CAAC;;;;;;;;;;;;;;;MAeP;;IAsBV,gBAAgB;IAEhB;;;;;OAKG;IACH,aAAa,IAAI,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAoBvC,WAAW,IAAI,MAAM;IAErB,WAAW,CAAC,GAAG,EAAE,cAAc,GAAG,MAAM;CAmBzC"}