@triforge/shader-core 0.1.0

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

@@ -0,0 +1,95 @@
+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';
+/**
+ * Declare an input socket: [glslType, defaultValue]
+ *   'float'  → float   (uniform or literal)
+ *   'color'  → vec3    (uniform or literal hex / [r,g,b])
+ *   'vector' → vec2    (UV coordinates)
+ *   'shader' → vec3    (BSDF connection)
+ */
+export type ScriptInputDecl = ['float' | 'color' | 'vector' | 'shader', unknown];
+/** Output socket type map: socketName → glslType */
+export type ScriptOutputDecl = Record<string, 'float' | 'color' | 'vector' | 'shader'>;
+export interface ShaderScriptConfig {
+    /**
+     * Input sockets.  Each entry is either:
+     *   ['float'|'color'|'vector', defaultValue]   — static or connectable socket
+     *   OutputSocket                                — already-connected socket
+     */
+    inputs?: Record<string, ScriptInputDecl | OutputSocket>;
+    /** Output socket names and their types. */
+    outputs?: ScriptOutputDecl;
+    /**
+     * GLSL body.  Input names are available as local variables.
+     * Output names must be assigned before the block ends.
+     *
+     * @example
+     * glsl: `
+     *   result = sin(myScale * 6.28318) * 0.5 + 0.5;
+     *   outColor = mix(colorA, colorB, result);
+     * `
+     */
+    glsl: string;
+    /**
+     * Optional GLSL helper functions emitted once above main().
+     * Use this for custom math utilities, noise functions, etc.
+     */
+    defs?: string;
+    /** Display name shown in error messages and metadata. */
+    label?: string;
+}
+/**
+ * ShaderScript — Blender "Script Node (OSL)" equivalent for st-shader-core.
+ *
+ * Wraps a block of custom GLSL as a first-class node in the shader graph.
+ * Input and output sockets connect to all other nodes normally.
+ *
+ * Inside the GLSL body:
+ *   • Input sockets are available as local variables with the exact name you declared.
+ *   • Output sockets must be assigned by name before the block ends.
+ *   • GLSL types: 'float' → float, 'color'/'shader' → vec3, 'vector' → vec2
+ *
+ * @example
+ * const ripple = new ShaderScript({
+ *   inputs: {
+ *     uv:    textureCoord.output('UV'),   // connected vec2
+ *     speed: ['float', 1.0],              // animatable float uniform
+ *     color: ['color', '#0055ff'],        // live vec3 uniform
+ *   },
+ *   outputs: { result: 'float', tinted: 'color' },
+ *   glsl: `
+ *     float wave = sin(uv.x * 12.566 - speed * uTime) * 0.5 + 0.5;
+ *     result = wave;
+ *     tinted = color * wave;
+ *   `,
+ * })
+ */
+export declare class ShaderScript extends ProcessNode {
+    get nodeType(): string;
+    static instanceSpecificDef: boolean;
+    get metadata(): NodeMetadata;
+    private readonly _glsl;
+    private readonly _defs;
+    private readonly _label;
+    private readonly _outputDecl;
+    private readonly _inputs;
+    private readonly _outputs;
+    constructor(config: ShaderScriptConfig);
+    getInputSockets(): Record<string, import("../../core/InputSocket.js").InputSocket<unknown>>;
+    getOutputSockets(): Record<string, OutputSocket>;
+    /** Emit any helper functions the user declared. */
+    compileDefs(): string;
+    /**
+     * Emit the script body as a GLSL block:
+     *  1. Declare each input as a local variable (resolved from graph).
+     *  2. Declare each output as a local variable.
+     *  3. Execute the user's GLSL body in a scoped block.
+     *  4. Copy local output vars → canonical output variable names.
+     */
+    compileCall(ctx: CompileContext): string;
+    private _socketGlslType;
+    private _declGlslType;
+}
+//# sourceMappingURL=ShaderScript.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ShaderScript.d.ts","sourceRoot":"","sources":["../../../src/nodes/process/ShaderScript.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;AAK9D;;;;;;GAMG;AACH,MAAM,MAAM,eAAe,GAAG,CAAC,OAAO,GAAG,OAAO,GAAG,QAAQ,GAAG,QAAQ,EAAE,OAAO,CAAC,CAAA;AAEhF,oDAAoD;AACpD,MAAM,MAAM,gBAAgB,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,GAAG,OAAO,GAAG,QAAQ,GAAG,QAAQ,CAAC,CAAA;AAEtF,MAAM,WAAW,kBAAkB;IACjC;;;;OAIG;IACH,MAAM,CAAC,EAAG,MAAM,CAAC,MAAM,EAAE,eAAe,GAAG,YAAY,CAAC,CAAA;IAExD,2CAA2C;IAC3C,OAAO,CAAC,EAAE,gBAAgB,CAAA;IAE1B;;;;;;;;;OASG;IACH,IAAI,EAAE,MAAM,CAAA;IAEZ;;;OAGG;IACH,IAAI,CAAC,EAAE,MAAM,CAAA;IAEb,yDAAyD;IACzD,KAAK,CAAC,EAAE,MAAM,CAAA;CACf;AAID;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,qBAAa,YAAa,SAAQ,WAAW;IAC3C,IAAI,QAAQ,WAA4B;IACxC,MAAM,CAAC,mBAAmB,UAAO;IAEjC,IAAI,QAAQ,IAAI,YAAY,CAQ3B;IAED,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAe;IACrC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAe;IACrC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAc;IACrC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAmB;IAC/C,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA+E;IACvG,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAkC;gBAE/C,MAAM,EAAE,kBAAkB;IA8BtC,eAAe;IACf,gBAAgB;IAEhB,mDAAmD;IACnD,WAAW,IAAI,MAAM;IAErB;;;;;;OAMG;IACH,WAAW,CAAC,GAAG,EAAE,cAAc,GAAG,MAAM;IAkCxC,OAAO,CAAC,eAAe;IAMvB,OAAO,CAAC,aAAa;CAKtB"}

