@triforge/shader-core 0.3.0 → 0.4.1

package/dist/nodes/process/Bump.js

@@ -1,9 +1,14 @@
 import { ProcessNode } from '../../core/ProcessNode.js';
+import { ShaderNodeError } from '../../core/ShaderNodeError.js';
+import { ShaderConfig } from '../../core/ShaderConfig.js';
+import { assertGlslIdentifier } from '../../core/glslIdentifier.js';
 /**
  * Bump — Blender "Bump" node equivalent.
- * Converts a height map into a perturbed surface normal using screen-space derivatives.
+ * Converts a height map into a perturbed surface normal.
  *
  * Inputs:  strength [0-1], distance, height (float), normal (optional override)
+ *          method ('derivative' | 'uv-offset'), uniformName/vector/texelSize/lod
+ *          (uv-offset mode only)
  * Outputs: Normal (color/vec3)
  */
 export class Bump extends ProcessNode {
@@ -13,53 +18,130 @@ export class Bump extends ProcessNode {
     }
     constructor(inputs = {}) {
         super('Bump');
+        this._method = inputs.method ?? 'derivative';
+        if (this._method === 'uv-offset') {
+            if (ShaderConfig.errorLevel !== 'off' && !inputs.uniformName) {
+                ShaderNodeError.throw({
+                    nodeType: 'Bump',
+                    nodeId: this.id,
+                    problem: 'uniformName is required when method:"uv-offset".',
+                    fix: 'new Bump({ method: "uv-offset", uniformName: "uHeightTex" })\n  After compile(): mat.material.uniforms.uHeightTex = { value: texture }',
+                });
+            }
+            if (inputs.uniformName)
+                assertGlslIdentifier(inputs.uniformName, 'Bump uniformName');
+            this._uniformName = inputs.uniformName ?? null;
+        }
+        else {
+            this._uniformName = null;
+        }
         this._inputs = this.createInputs(inputs, {
             strength: ['float', inputs.strength ?? 1.0],
             distance: ['float', inputs.distance ?? 1.0],
             height: ['float', 0.5],
             normal: ['color', null],
+            vector: ['vector', null],
+            texelSize: ['float', inputs.texelSize ?? 1 / 512],
+            lod: ['float', inputs.lod ?? 0.0],
         });
         this._outputs = this.createOutputs({ Normal: 'color' });
     }
     getInputSockets() { return this._inputs; }
     getOutputSockets() { return this._outputs; }
-    compileDefs() { return Bump.glslFunction; }
+    compileDefs() {
+        if (this._method === 'uv-offset') {
+            // The #extension line is hoisted to the very top of the fragment shader
+            // (before `precision`) and deduplicated by CompileContext regardless of
+            // where/how many times it's emitted here — see
+            // CompileContext._extractExtensions. No local guard needed.
+            return [
+                '#extension GL_EXT_shader_texture_lod : enable',
+                `uniform sampler2D ${this._uniformName};`,
+            ].join('\n');
+        }
+        return Bump.derivativeGlslFunction;
+    }
     compileCall(ctx) {
-        const height = ctx.resolveInput(this._inputs.height);
         const strength = ctx.resolveInput(this._inputs.strength);
         const distance = ctx.resolveInput(this._inputs.distance);
         const normal = this._inputs.normal.isConnected()
             ? ctx.outputVar(this._inputs.normal.connection.node, this._inputs.normal.connection.name)
             : 'normalize(vNormal)';
+        if (this._method === 'uv-offset') {
+            const uv = this._inputs.vector.isConnected() ? ctx.resolveInput(this._inputs.vector) : 'vUv';
+            const texelSize = ctx.resolveInput(this._inputs.texelSize);
+            const lod = ctx.resolveInput(this._inputs.lod);
+            const id = this.id;
+            const hL = `_bmp_${id}_hL`, hR = `_bmp_${id}_hR`;
+            const hD = `_bmp_${id}_hD`, hU = `_bmp_${id}_hU`;
+            const dPdx = `_bmp_${id}_dPdx`, dPdy = `_bmp_${id}_dPdy`;
+            const dUdx = `_bmp_${id}_dUdx`, dUdy = `_bmp_${id}_dUdy`;
+            const det = `_bmp_${id}_det`, sgn = `_bmp_${id}_sgn`, invDet = `_bmp_${id}_invDet`;
+            const T = `_bmp_${id}_T`, B = `_bmp_${id}_B`;
+            const dhdu = `_bmp_${id}_dhdu`, dhdv = `_bmp_${id}_dhdv`;
+            const scale = `_bmp_${id}_scale`;
+            const ts = `_bmp_${id}_ts`;
+            return [
+                `float ${ts}  = ${texelSize};`,
+                `float ${hL}  = texture2DLodEXT(${this._uniformName}, ${uv} - vec2(${ts}, 0.0), ${lod}).r;`,
+                `float ${hR}  = texture2DLodEXT(${this._uniformName}, ${uv} + vec2(${ts}, 0.0), ${lod}).r;`,
+                `float ${hD}  = texture2DLodEXT(${this._uniformName}, ${uv} - vec2(0.0, ${ts}), ${lod}).r;`,
+                `float ${hU}  = texture2DLodEXT(${this._uniformName}, ${uv} + vec2(0.0, ${ts}), ${lod}).r;`,
+                // Cotangent frame from screen-space derivatives — this builds the tangent
+                // basis (surface-fixed), not the height sample, so it doesn't carry the
+                // camera-distance instability the uv-offset method exists to avoid.
+                `vec3  ${dPdx} = dFdx(vPosition);`,
+                `vec3  ${dPdy} = dFdy(vPosition);`,
+                `vec2  ${dUdx} = dFdx(vUv);`,
+                `vec2  ${dUdy} = dFdy(vUv);`,
+                `float ${det}    = ${dUdx}.x * ${dUdy}.y - ${dUdx}.y * ${dUdy}.x;`,
+                `float ${sgn}    = sign(${det});`,
+                `float ${invDet} = ${sgn} / max(abs(${det}), 1e-6);`,
+                `vec3  ${T} = normalize((${dUdy}.y * ${dPdx} - ${dUdx}.y * ${dPdy}) * ${invDet});`,
+                `vec3  ${B} = normalize(cross(${normal}, ${T})) * ${sgn};`,
+                `float ${dhdu} = (${hR} - ${hL}) / max(2.0 * ${ts}, 1e-6);`,
+                `float ${dhdv} = (${hU} - ${hD}) / max(2.0 * ${ts}, 1e-6);`,
+                `float ${scale} = ${strength} * ${distance} * 50.0;`,
+                `vec3 ${ctx.outputVar(this, 'Normal')} = normalize(${normal} - ${T} * ${dhdu} * ${scale} - ${B} * ${dhdv} * ${scale});`,
+            ].join('\n  ');
+        }
+        const height = ctx.resolveInput(this._inputs.height);
         return `vec3 ${ctx.outputVar(this, 'Normal')} = _st_bump(${height}, ${strength}, ${distance}, ${normal});`;
     }
 }
