three-stdlib 2.8.9 → 2.8.12

package/nodes/ShaderNode.js

@@ -0,0 +1,308 @@
+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] === undefined) {
+      if (/^[xyzwrgbastpq]{1,4}$/.test(prop) === true) {
+        // 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 = new WeakMap();
+
+const ShaderNodeObject = function (obj) {
+  const type = typeof obj;
+
+  if (type === 'number' || type === 'boolean') {
+    return new ShaderNodeObject(getAutoTypedConstNode(obj));
+  } else if (type === 'object') {
+    if (obj.isNode === true) {
+      let nodeObject = nodeObjects.get(obj);
+
+      if (nodeObject === undefined) {
+        nodeObject = new Proxy(obj, NodeHandler);
+        nodeObjects.set(obj, nodeObject);
+        nodeObjects.set(nodeObject, nodeObject);
+      }
+
+      return nodeObject;
+    }
+  }
+
+  return obj;
+};
+
+const ShaderNodeObjects = function (objects) {
+  for (const name in objects) {
+    objects[name] = new ShaderNodeObject(objects[name]);
+  }
+
+  return objects;
+};
+
+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) {
+  if (scope === null) {
+    return (...params) => {
+      return new ShaderNodeObject(new NodeClass(...getShaderNodeArray(params)));
+    };
+  } else if (factor === null) {
+    return (...params) => {
+      return new ShaderNodeObject(new NodeClass(scope, ...getShaderNodeArray(params)));
+    };
+  } else {
+    factor = new ShaderNodeObject(factor);
+    return (...params) => {
+      return new ShaderNodeObject(new NodeClass(scope, ...getShaderNodeArray(params), factor));
+    };
+  }
+};
+
+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 = 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 => {
+  if (constNodesCacheMap.has(value)) {
+    return constNodesCacheMap.get(value);
+  } else if (value.isNode === true) {
+    return value;
+  } else {
+    return new ConstNode(value);
+  }
+};
+
+const ConvertType = function (type, cacheMap = null) {
+  return (...params) => {
+    if (params.length === 0) {
+      return nodeObject(new ConstNode(getValueFromType(type), type));
+    } else {
+      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 => {
+  return new ShaderNodeObject(val);
+};
+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 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 = 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 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 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 EPSILON = float(1e-6);
+const INFINITY = float(1e6);
+
+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

@@ -0,0 +1,18 @@
+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';
+  }
+
+}
+
+BufferNode.prototype.isBufferNode = true;
+
+export default BufferNode;

package/nodes/accessors/CameraNode.cjs.js

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("../core/TempNode.cjs.js"),t=require("../core/FunctionNode.cjs.js"),o=require("../inputs/FloatNode.cjs.js"),r=require("./PositionNode.cjs.js");function s(t,o){e.TempNode.call(this,"v3"),this.setScope(t||s.POSITION),this.setCamera(o)}require("three"),require("../core/Node.cjs.js"),require("../core/NodeLib.cjs.js"),require("../core/InputNode.cjs.js"),s.Nodes={depthColor:new t.FunctionNode(["float depthColor( float mNear, float mFar ) {","\t#ifdef USE_LOGDEPTHBUF_EXT","\t\tfloat depth = gl_FragDepthEXT / gl_FragCoord.w;","\t#else","\t\tfloat depth = gl_FragCoord.z / gl_FragCoord.w;","\t#endif","\treturn 1.0 - smoothstep( mNear, mFar, depth );","}"].join("\n"))},s.POSITION="position",s.DEPTH="depth",s.TO_VERTEX="toVertex",s.prototype=Object.create(e.TempNode.prototype),s.prototype.constructor=s,s.prototype.nodeType="Camera",s.prototype.setCamera=function(e){this.camera=e,this.updateFrame=void 0!==e?this.onUpdateFrame:void 0},s.prototype.setScope=function(e){switch(this.scope){case s.DEPTH:delete this.near,delete this.far}switch(this.scope=e,e){case s.DEPTH:var t=this.camera;this.near=new o.FloatNode(t?t.near:1),this.far=new o.FloatNode(t?t.far:1200)}},s.prototype.getType=function(){switch(this.scope){case s.DEPTH:return"f"}return this.type},s.prototype.getUnique=function(){switch(this.scope){case s.DEPTH:case s.TO_VERTEX:return!0}return!1},s.prototype.getShared=function(){switch(this.scope){case s.POSITION:return!1}return!0},s.prototype.generate=function(e,t){var o;switch(this.scope){case s.POSITION:o="cameraPosition";break;case s.DEPTH:o=e.include(s.Nodes.depthColor)+"( "+this.near.build(e,"f")+", "+this.far.build(e,"f")+" )";break;case s.TO_VERTEX:o="normalize( "+new r.PositionNode(r.PositionNode.WORLD).build(e,"v3")+" - cameraPosition )"}return e.format(o,this.getType(e),t)},s.prototype.onUpdateFrame=function(){switch(this.scope){case s.DEPTH:var e=this.camera;this.near.value=e.near,this.far.value=e.far}},s.prototype.copy=function(t){switch(e.TempNode.prototype.copy.call(this,t),this.setScope(t.scope),t.camera&&this.setCamera(t.camera),t.scope){case s.DEPTH:this.near.number=t.near,this.far.number=t.far}return this},s.prototype.toJSON=function(e){var t=this.getJSONNode(e);if(!t)switch((t=this.createJSONNode(e)).scope=this.scope,this.camera&&(t.camera=this.camera.uuid),this.scope){case s.DEPTH:t.near=this.near.value,t.far=this.far.value}return t},exports.CameraNode=s;
+"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;

package/nodes/accessors/CameraNode.js

@@ -1,154 +1,48 @@
-import { TempNode } from '../core/TempNode.js';
-import { FunctionNode } from '../core/FunctionNode.js';
-import { FloatNode } from '../inputs/FloatNode.js';
-import { PositionNode } from './PositionNode.js';
+import _defineProperty from '@babel/runtime/helpers/esm/defineProperty';
+import Object3DNode from './Object3DNode.js';
 
-function CameraNode(scope, camera) {
-  TempNode.call(this, 'v3');
-  this.setScope(scope || CameraNode.POSITION);
-  this.setCamera(camera);
-}
-
-CameraNode.Nodes = function () {
-  var depthColor = new FunctionNode(['float depthColor( float mNear, float mFar ) {', '	#ifdef USE_LOGDEPTHBUF_EXT', '		float depth = gl_FragDepthEXT / gl_FragCoord.w;', '	#else', '		float depth = gl_FragCoord.z / gl_FragCoord.w;', '	#endif', '	return 1.0 - smoothstep( mNear, mFar, depth );', '}'].join('\n'));
-  return {
-    depthColor: depthColor
-  };
-}();
-
-CameraNode.POSITION = 'position';
-CameraNode.DEPTH = 'depth';
-CameraNode.TO_VERTEX = 'toVertex';
-CameraNode.prototype = Object.create(TempNode.prototype);
-CameraNode.prototype.constructor = CameraNode;
-CameraNode.prototype.nodeType = 'Camera';
-
-CameraNode.prototype.setCamera = function (camera) {
-  this.camera = camera;
-  this.updateFrame = camera !== undefined ? this.onUpdateFrame : undefined;
-};
-
-CameraNode.prototype.setScope = function (scope) {
-  switch (this.scope) {
-    case CameraNode.DEPTH:
-      delete this.near;
-      delete this.far;
-      break;
-  }
-
-  this.scope = scope;
-
-  switch (scope) {
-    case CameraNode.DEPTH:
-      var camera = this.camera;
-      this.near = new FloatNode(camera ? camera.near : 1);
-      this.far = new FloatNode(camera ? camera.far : 1200);
-      break;
-  }
-};
-
-CameraNode.prototype.getType = function
-  /* builder */
-() {
-  switch (this.scope) {
-    case CameraNode.DEPTH:
-      return 'f';
-  }
-
-  return this.type;
-};
-
-CameraNode.prototype.getUnique = function
-  /* builder */
-() {
-  switch (this.scope) {
-    case CameraNode.DEPTH:
-    case CameraNode.TO_VERTEX:
-      return true;
-  }
-
-  return false;
-};
-
-CameraNode.prototype.getShared = function
-  /* builder */
-() {
-  switch (this.scope) {
-    case CameraNode.POSITION:
-      return false;
+class CameraNode extends Object3DNode {
+  constructor(scope = CameraNode.POSITION) {
+    super(scope);
   }
 
-  return true;
-};
-
-CameraNode.prototype.generate = function (builder, output) {
-  var result;
-
-  switch (this.scope) {
-    case CameraNode.POSITION:
-      result = 'cameraPosition';
-      break;
+  getNodeType(builder) {
+    const scope = this.scope;
 
-    case CameraNode.DEPTH:
-      var depthColor = builder.include(CameraNode.Nodes.depthColor);
-      result = depthColor + '( ' + this.near.build(builder, 'f') + ', ' + this.far.build(builder, 'f') + ' )';
-      break;
+    if (scope === CameraNode.PROJECTION_MATRIX) {
+      return 'mat4';
+    }
 
-    case CameraNode.TO_VERTEX:
-      result = 'normalize( ' + new PositionNode(PositionNode.WORLD).build(builder, 'v3') + ' - cameraPosition )';
-      break;
+    return super.getNodeType(builder);
   }
 
-  return builder.format(result, this.getType(builder), output);
-};
+  update(frame) {
+    const camera = frame.camera;
+    const uniformNode = this._uniformNode;
+    const scope = this.scope;
 
-CameraNode.prototype.onUpdateFrame = function
-  /* frame */
-() {
-  switch (this.scope) {
-    case CameraNode.DEPTH:
-      var camera = this.camera;
-      this.near.value = camera.near;
-      this.far.value = camera.far;
-      break;
+    if (scope === CameraNode.PROJECTION_MATRIX) {
+      uniformNode.value = camera.projectionMatrix;
+    } else if (scope === CameraNode.VIEW_MATRIX) {
+      uniformNode.value = camera.matrixWorldInverse;
+    } else {
+      this.object3d = camera;
+      super.update(frame);
+    }
   }
-};
 
-CameraNode.prototype.copy = function (source) {
-  TempNode.prototype.copy.call(this, source);
-  this.setScope(source.scope);
+  generate(builder) {
+    const scope = this.scope;
 
-  if (source.camera) {
-    this.setCamera(source.camera);
-  }
+    if (scope === CameraNode.PROJECTION_MATRIX) {
+      this._uniformNode.nodeType = 'mat4';
+    }
 
-  switch (source.scope) {
-    case CameraNode.DEPTH:
-      this.near.number = source.near;
-      this.far.number = source.far;
-      break;
+    return super.generate(builder);
   }
 
-  return this;
-};
-
-CameraNode.prototype.toJSON = function (meta) {
-  var data = this.getJSONNode(meta);
-
-  if (!data) {
-    data = this.createJSONNode(meta);
-    data.scope = this.scope;
-    if (this.camera) data.camera = this.camera.uuid;
-
-    switch (this.scope) {
-      case CameraNode.DEPTH:
-        data.near = this.near.value;
-        data.far = this.far.value;
-        break;
-    }
-  }
+}
 
-  return data;
-};
+_defineProperty(CameraNode, "PROJECTION_MATRIX", 'projectionMatrix');
 
-export { CameraNode };
+export default CameraNode;

package/nodes/accessors/CubeTextureNode.cjs.js

@@ -0,0 +1 @@
+"use strict";var e=require("./TextureNode.cjs.js"),r=require("../core/UniformNode.cjs.js"),s=require("./ReflectNode.cjs.js");require("./UVNode.cjs.js"),require("../core/AttributeNode.cjs.js"),require("../core/Node.cjs.js"),require("../core/constants.cjs.js"),require("../core/NodeUtils.cjs.js"),require("three"),require("../core/VaryNode.cjs.js"),require("../core/InputNode.cjs.js"),require("@babel/runtime/helpers/defineProperty"),require("../ShaderNode.cjs.js"),require("../core/PropertyNode.cjs.js"),require("../core/VarNode.cjs.js"),require("../core/ConstNode.cjs.js"),require("./BufferNode.cjs.js"),require("./PositionNode.cjs.js"),require("./ModelNode.cjs.js"),require("./Object3DNode.cjs.js"),require("../math/MathNode.cjs.js"),require("../core/TempNode.cjs.js"),require("../core/ExpressionNode.cjs.js"),require("../utils/JoinNode.cjs.js"),require("../utils/SplitNode.cjs.js"),require("../core/NodeBuilder.cjs.js"),require("../core/NodeUniform.cjs.js"),require("../core/NodeAttribute.cjs.js"),require("../core/NodeVary.cjs.js"),require("../core/NodeVar.cjs.js"),require("../core/NodeCode.cjs.js"),require("../core/NodeKeywords.cjs.js"),require("../math/OperatorNode.cjs.js"),require("./NormalNode.cjs.js"),require("./CameraNode.cjs.js"),require("../math/CondNode.cjs.js"),require("../core/ContextNode.cjs.js"),require("../utils/ArrayElementNode.cjs.js"),require("../utils/ConvertNode.cjs.js");class o extends e{constructor(e,r=new s,o=null){super(e,r,o)}getInputType(){return"cubeTexture"}generate(e,s){const o=this.value;if(!o||!0!==o.isCubeTexture)throw new Error("CubeTextureNode: Need a three.js cube texture.");const t=r.prototype.generate.call(this,e,"cubeTexture");if("sampler"===s)return t+"_sampler";if(e.isReference(s))return t;{const r=e.getDataFromNode(this);let o=r.snippet;if(void 0===o){const s=this.uvNode.build(e,"vec3"),u=this.biasNode;if(null!==u){const r=u.build(e,"float");o=e.getCubeTextureBias(t,s,r)}else o=e.getCubeTexture(t,s);r.snippet=o}return e.format(o,"vec4",s)}}}o.prototype.isCubeTextureNode=!0,module.exports=o;

package/nodes/accessors/CubeTextureNode.js

@@ -0,0 +1,53 @@
+import TextureNode from './TextureNode.js';
+import UniformNode from '../core/UniformNode.js';
+import ReflectNode from './ReflectNode.js';
+
+class CubeTextureNode extends TextureNode {
+  constructor(value, uvNode = new ReflectNode(), biasNode = null) {
+    super(value, uvNode, biasNode);
+  }
+
+  getInputType() {
+    return 'cubeTexture';
+  }
+
+  generate(builder, output) {
+    const texture = this.value;
+
+    if (!texture || texture.isCubeTexture !== true) {
+      throw new Error('CubeTextureNode: Need a three.js cube texture.');
+    }
+
+    const textureProperty = UniformNode.prototype.generate.call(this, builder, 'cubeTexture');
+
+    if (output === 'sampler') {
+      return textureProperty + '_sampler';
+    } else if (builder.isReference(output)) {
+      return textureProperty;
+    } else {
+      const nodeData = builder.getDataFromNode(this);
+      let snippet = nodeData.snippet;
+
+      if (snippet === undefined) {
+        const uvSnippet = this.uvNode.build(builder, 'vec3');
+        const biasNode = this.biasNode;
+
+        if (biasNode !== null) {
+          const biasSnippet = biasNode.build(builder, 'float');
+          snippet = builder.getCubeTextureBias(textureProperty, uvSnippet, biasSnippet);
+        } else {
+          snippet = builder.getCubeTexture(textureProperty, uvSnippet);
+        }
+
+        nodeData.snippet = snippet;
+      }
+
+      return builder.format(snippet, 'vec4', output);
+    }
+  }
+
+}
+
+CubeTextureNode.prototype.isCubeTextureNode = true;
+
+export default CubeTextureNode;

package/nodes/accessors/MaterialNode.cjs.js

@@ -0,0 +1 @@
+"use strict";var e=require("@babel/runtime/helpers/defineProperty"),r=require("../core/Node.cjs.js"),t=require("../math/OperatorNode.cjs.js"),o=require("./MaterialReferenceNode.cjs.js");function s(e){return e&&"object"==typeof e&&"default"in e?e:{default:e}}require("../core/constants.cjs.js"),require("../core/NodeUtils.cjs.js"),require("three"),require("../core/TempNode.cjs.js"),require("./ReferenceNode.cjs.js"),require("../core/UniformNode.cjs.js"),require("../core/InputNode.cjs.js");var a=s(e);class l extends r{constructor(e=l.COLOR){super(),this.scope=e}getNodeType(e){const r=this.scope,t=e.context.material;return r===l.COLOR?null!==t.map?"vec4":"vec3":r===l.OPACITY?"float":r===l.SPECULAR?"vec3":r===l.ROUGHNESS||r===l.METALNESS?"float":void 0}generate(e,r){const s=e.context.material,a=this.scope;let c=null;if(a===l.ALPHA_TEST)c=new o("alphaTest","float");else if(a===l.COLOR){const e=new o("color","color");c=null!==s.map&&void 0!==s.map&&!0===s.map.isTexture?new t("*",e,new o("map","texture")):e}else if(a===l.OPACITY){const e=new o("opacity","float");c=null!==s.alphaMap&&void 0!==s.alphaMap&&!0===s.alphaMap.isTexture?new t("*",e,new o("alphaMap","texture")):e}else if(a===l.SPECULAR){const e=new o("specularColor","color");c=null!==s.specularColorMap&&void 0!==s.specularColorMap&&!0===s.specularColorMap.isTexture?new t("*",e,new o("specularColorMap","texture")):e}else{const r=this.getNodeType(e);c=new o(a,r)}return c.build(e,r)}}a.default(l,"ALPHA_TEST","alphaTest"),a.default(l,"COLOR","color"),a.default(l,"OPACITY","opacity"),a.default(l,"SPECULAR","specular"),a.default(l,"ROUGHNESS","roughness"),a.default(l,"METALNESS","metalness"),module.exports=l;