package/dist/nodes/process/ShaderScript.js

@@ -0,0 +1,119 @@
+import { ProcessNode } from '../../core/ProcessNode.js';
+// ── ShaderScript node ─────────────────────────────────────────────────────────
+/**
+ * ShaderScript — Blender "Script Node (OSL)" equivalent for st-shader-core.
+ *
+ * Wraps a block of custom GLSL as a first-class node in the shader graph.
+ * Input and output sockets connect to all other nodes normally.
+ *
+ * Inside the GLSL body:
+ *   • Input sockets are available as local variables with the exact name you declared.
+ *   • Output sockets must be assigned by name before the block ends.
+ *   • GLSL types: 'float' → float, 'color'/'shader' → vec3, 'vector' → vec2
+ *
+ * @example
+ * const ripple = new ShaderScript({
+ *   inputs: {
+ *     uv:    textureCoord.output('UV'),   // connected vec2
+ *     speed: ['float', 1.0],              // animatable float uniform
+ *     color: ['color', '#0055ff'],        // live vec3 uniform
+ *   },
+ *   outputs: { result: 'float', tinted: 'color' },
+ *   glsl: `
+ *     float wave = sin(uv.x * 12.566 - speed * uTime) * 0.5 + 0.5;
+ *     result = wave;
+ *     tinted = color * wave;
+ *   `,
+ * })
+ */
+export class ShaderScript extends ProcessNode {
+    get nodeType() { return 'ShaderScript'; }
+    get metadata() {
+        return {
+            label: this._label,
+            category: 'Script',
+            color: '#336655',
+            cost: 'high',
+            costNote: 'Custom GLSL — performance depends on script content.',
+        };
+    }
+    constructor(config) {
+        super('ShaderScript');
+        this._glsl = config.glsl ?? '';
+        this._defs = config.defs ?? '';
+        this._label = config.label ?? 'Shader Script';
+        this._outputDecl = config.outputs ?? {};
+        // ── Build input defs + supplied maps ────────────────────────────────────
+        const defs = {};
+        const supplied = {};
+        for (const [name, spec] of Object.entries(config.inputs ?? {})) {
+            if (Array.isArray(spec)) {
+                // ['float'|'color'|'vector'|'shader', defaultValue]
+                const [type, defaultVal] = spec;
+                defs[name] = [type, defaultVal];
+                // Leave supplied[name] undefined → createInputs uses defs default
+            }
+            else {
+                // It's an OutputSocket (already connected)
+                const sock = spec;
+                defs[name] = [sock.type, null];
+                supplied[name] = sock;
+            }
+        }
+        this._inputs = this.createInputs(supplied, defs);
+        this._outputs = this.createOutputs(this._outputDecl);
+    }
+    getInputSockets() { return this._inputs; }
+    getOutputSockets() { return this._outputs; }
+    /** Emit any helper functions the user declared. */
+    compileDefs() { return this._defs.trim(); }
+    /**
+     * Emit the script body as a GLSL block:
+     *  1. Declare each input as a local variable (resolved from graph).
+     *  2. Declare each output as a local variable.
+     *  3. Execute the user's GLSL body in a scoped block.
+     *  4. Copy local output vars → canonical output variable names.
+     */
+    compileCall(ctx) {
+        const lines = [];
+        // ── 1. Inputs as local variables ─────────────────────────────────────────
+        for (const [name, socket] of Object.entries(this._inputs)) {
+            const glslType = this._socketGlslType(socket.type);
+            const resolved = ctx.resolveInput(socket);
+            lines.push(`${glslType} ${name} = ${resolved};`);
+        }
+        // ── 2. Output local variables ─────────────────────────────────────────────
+        for (const [name, type] of Object.entries(this._outputDecl)) {
+            const glslType = this._declGlslType(type);
+            lines.push(`${glslType} ${name};`);
+        }
+        // ── 3. User script body in a scoped block ─────────────────────────────────
+        lines.push('{');
+        for (const line of this._glsl.trim().split('\n')) {
+            lines.push(`  ${line}`);
+        }
+        lines.push('}');
+        // ── 4. Copy locals → canonical output var names ───────────────────────────
+        for (const [name, type] of Object.entries(this._outputDecl)) {
+            const glslType = this._declGlslType(type);
+            lines.push(`${glslType} ${ctx.outputVar(this, name)} = ${name};`);
+        }
+        return lines.join('\n  ');
+    }
+    // ── Helpers ──────────────────────────────────────────────────────────────────
+    _socketGlslType(type) {
+        if (type === 'float')
+            return 'float';
+        if (type === 'vector')
+            return 'vec2';
+        return 'vec3'; // 'color' | 'shader'
+    }
+    _declGlslType(type) {
+        if (type === 'float')
+            return 'float';
+        if (type === 'vector')
+            return 'vec2';
+        return 'vec3'; // 'color' | 'shader'
+    }
+}
+ShaderScript.instanceSpecificDef = true; // every script is unique — no dedup

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