-Bump.instanceSpecificDef = false;
-Bump.glslFunction = `
-vec3 _st_bump(float height, float strength, float distance, vec3 N) {
-  // Cotangent frame bump — camera-independent.
-  // We derive world-space surface tangent T and bitangent B from the UV
-  // parameterisation (cotangent frame). This gives vectors that are fixed
-  // to the surface regardless of camera orientation.
-  // Then we express the height gradient in UV space (dh/du, dh/dv) which
-  // is also surface-fixed, eliminating the screen-space dependency.
-  vec3 dPdx = dFdx(vPosition);
-  vec3 dPdy = dFdy(vPosition);
-  vec2 dUdx = dFdx(vUv);
-  vec2 dUdy = dFdy(vUv);
-
-  float det    = dUdx.x * dUdy.y - dUdx.y * dUdy.x;
-  float sgn    = sign(det);
-  float invDet = sgn / max(abs(det), 1e-6);
-
-  // World-space tangent and bitangent from UV Jacobian (camera-independent)
-  vec3 T = normalize((dUdy.y * dPdx - dUdx.y * dPdy) * invDet);
-  vec3 B = normalize(cross(N, T)) * sgn;
-
-  // Height gradient in UV space (camera-independent)
-  float dhdu = (dUdy.y * dFdx(height) - dUdx.y * dFdy(height)) * invDet;
-  float dhdv = (dUdx.x * dFdy(height) - dUdy.x * dFdx(height)) * invDet;
-
-  float scale = strength * distance * 50.0;
-  return normalize(N - T * dhdu * scale - B * dhdv * scale);
-}`;
+// Both modes emit their own per-instance defs (a #ifndef-guarded shared function
+// for 'derivative', a per-instance uniform declaration for 'uv-offset' — see
+// compileDefs). instanceSpecificDef:true is required so multiple 'uv-offset'
+// instances each get their own uniform decl instead of being deduped by nodeType.
+Bump.instanceSpecificDef = true;
+Bump.derivativeGlslFunction = `
+#ifndef _ST_BUMP_FN
+#define _ST_BUMP_FN
+vec3 _st_bump(float height, float strength, float distance, vec3 N) {
+  // Cotangent frame bump — camera-independent.
+  // We derive world-space surface tangent T and bitangent B from the UV
+  // parameterisation (cotangent frame). This gives vectors that are fixed
+  // to the surface regardless of camera orientation.
+  // Then we express the height gradient in UV space (dh/du, dh/dv) which
+  // is also surface-fixed, eliminating the screen-space dependency.
+  vec3 dPdx = dFdx(vPosition);
+  vec3 dPdy = dFdy(vPosition);
+  vec2 dUdx = dFdx(vUv);
+  vec2 dUdy = dFdy(vUv);
+
+  float det    = dUdx.x * dUdy.y - dUdx.y * dUdy.x;
+  float sgn    = sign(det);
+  float invDet = sgn / max(abs(det), 1e-6);
+
+  // World-space tangent and bitangent from UV Jacobian (camera-independent)
+  vec3 T = normalize((dUdy.y * dPdx - dUdx.y * dPdy) * invDet);
+  vec3 B = normalize(cross(N, T)) * sgn;
+
+  // Height gradient in UV space (camera-independent)
+  float dhdu = (dUdy.y * dFdx(height) - dUdx.y * dFdy(height)) * invDet;
+  float dhdv = (dUdx.x * dFdy(height) - dUdy.x * dFdx(height)) * invDet;
+
+  float scale = strength * distance * 50.0;
+  return normalize(N - T * dhdu * scale - B * dhdv * scale);
+}
+#endif`;

