@triforge/shader-core 0.1.0

package/dist/nodes/shader/RayPortal.d.ts

@@ -0,0 +1,57 @@
+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';
+import type { InputSocket } from '../../core/InputSocket.js';
+export interface RayPortalInputs {
+    /** Surface color emitted through the portal */
+    color?: OutputSocket | [number, number, number] | string;
+    /**
+     * Portal Transform (mat4) — defines the exit portal's position and
+     * orientation. Ignored in rasterizer mode; reserved for when
+     * three-gpu-pathtracer supports portal geometry.
+     */
+    portalTransform?: OutputSocket;
+}
+/**
+ * Ray Portal — Blender "Ray Portal" shader node equivalent.
+ *
+ * Path-tracer-only node. Teleports rays from an entry surface to an exit
+ * surface defined by `Portal Transform`. Useful for mirrors, windows, and
+ * non-Euclidean geometry tricks in Cycles.
+ *
+ * In rasterizer mode this node acts as a simple passthrough emitter:
+ * it outputs the input `Color` unchanged and ignores `Portal Transform`.
+ * This produces plausible results for scenes where the portal would look
+ * like a glowing or transparent surface.
+ *
+ * NOTE: Full portal behaviour (ray teleportation) will be enabled once
+ * three-gpu-pathtracer exposes geometry-driven portal BSDF support.
+ *
+ * Parameters:
+ *   blend (number) — blend factor [0–1] between portal BSDF and surface
+ *                    (rasterizer approximation only, default 1.0)
+ *
+ * Inputs:
+ *   Color            (color)  — surface/portal color
+ *   Portal Transform (shader) — exit-portal transform (rasterizer: ignored)
+ *
+ * Outputs:
+ *   BSDF (shader/color) — emitted color (rasterizer passthrough)
+ */
+export declare class RayPortal extends ProcessNode {
+    get nodeType(): string;
+    static instanceSpecificDef: boolean;
+    get metadata(): NodeMetadata;
+    parameters: {
+        blend: number;
+    };
+    private readonly _inputs;
+    private readonly _outputs;
+    constructor(inputs?: RayPortalInputs);
+    getInputSockets(): Record<string, InputSocket<unknown>>;
+    getOutputSockets(): Record<string, OutputSocket>;
+    compileDefs(): string;
+    compileCall(ctx: CompileContext): string;
+}
+//# sourceMappingURL=RayPortal.d.ts.map

package/dist/nodes/shader/RayPortal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RayPortal.d.ts","sourceRoot":"","sources":["../../../src/nodes/shader/RayPortal.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;AAC9D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAA;AAE5D,MAAM,WAAW,eAAe;IAC9B,+CAA+C;IAC/C,KAAK,CAAC,EAAa,YAAY,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,GAAG,MAAM,CAAA;IACnE;;;;OAIG;IACH,eAAe,CAAC,EAAG,YAAY,CAAA;CAChC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,qBAAa,SAAU,SAAQ,WAAW;IACxC,IAAI,QAAQ,WAAyB;IACrC,MAAM,CAAC,mBAAmB,UAAQ;IAElC,IAAI,QAAQ,IAAI,YAAY,CAE3B;IAEQ,UAAU,EAAE;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,CAAiB;IAEvD,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAuC;IAC/D,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAA8B;gBAE3C,MAAM,GAAE,eAAoB;IAUxC,eAAe;IACf,gBAAgB;IAEhB,WAAW,IAAI,MAAM;IAErB,WAAW,CAAC,GAAG,EAAE,cAAc,GAAG,MAAM;CAUzC"}

package/dist/nodes/shader/RayPortal.js

