three-stdlib 2.15.1 → 2.15.2

package/nodes/display/ColorSpaceNode.js

@@ -1,53 +1,51 @@
-import _defineProperty from '@babel/runtime/helpers/esm/defineProperty';
-import Node from '../core/Node.js';
-import { ShaderNode, sub, mul, pow, vec3, lessThanEqual, mix, join } from '../ShaderNode.js';
-import { LinearEncoding, sRGBEncoding } from 'three';
-
-const LinearToLinear = new ShaderNode(inputs => {
+"use strict";
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const Node = require("../core/Node.js");
+const ShaderNode = require("../ShaderNode.js");
+const THREE = require("three");
+const LinearToLinear = new ShaderNode.ShaderNode((inputs) => {
   return inputs.value;
 });
-const LinearTosRGB = new ShaderNode(inputs => {
-  const {
-    value
-  } = inputs;
+const LinearTosRGB = new ShaderNode.ShaderNode((inputs) => {
+  const { value } = inputs;
   const rgb = value.rgb;
-  const a = sub(mul(pow(value.rgb, vec3(0.41666)), 1.055), vec3(0.055));
-  const b = mul(rgb, 12.92);
-  const factor = vec3(lessThanEqual(rgb, vec3(0.0031308)));
-  const rgbResult = mix(a, b, factor);
-  return join(rgbResult.r, rgbResult.g, rgbResult.b, value.a);
+  const a = ShaderNode.sub(ShaderNode.mul(ShaderNode.pow(value.rgb, ShaderNode.vec3(0.41666)), 1.055), ShaderNode.vec3(0.055));
+  const b = ShaderNode.mul(rgb, 12.92);
+  const factor = ShaderNode.vec3(ShaderNode.lessThanEqual(rgb, ShaderNode.vec3(31308e-7)));
+  const rgbResult = ShaderNode.mix(a, b, factor);
+  return ShaderNode.join(rgbResult.r, rgbResult.g, rgbResult.b, value.a);
 });
 const EncodingLib = {
   LinearToLinear,
   LinearTosRGB
 };
-
-class ColorSpaceNode extends Node {
+const _ColorSpaceNode = class extends Node {
   constructor(method, node) {
-    super('vec4');
+    super("vec4");
     this.method = method;
     this.node = node;
   }
-
   fromEncoding(encoding) {
     let method = null;
-
-    if (encoding === LinearEncoding) {
-      method = 'Linear';
-    } else if (encoding === sRGBEncoding) {
-      method = 'sRGB';
+    if (encoding === THREE.LinearEncoding) {
+      method = "Linear";
+    } else if (encoding === THREE.sRGBEncoding) {
+      method = "sRGB";
     }
-
-    this.method = 'LinearTo' + method;
+    this.method = "LinearTo" + method;
     return this;
   }
-
   generate(builder) {
     const type = this.getNodeType(builder);
     const method = this.method;
     const node = this.node;
-
-    if (method !== ColorSpaceNode.LINEAR_TO_LINEAR) {
+    if (method !== _ColorSpaceNode.LINEAR_TO_LINEAR) {
       const encodingFunctionNode = EncodingLib[method];
       return encodingFunctionNode({
         value: node
@@ -56,12 +54,10 @@ class ColorSpaceNode extends Node {
       return node.build(builder, type);
     }
   }
-
-}
-
-_defineProperty(ColorSpaceNode, "LINEAR_TO_LINEAR", 'LinearToLinear');
-
-_defineProperty(ColorSpaceNode, "LINEAR_TO_SRGB", 'LinearTosRGB');
-
-export default ColorSpaceNode;
-export { LinearToLinear, LinearTosRGB };
+};
+let ColorSpaceNode = _ColorSpaceNode;
+__publicField(ColorSpaceNode, "LINEAR_TO_LINEAR", "LinearToLinear");
+__publicField(ColorSpaceNode, "LINEAR_TO_SRGB", "LinearTosRGB");
+exports.LinearToLinear = LinearToLinear;
+exports.LinearTosRGB = LinearTosRGB;
+exports.default = ColorSpaceNode;

package/nodes/display/ColorSpaceNode.mjs

@@ -0,0 +1,63 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+import Node from "../core/Node.mjs";
+import { ShaderNode, sub, mul, pow, vec3, lessThanEqual, mix, join } from "../ShaderNode.mjs";
+import { LinearEncoding, sRGBEncoding } from "three";
+const LinearToLinear = new ShaderNode((inputs) => {
+  return inputs.value;
+});
+const LinearTosRGB = new ShaderNode((inputs) => {
+  const { value } = inputs;
+  const rgb = value.rgb;
+  const a = sub(mul(pow(value.rgb, vec3(0.41666)), 1.055), vec3(0.055));
+  const b = mul(rgb, 12.92);
+  const factor = vec3(lessThanEqual(rgb, vec3(31308e-7)));
+  const rgbResult = mix(a, b, factor);
+  return join(rgbResult.r, rgbResult.g, rgbResult.b, value.a);
+});
+const EncodingLib = {
+  LinearToLinear,
+  LinearTosRGB
+};
+const _ColorSpaceNode = class extends Node {
+  constructor(method, node) {
+    super("vec4");
+    this.method = method;
+    this.node = node;
+  }
+  fromEncoding(encoding) {
+    let method = null;
+    if (encoding === LinearEncoding) {
+      method = "Linear";
+    } else if (encoding === sRGBEncoding) {
+      method = "sRGB";
+    }
+    this.method = "LinearTo" + method;
+    return this;
+  }
+  generate(builder) {
+    const type = this.getNodeType(builder);
+    const method = this.method;
+    const node = this.node;
+    if (method !== _ColorSpaceNode.LINEAR_TO_LINEAR) {
+      const encodingFunctionNode = EncodingLib[method];
+      return encodingFunctionNode({
+        value: node
+      }).build(builder, type);
+    } else {
+      return node.build(builder, type);
+    }
+  }
+};
+let ColorSpaceNode = _ColorSpaceNode;
+__publicField(ColorSpaceNode, "LINEAR_TO_LINEAR", "LinearToLinear");
+__publicField(ColorSpaceNode, "LINEAR_TO_SRGB", "LinearTosRGB");
+export {
+  LinearToLinear,
+  LinearTosRGB,
+  ColorSpaceNode as default
+};

package/nodes/display/NormalMapNode.js

@@ -1,71 +1,53 @@
-import TempNode from '../core/TempNode.js';
-import ModelNode from '../accessors/ModelNode.js';
-import { ShaderNode, dFdx, dFdy, cross, add, mul, max, dot, cond, inversesqrt, equal, normalize, sub, join, positionView, normalView, uv } from '../ShaderNode.js';
-import { TangentSpaceNormalMap, ObjectSpaceNormalMap } from 'three';
-
-// http://www.thetenthplanet.de/archives/1180
-
-const perturbNormal2ArbNode = new ShaderNode(inputs => {
-  const {
-    eye_pos,
-    surf_norm,
-    mapN,
-    faceDirection,
-    uv
-  } = inputs;
-  const q0 = dFdx(eye_pos.xyz);
-  const q1 = dFdy(eye_pos.xyz);
-  const st0 = dFdx(uv.st);
-  const st1 = dFdy(uv.st);
-  const N = surf_norm; // normalized
-
-  const q1perp = cross(q1, N);
-  const q0perp = cross(N, q0);
-  const T = add(mul(q1perp, st0.x), mul(q0perp, st1.x));
-  const B = add(mul(q1perp, st0.y), mul(q0perp, st1.y));
-  const det = max(dot(T, T), dot(B, B));
-  const scale = cond(equal(det, 0), 0, mul(faceDirection, inversesqrt(det)));
-  return normalize(add(mul(T, mul(mapN.x, scale)), mul(B, mul(mapN.y, scale)), mul(N, mapN.z)));
+"use strict";
+const TempNode = require("../core/TempNode.js");
+const ModelNode = require("../accessors/ModelNode.js");
+const ShaderNode = require("../ShaderNode.js");
+const THREE = require("three");
+const perturbNormal2ArbNode = new ShaderNode.ShaderNode((inputs) => {
+  const { eye_pos, surf_norm, mapN, faceDirection, uv } = inputs;
+  const q0 = ShaderNode.dFdx(eye_pos.xyz);
+  const q1 = ShaderNode.dFdy(eye_pos.xyz);
+  const st0 = ShaderNode.dFdx(uv.st);
+  const st1 = ShaderNode.dFdy(uv.st);
+  const N = surf_norm;
+  const q1perp = ShaderNode.cross(q1, N);
+  const q0perp = ShaderNode.cross(N, q0);
+  const T = ShaderNode.add(ShaderNode.mul(q1perp, st0.x), ShaderNode.mul(q0perp, st1.x));
+  const B = ShaderNode.add(ShaderNode.mul(q1perp, st0.y), ShaderNode.mul(q0perp, st1.y));
+  const det = ShaderNode.max(ShaderNode.dot(T, T), ShaderNode.dot(B, B));
+  const scale = ShaderNode.cond(ShaderNode.equal(det, 0), 0, ShaderNode.mul(faceDirection, ShaderNode.inversesqrt(det)));
+  return ShaderNode.normalize(ShaderNode.add(ShaderNode.mul(T, ShaderNode.mul(mapN.x, scale)), ShaderNode.mul(B, ShaderNode.mul(mapN.y, scale)), ShaderNode.mul(N, mapN.z)));
 });
-
 class NormalMapNode extends TempNode {
   constructor(node, scaleNode = null) {
-    super('vec3');
+    super("vec3");
     this.node = node;
     this.scaleNode = scaleNode;
-    this.normalMapType = TangentSpaceNormalMap;
+    this.normalMapType = THREE.TangentSpaceNormalMap;
   }
-
   generate(builder) {
     const type = this.getNodeType(builder);
-    const {
-      normalMapType,
-      scaleNode
-    } = this;
-    const normalOP = mul(this.node, 2.0);
-    let normalMap = sub(normalOP, 1.0);
-
+    const { normalMapType, scaleNode } = this;
+    const normalOP = ShaderNode.mul(this.node, 2);
+    let normalMap = ShaderNode.sub(normalOP, 1);
     if (scaleNode !== null) {
-      const normalMapScale = mul(normalMap.xy, scaleNode);
-      normalMap = join(normalMapScale, normalMap.z);
+      const normalMapScale = ShaderNode.mul(normalMap.xy, scaleNode);
+      normalMap = ShaderNode.join(normalMapScale, normalMap.z);
     }
-
-    if (normalMapType === ObjectSpaceNormalMap) {
-      const vertexNormalNode = mul(new ModelNode(ModelNode.NORMAL_MATRIX), normalMap);
-      const normal = normalize(vertexNormalNode);
+    if (normalMapType === THREE.ObjectSpaceNormalMap) {
+      const vertexNormalNode = ShaderNode.mul(new ModelNode(ModelNode.NORMAL_MATRIX), normalMap);
+      const normal = ShaderNode.normalize(vertexNormalNode);
       return normal.build(builder, type);
-    } else if (normalMapType === TangentSpaceNormalMap) {
+    } else if (normalMapType === THREE.TangentSpaceNormalMap) {
       const perturbNormal2ArbCall = perturbNormal2ArbNode({
-        eye_pos: positionView,
-        surf_norm: normalView,
+        eye_pos: ShaderNode.positionView,
+        surf_norm: ShaderNode.normalView,
         mapN: normalMap,
-        faceDirection: 1.0,
-        uv: uv()
+        faceDirection: 1,
+        uv: ShaderNode.uv()
       });
       return perturbNormal2ArbCall.build(builder, type);
     }
   }
-
 }
-
-export default NormalMapNode;
+module.exports = NormalMapNode;

package/nodes/display/NormalMapNode.mjs

@@ -0,0 +1,54 @@
+import TempNode from "../core/TempNode.mjs";
+import ModelNode from "../accessors/ModelNode.mjs";
+import { ShaderNode, dFdx, dFdy, cross, add, mul, max, dot, cond, equal, inversesqrt, normalize, sub, join, positionView, normalView, uv } from "../ShaderNode.mjs";
+import { TangentSpaceNormalMap, ObjectSpaceNormalMap } from "three";
+const perturbNormal2ArbNode = new ShaderNode((inputs) => {
+  const { eye_pos, surf_norm, mapN, faceDirection, uv: uv2 } = inputs;
+  const q0 = dFdx(eye_pos.xyz);
+  const q1 = dFdy(eye_pos.xyz);
+  const st0 = dFdx(uv2.st);
+  const st1 = dFdy(uv2.st);
+  const N = surf_norm;
+  const q1perp = cross(q1, N);
+  const q0perp = cross(N, q0);
+  const T = add(mul(q1perp, st0.x), mul(q0perp, st1.x));
+  const B = add(mul(q1perp, st0.y), mul(q0perp, st1.y));
+  const det = max(dot(T, T), dot(B, B));
+  const scale = cond(equal(det, 0), 0, mul(faceDirection, inversesqrt(det)));
+  return normalize(add(mul(T, mul(mapN.x, scale)), mul(B, mul(mapN.y, scale)), mul(N, mapN.z)));
+});
+class NormalMapNode extends TempNode {
+  constructor(node, scaleNode = null) {
+    super("vec3");
+    this.node = node;
+    this.scaleNode = scaleNode;
+    this.normalMapType = TangentSpaceNormalMap;
+  }
+  generate(builder) {
+    const type = this.getNodeType(builder);
+    const { normalMapType, scaleNode } = this;
+    const normalOP = mul(this.node, 2);
+    let normalMap = sub(normalOP, 1);
+    if (scaleNode !== null) {
+      const normalMapScale = mul(normalMap.xy, scaleNode);
+      normalMap = join(normalMapScale, normalMap.z);
+    }
+    if (normalMapType === ObjectSpaceNormalMap) {
+      const vertexNormalNode = mul(new ModelNode(ModelNode.NORMAL_MATRIX), normalMap);
+      const normal = normalize(vertexNormalNode);
+      return normal.build(builder, type);
+    } else if (normalMapType === TangentSpaceNormalMap) {
+      const perturbNormal2ArbCall = perturbNormal2ArbNode({
+        eye_pos: positionView,
+        surf_norm: normalView,
+        mapN: normalMap,
+        faceDirection: 1,
+        uv: uv()
+      });
+      return perturbNormal2ArbCall.build(builder, type);
+    }
+  }
+}
+export {
+  NormalMapNode as default
+};

package/nodes/fog/FogNode.js

@@ -1,18 +1,14 @@
-import Node from '../core/Node.js';
-
+"use strict";
+const Node = require("../core/Node.js");
 class FogNode extends Node {
   constructor(colorNode, factorNode) {
-    super('float');
+    super("float");
     this.colorNode = colorNode;
     this.factorNode = factorNode;
   }
-
   generate(builder) {
-    return this.factorNode.build(builder, 'float');
+    return this.factorNode.build(builder, "float");
   }
-
 }
-
 FogNode.prototype.isFogNode = true;
-
-export default FogNode;
+module.exports = FogNode;

package/nodes/fog/FogNode.mjs

@@ -0,0 +1,15 @@
+import Node from "../core/Node.mjs";
+class FogNode extends Node {
+  constructor(colorNode, factorNode) {
+    super("float");
+    this.colorNode = colorNode;
+    this.factorNode = factorNode;
+  }
+  generate(builder) {
+    return this.factorNode.build(builder, "float");
+  }
+}
+FogNode.prototype.isFogNode = true;
+export {
+  FogNode as default
+};

package/nodes/fog/FogRangeNode.js

@@ -1,20 +1,16 @@
-import FogNode from './FogNode.js';
-import { smoothstep, negate, positionView } from '../ShaderNode.js';
-
+"use strict";
+const FogNode = require("./FogNode.js");
+const ShaderNode = require("../ShaderNode.js");
 class FogRangeNode extends FogNode {
   constructor(colorNode, nearNode, farNode) {
     super(colorNode);
     this.nearNode = nearNode;
     this.farNode = farNode;
   }
-
   generate(builder) {
-    this.factorNode = smoothstep(this.nearNode, this.farNode, negate(positionView.z));
+    this.factorNode = ShaderNode.smoothstep(this.nearNode, this.farNode, ShaderNode.negate(ShaderNode.positionView.z));
     return super.generate(builder);
   }
-
 }
-
 FogRangeNode.prototype.isFogRangeNode = true;
-
-export default FogRangeNode;
+module.exports = FogRangeNode;

package/nodes/fog/FogRangeNode.mjs

@@ -0,0 +1,17 @@
+import FogNode from "./FogNode.mjs";
+import { smoothstep, negate, positionView } from "../ShaderNode.mjs";
+class FogRangeNode extends FogNode {
+  constructor(colorNode, nearNode, farNode) {
+    super(colorNode);
+    this.nearNode = nearNode;
+    this.farNode = farNode;
+  }
+  generate(builder) {
+    this.factorNode = smoothstep(this.nearNode, this.farNode, negate(positionView.z));
+    return super.generate(builder);
+  }
+}
+FogRangeNode.prototype.isFogRangeNode = true;
+export {
+  FogRangeNode as default
+};

package/nodes/functions/BSDFs.js

@@ -1,121 +1,64 @@
-import { ShaderNode, exp2, mul, sub, add, cond, pow, saturate, div, negate, and, greaterThan, pow2, sqrt, max, EPSILON, normalize, positionViewDirection, dot, transformedNormalView, addTo, diffuseColor, specularColor, roughness } from '../ShaderNode.js';
-
-const F_Schlick = new ShaderNode(inputs => {
-  const {
-    f0,
-    f90,
-    dotVH
-  } = inputs; // Original approximation by Christophe Schlick '94
-  // float fresnel = pow( 1.0 - dotVH, 5.0 );
-  // Optimized variant (presented by Epic at SIGGRAPH '13)
-  // https://cdn2.unrealengine.com/Resources/files/2013SiggraphPresentationsNotes-26915738.pdf
-
-  const fresnel = exp2(mul(sub(mul(-5.55473, dotVH), 6.98316), dotVH));
-  return add(mul(f0, sub(1.0, fresnel)), mul(f90, fresnel));
-}); // validated
-
-const BRDF_Lambert = new ShaderNode(inputs => {
-  return mul(1 / Math.PI, inputs.diffuseColor); // punctual light
-}); // validated
-
-const getDistanceAttenuation = new ShaderNode(inputs => {
-  const {
-    lightDistance,
-    cutoffDistance,
-    decayExponent
-  } = inputs;
-  return cond(and(greaterThan(cutoffDistance, 0), greaterThan(decayExponent, 0)), pow(saturate(add(div(negate(lightDistance), cutoffDistance), 1.0)), decayExponent), 1.0);
-}); // validated
-//
-// STANDARD
-//
-// Moving Frostbite to Physically Based Rendering 3.0 - page 12, listing 2
-// https://seblagarde.files.wordpress.com/2015/07/course_notes_moving_frostbite_to_pbr_v32.pdf
-
-const V_GGX_SmithCorrelated = new ShaderNode(inputs => {
-  const {
-    alpha,
-    dotNL,
-    dotNV
-  } = inputs;
-  const a2 = pow2(alpha);
-  const gv = mul(dotNL, sqrt(add(a2, mul(sub(1.0, a2), pow2(dotNV)))));
-  const gl = mul(dotNV, sqrt(add(a2, mul(sub(1.0, a2), pow2(dotNL)))));
-  return div(0.5, max(add(gv, gl), EPSILON));
-}); // validated
-// Microfacet Models for Refraction through Rough Surfaces - equation (33)
-// http://graphicrants.blogspot.com/2013/08/specular-brdf-reference.html
-// alpha is "roughness squared" in Disney’s reparameterization
-
-const D_GGX = new ShaderNode(inputs => {
-  const {
-    alpha,
-    dotNH
-  } = inputs;
-  const a2 = pow2(alpha);
-  const denom = add(mul(pow2(dotNH), sub(a2, 1.0)), 1.0); // avoid alpha = 0 with dotNH = 1
-
-  return mul(1 / Math.PI, div(a2, pow2(denom)));
-}); // validated
-// GGX Distribution, Schlick Fresnel, GGX_SmithCorrelated Visibility
-
-const BRDF_GGX = new ShaderNode(inputs => {
-  const {
-    lightDirection,
-    f0,
-    f90,
-    roughness
-  } = inputs;
-  const alpha = pow2(roughness); // UE4's roughness
-
-  const halfDir = normalize(add(lightDirection, positionViewDirection));
-  const dotNL = saturate(dot(transformedNormalView, lightDirection));
-  const dotNV = saturate(dot(transformedNormalView, positionViewDirection));
-  const dotNH = saturate(dot(transformedNormalView, halfDir));
-  const dotVH = saturate(dot(positionViewDirection, halfDir));
-  const F = F_Schlick({
-    f0,
-    f90,
-    dotVH
-  });
-  const V = V_GGX_SmithCorrelated({
-    alpha,
-    dotNL,
-    dotNV
-  });
-  const D = D_GGX({
-    alpha,
-    dotNH
-  });
-  return mul(F, mul(V, D));
-}); // validated
-
-const RE_Direct_Physical = new ShaderNode(inputs => {
-  const {
-    lightDirection,
-    lightColor,
-    directDiffuse,
-    directSpecular
-  } = inputs;
-  const dotNL = saturate(dot(transformedNormalView, lightDirection));
-  let irradiance = mul(dotNL, lightColor);
-  irradiance = mul(irradiance, Math.PI); // punctual light
-
-  addTo(directDiffuse, mul(irradiance, BRDF_Lambert({
-    diffuseColor: diffuseColor.rgb
-  })));
-  addTo(directSpecular, mul(irradiance, BRDF_GGX({
-    lightDirection,
-    f0: specularColor,
-    f90: 1,
-    roughness
-  })));
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const ShaderNode = require("../ShaderNode.js");
+const F_Schlick = new ShaderNode.ShaderNode((inputs) => {
+  const { f0, f90, dotVH } = inputs;
+  const fresnel = ShaderNode.exp2(ShaderNode.mul(ShaderNode.sub(ShaderNode.mul(-5.55473, dotVH), 6.98316), dotVH));
+  return ShaderNode.add(ShaderNode.mul(f0, ShaderNode.sub(1, fresnel)), ShaderNode.mul(f90, fresnel));
 });
-const PhysicalLightingModel = new ShaderNode((inputs
-/*, builder*/
-) => {
-  // PHYSICALLY_CORRECT_LIGHTS <-> builder.renderer.physicallyCorrectLights === true
+const BRDF_Lambert = new ShaderNode.ShaderNode((inputs) => {
+  return ShaderNode.mul(1 / Math.PI, inputs.diffuseColor);
+});
+const getDistanceAttenuation = new ShaderNode.ShaderNode((inputs) => {
+  const { lightDistance, cutoffDistance, decayExponent } = inputs;
+  return ShaderNode.cond(
+    ShaderNode.and(ShaderNode.greaterThan(cutoffDistance, 0), ShaderNode.greaterThan(decayExponent, 0)),
+    ShaderNode.pow(ShaderNode.saturate(ShaderNode.add(ShaderNode.div(ShaderNode.negate(lightDistance), cutoffDistance), 1)), decayExponent),
+    1
+  );
+});
+const V_GGX_SmithCorrelated = new ShaderNode.ShaderNode((inputs) => {
+  const { alpha, dotNL, dotNV } = inputs;
+  const a2 = ShaderNode.pow2(alpha);
+  const gv = ShaderNode.mul(dotNL, ShaderNode.sqrt(ShaderNode.add(a2, ShaderNode.mul(ShaderNode.sub(1, a2), ShaderNode.pow2(dotNV)))));
+  const gl = ShaderNode.mul(dotNV, ShaderNode.sqrt(ShaderNode.add(a2, ShaderNode.mul(ShaderNode.sub(1, a2), ShaderNode.pow2(dotNL)))));
+  return ShaderNode.div(0.5, ShaderNode.max(ShaderNode.add(gv, gl), ShaderNode.EPSILON));
+});
+const D_GGX = new ShaderNode.ShaderNode((inputs) => {
+  const { alpha, dotNH } = inputs;
+  const a2 = ShaderNode.pow2(alpha);
+  const denom = ShaderNode.add(ShaderNode.mul(ShaderNode.pow2(dotNH), ShaderNode.sub(a2, 1)), 1);
+  return ShaderNode.mul(1 / Math.PI, ShaderNode.div(a2, ShaderNode.pow2(denom)));
+});
+const BRDF_GGX = new ShaderNode.ShaderNode((inputs) => {
+  const { lightDirection, f0, f90, roughness } = inputs;
+  const alpha = ShaderNode.pow2(roughness);
+  const halfDir = ShaderNode.normalize(ShaderNode.add(lightDirection, ShaderNode.positionViewDirection));
+  const dotNL = ShaderNode.saturate(ShaderNode.dot(ShaderNode.transformedNormalView, lightDirection));
+  const dotNV = ShaderNode.saturate(ShaderNode.dot(ShaderNode.transformedNormalView, ShaderNode.positionViewDirection));
+  const dotNH = ShaderNode.saturate(ShaderNode.dot(ShaderNode.transformedNormalView, halfDir));
+  const dotVH = ShaderNode.saturate(ShaderNode.dot(ShaderNode.positionViewDirection, halfDir));
+  const F = F_Schlick({ f0, f90, dotVH });
+  const V = V_GGX_SmithCorrelated({ alpha, dotNL, dotNV });
+  const D = D_GGX({ alpha, dotNH });
+  return ShaderNode.mul(F, ShaderNode.mul(V, D));
+});
+const RE_Direct_Physical = new ShaderNode.ShaderNode((inputs) => {
+  const { lightDirection, lightColor, directDiffuse, directSpecular } = inputs;
+  const dotNL = ShaderNode.saturate(ShaderNode.dot(ShaderNode.transformedNormalView, lightDirection));
+  let irradiance = ShaderNode.mul(dotNL, lightColor);
+  irradiance = ShaderNode.mul(irradiance, Math.PI);
+  ShaderNode.addTo(directDiffuse, ShaderNode.mul(irradiance, BRDF_Lambert({ diffuseColor: ShaderNode.diffuseColor.rgb })));
+  ShaderNode.addTo(directSpecular, ShaderNode.mul(irradiance, BRDF_GGX({ lightDirection, f0: ShaderNode.specularColor, f90: 1, roughness: ShaderNode.roughness })));
+});
+const PhysicalLightingModel = new ShaderNode.ShaderNode((inputs) => {
   RE_Direct_Physical(inputs);
 });
-
-export { BRDF_GGX, BRDF_Lambert, D_GGX, F_Schlick, PhysicalLightingModel, RE_Direct_Physical, V_GGX_SmithCorrelated, getDistanceAttenuation };
+exports.BRDF_GGX = BRDF_GGX;
+exports.BRDF_Lambert = BRDF_Lambert;
+exports.D_GGX = D_GGX;
+exports.F_Schlick = F_Schlick;
+exports.PhysicalLightingModel = PhysicalLightingModel;
+exports.RE_Direct_Physical = RE_Direct_Physical;
+exports.V_GGX_SmithCorrelated = V_GGX_SmithCorrelated;
+exports.getDistanceAttenuation = getDistanceAttenuation;

package/nodes/functions/BSDFs.mjs

@@ -0,0 +1,64 @@
+import { ShaderNode, exp2, mul, sub, add, cond, and, greaterThan, pow, saturate, div, negate, pow2, sqrt, max, EPSILON, normalize, positionViewDirection, dot, transformedNormalView, addTo, diffuseColor, specularColor, roughness } from "../ShaderNode.mjs";
+const F_Schlick = new ShaderNode((inputs) => {
+  const { f0, f90, dotVH } = inputs;
+  const fresnel = exp2(mul(sub(mul(-5.55473, dotVH), 6.98316), dotVH));
+  return add(mul(f0, sub(1, fresnel)), mul(f90, fresnel));
+});
+const BRDF_Lambert = new ShaderNode((inputs) => {
+  return mul(1 / Math.PI, inputs.diffuseColor);
+});
+const getDistanceAttenuation = new ShaderNode((inputs) => {
+  const { lightDistance, cutoffDistance, decayExponent } = inputs;
+  return cond(
+    and(greaterThan(cutoffDistance, 0), greaterThan(decayExponent, 0)),
+    pow(saturate(add(div(negate(lightDistance), cutoffDistance), 1)), decayExponent),
+    1
+  );
+});
+const V_GGX_SmithCorrelated = new ShaderNode((inputs) => {
+  const { alpha, dotNL, dotNV } = inputs;
+  const a2 = pow2(alpha);
+  const gv = mul(dotNL, sqrt(add(a2, mul(sub(1, a2), pow2(dotNV)))));
+  const gl = mul(dotNV, sqrt(add(a2, mul(sub(1, a2), pow2(dotNL)))));
+  return div(0.5, max(add(gv, gl), EPSILON));
+});
+const D_GGX = new ShaderNode((inputs) => {
+  const { alpha, dotNH } = inputs;
+  const a2 = pow2(alpha);
+  const denom = add(mul(pow2(dotNH), sub(a2, 1)), 1);
+  return mul(1 / Math.PI, div(a2, pow2(denom)));
+});
+const BRDF_GGX = new ShaderNode((inputs) => {
+  const { lightDirection, f0, f90, roughness: roughness2 } = inputs;
+  const alpha = pow2(roughness2);
+  const halfDir = normalize(add(lightDirection, positionViewDirection));
+  const dotNL = saturate(dot(transformedNormalView, lightDirection));
+  const dotNV = saturate(dot(transformedNormalView, positionViewDirection));
+  const dotNH = saturate(dot(transformedNormalView, halfDir));
+  const dotVH = saturate(dot(positionViewDirection, halfDir));
+  const F = F_Schlick({ f0, f90, dotVH });
+  const V = V_GGX_SmithCorrelated({ alpha, dotNL, dotNV });
+  const D = D_GGX({ alpha, dotNH });
+  return mul(F, mul(V, D));
+});
+const RE_Direct_Physical = new ShaderNode((inputs) => {
+  const { lightDirection, lightColor, directDiffuse, directSpecular } = inputs;
+  const dotNL = saturate(dot(transformedNormalView, lightDirection));
+  let irradiance = mul(dotNL, lightColor);
+  irradiance = mul(irradiance, Math.PI);
+  addTo(directDiffuse, mul(irradiance, BRDF_Lambert({ diffuseColor: diffuseColor.rgb })));
+  addTo(directSpecular, mul(irradiance, BRDF_GGX({ lightDirection, f0: specularColor, f90: 1, roughness })));
+});
+const PhysicalLightingModel = new ShaderNode((inputs) => {
+  RE_Direct_Physical(inputs);
+});
+export {
+  BRDF_GGX,
+  BRDF_Lambert,
+  D_GGX,
+  F_Schlick,
+  PhysicalLightingModel,
+  RE_Direct_Physical,
+  V_GGX_SmithCorrelated,
+  getDistanceAttenuation
+};