package/dist/nodes/process/DiffuseBSDF.js

@@ -33,11 +33,11 @@ export class DiffuseBSDF extends ProcessNode {
     }
 }
 DiffuseBSDF.instanceSpecificDef = false;
-DiffuseBSDF.glslFunction = `
-vec3 _st_diffuseBSDF(vec3 color, float roughness, vec3 N) {
-  vec3  L       = normalize(vec3(1.0, 2.0, 1.0));
-  float NdotL   = max(dot(N, L), 0.0);
-  float diffuse = NdotL / 3.14159265;
-  vec3  ambient = color * 0.15;
-  return ambient + color * (diffuse * (1.0 - roughness * 0.5));
+DiffuseBSDF.glslFunction = `
+vec3 _st_diffuseBSDF(vec3 color, float roughness, vec3 N) {
+  vec3  L       = normalize(vec3(1.0, 2.0, 1.0));
+  float NdotL   = max(dot(N, L), 0.0);
+  float diffuse = NdotL / 3.14159265;
+  vec3  ambient = color * 0.15;
+  return ambient + color * (diffuse * (1.0 - roughness * 0.5));
 }`;

package/dist/nodes/process/Emission.js

@@ -30,7 +30,7 @@ export class Emission extends ProcessNode {
     }
 }
 Emission.instanceSpecificDef = false;
-Emission.glslFunction = `
-vec3 _st_emission(vec3 color, float strength) {
-  return color * strength;
+Emission.glslFunction = `
+vec3 _st_emission(vec3 color, float strength) {
+  return color * strength;
 }`;

package/dist/nodes/process/GlassBSDF.js

@@ -35,17 +35,17 @@ export class GlassBSDF extends ProcessNode {
     }
 }
 GlassBSDF.instanceSpecificDef = false;
