three-stdlib 2.16.0 → 2.16.1

package/nodes/ShaderNode.js

@@ -1,74 +1,89 @@
-"use strict";
-Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
-const PropertyNode = require("./core/PropertyNode.js");
-const VarNode = require("./core/VarNode.js");
-const AttributeNode = require("./core/AttributeNode.js");
-const ConstNode = require("./core/ConstNode.js");
-const UniformNode = require("./core/UniformNode.js");
-const BufferNode = require("./accessors/BufferNode.js");
-const PositionNode = require("./accessors/PositionNode.js");
-const NormalNode = require("./accessors/NormalNode.js");
-const CameraNode = require("./accessors/CameraNode.js");
-const ModelNode = require("./accessors/ModelNode.js");
-const TextureNode = require("./accessors/TextureNode.js");
-const UVNode = require("./accessors/UVNode.js");
-const OperatorNode = require("./math/OperatorNode.js");
-const CondNode = require("./math/CondNode.js");
-const MathNode = require("./math/MathNode.js");
-const ArrayElementNode = require("./utils/ArrayElementNode.js");
-const ConvertNode = require("./utils/ConvertNode.js");
-const JoinNode = require("./utils/JoinNode.js");
-const SplitNode = require("./utils/SplitNode.js");
-const NodeUtils = require("./core/NodeUtils.js");
+import PropertyNode from './core/PropertyNode.js';
+import VarNode from './core/VarNode.js';
+import AttributeNode from './core/AttributeNode.js';
+import ConstNode from './core/ConstNode.js';
+import UniformNode from './core/UniformNode.js';
+import BufferNode from './accessors/BufferNode.js';
+import PositionNode from './accessors/PositionNode.js';
+import NormalNode from './accessors/NormalNode.js';
+import CameraNode from './accessors/CameraNode.js';
+import ModelNode from './accessors/ModelNode.js';
+import TextureNode from './accessors/TextureNode.js';
+import UVNode from './accessors/UVNode.js';
+import OperatorNode from './math/OperatorNode.js';
+import CondNode from './math/CondNode.js';
+import MathNode from './math/MathNode.js';
+import ArrayElementNode from './utils/ArrayElementNode.js';
+import ConvertNode from './utils/ConvertNode.js';
+import JoinNode from './utils/JoinNode.js';
+import SplitNode from './utils/SplitNode.js';
+import { getValueFromType } from './core/NodeUtils.js';
+
+// core nodes
 const NodeHandler = {
   construct(NodeClosure, params) {
     const inputs = params.shift();
     return NodeClosure(new ShaderNodeObjects(inputs), ...params);
   },
-  get: function(node, prop) {
-    if (typeof prop === "string" && node[prop] === void 0) {
+
+  get: function (node, prop) {
+    if (typeof prop === 'string' && node[prop] === undefined) {
       if (/^[xyzwrgbastpq]{1,4}$/.test(prop) === true) {
-        prop = prop.replace(/r|s/g, "x").replace(/g|t/g, "y").replace(/b|p/g, "z").replace(/a|q/g, "w");
+        // accessing properties ( swizzle )
+        prop = prop.replace(/r|s/g, 'x').replace(/g|t/g, 'y').replace(/b|p/g, 'z').replace(/a|q/g, 'w');
         return new ShaderNodeObject(new SplitNode(node, prop));
       } else if (/^\d+$/.test(prop) === true) {
+        // accessing array
         return new ShaderNodeObject(new ArrayElementNode(node, uint(Number(prop))));
       }
     }
+
     return node[prop];
   }
 };
-const nodeObjects = /* @__PURE__ */ new WeakMap();
-const ShaderNodeObject = function(obj) {
+const nodeObjects = new WeakMap();
+
+const ShaderNodeObject = function (obj) {
   const type = typeof obj;
-  if (type === "number" || type === "boolean") {
+
+  if (type === 'number' || type === 'boolean') {
     return new ShaderNodeObject(getAutoTypedConstNode(obj));
-  } else if (type === "object") {
+  } else if (type === 'object') {
     if (obj.isNode === true) {
-      let nodeObject2 = nodeObjects.get(obj);
-      if (nodeObject2 === void 0) {
-        nodeObject2 = new Proxy(obj, NodeHandler);
-        nodeObjects.set(obj, nodeObject2);
-        nodeObjects.set(nodeObject2, nodeObject2);
+      let nodeObject = nodeObjects.get(obj);
+
+      if (nodeObject === undefined) {
+        nodeObject = new Proxy(obj, NodeHandler);
+        nodeObjects.set(obj, nodeObject);
+        nodeObjects.set(nodeObject, nodeObject);
       }
-      return nodeObject2;
+
+      return nodeObject;
     }
   }
+
   return obj;
 };
-const ShaderNodeObjects = function(objects) {
+
+const ShaderNodeObjects = function (objects) {
   for (const name in objects) {
     objects[name] = new ShaderNodeObject(objects[name]);
   }
+
   return objects;
 };
-const getShaderNodeArray = (array) => {
+
+const getShaderNodeArray = array => {
   const len = array.length;
+
   for (let i = 0; i < len; i++) {
     array[i] = new ShaderNodeObject(array[i]);
   }
+
   return array;
 };
-const ShaderNodeProxy = function(NodeClass, scope = null, factor = null) {
+
+const ShaderNodeProxy = function (NodeClass, scope = null, factor = null) {
   if (scope === null) {
     return (...params) => {
       return new ShaderNodeObject(new NodeClass(...getShaderNodeArray(params)));
@@ -84,44 +99,39 @@ const ShaderNodeProxy = function(NodeClass, scope = null, factor = null) {
     };
   }
 };
-const ShaderNodeScript = function(jsFunc) {
+
+const ShaderNodeScript = function (jsFunc) {
   return (inputs, builder) => {
     new ShaderNodeObjects(inputs);
     return new ShaderNodeObject(jsFunc(inputs, builder));
   };
 };
+
 const bools = [false, true];
 const uints = [0, 1, 2, 3];
 const ints = [-1, -2];
-const floats = [
-  0.5,
-  1.5,
-  1 / 3,
-  1e-6,
-  1e6,
-  Math.PI,
-  Math.PI * 2,
-  1 / Math.PI,
-  2 / Math.PI,
-  1 / (Math.PI * 2),
-  Math.PI / 2
-];
-const boolsCacheMap = /* @__PURE__ */ new Map();
-for (let bool2 of bools)
-  boolsCacheMap.set(bool2, new ConstNode(bool2));
-const uintsCacheMap = /* @__PURE__ */ new Map();
-for (let uint2 of uints)
-  uintsCacheMap.set(uint2, new ConstNode(uint2, "uint"));
-const intsCacheMap = new Map([...uintsCacheMap].map((el) => new ConstNode(el.value, "int")));
-for (let int2 of ints)
-  intsCacheMap.set(int2, new ConstNode(int2, "int"));
-const floatsCacheMap = new Map([...intsCacheMap].map((el) => new ConstNode(el.value)));
-for (let float2 of floats)
-  floatsCacheMap.set(float2, new ConstNode(float2));
-for (let float2 of floats)
-  floatsCacheMap.set(-float2, new ConstNode(-float2));
+const floats = [0.5, 1.5, 1 / 3, 1e-6, 1e6, Math.PI, Math.PI * 2, 1 / Math.PI, 2 / Math.PI, 1 / (Math.PI * 2), Math.PI / 2];
+const boolsCacheMap = new Map();
+
+for (let bool of bools) boolsCacheMap.set(bool, new ConstNode(bool));
+
+const uintsCacheMap = new Map();
+
+for (let uint of uints) uintsCacheMap.set(uint, new ConstNode(uint, 'uint'));
+
+const intsCacheMap = new Map([...uintsCacheMap].map(el => new ConstNode(el.value, 'int')));
+
+for (let int of ints) intsCacheMap.set(int, new ConstNode(int, 'int'));
+
+const floatsCacheMap = new Map([...intsCacheMap].map(el => new ConstNode(el.value)));
+
+for (let float of floats) floatsCacheMap.set(float, new ConstNode(float));
+
+for (let float of floats) floatsCacheMap.set(-float, new ConstNode(-float));
+
 const constNodesCacheMap = new Map([...boolsCacheMap, ...floatsCacheMap]);
-const getAutoTypedConstNode = (value) => {
+
+const getAutoTypedConstNode = value => {
   if (constNodesCacheMap.has(value)) {
     return constNodesCacheMap.get(value);
   } else if (value.isNode === true) {
@@ -130,279 +140,169 @@ const getAutoTypedConstNode = (value) => {
     return new ConstNode(value);
   }
 };
-const ConvertType = function(type, cacheMap = null) {
+
+const ConvertType = function (type, cacheMap = null) {
   return (...params) => {
     if (params.length === 0) {
-      return nodeObject(new ConstNode(NodeUtils.getValueFromType(type), type));
+      return nodeObject(new ConstNode(getValueFromType(type), type));
     } else {
-      if (type === "color" && params[0].isNode !== true) {
-        params = [NodeUtils.getValueFromType(type, ...params)];
+      if (type === 'color' && params[0].isNode !== true) {
+        params = [getValueFromType(type, ...params)];
       }
+
       if (params.length === 1 && cacheMap !== null && cacheMap.has(params[0])) {
         return cacheMap.get(params[0]);
       }
+
       const nodes = params.map(getAutoTypedConstNode);
       return nodeObject(new ConvertNode(nodes.length === 1 ? nodes[0] : new JoinNode(nodes), type));
     }
   };
-};
+}; //
+// Node Material Shader Syntax
+//
+
+
 const ShaderNode = new Proxy(ShaderNodeScript, NodeHandler);
-const nodeObject = (val) => {
+const nodeObject = val => {
   return new ShaderNodeObject(val);
 };
-const uniform = (value) => {
-  var _a;
-  value = value.isNode === true ? ((_a = value.node) == null ? void 0 : _a.value) || value.value : value;
+const uniform = value => {
+  var _value$node;
+
+  // TODO: get ConstNode from .traverse() in the future
+  value = value.isNode === true ? ((_value$node = value.node) === null || _value$node === void 0 ? void 0 : _value$node.value) || value.value : value;
   return nodeObject(new UniformNode(value, value.nodeType));
 };
 const label = (node, name) => {
   node = nodeObject(node);
+
   if (node.isVarNode === true) {
     node.name = name;
     return node;
   }
+
   return nodeObject(new VarNode(node, name));
 };
-const temp = (node) => nodeObject(new VarNode(nodeObject(node)));
-const color = new ConvertType("color");
-const float = new ConvertType("float", floatsCacheMap);
-const int = new ConvertType("int", intsCacheMap);
-const uint = new ConvertType("uint", uintsCacheMap);
-const bool = new ConvertType("bool", boolsCacheMap);
-const vec2 = new ConvertType("vec2");
-const ivec2 = new ConvertType("ivec2");
-const uvec2 = new ConvertType("uvec2");
-const bvec2 = new ConvertType("bvec2");
-const vec3 = new ConvertType("vec3");
-const ivec3 = new ConvertType("ivec3");
-const uvec3 = new ConvertType("uvec3");
-const bvec3 = new ConvertType("bvec3");
-const vec4 = new ConvertType("vec4");
-const ivec4 = new ConvertType("ivec4");
-const uvec4 = new ConvertType("uvec4");
-const bvec4 = new ConvertType("bvec4");
-const mat3 = new ConvertType("mat3");
-const imat3 = new ConvertType("imat3");
-const umat3 = new ConvertType("umat3");
-const bmat3 = new ConvertType("bmat3");
-const mat4 = new ConvertType("mat4");
-const imat4 = new ConvertType("imat4");
-const umat4 = new ConvertType("umat4");
-const bmat4 = new ConvertType("bmat4");
+const temp = node => nodeObject(new VarNode(nodeObject(node)));
+const color = new ConvertType('color');
+const float = new ConvertType('float', floatsCacheMap);
+const int = new ConvertType('int', intsCacheMap);
+const uint = new ConvertType('uint', uintsCacheMap);
+const bool = new ConvertType('bool', boolsCacheMap);
+const vec2 = new ConvertType('vec2');
+const ivec2 = new ConvertType('ivec2');
+const uvec2 = new ConvertType('uvec2');
+const bvec2 = new ConvertType('bvec2');
+const vec3 = new ConvertType('vec3');
+const ivec3 = new ConvertType('ivec3');
+const uvec3 = new ConvertType('uvec3');
+const bvec3 = new ConvertType('bvec3');
+const vec4 = new ConvertType('vec4');
+const ivec4 = new ConvertType('ivec4');
+const uvec4 = new ConvertType('uvec4');
+const bvec4 = new ConvertType('bvec4');
+const mat3 = new ConvertType('mat3');
+const imat3 = new ConvertType('imat3');
+const umat3 = new ConvertType('umat3');
+const bmat3 = new ConvertType('bmat3');
+const mat4 = new ConvertType('mat4');
+const imat4 = new ConvertType('imat4');
+const umat4 = new ConvertType('umat4');
+const bmat4 = new ConvertType('bmat4');
 const join = (...params) => nodeObject(new JoinNode(getShaderNodeArray(params)));
 const uv = (...params) => nodeObject(new UVNode(...params));
 const attribute = (...params) => nodeObject(new AttributeNode(...params));
 const buffer = (...params) => nodeObject(new BufferNode(...params));
 const texture = (...params) => nodeObject(new TextureNode(...params));
-const sampler = (texture2) => nodeObject(new ConvertNode(texture2.isNode === true ? texture2 : new TextureNode(texture2), "sampler"));
+const sampler = texture => nodeObject(new ConvertNode(texture.isNode === true ? texture : new TextureNode(texture), 'sampler'));
 const cond = (...params) => nodeObject(new CondNode(...getShaderNodeArray(params)));
 const addTo = (varNode, ...params) => {
   varNode.node = add(varNode.node, ...getShaderNodeArray(params));
   return nodeObject(varNode);
 };
-const add = new ShaderNodeProxy(OperatorNode, "+");
-const sub = new ShaderNodeProxy(OperatorNode, "-");
-const mul = new ShaderNodeProxy(OperatorNode, "*");
-const div = new ShaderNodeProxy(OperatorNode, "/");
-const remainder = new ShaderNodeProxy(OperatorNode, "%");
-const equal = new ShaderNodeProxy(OperatorNode, "==");
-const assign = new ShaderNodeProxy(OperatorNode, "=");
-const lessThan = new ShaderNodeProxy(OperatorNode, "<");
-const greaterThan = new ShaderNodeProxy(OperatorNode, ">");
-const lessThanEqual = new ShaderNodeProxy(OperatorNode, "<=");
-const greaterThanEqual = new ShaderNodeProxy(OperatorNode, ">=");
-const and = new ShaderNodeProxy(OperatorNode, "&&");
-const or = new ShaderNodeProxy(OperatorNode, "||");
-const xor = new ShaderNodeProxy(OperatorNode, "^^");
-const bitAnd = new ShaderNodeProxy(OperatorNode, "&");
-const bitOr = new ShaderNodeProxy(OperatorNode, "|");
-const bitXor = new ShaderNodeProxy(OperatorNode, "^");
-const shiftLeft = new ShaderNodeProxy(OperatorNode, "<<");
-const shiftRight = new ShaderNodeProxy(OperatorNode, ">>");
+const add = new ShaderNodeProxy(OperatorNode, '+');
+const sub = new ShaderNodeProxy(OperatorNode, '-');
+const mul = new ShaderNodeProxy(OperatorNode, '*');
+const div = new ShaderNodeProxy(OperatorNode, '/');
+const remainder = new ShaderNodeProxy(OperatorNode, '%');
+const equal = new ShaderNodeProxy(OperatorNode, '==');
+const assign = new ShaderNodeProxy(OperatorNode, '=');
+const lessThan = new ShaderNodeProxy(OperatorNode, '<');
+const greaterThan = new ShaderNodeProxy(OperatorNode, '>');
+const lessThanEqual = new ShaderNodeProxy(OperatorNode, '<=');
+const greaterThanEqual = new ShaderNodeProxy(OperatorNode, '>=');
+const and = new ShaderNodeProxy(OperatorNode, '&&');
+const or = new ShaderNodeProxy(OperatorNode, '||');
+const xor = new ShaderNodeProxy(OperatorNode, '^^');
+const bitAnd = new ShaderNodeProxy(OperatorNode, '&');
+const bitOr = new ShaderNodeProxy(OperatorNode, '|');
+const bitXor = new ShaderNodeProxy(OperatorNode, '^');
+const shiftLeft = new ShaderNodeProxy(OperatorNode, '<<');
+const shiftRight = new ShaderNodeProxy(OperatorNode, '>>');
 const element = new ShaderNodeProxy(ArrayElementNode);
 const normalGeometry = new ShaderNodeObject(new NormalNode(NormalNode.GEOMETRY));
 const normalLocal = new ShaderNodeObject(new NormalNode(NormalNode.LOCAL));
 const normalWorld = new ShaderNodeObject(new NormalNode(NormalNode.WORLD));
 const normalView = new ShaderNodeObject(new NormalNode(NormalNode.VIEW));
-const transformedNormalView = new ShaderNodeObject(
-  new VarNode(new NormalNode(NormalNode.VIEW), "TransformedNormalView", "vec3")
-);
+const transformedNormalView = new ShaderNodeObject(new VarNode(new NormalNode(NormalNode.VIEW), 'TransformedNormalView', 'vec3'));
 const positionLocal = new ShaderNodeObject(new PositionNode(PositionNode.LOCAL));
 const positionWorld = new ShaderNodeObject(new PositionNode(PositionNode.WORLD));
 const positionView = new ShaderNodeObject(new PositionNode(PositionNode.VIEW));
 const positionViewDirection = new ShaderNodeObject(new PositionNode(PositionNode.VIEW_DIRECTION));
 const viewMatrix = new ShaderNodeObject(new ModelNode(ModelNode.VIEW_MATRIX));
 const cameraPosition = new ShaderNodeObject(new CameraNode(CameraNode.POSITION));
-const diffuseColor = new ShaderNodeObject(new PropertyNode("DiffuseColor", "vec4"));
-const roughness = new ShaderNodeObject(new PropertyNode("Roughness", "float"));
-const metalness = new ShaderNodeObject(new PropertyNode("Metalness", "float"));
-const alphaTest = new ShaderNodeObject(new PropertyNode("AlphaTest", "float"));
-const specularColor = new ShaderNodeObject(new PropertyNode("SpecularColor", "color"));
-const abs = new ShaderNodeProxy(MathNode, "abs");
-const acos = new ShaderNodeProxy(MathNode, "acos");
-const asin = new ShaderNodeProxy(MathNode, "asin");
-const atan = new ShaderNodeProxy(MathNode, "atan");
-const ceil = new ShaderNodeProxy(MathNode, "ceil");
-const clamp = new ShaderNodeProxy(MathNode, "clamp");
-const cos = new ShaderNodeProxy(MathNode, "cos");
-const cross = new ShaderNodeProxy(MathNode, "cross");
-const degrees = new ShaderNodeProxy(MathNode, "degrees");
-const dFdx = new ShaderNodeProxy(MathNode, "dFdx");
-const dFdy = new ShaderNodeProxy(MathNode, "dFdy");
-const distance = new ShaderNodeProxy(MathNode, "distance");
-const dot = new ShaderNodeProxy(MathNode, "dot");
-const exp = new ShaderNodeProxy(MathNode, "exp");
-const exp2 = new ShaderNodeProxy(MathNode, "exp2");
-const faceforward = new ShaderNodeProxy(MathNode, "faceforward");
-const floor = new ShaderNodeProxy(MathNode, "floor");
-const fract = new ShaderNodeProxy(MathNode, "fract");
-const invert = new ShaderNodeProxy(MathNode, "invert");
-const inversesqrt = new ShaderNodeProxy(MathNode, "inversesqrt");
-const length = new ShaderNodeProxy(MathNode, "length");
-const log = new ShaderNodeProxy(MathNode, "log");
-const log2 = new ShaderNodeProxy(MathNode, "log2");
-const max = new ShaderNodeProxy(MathNode, "max");
-const min = new ShaderNodeProxy(MathNode, "min");
-const mix = new ShaderNodeProxy(MathNode, "mix");
-const mod = new ShaderNodeProxy(MathNode, "mod");
-const negate = new ShaderNodeProxy(MathNode, "negate");
-const normalize = new ShaderNodeProxy(MathNode, "normalize");
-const pow = new ShaderNodeProxy(MathNode, "pow");
-const pow2 = new ShaderNodeProxy(MathNode, "pow", 2);
-const pow3 = new ShaderNodeProxy(MathNode, "pow", 3);
-const pow4 = new ShaderNodeProxy(MathNode, "pow", 4);
-const radians = new ShaderNodeProxy(MathNode, "radians");
-const reflect = new ShaderNodeProxy(MathNode, "reflect");
-const refract = new ShaderNodeProxy(MathNode, "refract");
-const round = new ShaderNodeProxy(MathNode, "round");
-const saturate = new ShaderNodeProxy(MathNode, "saturate");
-const sign = new ShaderNodeProxy(MathNode, "sign");
-const sin = new ShaderNodeProxy(MathNode, "sin");
-const smoothstep = new ShaderNodeProxy(MathNode, "smoothstep");
-const sqrt = new ShaderNodeProxy(MathNode, "sqrt");
-const step = new ShaderNodeProxy(MathNode, "step");
-const tan = new ShaderNodeProxy(MathNode, "tan");
-const transformDirection = new ShaderNodeProxy(MathNode, "transformDirection");
+const diffuseColor = new ShaderNodeObject(new PropertyNode('DiffuseColor', 'vec4'));
+const roughness = new ShaderNodeObject(new PropertyNode('Roughness', 'float'));
+const metalness = new ShaderNodeObject(new PropertyNode('Metalness', 'float'));
+const alphaTest = new ShaderNodeObject(new PropertyNode('AlphaTest', 'float'));
+const specularColor = new ShaderNodeObject(new PropertyNode('SpecularColor', 'color'));
+const abs = new ShaderNodeProxy(MathNode, 'abs');
+const acos = new ShaderNodeProxy(MathNode, 'acos');
+const asin = new ShaderNodeProxy(MathNode, 'asin');
+const atan = new ShaderNodeProxy(MathNode, 'atan');
+const ceil = new ShaderNodeProxy(MathNode, 'ceil');
+const clamp = new ShaderNodeProxy(MathNode, 'clamp');
+const cos = new ShaderNodeProxy(MathNode, 'cos');
+const cross = new ShaderNodeProxy(MathNode, 'cross');
+const degrees = new ShaderNodeProxy(MathNode, 'degrees');
+const dFdx = new ShaderNodeProxy(MathNode, 'dFdx');
+const dFdy = new ShaderNodeProxy(MathNode, 'dFdy');
+const distance = new ShaderNodeProxy(MathNode, 'distance');
+const dot = new ShaderNodeProxy(MathNode, 'dot');
+const exp = new ShaderNodeProxy(MathNode, 'exp');
+const exp2 = new ShaderNodeProxy(MathNode, 'exp2');
+const faceforward = new ShaderNodeProxy(MathNode, 'faceforward');
+const floor = new ShaderNodeProxy(MathNode, 'floor');
+const fract = new ShaderNodeProxy(MathNode, 'fract');
+const invert = new ShaderNodeProxy(MathNode, 'invert');
+const inversesqrt = new ShaderNodeProxy(MathNode, 'inversesqrt');
+const length = new ShaderNodeProxy(MathNode, 'length');
+const log = new ShaderNodeProxy(MathNode, 'log');
+const log2 = new ShaderNodeProxy(MathNode, 'log2');
+const max = new ShaderNodeProxy(MathNode, 'max');
+const min = new ShaderNodeProxy(MathNode, 'min');
+const mix = new ShaderNodeProxy(MathNode, 'mix');
+const mod = new ShaderNodeProxy(MathNode, 'mod');
+const negate = new ShaderNodeProxy(MathNode, 'negate');
+const normalize = new ShaderNodeProxy(MathNode, 'normalize');
+const pow = new ShaderNodeProxy(MathNode, 'pow');
+const pow2 = new ShaderNodeProxy(MathNode, 'pow', 2);
+const pow3 = new ShaderNodeProxy(MathNode, 'pow', 3);
+const pow4 = new ShaderNodeProxy(MathNode, 'pow', 4);
+const radians = new ShaderNodeProxy(MathNode, 'radians');
+const reflect = new ShaderNodeProxy(MathNode, 'reflect');
+const refract = new ShaderNodeProxy(MathNode, 'refract');
+const round = new ShaderNodeProxy(MathNode, 'round');
+const saturate = new ShaderNodeProxy(MathNode, 'saturate');
+const sign = new ShaderNodeProxy(MathNode, 'sign');
+const sin = new ShaderNodeProxy(MathNode, 'sin');
+const smoothstep = new ShaderNodeProxy(MathNode, 'smoothstep');
+const sqrt = new ShaderNodeProxy(MathNode, 'sqrt');
+const step = new ShaderNodeProxy(MathNode, 'step');
+const tan = new ShaderNodeProxy(MathNode, 'tan');
+const transformDirection = new ShaderNodeProxy(MathNode, 'transformDirection');
 const EPSILON = float(1e-6);
 const INFINITY = float(1e6);
-exports.EPSILON = EPSILON;
-exports.INFINITY = INFINITY;
-exports.ShaderNode = ShaderNode;
-exports.abs = abs;
-exports.acos = acos;
-exports.add = add;
-exports.addTo = addTo;
-exports.alphaTest = alphaTest;
-exports.and = and;
-exports.asin = asin;
-exports.assign = assign;
-exports.atan = atan;
-exports.attribute = attribute;
-exports.bitAnd = bitAnd;
-exports.bitOr = bitOr;
-exports.bitXor = bitXor;
-exports.bmat3 = bmat3;
-exports.bmat4 = bmat4;
-exports.bool = bool;
-exports.buffer = buffer;
-exports.bvec2 = bvec2;
-exports.bvec3 = bvec3;
-exports.bvec4 = bvec4;
-exports.cameraPosition = cameraPosition;
-exports.ceil = ceil;
-exports.clamp = clamp;
-exports.color = color;
-exports.cond = cond;
-exports.cos = cos;
-exports.cross = cross;
-exports.dFdx = dFdx;
-exports.dFdy = dFdy;
-exports.degrees = degrees;
-exports.diffuseColor = diffuseColor;
-exports.distance = distance;
-exports.div = div;
-exports.dot = dot;
-exports.element = element;
-exports.equal = equal;
-exports.exp = exp;
-exports.exp2 = exp2;
-exports.faceforward = faceforward;
-exports.float = float;
-exports.floor = floor;
-exports.fract = fract;
-exports.greaterThan = greaterThan;
-exports.greaterThanEqual = greaterThanEqual;
-exports.imat3 = imat3;
-exports.imat4 = imat4;
-exports.int = int;
-exports.inversesqrt = inversesqrt;
-exports.invert = invert;
-exports.ivec2 = ivec2;
-exports.ivec3 = ivec3;
-exports.ivec4 = ivec4;
-exports.join = join;
-exports.label = label;
-exports.length = length;
-exports.lessThan = lessThan;
-exports.lessThanEqual = lessThanEqual;
-exports.log = log;
-exports.log2 = log2;
-exports.mat3 = mat3;
-exports.mat4 = mat4;
-exports.max = max;
-exports.metalness = metalness;
-exports.min = min;
-exports.mix = mix;
-exports.mod = mod;
-exports.mul = mul;
-exports.negate = negate;
-exports.nodeObject = nodeObject;
-exports.normalGeometry = normalGeometry;
-exports.normalLocal = normalLocal;
-exports.normalView = normalView;
-exports.normalWorld = normalWorld;
-exports.normalize = normalize;
-exports.or = or;
-exports.positionLocal = positionLocal;
-exports.positionView = positionView;
-exports.positionViewDirection = positionViewDirection;
-exports.positionWorld = positionWorld;
-exports.pow = pow;
-exports.pow2 = pow2;
-exports.pow3 = pow3;
-exports.pow4 = pow4;
-exports.radians = radians;
-exports.reflect = reflect;
-exports.refract = refract;
-exports.remainder = remainder;
-exports.roughness = roughness;
-exports.round = round;
-exports.sampler = sampler;
-exports.saturate = saturate;
-exports.shiftLeft = shiftLeft;
-exports.shiftRight = shiftRight;
-exports.sign = sign;
-exports.sin = sin;
-exports.smoothstep = smoothstep;
-exports.specularColor = specularColor;
-exports.sqrt = sqrt;
-exports.step = step;
-exports.sub = sub;
-exports.tan = tan;
-exports.temp = temp;
-exports.texture = texture;
-exports.transformDirection = transformDirection;
-exports.transformedNormalView = transformedNormalView;
-exports.uint = uint;
-exports.umat3 = umat3;
-exports.umat4 = umat4;
-exports.uniform = uniform;
-exports.uv = uv;
-exports.uvec2 = uvec2;
-exports.uvec3 = uvec3;
-exports.uvec4 = uvec4;
-exports.vec2 = vec2;
-exports.vec3 = vec3;
-exports.vec4 = vec4;
-exports.viewMatrix = viewMatrix;
-exports.xor = xor;
+
+export { EPSILON, INFINITY, ShaderNode, abs, acos, add, addTo, alphaTest, and, asin, assign, atan, attribute, bitAnd, bitOr, bitXor, bmat3, bmat4, bool, buffer, bvec2, bvec3, bvec4, cameraPosition, ceil, clamp, color, cond, cos, cross, dFdx, dFdy, degrees, diffuseColor, distance, div, dot, element, equal, exp, exp2, faceforward, float, floor, fract, greaterThan, greaterThanEqual, imat3, imat4, int, inversesqrt, invert, ivec2, ivec3, ivec4, join, label, length, lessThan, lessThanEqual, log, log2, mat3, mat4, max, metalness, min, mix, mod, mul, negate, nodeObject, normalGeometry, normalLocal, normalView, normalWorld, normalize, or, positionLocal, positionView, positionViewDirection, positionWorld, pow, pow2, pow3, pow4, radians, reflect, refract, remainder, roughness, round, sampler, saturate, shiftLeft, shiftRight, sign, sin, smoothstep, specularColor, sqrt, step, sub, tan, temp, texture, transformDirection, transformedNormalView, uint, umat3, umat4, uniform, uv, uvec2, uvec3, uvec4, vec2, vec3, vec4, viewMatrix, xor };

package/nodes/accessors/BufferNode.cjs.js

@@ -0,0 +1 @@
+"use strict";var e=require("../core/UniformNode.cjs.js");require("../core/InputNode.cjs.js"),require("../core/Node.cjs.js"),require("../core/constants.cjs.js"),require("../core/NodeUtils.cjs.js"),require("three");class r extends e{constructor(e,r,s=0){super(e,r),this.bufferType=r,this.bufferCount=s}getInputType(){return"buffer"}}r.prototype.isBufferNode=!0,module.exports=r;

package/nodes/accessors/BufferNode.js

@@ -1,14 +1,18 @@
-"use strict";
-const UniformNode = require("../core/UniformNode.js");
+import UniformNode from '../core/UniformNode.js';
+
 class BufferNode extends UniformNode {
   constructor(value, bufferType, bufferCount = 0) {
     super(value, bufferType);
     this.bufferType = bufferType;
     this.bufferCount = bufferCount;
   }
+
   getInputType() {
-    return "buffer";
+    return 'buffer';
   }
+
 }
+
 BufferNode.prototype.isBufferNode = true;
-module.exports = BufferNode;
+
+export default BufferNode;

package/nodes/accessors/CameraNode.cjs.js

@@ -0,0 +1 @@
+"use strict";var e=require("@babel/runtime/helpers/defineProperty"),r=require("./Object3DNode.cjs.js");function t(e){return e&&"object"==typeof e&&"default"in e?e:{default:e}}require("three"),require("../core/Node.cjs.js"),require("../core/constants.cjs.js"),require("../core/NodeUtils.cjs.js"),require("../core/UniformNode.cjs.js"),require("../core/InputNode.cjs.js");var s=t(e);class o extends r{constructor(e=o.POSITION){super(e)}getNodeType(e){return this.scope===o.PROJECTION_MATRIX?"mat4":super.getNodeType(e)}update(e){const r=e.camera,t=this._uniformNode,s=this.scope;s===o.PROJECTION_MATRIX?t.value=r.projectionMatrix:s===o.VIEW_MATRIX?t.value=r.matrixWorldInverse:(this.object3d=r,super.update(e))}generate(e){return this.scope===o.PROJECTION_MATRIX&&(this._uniformNode.nodeType="mat4"),super.generate(e)}}s.default(o,"PROJECTION_MATRIX","projectionMatrix"),module.exports=o;