@@ -0,0 +1,56 @@
+import { ProcessNode } from '../../core/ProcessNode.js';
+/**
+ * Ray Portal — Blender "Ray Portal" shader node equivalent.
+ *
+ * Path-tracer-only node. Teleports rays from an entry surface to an exit
+ * surface defined by `Portal Transform`. Useful for mirrors, windows, and
+ * non-Euclidean geometry tricks in Cycles.
+ *
+ * In rasterizer mode this node acts as a simple passthrough emitter:
+ * it outputs the input `Color` unchanged and ignores `Portal Transform`.
+ * This produces plausible results for scenes where the portal would look
+ * like a glowing or transparent surface.
+ *
+ * NOTE: Full portal behaviour (ray teleportation) will be enabled once
+ * three-gpu-pathtracer exposes geometry-driven portal BSDF support.
+ *
+ * Parameters:
+ *   blend (number) — blend factor [0–1] between portal BSDF and surface
+ *                    (rasterizer approximation only, default 1.0)
+ *
+ * Inputs:
+ *   Color            (color)  — surface/portal color
+ *   Portal Transform (shader) — exit-portal transform (rasterizer: ignored)
+ *
+ * Outputs:
+ *   BSDF (shader/color) — emitted color (rasterizer passthrough)
+ */
+export class RayPortal extends ProcessNode {
+    get nodeType() { return 'RayPortal'; }
+    get metadata() {
+        return { label: 'Ray Portal', category: 'Shader', color: '#7a3d5a', cost: 'low' };
+    }
+    constructor(inputs = {}) {
+        super('RayPortal');
+        this.parameters = { blend: 1.0 };
+        this._inputs = this.createInputs(inputs, {
+            color: ['color', inputs.color ?? '#ffffff'],
+            // portalTransform is accepted but not wired in rasterizer mode
+            portalTransform: ['shader', null],
+        });
+        this._outputs = this.createOutputs({ BSDF: 'shader' });
+    }
+    getInputSockets() { return this._inputs; }
+    getOutputSockets() { return this._outputs; }
+    compileDefs() { return ''; }
+    compileCall(ctx) {
+        const color = ctx.resolveInput(this._inputs.color);
+        // SECURITY: validate blend is a finite number before emitting GLSL
+        const rawBlend = this.parameters.blend;
+        const blend = Number.isFinite(rawBlend) ? Math.min(Math.max(rawBlend, 0.0), 1.0).toFixed(4) : '1.0000';
+        // Rasterizer passthrough: BSDF = color * blend
+        // Portal Transform is intentionally unused in this mode.
+        return `vec3 ${ctx.outputVar(this, 'BSDF')} = ${color} * ${blend};`;
+    }
+}
+RayPortal.instanceSpecificDef = false;

package/dist/shaders/color.d.ts

@@ -0,0 +1,12 @@
+import type { ShaderOutput } from '../types/shader.js';
+/**
+ * Color Ramp — Blender ColorRamp node equivalent.
+ * Output variable: rampColor (vec3)
+ */
+export declare function colorRamp(value: string, colors?: string[]): ShaderOutput;
+/**
+ * Principled BSDF — simplified PBR, Blender Principled BSDF node equivalent.
+ * Output variable: bsdf (vec3)
+ */
+export declare function principalBSDF(baseColor: string, roughness?: string, metallic?: string): ShaderOutput;
+//# sourceMappingURL=color.d.ts.map

package/dist/shaders/color.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"color.d.ts","sourceRoot":"","sources":["../../src/shaders/color.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAA;AAUtD;;;GAGG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,GAAE,MAAM,EAA2B,GAAG,YAAY,CAiBhG;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAC3B,SAAS,EAAE,MAAM,EACjB,SAAS,GAAE,MAAc,EACzB,QAAQ,GAAG,MAAc,GACxB,YAAY,CAad"}

package/dist/shaders/color.js