-GlassBSDF.glslFunction = `
-vec3 _st_glassBSDF(vec3 color, float roughness, float ior, vec3 N) {
-  vec3  V       = normalize(cameraPosition - vPosition);
-  vec3  L       = normalize(vec3(1.0, 2.0, 1.0));
-  vec3  H       = normalize(L + V);
-  float F0      = pow((1.0 - ior) / (1.0 + ior), 2.0);
-  float fresnel = F0 + (1.0 - F0) * pow(1.0 - max(dot(V, N), 0.0), 5.0);
-  float NdotH   = max(dot(N, H), 0.0);
-  float a2      = roughness * roughness * roughness * roughness;
-  float D       = a2 / max(3.14159 * pow(NdotH * NdotH * (a2 - 1.0) + 1.0, 2.0), 0.0001);
-  vec3  spec    = vec3(1.0) * D * fresnel;
-  vec3  refr    = color * (1.0 - fresnel) * (1.0 - roughness * 0.3);
-  return spec + refr;
+GlassBSDF.glslFunction = `
+vec3 _st_glassBSDF(vec3 color, float roughness, float ior, vec3 N) {
+  vec3  V       = normalize(cameraPosition - vPosition);
+  vec3  L       = normalize(vec3(1.0, 2.0, 1.0));
+  vec3  H       = normalize(L + V);
+  float F0      = pow((1.0 - ior) / (1.0 + ior), 2.0);
+  float fresnel = F0 + (1.0 - F0) * pow(1.0 - max(dot(V, N), 0.0), 5.0);
+  float NdotH   = max(dot(N, H), 0.0);
+  float a2      = roughness * roughness * roughness * roughness;
+  float D       = a2 / max(3.14159 * pow(NdotH * NdotH * (a2 - 1.0) + 1.0, 2.0), 0.0001);
+  vec3  spec    = vec3(1.0) * D * fresnel;
+  vec3  refr    = color * (1.0 - fresnel) * (1.0 - roughness * 0.3);
+  return spec + refr;
 }`;

package/dist/nodes/process/GlossyBSDF.js

@@ -33,18 +33,18 @@ export class GlossyBSDF extends ProcessNode {
     }
 }
 GlossyBSDF.instanceSpecificDef = false;
-GlossyBSDF.glslFunction = `
-vec3 _st_glossyBSDF(vec3 color, 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 a     = roughness * roughness;
-  float a2    = a * a;
-  float NdotH = max(dot(N, H), 0.0);
-  float D     = a2 / max(3.14159265 * pow(NdotH * NdotH * (a2 - 1.0) + 1.0, 2.0), 0.0001);
-  float NdotL = max(dot(N, L), 0.0);
-  float NdotV = max(dot(N, V), 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));
-  return color * D * G / max(4.0 * NdotL * NdotV, 0.0001) * NdotL;
+GlossyBSDF.glslFunction = `
+vec3 _st_glossyBSDF(vec3 color, 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 a     = roughness * roughness;
+  float a2    = a * a;
+  float NdotH = max(dot(N, H), 0.0);
+  float D     = a2 / max(3.14159265 * pow(NdotH * NdotH * (a2 - 1.0) + 1.0, 2.0), 0.0001);
+  float NdotL = max(dot(N, L), 0.0);
+  float NdotV = max(dot(N, V), 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));
+  return color * D * G / max(4.0 * NdotL * NdotV, 0.0001) * NdotL;
 }`;

package/dist/nodes/process/MixShader.js

@@ -41,7 +41,7 @@ export class MixShader extends ProcessNode {
     }
 }
 MixShader.instanceSpecificDef = false;