@@ -0,0 +1,28 @@
+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 ShaderToRGBInputs {
+    shader?: OutputSocket;
+}
+/**
+ * Shader to RGB — Blender "Shader to RGB" converter node equivalent.
+ * Converts a BSDF shader output back into a colour for further processing.
+ * Useful for cel shading and NPR (non-photorealistic) rendering.
+ *
+ * Inputs:  shader (BSDF)
+ * Outputs: Color (color), Alpha (float)
+ */
+export declare class ShaderToRGB extends ProcessNode {
+    get nodeType(): string;
+    static instanceSpecificDef: boolean;
+    get metadata(): NodeMetadata;
+    private readonly _inputs;
+    private readonly _outputs;
+    constructor(inputs?: ShaderToRGBInputs);
+    getInputSockets(): Record<string, import("../../core/InputSocket.js").InputSocket<unknown>>;
+    getOutputSockets(): Record<string, OutputSocket>;
+    compileDefs(): string;
+    compileCall(ctx: CompileContext): string;
+}
+//# sourceMappingURL=ShaderToRGB.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ShaderToRGB.d.ts","sourceRoot":"","sources":["../../../src/nodes/process/ShaderToRGB.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAA;AACvD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAA;AAC5D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAA;AAClE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAA;AAE9D,MAAM,WAAW,iBAAiB;IAChC,MAAM,CAAC,EAAE,YAAY,CAAA;CACtB;AAED;;;;;;;GAOG;AACH,qBAAa,WAAY,SAAQ,WAAW;IAC1C,IAAI,QAAQ,WAA2B;IACvC,MAAM,CAAC,mBAAmB,UAAQ;IAElC,IAAI,QAAQ,IAAI,YAAY,CAE3B;IAED,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA2E;IACnG,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAmE;gBAEhF,MAAM,GAAE,iBAAsB;IAM1C,eAAe;IACf,gBAAgB;IAChB,WAAW;IAEX,WAAW,CAAC,GAAG,EAAE,cAAc,GAAG,MAAM;CASzC"}

