@triforge/shader-core 0.2.1 → 0.4.0

package/dist/nodes/process/PrincipledBSDF.js

@@ -25,51 +25,66 @@ export class PrincipledBSDF extends ProcessNode {
     getInputSockets() { return this._inputs; }
     getOutputSockets() { return this._outputs; }
     compileDefs() { return this.glslFunction ?? PrincipledBSDF.glslFunction; }
+    /**
+     * Alpha has no channel of its own in the underlying vec3 lighting function —
+     * it's applied as the vec4 alpha component at the call site instead (see
+     * compileCall). transparent:true is needed whenever alpha can read below 1.0:
+     * a non-default literal, or any live/connected value (conservatively true).
+     */
+    wantsTransparency() {
+        const alphaSocket = this._inputs.alpha;
+        if (alphaSocket.isConnected())
+            return true;
+        const v = alphaSocket.defaultValue;
+        return typeof v === 'number' && v < 1.0;
+    }
     compileCall(ctx) {
         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_principledBSDF(${ctx.resolveInput(this._inputs.baseColor)}, ${ctx.resolveInput(this._inputs.metallic)}, ${ctx.resolveInput(this._inputs.roughness)}, ${ctx.resolveInput(this._inputs.ior)}, ${ctx.resolveInput(this._inputs.alpha)}, ${normal});`;
+        const rgb = `_st_principledBSDF(${ctx.resolveInput(this._inputs.baseColor)}, ${ctx.resolveInput(this._inputs.metallic)}, ${ctx.resolveInput(this._inputs.roughness)}, ${ctx.resolveInput(this._inputs.ior)}, ${normal})`;
+        const alpha = ctx.resolveInput(this._inputs.alpha);
+        return `vec4 ${ctx.outputVar(this, 'BSDF')} = vec4(${rgb}, ${alpha});`;
     }
 }
 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, float alpha, 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

@@ -59,79 +59,79 @@ export class PrincipledHair extends ProcessNode {
         const tangent = this._inputs.tangent.isConnected()
             ? ctx.outputVar(this._inputs.tangent.connection.node, this._inputs.tangent.connection.name)
             : 'normalize(vStrandTangent)'; // fallback: read attribute directly if not connected
-        return `vec3 ${ctx.outputVar(this, 'BSDF')} = _st_principledHair(${color}, ${roughness}, ${radialRoughness}, ${coat}, ${ior}, ${offset}, ${randomColor}, ${randomRoughness}, ${random}, ${tangent});`;
+        return `vec4 ${ctx.outputVar(this, 'BSDF')} = vec4(_st_principledHair(${color}, ${roughness}, ${radialRoughness}, ${coat}, ${ior}, ${offset}, ${randomColor}, ${randomRoughness}, ${random}, ${tangent}), 1.0);`;
     }
 }
 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

@@ -39,29 +39,29 @@ export class PrincipledVolume extends ProcessNode {
         const emissionStrength = ctx.resolveInput(this._inputs.emissionStrength);
         const blackbodyIntensity = ctx.resolveInput(this._inputs.blackbodyIntensity);
         const temperature = ctx.resolveInput(this._inputs.temperature);
-        return `vec3 ${ctx.outputVar(this, 'Volume')} = _st_principledVolume(${color}, ${density}, ${anisotropy}, ${absorptionColor}, ${emissionColor}, ${emissionStrength}, ${blackbodyIntensity}, ${temperature});`;
+        return `vec4 ${ctx.outputVar(this, 'Volume')} = vec4(_st_principledVolume(${color}, ${density}, ${anisotropy}, ${absorptionColor}, ${emissionColor}, ${emissionStrength}, ${blackbodyIntensity}, ${temperature}), 1.0);`;
     }
 }
 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

@@ -32,15 +32,15 @@ export class RefractionBSDF extends ProcessNode {
         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_refractionBSDF(${color}, ${roughness}, ${ior}, ${normal});`;
+        return `vec4 ${ctx.outputVar(this, 'BSDF')} = vec4(_st_refractionBSDF(${color}, ${roughness}, ${ior}, ${normal}), 1.0);`;
     }
 }
 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/ShaderScript.d.ts

@@ -7,7 +7,7 @@ import type { OutputSocket } from '../../core/OutputSocket.js';
  *   'float'  → float   (uniform or literal)
  *   'color'  → vec3    (uniform or literal hex / [r,g,b])
  *   'vector' → vec2    (UV coordinates)
- *   'shader' → vec3    (BSDF connection)
+ *   'shader' → vec4    (BSDF connection, rgb + alpha)
  */
 export type ScriptInputDecl = ['float' | 'color' | 'vector' | 'shader', unknown];
 /** Output socket type map: socketName → glslType */