-MixShader.glslFunction = `
-vec4 _st_mixShader(float fac, vec4 a, vec4 b) {
-  return mix(a, b, clamp(fac, 0.0, 1.0));
+MixShader.glslFunction = `
+vec4 _st_mixShader(float fac, vec4 a, vec4 b) {
+  return mix(a, b, clamp(fac, 0.0, 1.0));
 }`;

package/dist/nodes/process/PrincipledBSDF.js

@@ -48,43 +48,43 @@ export class PrincipledBSDF extends ProcessNode {
     }
 }
 PrincipledBSDF.instanceSpecificDef = false;
-PrincipledBSDF.glslFunction = `
-// Set these on material.uniforms after compile()
-#ifndef _ST_HAIR_LIGHT_UNIFORMS
-#define _ST_HAIR_LIGHT_UNIFORMS
-uniform vec3 uSunDirection;
-uniform vec3 uSunColor;
-uniform vec3 uAmbientColor;
-#endif
-
-vec3 _st_schlick(vec3 F0, float c) {
-  return F0 + (1.0 - F0) * pow(clamp(1.0 - c, 0.0, 1.0), 5.0);
-}
-float _st_ggx(float NdotH, float r) {
-  float a = r * r, a2 = a * a;
-  float d = (NdotH * NdotH) * (a2 - 1.0) + 1.0;
-  return a2 / max(3.14159 * d * d, 1e-7);
-}
-float _st_geo(float NdotX, float r) {
-  float k = (r + 1.0) * (r + 1.0) / 8.0;
-  return NdotX / max(NdotX * (1.0 - k) + k, 1e-7);
-}
-vec3 _st_principledBSDF(vec3 base, float metallic, float roughness, float ior, vec3 N) {
-  vec3  V     = normalize(cameraPosition - vPosition);
-  vec3  L     = normalize(uSunDirection);
-  vec3  H     = normalize(L + V);
-  float r     = max(roughness, 0.04);
-  float NdotL = max(dot(N, L), 0.0);
-  float NdotV = max(dot(N, V), 1e-4);
-  float NdotH = max(dot(N, H), 0.0);
-  float HdotV = max(dot(H, V), 0.0);
-  float f0s   = pow((1.0 - ior) / (1.0 + ior), 2.0);
-  vec3  F0    = mix(vec3(f0s), base, metallic);
-  vec3  F     = _st_schlick(F0, HdotV);
-  float D     = _st_ggx(NdotH, r);
-  float G     = _st_geo(NdotL, r) * _st_geo(NdotV, r);
-  vec3  spec  = (D * G * F) / max(4.0 * NdotV * NdotL, 1e-7);
-  vec3  kD    = (1.0 - F) * (1.0 - metallic);
-  vec3  ambient = uAmbientColor * base;
-  return ambient + (kD * base / 3.14159 + spec * uSunColor) * NdotL;
+PrincipledBSDF.glslFunction = `
+// Set these on material.uniforms after compile()
+#ifndef _ST_HAIR_LIGHT_UNIFORMS
+#define _ST_HAIR_LIGHT_UNIFORMS
+uniform vec3 uSunDirection;
+uniform vec3 uSunColor;
+uniform vec3 uAmbientColor;
+#endif
+
+vec3 _st_schlick(vec3 F0, float c) {
+  return F0 + (1.0 - F0) * pow(clamp(1.0 - c, 0.0, 1.0), 5.0);
+}
+float _st_ggx(float NdotH, float r) {
+  float a = r * r, a2 = a * a;
+  float d = (NdotH * NdotH) * (a2 - 1.0) + 1.0;
+  return a2 / max(3.14159 * d * d, 1e-7);
+}
+float _st_geo(float NdotX, float r) {
+  float k = (r + 1.0) * (r + 1.0) / 8.0;
+  return NdotX / max(NdotX * (1.0 - k) + k, 1e-7);
+}
+vec3 _st_principledBSDF(vec3 base, float metallic, float roughness, float ior, vec3 N) {
+  vec3  V     = normalize(cameraPosition - vPosition);
+  vec3  L     = normalize(uSunDirection);
+  vec3  H     = normalize(L + V);
+  float r     = max(roughness, 0.04);
+  float NdotL = max(dot(N, L), 0.0);
+  float NdotV = max(dot(N, V), 1e-4);
+  float NdotH = max(dot(N, H), 0.0);
+  float HdotV = max(dot(H, V), 0.0);
+  float f0s   = pow((1.0 - ior) / (1.0 + ior), 2.0);
+  vec3  F0    = mix(vec3(f0s), base, metallic);
+  vec3  F     = _st_schlick(F0, HdotV);
+  float D     = _st_ggx(NdotH, r);
+  float G     = _st_geo(NdotL, r) * _st_geo(NdotV, r);
+  vec3  spec  = (D * G * F) / max(4.0 * NdotV * NdotL, 1e-7);
+  vec3  kD    = (1.0 - F) * (1.0 - metallic);
+  vec3  ambient = uAmbientColor * base;
+  return ambient + (kD * base / 3.14159 + spec * uSunColor) * NdotL;
 }`;

package/dist/nodes/process/PrincipledHair.js

@@ -64,74 +64,74 @@ export class PrincipledHair extends ProcessNode {
 }
 PrincipledHair.instanceSpecificDef = false;
 // Light uniforms guarded by a #define so they survive alongside PrincipledBSDF in the same graph.
-PrincipledHair.glslFunction = `
-#ifndef _ST_HAIR_LIGHT_UNIFORMS
-#define _ST_HAIR_LIGHT_UNIFORMS
-uniform vec3 uSunDirection;
-uniform vec3 uSunColor;
-uniform vec3 uAmbientColor;
-#endif
-
-float _st_hairHash(float n) {
-  return fract(sin(n * 127.1 + 311.7) * 43758.5453);
-}
-
-// Kajiya-Kay dual-lobe hair BSDF.
-// T  = strand tangent (unit, world space)
-// R  = primary specular exponent = 1 / (roughness^2)
-// R2 = secondary specular exponent = 1 / (radialRoughness^2)
-vec3 _st_principledHair(
-  vec3  color,
-  float roughness,
-  float radialRoughness,
-  float coat,
-  float ior,
-  float offset,
-  float randomColor,
-  float randomRoughness,
-  float rnd,
-  vec3  T
-) {
-  // Per-strand variation
-  float rc = _st_hairHash(rnd * 1.3731 + 0.1);
-  float rr = _st_hairHash(rnd * 2.7183 + 0.2);
-  color     = mix(color, color * (0.6 + 0.8 * rc), randomColor);
-  roughness = clamp(roughness + (rr - 0.5) * randomRoughness * 0.5, 0.02, 1.0);
-
-  vec3  V   = normalize(cameraPosition - vPosition);
-  vec3  L   = normalize(uSunDirection);
-  vec3  H   = normalize(L + V);
-  vec3  N   = normalize(vNormal);
-
-  // Kajiya-Kay diffuse: sin(angle T, L)
-  float cosT  = dot(T, L);
-  float sinT  = sqrt(max(1.0 - cosT * cosT, 0.0));
-  float diff  = sinT * max(dot(N, L) * 0.5 + 0.5, 0.0);  // wrap diffuse
-
-  // R lobe — primary specular, shifted by +offset along normal
-  float f0    = pow(clamp((1.0 - ior) / (1.0 + ior), 0.0, 1.0), 2.0);
-  vec3  T1    = normalize(T + offset * N);
-  float cosTH1 = dot(T1, H);
-  float sinTH1 = sqrt(max(1.0 - cosTH1 * cosTH1, 0.0));
-  float exp1   = max(1.0 / max(roughness * roughness, 0.001), 1.0);
-  float spec1  = pow(sinTH1, exp1);
-  vec3  F1     = vec3(f0) + (vec3(1.0) - vec3(f0)) * pow(1.0 - max(dot(H, V), 0.0), 5.0);
-
-  // TRT lobe — secondary specular, shifted by -2*offset, colored
-  vec3  T2    = normalize(T - 2.0 * offset * N);
-  float cosTH2 = dot(T2, H);
-  float sinTH2 = sqrt(max(1.0 - cosTH2 * cosTH2, 0.0));
-  float rr2    = clamp(radialRoughness, 0.02, 1.0);
-  float exp2   = max(1.0 / max(rr2 * rr2, 0.001), 1.0);
-  float spec2  = pow(sinTH2, exp2) * 0.25;
-
-  // Coat gloss
-  float cosTHc  = dot(T, H);
-  float sinTHc  = sqrt(max(1.0 - cosTHc * cosTHc, 0.0));
-  float coatSpec = pow(sinTHc, 128.0) * coat;
-
-  vec3 diffuse  = color * (uSunColor * diff + uAmbientColor);
-  vec3 specular = uSunColor * (F1 * spec1 + vec3(coatSpec)) + color * uSunColor * spec2;
-
-  return diffuse + specular;
+PrincipledHair.glslFunction = `
+#ifndef _ST_HAIR_LIGHT_UNIFORMS
+#define _ST_HAIR_LIGHT_UNIFORMS
+uniform vec3 uSunDirection;
+uniform vec3 uSunColor;
+uniform vec3 uAmbientColor;
+#endif
+
+float _st_hairHash(float n) {
+  return fract(sin(n * 127.1 + 311.7) * 43758.5453);
+}
+
+// Kajiya-Kay dual-lobe hair BSDF.
+// T  = strand tangent (unit, world space)
+// R  = primary specular exponent = 1 / (roughness^2)
+// R2 = secondary specular exponent = 1 / (radialRoughness^2)
+vec3 _st_principledHair(
+  vec3  color,
+  float roughness,
+  float radialRoughness,
+  float coat,
+  float ior,
+  float offset,
+  float randomColor,
+  float randomRoughness,
+  float rnd,
+  vec3  T
+) {
+  // Per-strand variation
+  float rc = _st_hairHash(rnd * 1.3731 + 0.1);
+  float rr = _st_hairHash(rnd * 2.7183 + 0.2);
+  color     = mix(color, color * (0.6 + 0.8 * rc), randomColor);
+  roughness = clamp(roughness + (rr - 0.5) * randomRoughness * 0.5, 0.02, 1.0);
+
+  vec3  V   = normalize(cameraPosition - vPosition);
+  vec3  L   = normalize(uSunDirection);
+  vec3  H   = normalize(L + V);
+  vec3  N   = normalize(vNormal);
+
+  // Kajiya-Kay diffuse: sin(angle T, L)
+  float cosT  = dot(T, L);
+  float sinT  = sqrt(max(1.0 - cosT * cosT, 0.0));
+  float diff  = sinT * max(dot(N, L) * 0.5 + 0.5, 0.0);  // wrap diffuse
+
+  // R lobe — primary specular, shifted by +offset along normal
+  float f0    = pow(clamp((1.0 - ior) / (1.0 + ior), 0.0, 1.0), 2.0);
+  vec3  T1    = normalize(T + offset * N);
+  float cosTH1 = dot(T1, H);
+  float sinTH1 = sqrt(max(1.0 - cosTH1 * cosTH1, 0.0));
+  float exp1   = max(1.0 / max(roughness * roughness, 0.001), 1.0);
+  float spec1  = pow(sinTH1, exp1);
+  vec3  F1     = vec3(f0) + (vec3(1.0) - vec3(f0)) * pow(1.0 - max(dot(H, V), 0.0), 5.0);
+
+  // TRT lobe — secondary specular, shifted by -2*offset, colored
+  vec3  T2    = normalize(T - 2.0 * offset * N);
+  float cosTH2 = dot(T2, H);
+  float sinTH2 = sqrt(max(1.0 - cosTH2 * cosTH2, 0.0));
+  float rr2    = clamp(radialRoughness, 0.02, 1.0);
+  float exp2   = max(1.0 / max(rr2 * rr2, 0.001), 1.0);
+  float spec2  = pow(sinTH2, exp2) * 0.25;
+
+  // Coat gloss
+  float cosTHc  = dot(T, H);
+  float sinTHc  = sqrt(max(1.0 - cosTHc * cosTHc, 0.0));
+  float coatSpec = pow(sinTHc, 128.0) * coat;
+
+  vec3 diffuse  = color * (uSunColor * diff + uAmbientColor);
+  vec3 specular = uSunColor * (F1 * spec1 + vec3(coatSpec)) + color * uSunColor * spec2;
+
+  return diffuse + specular;
 }`;

package/dist/nodes/process/PrincipledVolume.js

@@ -43,25 +43,25 @@ export class PrincipledVolume extends ProcessNode {
     }
 }
 PrincipledVolume.instanceSpecificDef = false;
-PrincipledVolume.glslFunction = `
-vec3 _st_principledVolume(
-  vec3  scatterColor,   float density,
-  float anisotropy,     vec3  absorptionColor,
-  vec3  emissionColor,  float emissionStrength,
-  float blackbodyIntensity, float temperature
-) {
-  float g  = clamp(anisotropy, -0.9999, 0.9999);
-  float g2 = g * g;
-  float phase = (1.0 - g2) / pow(1.0 + g2, 1.5);
-
-  vec3 scatter    = scatterColor * density * phase;
-  vec3 absorption = absorptionColor * density;
-  vec3 emission   = emissionColor * emissionStrength;
-
-  // Simplified blackbody tint: blend toward hot white at high temperature
-  float tNorm = clamp((temperature - 800.0) / 4200.0, 0.0, 1.0);
-  vec3  bb    = mix(vec3(1.0, 0.2, 0.0), vec3(1.0, 0.95, 0.8), tNorm);
-  emission   += bb * blackbodyIntensity * density;
-
-  return scatter + emission - absorption * 0.5;
+PrincipledVolume.glslFunction = `
+vec3 _st_principledVolume(
+  vec3  scatterColor,   float density,
+  float anisotropy,     vec3  absorptionColor,
+  vec3  emissionColor,  float emissionStrength,
+  float blackbodyIntensity, float temperature
+) {
+  float g  = clamp(anisotropy, -0.9999, 0.9999);
+  float g2 = g * g;
+  float phase = (1.0 - g2) / pow(1.0 + g2, 1.5);
+
+  vec3 scatter    = scatterColor * density * phase;
+  vec3 absorption = absorptionColor * density;
+  vec3 emission   = emissionColor * emissionStrength;
+
+  // Simplified blackbody tint: blend toward hot white at high temperature
+  float tNorm = clamp((temperature - 800.0) / 4200.0, 0.0, 1.0);
+  vec3  bb    = mix(vec3(1.0, 0.2, 0.0), vec3(1.0, 0.95, 0.8), tNorm);
+  emission   += bb * blackbodyIntensity * density;
+
+  return scatter + emission - absorption * 0.5;
 }`;

package/dist/nodes/process/RefractionBSDF.js

@@ -36,11 +36,11 @@ export class RefractionBSDF extends ProcessNode {
     }
 }
 RefractionBSDF.instanceSpecificDef = false;
-RefractionBSDF.glslFunction = `
-vec3 _st_refractionBSDF(vec3 color, float roughness, float ior, vec3 N) {
-  vec3  V        = normalize(cameraPosition - vPosition);
-  vec3  refDir   = refract(-V, N, 1.0 / ior);
-  float fresnel  = pow(1.0 - max(dot(V, N), 0.0), 5.0);
-  vec3  refColor = color * (1.0 - fresnel) * (1.0 - roughness * 0.5);
-  return refColor;
+RefractionBSDF.glslFunction = `
+vec3 _st_refractionBSDF(vec3 color, float roughness, float ior, vec3 N) {
+  vec3  V        = normalize(cameraPosition - vPosition);
+  vec3  refDir   = refract(-V, N, 1.0 / ior);
+  float fresnel  = pow(1.0 - max(dot(V, N), 0.0), 5.0);
+  vec3  refColor = color * (1.0 - fresnel) * (1.0 - roughness * 0.5);
+  return refColor;
 }`;

package/dist/nodes/process/SheenBSDF.js

@@ -34,16 +34,16 @@ export class SheenBSDF extends ProcessNode {
     }
 }
 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;
+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.js

@@ -36,19 +36,19 @@ export class SpecularBSDF extends ProcessNode {
     }
 }
 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;
+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;
 }`;