package/dist/nodes/process/ShaderToRGB.js

@@ -0,0 +1,33 @@
+import { ProcessNode } from '../../core/ProcessNode.js';
+/**
+ * Shader to RGB — Blender "Shader to RGB" converter node equivalent.
+ * Converts a BSDF shader output back into a colour for further processing.
+ * Useful for cel shading and NPR (non-photorealistic) rendering.
+ *
+ * Inputs:  shader (BSDF)
+ * Outputs: Color (color), Alpha (float)
+ */
+export class ShaderToRGB extends ProcessNode {
+    get nodeType() { return 'ShaderToRGB'; }
+    get metadata() {
+        return { label: 'Shader to RGB', category: 'Converter', color: '#4a3a6a', cost: 'low' };
+    }
+    constructor(inputs = {}) {
+        super('ShaderToRGB');
+        this._inputs = this.createInputs(inputs, { shader: ['shader', null] });
+        this._outputs = this.createOutputs({ Color: 'color', Alpha: 'float' });
+    }
+    getInputSockets() { return this._inputs; }
+    getOutputSockets() { return this._outputs; }
+    compileDefs() { return ''; }
+    compileCall(ctx) {
+        const shader = ctx.resolveInput(this._inputs.shader);
+        const cv = ctx.outputVar(this, 'Color');
+        const av = ctx.outputVar(this, 'Alpha');
+        return [
+            `vec3  ${cv} = ${shader};`,
+            `float ${av} = 1.0;`,
+        ].join('\n  ');
+    }
+}
+ShaderToRGB.instanceSpecificDef = false;

package/dist/nodes/process/SheenBSDF.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 SheenBSDFInputs {
+    color?: OutputSocket | string;
+    roughness?: OutputSocket | number;
+    normal?: OutputSocket;
+}
+/**
+ * Sheen BSDF — Blender "Sheen BSDF" node equivalent.
+ * Simulates fuzzy micro-fibre cloth surfaces — velvet, satin, felt.
+ * Uses Ashikhmin sheen model approximation.
+ *
+ * Inputs:  color, roughness, normal
+ * Outputs: BSDF (shader)
+ */
+export declare class SheenBSDF extends ProcessNode {
+    get nodeType(): string;
+    static instanceSpecificDef: boolean;
+    get metadata(): NodeMetadata;
+    static glslFunction: string;
+    private readonly _inputs;
+    private readonly _outputs;
+    constructor(inputs?: SheenBSDFInputs);
+    getInputSockets(): Record<string, import("../../core/InputSocket.js").InputSocket<unknown>>;
+    getOutputSockets(): Record<string, OutputSocket>;
+    compileDefs(): string;
+    compileCall(ctx: CompileContext): string;
+}
+//# sourceMappingURL=SheenBSDF.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"SheenBSDF.d.ts","sourceRoot":"","sources":["../../../src/nodes/process/SheenBSDF.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,KAAK,CAAC,EAAM,YAAY,GAAG,MAAM,CAAA;IACjC,SAAS,CAAC,EAAE,YAAY,GAAG,MAAM,CAAA;IACjC,MAAM,CAAC,EAAK,YAAY,CAAA;CACzB;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,SAYnB;IAEA,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA2E;IACnG,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAmE;gBAEhF,MAAM,GAAE,eAAoB;IAUxC,eAAe;IACf,gBAAgB;IAChB,WAAW;IAEX,WAAW,CAAC,GAAG,EAAE,cAAc,GAAG,MAAM;CAQzC"}

package/dist/nodes/process/SheenBSDF.js