@@ -49,7 +49,7 @@ export interface ShaderScriptConfig {
  * 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
+ *   • GLSL types: 'float' → float, 'color' → vec3, 'shader' → vec4, 'vector' → vec2
  *
  * @example
  * const ripple = new ShaderScript({

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

@@ -1 +1 @@
-{"version":3,"file":"ShaderScript.d.ts","sourceRoot":"","sources":["../../../src/nodes/process/ShaderScript.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAA;AAEvD,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;IAmCtC,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"}
+{"version":3,"file":"ShaderScript.d.ts","sourceRoot":"","sources":["../../../src/nodes/process/ShaderScript.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAA;AAEvD,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;IAmCtC,eAAe;IACf,gBAAgB;IAEhB,mDAAmD;IACnD,WAAW,IAAI,MAAM;IAErB;;;;;;OAMG;IACH,WAAW,CAAC,GAAG,EAAE,cAAc,GAAG,MAAM;IAkCxC,OAAO,CAAC,eAAe;IAOvB,OAAO,CAAC,aAAa;CAMtB"}

package/dist/nodes/process/ShaderScript.js

@@ -10,7 +10,7 @@ import { assertGlslIdentifier } from '../../core/glslIdentifier.js';
  * 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
+ *   • GLSL types: 'float' → float, 'color' → vec3, 'shader' → vec4, 'vector' → vec2
  *
  * @example
  * const ripple = new ShaderScript({
@@ -111,14 +111,18 @@ export class ShaderScript extends ProcessNode {
             return 'float';
         if (type === 'vector')
             return 'vec2';
-        return 'vec3'; // 'color' | 'shader'
+        if (type === 'shader')
+            return 'vec4';
+        return 'vec3'; // 'color'
     }
     _declGlslType(type) {
         if (type === 'float')
             return 'float';
         if (type === 'vector')
             return 'vec2';
-        return 'vec3'; // 'color' | 'shader'
+        if (type === 'shader')
+            return 'vec4';
+        return 'vec3'; // 'color'
     }
 }
 ShaderScript.instanceSpecificDef = true; // every script is unique — no dedup

package/dist/nodes/process/ShaderToRGB.js

@@ -25,8 +25,8 @@ export class ShaderToRGB extends ProcessNode {
         const cv = ctx.outputVar(this, 'Color');
         const av = ctx.outputVar(this, 'Alpha');
         return [
-            `vec3  ${cv} = ${shader};`,
-            `float ${av} = 1.0;`,
+            `vec3  ${cv} = (${shader}).rgb;`,
+            `float ${av} = (${shader}).a;`,
         ].join('\n  ');
     }
 }

package/dist/nodes/process/SheenBSDF.js

@@ -30,20 +30,20 @@ export class SheenBSDF extends ProcessNode {
         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});`;
+        return `vec4 ${ctx.outputVar(this, 'BSDF')} = vec4(_st_sheenBSDF(${color}, ${roughness}, ${normal}), 1.0);`;
     }
 }
 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

@@ -32,23 +32,23 @@ export class SpecularBSDF extends ProcessNode {
         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});`;
+        return `vec4 ${ctx.outputVar(this, 'BSDF')} = vec4(_st_specularBSDF(${base}, ${spec}, ${roughness}, ${normal}), 1.0);`;
     }
 }
 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;
 }`;

package/dist/nodes/process/SubsurfaceScattering.js

@@ -32,15 +32,15 @@ export class SubsurfaceScattering extends ProcessNode {
         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});`;
+        return `vec4 ${ctx.outputVar(this, 'BSDF')} = vec4(_st_sss(${color}, ${scale}, vec3(${r.toFixed(4)}, ${g.toFixed(4)}, ${b.toFixed(4)}), ${normal}), 1.0);`;
     }
 }
 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;
+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.js

@@ -31,14 +31,14 @@ export class ToonBSDF extends ProcessNode {
         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});`;
+        return `vec4 ${ctx.outputVar(this, 'BSDF')} = vec4(_st_toonBSDF(${color}, ${size}, ${smoothWidth}, ${normal}), 1.0);`;
     }
 }
 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;
+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;
 }`;

package/dist/nodes/process/TranslucentBSDF.js