@@ -0,0 +1,42 @@
+function hexToVec3(hex) {
+    const h = hex.replace('#', '');
+    const r = (parseInt(h.substring(0, 2), 16) / 255).toFixed(4);
+    const g = (parseInt(h.substring(2, 4), 16) / 255).toFixed(4);
+    const b = (parseInt(h.substring(4, 6), 16) / 255).toFixed(4);
+    return `vec3(${r}, ${g}, ${b})`;
+}
+/**
+ * Color Ramp — Blender ColorRamp node equivalent.
+ * Output variable: rampColor (vec3)
+ */
+export function colorRamp(value, colors = ['#000000', '#ffffff']) {
+    const count = colors.length;
+    const colorLiterals = colors.map(hexToVec3).join(', ');
+    const defs = `
+vec3 colorRamp(float t) {
+  vec3 _cr[${count}] = vec3[${count}](${colorLiterals});
+  float scaled = clamp(t, 0.0, 1.0) * float(${count - 1});
+  int   idx    = int(floor(scaled));
+  int   next   = min(idx + 1, ${count - 1});
+  return mix(_cr[idx], _cr[next], fract(scaled));
+}
+`;
+    const call = `vec3 rampColor = colorRamp(${value});`;
+    return { defs, call, varName: 'rampColor', type: 'vec3', uniforms: {} };
+}
+/**
+ * Principled BSDF — simplified PBR, Blender Principled BSDF node equivalent.
+ * Output variable: bsdf (vec3)
+ */
+export function principalBSDF(baseColor, roughness = '0.5', metallic = '0.0') {
+    const defs = `
+vec3 principledBSDF(vec3 baseColor, float roughness, float metallic) {
+  vec3  diffuse  = baseColor * (1.0 - metallic);
+  vec3  specular = mix(vec3(0.04), baseColor, metallic);
+  float gloss    = 1.0 - roughness;
+  return diffuse * (0.5 + 0.5 * gloss) + specular * gloss * gloss;
+}
+`;
+    const call = `vec3 bsdf = principledBSDF(${baseColor}, ${roughness}, ${metallic});`;
+    return { defs, call, varName: 'bsdf', type: 'vec3', uniforms: {} };
+}

package/dist/shaders/noise.d.ts

@@ -0,0 +1,12 @@
+import type { ShaderOutput, ShaderFunctionOptions } from '../types/shader.js';
+/**
+ * Perlin Noise — Blender Noise Texture node equivalent.
+ * Output variable: noiseValue (float)
+ */
+export declare function perlinNoise(uv: string, options?: ShaderFunctionOptions): ShaderOutput;
+/**
+ * Voronoi Noise — Blender Voronoi Texture node equivalent.
+ * Output variable: voronoiValue (float)
+ */
+export declare function voronoiNoise(uv: string, options?: ShaderFunctionOptions): ShaderOutput;
+//# sourceMappingURL=noise.d.ts.map

package/dist/shaders/noise.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"noise.d.ts","sourceRoot":"","sources":["../../src/shaders/noise.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,qBAAqB,EAAE,MAAM,oBAAoB,CAAA;AAE7E;;;GAGG;AACH,wBAAgB,WAAW,CAAC,EAAE,EAAE,MAAM,EAAE,OAAO,GAAE,qBAA0B,GAAG,YAAY,CAqCzF;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAAC,EAAE,EAAE,MAAM,EAAE,OAAO,GAAE,qBAA0B,GAAG,YAAY,CA6B1F"}

package/dist/shaders/noise.js

@@ -0,0 +1,70 @@
+/**
+ * Perlin Noise — Blender Noise Texture node equivalent.
+ * Output variable: noiseValue (float)
+ */
+export function perlinNoise(uv, options = {}) {
+    const scale = options.scale ?? 1.0;
+    const seed = options.seed ?? 0.0;
+    const defs = `
+float _phash(vec3 p) {
+  return fract(sin(dot(p, vec3(127.1, 311.7, 74.7))) * 43758.5453);
+}
+
+vec3 _pgrad(vec3 p) {
+  float h = _phash(floor(p));
+  return normalize(vec3(h, fract(h * 34.0), fract(h * 89.0)) * 2.0 - 1.0);
+}
+
+float perlinNoise(vec3 p) {
+  vec3 pi = floor(p);
+  vec3 pf = p - pi;
+  vec3 u  = pf * pf * (3.0 - 2.0 * pf);
+  float v000 = dot(_pgrad(pi + vec3(0,0,0)), pf - vec3(0,0,0));
+  float v100 = dot(_pgrad(pi + vec3(1,0,0)), pf - vec3(1,0,0));
+  float v010 = dot(_pgrad(pi + vec3(0,1,0)), pf - vec3(0,1,0));
+  float v110 = dot(_pgrad(pi + vec3(1,1,0)), pf - vec3(1,1,0));
+  float v001 = dot(_pgrad(pi + vec3(0,0,1)), pf - vec3(0,0,1));
+  float v101 = dot(_pgrad(pi + vec3(1,0,1)), pf - vec3(1,0,1));
+  float v011 = dot(_pgrad(pi + vec3(0,1,1)), pf - vec3(0,1,1));
+  float v111 = dot(_pgrad(pi + vec3(1,1,1)), pf - vec3(1,1,1));
+  return mix(
+    mix(mix(v000, v100, u.x), mix(v010, v110, u.x), u.y),
+    mix(mix(v001, v101, u.x), mix(v011, v111, u.x), u.y),
+    u.z
+  ) * 0.5 + 0.5;
+}
+`;
+    const call = `float noiseValue = perlinNoise(vec3(${uv}, 0.0) * ${scale.toFixed(4)} + vec3(${seed.toFixed(4)}));`;
+    return { defs, call, varName: 'noiseValue', type: 'float', uniforms: {} };
+}
+/**
+ * Voronoi Noise — Blender Voronoi Texture node equivalent.
+ * Output variable: voronoiValue (float)
+ */
+export function voronoiNoise(uv, options = {}) {
+    const scale = options.scale ?? 1.0;
+    const defs = `
+float voronoiNoise(vec3 p) {
+  vec3 pi = floor(p);
+  vec3 pf = fract(p);
+  float minDist = 1.0;
+  for (int x = -1; x <= 1; x++) {
+    for (int y = -1; y <= 1; y++) {
+      for (int z = -1; z <= 1; z++) {
+        vec3 neighbor  = vec3(float(x), float(y), float(z));
+        vec3 cell      = pi + neighbor;
+        vec3 cellPoint = fract(sin(vec3(
+          dot(cell, vec3(127.1, 311.7, 74.7)),
+          dot(cell, vec3(269.5, 183.3, 246.1)),
+          dot(cell, vec3(113.5, 271.9, 124.6))
+        )) * 43758.5453);
+        minDist = min(minDist, length(neighbor + cellPoint - pf));
+      }
+    }
+  }
+  return minDist;
+}
+`;
+    const call = `float voronoiValue = voronoiNoise(vec3(${uv}, 0.0) * ${scale.toFixed(4)});`;
+    return { defs, call, varName: 'voronoiValue', type: 'float', uniforms: {} };
+}