@@ -0,0 +1,49 @@
+import { ProcessNode } from '../../core/ProcessNode.js';
+/**
+ * Sheen BSDF — Blender "Sheen BSDF" node equivalent.
+ * Simulates fuzzy micro-fibre cloth surfaces — velvet, satin, felt.
+ * Uses Ashikhmin sheen model approximation.
+ *
+ * Inputs:  color, roughness, normal
+ * Outputs: BSDF (shader)
+ */
+export class SheenBSDF extends ProcessNode {
+    get nodeType() { return 'SheenBSDF'; }
+    get metadata() {
+        return { label: 'Sheen BSDF', category: 'Shader', color: '#336699', cost: 'medium' };
+    }
+    constructor(inputs = {}) {
+        super('SheenBSDF');
+        this._inputs = this.createInputs(inputs, {
+            color: ['color', '#ffffff'],
+            roughness: ['float', inputs.roughness ?? 0.5],
+            normal: ['color', null],
+        });
+        this._outputs = this.createOutputs({ BSDF: 'shader' });
+    }
+    getInputSockets() { return this._inputs; }
+    getOutputSockets() { return this._outputs; }
+    compileDefs() { return SheenBSDF.glslFunction; }
+    compileCall(ctx) {
+        const color = ctx.resolveInput(this._inputs.color);
+        const roughness = ctx.resolveInput(this._inputs.roughness);
+        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_sheenBSDF(${color}, ${roughness}, ${normal});`;
+    }
+}
+SheenBSDF.instanceSpecificDef = false;
+SheenBSDF.glslFunction = `
+vec3 _st_sheenBSDF(vec3 color, float roughness, vec3 N) {
+  vec3  V     = normalize(cameraPosition - vPosition);
+  vec3  L     = normalize(vec3(1.0, 2.0, 1.0));
+  vec3  H     = normalize(L + V);
+  float NdotL = max(dot(N, L), 0.0);
+  float NdotV = max(dot(N, V), 0.0001);
+  float NdotH = max(dot(N, H), 0.0);
+  float sinThetaH = sqrt(max(1.0 - NdotH * NdotH, 0.0));
+  float r2 = roughness * roughness;
+  float sheen = (2.0 + 1.0 / r2) * pow(sinThetaH, 1.0 / r2) / (2.0 * 3.14159);
+  return color * sheen * NdotL / max(NdotL + NdotV - NdotL * NdotV, 0.0001) + color * 0.03;
+}`;

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

@@ -0,0 +1,32 @@
+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 SpecularBSDFInputs {
+    baseColor?: OutputSocket | string;
+    specular?: OutputSocket | string;
+    roughness?: OutputSocket | number;
+    normal?: OutputSocket;
+}
+/**
+ * Specular BSDF — Blender "Specular BSDF" node equivalent.
+ * Specular workflow alternative to metalness-roughness PBR.
+ * Uses explicit specular colour rather than metallic factor.
+ *
+ * Inputs:  baseColor, specular (color), roughness, normal
+ * Outputs: BSDF (shader)
+ */
+export declare class SpecularBSDF extends ProcessNode {
+    get nodeType(): string;
+    static instanceSpecificDef: boolean;
+    get metadata(): NodeMetadata;
+    static glslFunction: string;
+    private readonly _inputs;
+    private readonly _outputs;
+    constructor(inputs?: SpecularBSDFInputs);
+    getInputSockets(): Record<string, import("../../core/InputSocket.js").InputSocket<unknown>>;
+    getOutputSockets(): Record<string, OutputSocket>;
+    compileDefs(): string;
+    compileCall(ctx: CompileContext): string;
+}
+//# sourceMappingURL=SpecularBSDF.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"SpecularBSDF.d.ts","sourceRoot":"","sources":["../../../src/nodes/process/SpecularBSDF.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAA;AACvD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAA;AAC5D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAA;AAClE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAA;AAE9D,MAAM,WAAW,kBAAkB;IACjC,SAAS,CAAC,EAAI,YAAY,GAAG,MAAM,CAAA;IACnC,QAAQ,CAAC,EAAK,YAAY,GAAG,MAAM,CAAA;IACnC,SAAS,CAAC,EAAI,YAAY,GAAG,MAAM,CAAA;IACnC,MAAM,CAAC,EAAO,YAAY,CAAA;CAC3B;AAED;;;;;;;GAOG;AACH,qBAAa,YAAa,SAAQ,WAAW;IAC3C,IAAI,QAAQ,WAA4B;IACxC,MAAM,CAAC,mBAAmB,UAAQ;IAElC,IAAI,QAAQ,IAAI,YAAY,CAE3B;IAED,MAAM,CAAC,YAAY,SAenB;IAEA,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA2E;IACnG,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAmE;gBAEhF,MAAM,GAAE,kBAAuB;IAW3C,eAAe;IACf,gBAAgB;IAChB,WAAW;IAEX,WAAW,CAAC,GAAG,EAAE,cAAc,GAAG,MAAM;CASzC"}

package/dist/nodes/process/SpecularBSDF.js

@@ -0,0 +1,54 @@
+import { ProcessNode } from '../../core/ProcessNode.js';
+/**
+ * Specular BSDF — Blender "Specular BSDF" node equivalent.
+ * Specular workflow alternative to metalness-roughness PBR.
+ * Uses explicit specular colour rather than metallic factor.
+ *
+ * Inputs:  baseColor, specular (color), roughness, normal
+ * Outputs: BSDF (shader)
+ */
+export class SpecularBSDF extends ProcessNode {
+    get nodeType() { return 'SpecularBSDF'; }
+    get metadata() {
+        return { label: 'Specular BSDF', category: 'Shader', color: '#336699', cost: 'medium' };
+    }
+    constructor(inputs = {}) {
+        super('SpecularBSDF');
+        this._inputs = this.createInputs(inputs, {
+            baseColor: ['color', '#ffffff'],
+            specular: ['color', '#888888'],
+            roughness: ['float', inputs.roughness ?? 0.5],
+            normal: ['color', null],
+        });
+        this._outputs = this.createOutputs({ BSDF: 'shader' });
+    }
+    getInputSockets() { return this._inputs; }
+    getOutputSockets() { return this._outputs; }
+    compileDefs() { return SpecularBSDF.glslFunction; }
+    compileCall(ctx) {
+        const base = ctx.resolveInput(this._inputs.baseColor);
+        const spec = ctx.resolveInput(this._inputs.specular);
+        const roughness = ctx.resolveInput(this._inputs.roughness);
+        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_specularBSDF(${base}, ${spec}, ${roughness}, ${normal});`;
+    }
+}
+SpecularBSDF.instanceSpecificDef = false;
+SpecularBSDF.glslFunction = `
+vec3 _st_specularBSDF(vec3 base, vec3 spec, float roughness, vec3 N) {
+  vec3  L     = normalize(vec3(1.0, 2.0, 1.0));
+  vec3  V     = normalize(cameraPosition - vPosition);
+  vec3  H     = normalize(L + V);
+  float NdotL = max(dot(N, L), 0.0);
+  float NdotH = max(dot(N, H), 0.0);
+  float NdotV = max(dot(N, V), 0.0001);
+  float a2    = pow(roughness, 4.0);
+  float D     = a2 / max(3.14159 * pow(NdotH * NdotH * (a2 - 1.0) + 1.0, 2.0), 0.0001);
+  float k     = (roughness + 1.0) * (roughness + 1.0) / 8.0;
+  float G     = (NdotL / (NdotL * (1.0 - k) + k)) * (NdotV / (NdotV * (1.0 - k) + k));
+  vec3  F     = spec + (1.0 - spec) * pow(1.0 - max(dot(H, V), 0.0), 5.0);
+  vec3  specColor = D * G * F / max(4.0 * NdotL * NdotV, 0.0001);
+  return (base / 3.14159 + specColor) * NdotL + base * 0.04;
+}`;

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