@@ -27,13 +27,13 @@ export class TranslucentBSDF extends ProcessNode {
         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_translucentBSDF(${color}, ${normal});`;
+        return `vec4 ${ctx.outputVar(this, 'BSDF')} = vec4(_st_translucentBSDF(${color}, ${normal}), 1.0);`;
     }
 }
 TranslucentBSDF.instanceSpecificDef = false;
-TranslucentBSDF.glslFunction = `
-vec3 _st_translucentBSDF(vec3 color, vec3 N) {
-  vec3  L       = normalize(vec3(1.0, 2.0, 1.0));
-  float backDot = max(dot(-N, L), 0.0);
-  return color * backDot / 3.14159265 + color * 0.02;
+TranslucentBSDF.glslFunction = `
+vec3 _st_translucentBSDF(vec3 color, vec3 N) {
+  vec3  L       = normalize(vec3(1.0, 2.0, 1.0));
+  float backDot = max(dot(-N, L), 0.0);
+  return color * backDot / 3.14159265 + color * 0.02;
 }`;

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

@@ -0,0 +1,26 @@
+import { ProcessNode } from '../../core/ProcessNode.js';
+import type { NodeMetadata } from '../../core/ShaderNode.js';
+import type { CompileContext } from '../../core/CompileContext.js';
+/**
+ * Transparent BSDF — Blender "Transparent BSDF" node equivalent.
+ * Passes light through unfiltered — full transparency, colorless, no inputs.
+ * Combine with MixShader/AddShader to build cutout, fresnel-fade, or
+ * rim-light materials without a hand-written GLSL output node.
+ *
+ * Outputs: BSDF (shader) — always vec4(0.0, 0.0, 0.0, 0.0)
+ */
+export declare class TransparentBSDF extends ProcessNode {
+    get nodeType(): string;
+    static instanceSpecificDef: boolean;
+    get metadata(): NodeMetadata;
+    private readonly _inputs;
+    private readonly _outputs;
+    constructor();
+    getInputSockets(): Record<string, import("../../index.js").InputSocket<unknown>>;
+    getOutputSockets(): Record<string, import("../../index.js").OutputSocket>;
+    compileDefs(): string;
+    /** Always fully transparent — a constant, not a dynamic value, so this always requests transparent:true. */
+    wantsTransparency(): boolean;
+    compileCall(ctx: CompileContext): string;
+}
+//# sourceMappingURL=TransparentBSDF.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"TransparentBSDF.d.ts","sourceRoot":"","sources":["../../../src/nodes/process/TransparentBSDF.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;AAElE;;;;;;;GAOG;AACH,qBAAa,eAAgB,SAAQ,WAAW;IAC9C,IAAI,QAAQ,WAA+B;IAC3C,MAAM,CAAC,mBAAmB,UAAQ;IAElC,IAAI,QAAQ,IAAI,YAAY,CAE3B;IAED,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA2E;IACnG,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAmE;;IAQ5F,eAAe;IACf,gBAAgB;IAChB,WAAW;IAEX,4GAA4G;IAC5G,iBAAiB,IAAI,OAAO;IAE5B,WAAW,CAAC,GAAG,EAAE,cAAc,GAAG,MAAM;CAGzC"}

package/dist/nodes/process/TransparentBSDF.js

@@ -0,0 +1,29 @@
+import { ProcessNode } from '../../core/ProcessNode.js';
+/**
+ * Transparent BSDF — Blender "Transparent BSDF" node equivalent.
+ * Passes light through unfiltered — full transparency, colorless, no inputs.
+ * Combine with MixShader/AddShader to build cutout, fresnel-fade, or
+ * rim-light materials without a hand-written GLSL output node.
+ *
+ * Outputs: BSDF (shader) — always vec4(0.0, 0.0, 0.0, 0.0)
+ */
+export class TransparentBSDF extends ProcessNode {
+    get nodeType() { return 'TransparentBSDF'; }
+    get metadata() {
+        return { label: 'Transparent BSDF', category: 'Shader', color: '#336699', cost: 'low' };
+    }
+    constructor() {
+        super('TransparentBSDF');
+        this._inputs = this.createInputs({}, {});
+        this._outputs = this.createOutputs({ BSDF: 'shader' });
+    }
+    getInputSockets() { return this._inputs; }
+    getOutputSockets() { return this._outputs; }
+    compileDefs() { return ''; }
+    /** Always fully transparent — a constant, not a dynamic value, so this always requests transparent:true. */
+    wantsTransparency() { return true; }
+    compileCall(ctx) {
+        return `vec4 ${ctx.outputVar(this, 'BSDF')} = vec4(0.0, 0.0, 0.0, 0.0);`;
+    }
+}
+TransparentBSDF.instanceSpecificDef = false;

package/dist/nodes/process/VolumeAbsorption.js

@@ -26,11 +26,11 @@ export class VolumeAbsorption extends ProcessNode {
     compileCall(ctx) {
         const color = ctx.resolveInput(this._inputs.color);
         const density = ctx.resolveInput(this._inputs.density);
-        return `vec3 ${ctx.outputVar(this, 'Volume')} = _st_volumeAbsorption(${color}, ${density});`;
+        return `vec4 ${ctx.outputVar(this, 'Volume')} = vec4(_st_volumeAbsorption(${color}, ${density}), 1.0);`;
     }
 }
 VolumeAbsorption.instanceSpecificDef = false;
-VolumeAbsorption.glslFunction = `
-vec3 _st_volumeAbsorption(vec3 color, float density) {
-  return color * density;
+VolumeAbsorption.glslFunction = `
+vec3 _st_volumeAbsorption(vec3 color, float density) {
+  return color * density;
 }`;