package/dist/types/shader.d.ts

@@ -0,0 +1,17 @@
+export type ShaderOutput = {
+    /** Function definitions — inject before main() */
+    defs: string;
+    /** Variable assignment — inject inside main() */
+    call: string;
+    /** Name of the output variable produced by `call` */
+    varName: string;
+    type: 'float' | 'vec2' | 'vec3' | 'vec4';
+    uniforms?: Record<string, unknown>;
+};
+export interface ShaderFunctionOptions {
+    scale?: number;
+    intensity?: number;
+    octaves?: number;
+    seed?: number;
+}
+//# sourceMappingURL=shader.d.ts.map

package/dist/types/shader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shader.d.ts","sourceRoot":"","sources":["../../src/types/shader.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,YAAY,GAAG;IACzB,kDAAkD;IAClD,IAAI,EAAE,MAAM,CAAA;IACZ,iDAAiD;IACjD,IAAI,EAAE,MAAM,CAAA;IACZ,qDAAqD;IACrD,OAAO,EAAE,MAAM,CAAA;IACf,IAAI,EAAE,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,MAAM,CAAA;IACxC,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CACnC,CAAA;AAED,MAAM,WAAW,qBAAqB;IACpC,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,IAAI,CAAC,EAAE,MAAM,CAAA;CACd"}

package/dist/types/shader.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@triforge/shader-core",
+  "version": "0.1.0",
+  "description": "GLSL shader library for Three.js with Blender workflow",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist",
+    "package.json"
+  ],
+  "scripts": {
+    "build": "tsc && esbuild src/index.ts --bundle --format=esm --external:three --outfile=dist/bundle.js",
+    "dev": "tsc --watch",
+    "test": "node test/run-tests.js"
+  },
+  "keywords": [
+    "shader",
+    "glsl",
+    "three.js",
+    "materials",
+    "blender"
+  ],
+  "author": "Aftab Ibrahim Kazi",
+  "license": "MIT",
+  "peerDependencies": {
+    "three": ">=0.128.0"
+  },
+  "devDependencies": {
+    "@types/three": "^0.156.0",
+    "esbuild": "^0.28.0",
+    "three": "^0.156.0",
+    "typescript": "^5.3.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/AftabIbrahimKazi/triforge.git",
+    "directory": "st-shader-core"
+  },
+  "homepage": "https://github.com/AftabIbrahimKazi/triforge#readme",
+  "publishConfig": {
+    "access": "public"
+  }
+}