@@ -0,0 +1,33 @@
+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 SubsurfaceScatteringInputs {
+    color?: OutputSocket | string;
+    scale?: OutputSocket | number;
+    radius?: [number, number, number];
+    normal?: OutputSocket;
+}
+/**
+ * Subsurface Scattering — Blender "Subsurface Scattering" node equivalent.
+ * Simulates light bleeding beneath thin surfaces — skin, marble, wax, candles.
+ * Real-time approximation using wrap lighting and translucency.
+ *
+ * Inputs:  color, scale [0-1], radius (RGB scatter distances), normal
+ * Outputs: BSDF (shader)
+ */
+export declare class SubsurfaceScattering extends ProcessNode {
+    get nodeType(): string;
+    static instanceSpecificDef: boolean;
+    get metadata(): NodeMetadata;
+    static glslFunction: string;
+    private readonly radius;
+    private readonly _inputs;
+    private readonly _outputs;
+    constructor(inputs?: SubsurfaceScatteringInputs);
+    getInputSockets(): Record<string, import("../../core/InputSocket.js").InputSocket<unknown>>;
+    getOutputSockets(): Record<string, OutputSocket>;
+    compileDefs(): string;
+    compileCall(ctx: CompileContext): string;
+}
+//# sourceMappingURL=SubsurfaceScattering.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"SubsurfaceScattering.d.ts","sourceRoot":"","sources":["../../../src/nodes/process/SubsurfaceScattering.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,KAAK,CAAC,EAAK,YAAY,GAAG,MAAM,CAAA;IAChC,KAAK,CAAC,EAAK,YAAY,GAAG,MAAM,CAAA;IAChC,MAAM,CAAC,EAAI,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;IACnC,MAAM,CAAC,EAAI,YAAY,CAAA;CACxB;AAED;;;;;;;GAOG;AACH,qBAAa,oBAAqB,SAAQ,WAAW;IACnD,IAAI,QAAQ,WAAoC;IAChD,MAAM,CAAC,mBAAmB,UAAQ;IAElC,IAAI,QAAQ,IAAI,YAAY,CAE3B;IAED,MAAM,CAAC,YAAY,SAOnB;IAEA,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA0B;IACjD,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA2E;IACnG,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAmE;gBAEhF,MAAM,GAAE,0BAA+B;IAWnD,eAAe;IACf,gBAAgB;IAChB,WAAW;IAEX,WAAW,CAAC,GAAG,EAAE,cAAc,GAAG,MAAM;CASzC"}

package/dist/nodes/process/SubsurfaceScattering.js

@@ -0,0 +1,46 @@
+import { ProcessNode } from '../../core/ProcessNode.js';
+/**
+ * Subsurface Scattering — Blender "Subsurface Scattering" node equivalent.
+ * Simulates light bleeding beneath thin surfaces — skin, marble, wax, candles.
+ * Real-time approximation using wrap lighting and translucency.
+ *
+ * Inputs:  color, scale [0-1], radius (RGB scatter distances), normal
+ * Outputs: BSDF (shader)
+ */
+export class SubsurfaceScattering extends ProcessNode {
+    get nodeType() { return 'SubsurfaceScattering'; }
+    get metadata() {
+        return { label: 'Subsurface Scattering', category: 'Shader', color: '#336699', cost: 'medium', costNote: 'Real-time approximation — not physically exact.' };
+    }
+    constructor(inputs = {}) {
+        super('SubsurfaceScattering');
+        this.radius = inputs.radius ?? [1.0, 0.2, 0.1];
+        this._inputs = this.createInputs(inputs, {
+            color: ['color', '#ffffff'],
+            scale: ['float', inputs.scale ?? 0.05],
+            normal: ['color', null],
+        });
+        this._outputs = this.createOutputs({ BSDF: 'shader' });
+    }
+    getInputSockets() { return this._inputs; }
+    getOutputSockets() { return this._outputs; }
+    compileDefs() { return SubsurfaceScattering.glslFunction; }
+    compileCall(ctx) {
+        const color = ctx.resolveInput(this._inputs.color);
+        const scale = ctx.resolveInput(this._inputs.scale);
+        const [r, g, b] = this.radius;
+        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_sss(${color}, ${scale}, vec3(${r.toFixed(4)}, ${g.toFixed(4)}, ${b.toFixed(4)}), ${normal});`;
+    }
+}
+SubsurfaceScattering.instanceSpecificDef = false;
+SubsurfaceScattering.glslFunction = `
+vec3 _st_sss(vec3 color, float scale, vec3 radius, vec3 N) {
+  vec3  L       = normalize(vec3(1.0, 2.0, 1.0));
+  float wrap    = max(dot(N, L) * 0.5 + 0.5, 0.0);
+  vec3  scatter = color * radius * wrap * scale;
+  float back    = max(-dot(N, L), 0.0) * scale * 0.3;
+  return color * (0.04 + wrap * 0.5) + scatter + color * back;
+}`;

package/dist/nodes/process/ToonBSDF.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 ToonBSDFInputs {
+    color?: OutputSocket | string;
+    size?: OutputSocket | number;
+    smooth?: OutputSocket | number;
+    normal?: OutputSocket;
+}
+/**
+ * Toon BSDF — Blender "Toon BSDF" node equivalent.
+ * Hard cel-shading bands — cartoon and anime aesthetics.
+ *
+ * Inputs:  color, size [0-1], smooth [0-1], normal
+ * Outputs: BSDF (shader)
+ */
+export declare class ToonBSDF extends ProcessNode {
+    get nodeType(): string;
+    static instanceSpecificDef: boolean;
+    get metadata(): NodeMetadata;
+    static glslFunction: string;
+    private readonly _inputs;
+    private readonly _outputs;
+    constructor(inputs?: ToonBSDFInputs);
+    getInputSockets(): Record<string, import("../../core/InputSocket.js").InputSocket<unknown>>;
+    getOutputSockets(): Record<string, OutputSocket>;
+    compileDefs(): string;
+    compileCall(ctx: CompileContext): string;
+}
+//# sourceMappingURL=ToonBSDF.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ToonBSDF.d.ts","sourceRoot":"","sources":["../../../src/nodes/process/ToonBSDF.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,cAAc;IAC7B,KAAK,CAAC,EAAI,YAAY,GAAG,MAAM,CAAA;IAC/B,IAAI,CAAC,EAAK,YAAY,GAAG,MAAM,CAAA;IAC/B,MAAM,CAAC,EAAG,YAAY,GAAG,MAAM,CAAA;IAC/B,MAAM,CAAC,EAAG,YAAY,CAAA;CACvB;AAED;;;;;;GAMG;AACH,qBAAa,QAAS,SAAQ,WAAW;IACvC,IAAI,QAAQ,WAAwB;IACpC,MAAM,CAAC,mBAAmB,UAAQ;IAElC,IAAI,QAAQ,IAAI,YAAY,CAE3B;IAED,MAAM,CAAC,YAAY,SAMnB;IAEA,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA2E;IACnG,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAmE;gBAEhF,MAAM,GAAE,cAAmB;IAWvC,eAAe;IACf,gBAAgB;IAChB,WAAW;IAEX,WAAW,CAAC,GAAG,EAAE,cAAc,GAAG,MAAM;CASzC"}

package/dist/nodes/process/ToonBSDF.js

@@ -0,0 +1,44 @@
+import { ProcessNode } from '../../core/ProcessNode.js';
+/**
+ * Toon BSDF — Blender "Toon BSDF" node equivalent.
+ * Hard cel-shading bands — cartoon and anime aesthetics.
+ *
+ * Inputs:  color, size [0-1], smooth [0-1], normal
+ * Outputs: BSDF (shader)
+ */
+export class ToonBSDF extends ProcessNode {
+    get nodeType() { return 'ToonBSDF'; }
+    get metadata() {
+        return { label: 'Toon BSDF', category: 'Shader', color: '#336699', cost: 'low' };
+    }
+    constructor(inputs = {}) {
+        super('ToonBSDF');
+        this._inputs = this.createInputs(inputs, {
+            color: ['color', '#ffffff'],
+            size: ['float', inputs.size ?? 0.5],
+            smooth: ['float', inputs.smooth ?? 0.0],
+            normal: ['color', null],
+        });
+        this._outputs = this.createOutputs({ BSDF: 'shader' });
+    }
+    getInputSockets() { return this._inputs; }
+    getOutputSockets() { return this._outputs; }
+    compileDefs() { return ToonBSDF.glslFunction; }
+    compileCall(ctx) {
+        const color = ctx.resolveInput(this._inputs.color);
+        const size = ctx.resolveInput(this._inputs.size);
+        const smoothWidth = ctx.resolveInput(this._inputs.smooth);
+        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_toonBSDF(${color}, ${size}, ${smoothWidth}, ${normal});`;
+    }
+}
+ToonBSDF.instanceSpecificDef = false;
+ToonBSDF.glslFunction = `
+vec3 _st_toonBSDF(vec3 color, float size, float smoothWidth, vec3 N) {
+  vec3  L     = normalize(vec3(1.0, 2.0, 1.0));
+  float NdotL = dot(N, L) * 0.5 + 0.5;
+  float band  = smoothstep(size - smoothWidth, size + smoothWidth, NdotL);
+  return color * band + color * 0.1;
+}`;