three-stdlib 2.16.0 → 2.16.2

package/nodes/math/CondNode.js

@@ -1,7 +1,7 @@
-"use strict";
-const Node = require("../core/Node.js");
-const PropertyNode = require("../core/PropertyNode.js");
-const ContextNode = require("../core/ContextNode.js");
+import Node from '../core/Node.js';
+import PropertyNode from '../core/PropertyNode.js';
+import ContextNode from '../core/ContextNode.js';
+
 class CondNode extends Node {
   constructor(node, ifNode, elseNode) {
     super();
@@ -9,29 +9,41 @@ class CondNode extends Node {
     this.ifNode = ifNode;
     this.elseNode = elseNode;
   }
+
   getNodeType(builder) {
     const ifType = this.ifNode.getNodeType(builder);
     const elseType = this.elseNode.getNodeType(builder);
+
     if (builder.getTypeLength(elseType) > builder.getTypeLength(ifType)) {
       return elseType;
     }
+
     return ifType;
   }
+
   generate(builder) {
     const type = this.getNodeType(builder);
-    const context = { temp: false };
+    const context = {
+      temp: false
+    };
     const nodeProperty = new PropertyNode(null, type).build(builder);
-    const nodeSnippet = new ContextNode(this.node).build(builder, "bool"), ifSnippet = new ContextNode(this.ifNode, context).build(builder, type), elseSnippet = new ContextNode(this.elseNode, context).build(builder, type);
+    const nodeSnippet = new ContextNode(this.node
+    /*, context*/
+    ).build(builder, 'bool'),
+          ifSnippet = new ContextNode(this.ifNode, context).build(builder, type),
+          elseSnippet = new ContextNode(this.elseNode, context).build(builder, type);
     builder.addFlowCode(`if ( ${nodeSnippet} ) {
 
-		${nodeProperty} = ${ifSnippet};
+\t\t${nodeProperty} = ${ifSnippet};
 
-	} else {
+\t} else {
 
-		${nodeProperty} = ${elseSnippet};
+\t\t${nodeProperty} = ${elseSnippet};
 
-	}`);
+\t}`);
     return nodeProperty;
   }
+
 }
-module.exports = CondNode;
+
+export default CondNode;

package/nodes/math/MathNode.cjs.js

@@ -0,0 +1 @@
+"use strict";var e=require("@babel/runtime/helpers/defineProperty"),t=require("../core/TempNode.cjs.js"),d=require("../core/ExpressionNode.cjs.js"),u=require("../utils/JoinNode.cjs.js"),r=require("../utils/SplitNode.cjs.js"),l=require("./OperatorNode.cjs.js");function s(e){return e&&"object"==typeof e&&"default"in e?e:{default:e}}require("../core/Node.cjs.js"),require("../core/constants.cjs.js"),require("../core/NodeUtils.cjs.js"),require("three"),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");var i=s(e);class o extends t{constructor(e,t,d=null,u=null){super(),this.method=e,this.aNode=t,this.bNode=d,this.cNode=u}getInputType(e){const t=this.aNode.getNodeType(e),d=this.bNode?this.bNode.getNodeType(e):null,u=this.cNode?this.cNode.getNodeType(e):null,r=e.getTypeLength(t),l=e.getTypeLength(d),s=e.getTypeLength(u);return r>l&&r>s?t:l>s?d:s>r?u:t}getNodeType(e){const t=this.method;return t===o.LENGTH||t===o.DISTANCE||t===o.DOT?"float":t===o.CROSS?"vec3":this.getInputType(e)}generate(e,t){const s=this.method,i=this.getNodeType(e),a=this.getInputType(e),n=this.aNode,f=this.bNode,c=this.cNode,N=!0===e.renderer.isWebGLRenderer;if(!N||s!==o.DFDX&&s!==o.DFDY||"vec3"!==t){if(s===o.TRANSFORM_DIRECTION){let t=n,u=f;e.isMatrix(t.getNodeType(e))?u=new d(`${e.getType("vec4")}( ${u.build(e,"vec3")}, 0.0 )`,"vec4"):t=new d(`${e.getType("vec4")}( ${t.build(e,"vec3")}, 0.0 )`,"vec4");const s=new r(new l("*",t,u),"xyz");return new o(o.NORMALIZE,s).build(e)}if(s===o.SATURATE)return e.format(`clamp( ${n.build(e,a)}, 0.0, 1.0 )`,i,t);if(s===o.NEGATE)return e.format("( -"+n.build(e,a)+" )",i,t);if(s===o.INVERT)return e.format("( 1.0 - "+n.build(e,a)+" )",i,t);{const d=[];return s===o.CROSS?d.push(n.build(e,i),f.build(e,i)):s===o.STEP?d.push(n.build(e,1===e.getTypeLength(n.getNodeType(e))?"float":a),f.build(e,a)):N&&(s===o.MIN||s===o.MAX)||s===o.MOD?d.push(n.build(e,a),f.build(e,1===e.getTypeLength(f.getNodeType(e))?"float":a)):s===o.REFRACT?d.push(n.build(e,a),f.build(e,a),c.build(e,"float")):s===o.MIX?d.push(n.build(e,a),f.build(e,a),c.build(e,1===e.getTypeLength(c.getNodeType(e))?"float":a)):(d.push(n.build(e,a)),null!==c?d.push(f.build(e,a),c.build(e,a)):null!==f&&d.push(f.build(e,a))),e.format(`${e.getMethod(s)}( ${d.join(", ")} )`,i,t)}}return new u([new o(s,new r(n,"x")),new o(s,new r(n,"y")),new o(s,new r(n,"z"))]).build(e)}serialize(e){super.serialize(e),e.method=this.method}deserialize(e){super.deserialize(e),this.method=e.method}}i.default(o,"RAD","radians"),i.default(o,"DEG","degrees"),i.default(o,"EXP","exp"),i.default(o,"EXP2","exp2"),i.default(o,"LOG","log"),i.default(o,"LOG2","log2"),i.default(o,"SQRT","sqrt"),i.default(o,"INV_SQRT","inversesqrt"),i.default(o,"FLOOR","floor"),i.default(o,"CEIL","ceil"),i.default(o,"NORMALIZE","normalize"),i.default(o,"FRACT","fract"),i.default(o,"SIN","sin"),i.default(o,"COS","cos"),i.default(o,"TAN","tan"),i.default(o,"ASIN","asin"),i.default(o,"ACOS","acos"),i.default(o,"ATAN","atan"),i.default(o,"ABS","abs"),i.default(o,"SIGN","sign"),i.default(o,"LENGTH","length"),i.default(o,"NEGATE","negate"),i.default(o,"INVERT","invert"),i.default(o,"DFDX","dFdx"),i.default(o,"DFDY","dFdy"),i.default(o,"SATURATE","saturate"),i.default(o,"ROUND","round"),i.default(o,"MIN","min"),i.default(o,"MAX","max"),i.default(o,"MOD","mod"),i.default(o,"STEP","step"),i.default(o,"REFLECT","reflect"),i.default(o,"DISTANCE","distance"),i.default(o,"DOT","dot"),i.default(o,"CROSS","cross"),i.default(o,"POW","pow"),i.default(o,"TRANSFORM_DIRECTION","transformDirection"),i.default(o,"MIX","mix"),i.default(o,"CLAMP","clamp"),i.default(o,"REFRACT","refract"),i.default(o,"SMOOTHSTEP","smoothstep"),i.default(o,"FACEFORWARD","faceforward"),module.exports=o;

package/nodes/math/MathNode.js

@@ -1,16 +1,14 @@
-"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;
-};
-const TempNode = require("../core/TempNode.js");
-const ExpressionNode = require("../core/ExpressionNode.js");
-const JoinNode = require("../utils/JoinNode.js");
-const SplitNode = require("../utils/SplitNode.js");
-const OperatorNode = require("./OperatorNode.js");
-const _MathNode = class extends TempNode {
+import _defineProperty from '@babel/runtime/helpers/esm/defineProperty';
+import TempNode from '../core/TempNode.js';
+import ExpressionNode from '../core/ExpressionNode.js';
+import JoinNode from '../utils/JoinNode.js';
+import SplitNode from '../utils/SplitNode.js';
+import OperatorNode from './OperatorNode.js';
+
+class MathNode extends TempNode {
+  // 1 input
+  // 2 inputs
+  // 3 inputs
   constructor(method, aNode, bNode = null, cNode = null) {
     super();
     this.method = method;
@@ -18,6 +16,7 @@ const _MathNode = class extends TempNode {
     this.bNode = bNode;
     this.cNode = cNode;
   }
+
   getInputType(builder) {
     const aType = this.aNode.getNodeType(builder);
     const bType = this.bNode ? this.bNode.getNodeType(builder) : null;
@@ -25,6 +24,7 @@ const _MathNode = class extends TempNode {
     const aLen = builder.getTypeLength(aType);
     const bLen = builder.getTypeLength(bType);
     const cLen = builder.getTypeLength(cType);
+
     if (aLen > bLen && aLen > cLen) {
       return aType;
     } else if (bLen > cLen) {
@@ -32,18 +32,22 @@ const _MathNode = class extends TempNode {
     } else if (cLen > aLen) {
       return cType;
     }
+
     return aType;
   }
+
   getNodeType(builder) {
     const method = this.method;
-    if (method === _MathNode.LENGTH || method === _MathNode.DISTANCE || method === _MathNode.DOT) {
-      return "float";
-    } else if (method === _MathNode.CROSS) {
-      return "vec3";
+
+    if (method === MathNode.LENGTH || method === MathNode.DISTANCE || method === MathNode.DOT) {
+      return 'float';
+    } else if (method === MathNode.CROSS) {
+      return 'vec3';
     } else {
       return this.getInputType(builder);
     }
   }
+
   generate(builder, output) {
     const method = this.method;
     const type = this.getNodeType(builder);
@@ -52,111 +56,151 @@ const _MathNode = class extends TempNode {
     const b = this.bNode;
     const c = this.cNode;
     const isWebGL = builder.renderer.isWebGLRenderer === true;
-    if (isWebGL && (method === _MathNode.DFDX || method === _MathNode.DFDY) && output === "vec3") {
-      return new JoinNode([
-        new _MathNode(method, new SplitNode(a, "x")),
-        new _MathNode(method, new SplitNode(a, "y")),
-        new _MathNode(method, new SplitNode(a, "z"))
-      ]).build(builder);
-    } else if (method === _MathNode.TRANSFORM_DIRECTION) {
+
+    if (isWebGL && (method === MathNode.DFDX || method === MathNode.DFDY) && output === 'vec3') {
+      // Workaround for Adreno 3XX dFd*( vec3 ) bug. See #9988
+      return new JoinNode([new MathNode(method, new SplitNode(a, 'x')), new MathNode(method, new SplitNode(a, 'y')), new MathNode(method, new SplitNode(a, 'z'))]).build(builder);
+    } else if (method === MathNode.TRANSFORM_DIRECTION) {
+      // dir can be either a direction vector or a normal vector
+      // upper-left 3x3 of matrix is assumed to be orthogonal
       let tA = a;
       let tB = b;
+
       if (builder.isMatrix(tA.getNodeType(builder))) {
-        tB = new ExpressionNode(`${builder.getType("vec4")}( ${tB.build(builder, "vec3")}, 0.0 )`, "vec4");
+        tB = new ExpressionNode(`${builder.getType('vec4')}( ${tB.build(builder, 'vec3')}, 0.0 )`, 'vec4');
       } else {
-        tA = new ExpressionNode(`${builder.getType("vec4")}( ${tA.build(builder, "vec3")}, 0.0 )`, "vec4");
+        tA = new ExpressionNode(`${builder.getType('vec4')}( ${tA.build(builder, 'vec3')}, 0.0 )`, 'vec4');
       }
-      const mulNode = new SplitNode(new OperatorNode("*", tA, tB), "xyz");
-      return new _MathNode(_MathNode.NORMALIZE, mulNode).build(builder);
-    } else if (method === _MathNode.SATURATE) {
+
+      const mulNode = new SplitNode(new OperatorNode('*', tA, tB), 'xyz');
+      return new MathNode(MathNode.NORMALIZE, mulNode).build(builder);
+    } else if (method === MathNode.SATURATE) {
       return builder.format(`clamp( ${a.build(builder, inputType)}, 0.0, 1.0 )`, type, output);
-    } else if (method === _MathNode.NEGATE) {
-      return builder.format("( -" + a.build(builder, inputType) + " )", type, output);
-    } else if (method === _MathNode.INVERT) {
-      return builder.format("( 1.0 - " + a.build(builder, inputType) + " )", type, output);
+    } else if (method === MathNode.NEGATE) {
+      return builder.format('( -' + a.build(builder, inputType) + ' )', type, output);
+    } else if (method === MathNode.INVERT) {
+      return builder.format('( 1.0 - ' + a.build(builder, inputType) + ' )', type, output);
     } else {
       const params = [];
-      if (method === _MathNode.CROSS) {
+
+      if (method === MathNode.CROSS) {
         params.push(a.build(builder, type), b.build(builder, type));
-      } else if (method === _MathNode.STEP) {
-        params.push(
-          a.build(builder, builder.getTypeLength(a.getNodeType(builder)) === 1 ? "float" : inputType),
-          b.build(builder, inputType)
-        );
-      } else if (isWebGL && (method === _MathNode.MIN || method === _MathNode.MAX) || method === _MathNode.MOD) {
-        params.push(
-          a.build(builder, inputType),
-          b.build(builder, builder.getTypeLength(b.getNodeType(builder)) === 1 ? "float" : inputType)
-        );
-      } else if (method === _MathNode.REFRACT) {
-        params.push(a.build(builder, inputType), b.build(builder, inputType), c.build(builder, "float"));
-      } else if (method === _MathNode.MIX) {
-        params.push(
-          a.build(builder, inputType),
-          b.build(builder, inputType),
-          c.build(builder, builder.getTypeLength(c.getNodeType(builder)) === 1 ? "float" : inputType)
-        );
+      } else if (method === MathNode.STEP) {
+        params.push(a.build(builder, builder.getTypeLength(a.getNodeType(builder)) === 1 ? 'float' : inputType), b.build(builder, inputType));
+      } else if (isWebGL && (method === MathNode.MIN || method === MathNode.MAX) || method === MathNode.MOD) {
+        params.push(a.build(builder, inputType), b.build(builder, builder.getTypeLength(b.getNodeType(builder)) === 1 ? 'float' : inputType));
+      } else if (method === MathNode.REFRACT) {
+        params.push(a.build(builder, inputType), b.build(builder, inputType), c.build(builder, 'float'));
+      } else if (method === MathNode.MIX) {
+        params.push(a.build(builder, inputType), b.build(builder, inputType), c.build(builder, builder.getTypeLength(c.getNodeType(builder)) === 1 ? 'float' : inputType));
       } else {
         params.push(a.build(builder, inputType));
+
         if (c !== null) {
           params.push(b.build(builder, inputType), c.build(builder, inputType));
         } else if (b !== null) {
           params.push(b.build(builder, inputType));
         }
       }
-      return builder.format(`${builder.getMethod(method)}( ${params.join(", ")} )`, type, output);
+
+      return builder.format(`${builder.getMethod(method)}( ${params.join(', ')} )`, type, output);
     }
   }
+
   serialize(data) {
     super.serialize(data);
     data.method = this.method;
   }
+
   deserialize(data) {
     super.deserialize(data);
     this.method = data.method;
   }
-};
-let MathNode = _MathNode;
-__publicField(MathNode, "RAD", "radians");
-__publicField(MathNode, "DEG", "degrees");
-__publicField(MathNode, "EXP", "exp");
-__publicField(MathNode, "EXP2", "exp2");
-__publicField(MathNode, "LOG", "log");
-__publicField(MathNode, "LOG2", "log2");
-__publicField(MathNode, "SQRT", "sqrt");
-__publicField(MathNode, "INV_SQRT", "inversesqrt");
-__publicField(MathNode, "FLOOR", "floor");
-__publicField(MathNode, "CEIL", "ceil");
-__publicField(MathNode, "NORMALIZE", "normalize");
-__publicField(MathNode, "FRACT", "fract");
-__publicField(MathNode, "SIN", "sin");
-__publicField(MathNode, "COS", "cos");
-__publicField(MathNode, "TAN", "tan");
-__publicField(MathNode, "ASIN", "asin");
-__publicField(MathNode, "ACOS", "acos");
-__publicField(MathNode, "ATAN", "atan");
-__publicField(MathNode, "ABS", "abs");
-__publicField(MathNode, "SIGN", "sign");
-__publicField(MathNode, "LENGTH", "length");
-__publicField(MathNode, "NEGATE", "negate");
-__publicField(MathNode, "INVERT", "invert");
-__publicField(MathNode, "DFDX", "dFdx");
-__publicField(MathNode, "DFDY", "dFdy");
-__publicField(MathNode, "SATURATE", "saturate");
-__publicField(MathNode, "ROUND", "round");
-__publicField(MathNode, "MIN", "min");
-__publicField(MathNode, "MAX", "max");
-__publicField(MathNode, "MOD", "mod");
-__publicField(MathNode, "STEP", "step");
-__publicField(MathNode, "REFLECT", "reflect");
-__publicField(MathNode, "DISTANCE", "distance");
-__publicField(MathNode, "DOT", "dot");
-__publicField(MathNode, "CROSS", "cross");
-__publicField(MathNode, "POW", "pow");
-__publicField(MathNode, "TRANSFORM_DIRECTION", "transformDirection");
-__publicField(MathNode, "MIX", "mix");
-__publicField(MathNode, "CLAMP", "clamp");
-__publicField(MathNode, "REFRACT", "refract");
-__publicField(MathNode, "SMOOTHSTEP", "smoothstep");
-__publicField(MathNode, "FACEFORWARD", "faceforward");
-module.exports = MathNode;
+
+}
+
+_defineProperty(MathNode, "RAD", 'radians');
+
+_defineProperty(MathNode, "DEG", 'degrees');
+
+_defineProperty(MathNode, "EXP", 'exp');
+
+_defineProperty(MathNode, "EXP2", 'exp2');
+
+_defineProperty(MathNode, "LOG", 'log');
+
+_defineProperty(MathNode, "LOG2", 'log2');
+
+_defineProperty(MathNode, "SQRT", 'sqrt');
+
+_defineProperty(MathNode, "INV_SQRT", 'inversesqrt');
+
+_defineProperty(MathNode, "FLOOR", 'floor');
+
+_defineProperty(MathNode, "CEIL", 'ceil');
+
+_defineProperty(MathNode, "NORMALIZE", 'normalize');
+
+_defineProperty(MathNode, "FRACT", 'fract');
+
+_defineProperty(MathNode, "SIN", 'sin');
+
+_defineProperty(MathNode, "COS", 'cos');
+
+_defineProperty(MathNode, "TAN", 'tan');
+
+_defineProperty(MathNode, "ASIN", 'asin');
+
+_defineProperty(MathNode, "ACOS", 'acos');
+
+_defineProperty(MathNode, "ATAN", 'atan');
+
+_defineProperty(MathNode, "ABS", 'abs');
+
+_defineProperty(MathNode, "SIGN", 'sign');
+
+_defineProperty(MathNode, "LENGTH", 'length');
+
+_defineProperty(MathNode, "NEGATE", 'negate');
+
+_defineProperty(MathNode, "INVERT", 'invert');
+
+_defineProperty(MathNode, "DFDX", 'dFdx');
+
+_defineProperty(MathNode, "DFDY", 'dFdy');
+
+_defineProperty(MathNode, "SATURATE", 'saturate');
+
+_defineProperty(MathNode, "ROUND", 'round');
+
+_defineProperty(MathNode, "MIN", 'min');
+
+_defineProperty(MathNode, "MAX", 'max');
+
+_defineProperty(MathNode, "MOD", 'mod');
+
+_defineProperty(MathNode, "STEP", 'step');
+
+_defineProperty(MathNode, "REFLECT", 'reflect');
+
+_defineProperty(MathNode, "DISTANCE", 'distance');
+
+_defineProperty(MathNode, "DOT", 'dot');
+
+_defineProperty(MathNode, "CROSS", 'cross');
+
+_defineProperty(MathNode, "POW", 'pow');
+
+_defineProperty(MathNode, "TRANSFORM_DIRECTION", 'transformDirection');
+
+_defineProperty(MathNode, "MIX", 'mix');
+
+_defineProperty(MathNode, "CLAMP", 'clamp');
+
+_defineProperty(MathNode, "REFRACT", 'refract');
+
+_defineProperty(MathNode, "SMOOTHSTEP", 'smoothstep');
+
+_defineProperty(MathNode, "FACEFORWARD", 'faceforward');
+
+export default MathNode;

package/nodes/math/OperatorNode.cjs.js

@@ -0,0 +1 @@
+"use strict";var e=require("../core/TempNode.cjs.js");require("../core/Node.cjs.js"),require("../core/constants.cjs.js"),require("../core/NodeUtils.cjs.js"),require("three");class t extends e{constructor(e,o,r,...i){if(super(),this.op=e,i.length>0){let o=r;for(let r=0;r<i.length;r++)o=new t(e,o,i[r]);r=o}this.aNode=o,this.bNode=r}getNodeType(e,t){const o=this.op,r=this.aNode,i=this.bNode,s=r.getNodeType(e),d=i.getNodeType(e);if("void"===s||"void"===d)return"void";if("="===o||"%"===o)return s;if("&"===o||"|"===o||"^"===o||">>"===o||"<<"===o)return"int";if("=="===o||"&&"===o||"||"===o||"^^"===o)return"bool";if("<"===o||">"===o||"<="===o||">="===o){const o=e.getTypeLength(t);return o>1?`bvec${o}`:"bool"}return"float"===s&&e.isMatrix(d)?d:e.isMatrix(s)&&e.isVector(d)?e.getVectorFromMatrix(s):e.isVector(s)&&e.isMatrix(d)?e.getVectorFromMatrix(d):e.getTypeLength(d)>e.getTypeLength(s)?d:s}generate(e,t){const o=this.op,r=this.aNode,i=this.bNode,s=this.getNodeType(e,t);let d=null,a=null;"void"!==s?(d=r.getNodeType(e),a=i.getNodeType(e),"="===o?a=d:"<"===o||">"===o||"<="===o||">="===o?e.isVector(d)?a=d:d=a="float":e.isMatrix(d)&&e.isVector(a)?a=e.getVectorFromMatrix(d):d=e.isVector(d)&&e.isMatrix(a)?e.getVectorFromMatrix(a):a=s):d=a=s;const n=r.build(e,d),c=i.build(e,a),h=e.getTypeLength(t);return"void"!==t?"="===o?(e.addFlowCode(`${n} ${this.op} ${c}`),n):">"===o&&h>1?e.format(`${e.getMethod("greaterThan")}( ${n}, ${c} )`,s,t):"<="===o&&h>1?e.format(`${e.getMethod("lessThanEqual")}( ${n}, ${c} )`,s,t):e.format(`( ${n} ${this.op} ${c} )`,s,t):"void"!==d?e.format(`${n} ${this.op} ${c}`,s,t):void 0}serialize(e){super.serialize(e),e.op=this.op}deserialize(e){super.deserialize(e),this.op=e.op}}module.exports=t;

package/nodes/math/OperatorNode.js

@@ -1,49 +1,60 @@
-"use strict";
-const TempNode = require("../core/TempNode.js");
+import TempNode from '../core/TempNode.js';
+
 class OperatorNode extends TempNode {
   constructor(op, aNode, bNode, ...params) {
     super();
     this.op = op;
+
     if (params.length > 0) {
       let finalBNode = bNode;
+
       for (let i = 0; i < params.length; i++) {
         finalBNode = new OperatorNode(op, finalBNode, params[i]);
       }
+
       bNode = finalBNode;
     }
+
     this.aNode = aNode;
     this.bNode = bNode;
   }
+
   getNodeType(builder, output) {
     const op = this.op;
     const aNode = this.aNode;
     const bNode = this.bNode;
     const typeA = aNode.getNodeType(builder);
     const typeB = bNode.getNodeType(builder);
-    if (typeA === "void" || typeB === "void") {
-      return "void";
-    } else if (op === "=" || op === "%") {
+
+    if (typeA === 'void' || typeB === 'void') {
+      return 'void';
+    } else if (op === '=' || op === '%') {
       return typeA;
-    } else if (op === "&" || op === "|" || op === "^" || op === ">>" || op === "<<") {
-      return "int";
-    } else if (op === "==" || op === "&&" || op === "||" || op === "^^") {
-      return "bool";
-    } else if (op === "<" || op === ">" || op === "<=" || op === ">=") {
+    } else if (op === '&' || op === '|' || op === '^' || op === '>>' || op === '<<') {
+      return 'int';
+    } else if (op === '==' || op === '&&' || op === '||' || op === '^^') {
+      return 'bool';
+    } else if (op === '<' || op === '>' || op === '<=' || op === '>=') {
       const typeLength = builder.getTypeLength(output);
-      return typeLength > 1 ? `bvec${typeLength}` : "bool";
+      return typeLength > 1 ? `bvec${typeLength}` : 'bool';
     } else {
-      if (typeA === "float" && builder.isMatrix(typeB)) {
+      if (typeA === 'float' && builder.isMatrix(typeB)) {
         return typeB;
       } else if (builder.isMatrix(typeA) && builder.isVector(typeB)) {
+        // matrix x vector
         return builder.getVectorFromMatrix(typeA);
       } else if (builder.isVector(typeA) && builder.isMatrix(typeB)) {
+        // vector x matrix
         return builder.getVectorFromMatrix(typeB);
       } else if (builder.getTypeLength(typeB) > builder.getTypeLength(typeA)) {
+        // anytype x anytype: use the greater length vector
         return typeB;
       }
+
       return typeA;
     }
   }
+
   generate(builder, output) {
     const op = this.op;
     const aNode = this.aNode;
@@ -51,52 +62,63 @@ class OperatorNode extends TempNode {
     const type = this.getNodeType(builder, output);
     let typeA = null;
     let typeB = null;
-    if (type !== "void") {
+
+    if (type !== 'void') {
       typeA = aNode.getNodeType(builder);
       typeB = bNode.getNodeType(builder);
-      if (op === "=") {
+
+      if (op === '=') {
         typeB = typeA;
-      } else if (op === "<" || op === ">" || op === "<=" || op === ">=") {
+      } else if (op === '<' || op === '>' || op === '<=' || op === '>=') {
         if (builder.isVector(typeA)) {
           typeB = typeA;
         } else {
-          typeA = typeB = "float";
+          typeA = typeB = 'float';
         }
       } else if (builder.isMatrix(typeA) && builder.isVector(typeB)) {
+        // matrix x vector
         typeB = builder.getVectorFromMatrix(typeA);
       } else if (builder.isVector(typeA) && builder.isMatrix(typeB)) {
+        // vector x matrix
         typeA = builder.getVectorFromMatrix(typeB);
       } else {
+        // anytype x anytype
         typeA = typeB = type;
       }
     } else {
       typeA = typeB = type;
     }
+
     const a = aNode.build(builder, typeA);
     const b = bNode.build(builder, typeB);
     const outputLength = builder.getTypeLength(output);
-    if (output !== "void") {
-      if (op === "=") {
+
+    if (output !== 'void') {
+      if (op === '=') {
         builder.addFlowCode(`${a} ${this.op} ${b}`);
         return a;
-      } else if (op === ">" && outputLength > 1) {
-        return builder.format(`${builder.getMethod("greaterThan")}( ${a}, ${b} )`, type, output);
-      } else if (op === "<=" && outputLength > 1) {
-        return builder.format(`${builder.getMethod("lessThanEqual")}( ${a}, ${b} )`, type, output);
+      } else if (op === '>' && outputLength > 1) {
+        return builder.format(`${builder.getMethod('greaterThan')}( ${a}, ${b} )`, type, output);
+      } else if (op === '<=' && outputLength > 1) {
+        return builder.format(`${builder.getMethod('lessThanEqual')}( ${a}, ${b} )`, type, output);
       } else {
         return builder.format(`( ${a} ${this.op} ${b} )`, type, output);
       }
-    } else if (typeA !== "void") {
+    } else if (typeA !== 'void') {
       return builder.format(`${a} ${this.op} ${b}`, type, output);
     }
   }
+
   serialize(data) {
     super.serialize(data);
     data.op = this.op;
   }
+
   deserialize(data) {
     super.deserialize(data);
     this.op = data.op;
   }
+
 }
-module.exports = OperatorNode;
+
+export default OperatorNode;

package/nodes/parsers/GLSLNodeFunction.cjs.js

@@ -0,0 +1 @@
+"use strict";var e=require("../core/NodeFunction.cjs.js"),t=require("../core/NodeFunctionInput.cjs.js");const o=/^\s*(highp|mediump|lowp)?\s*([a-z_0-9]+)\s*([a-z_0-9]+)?\s*\(([\s\S]*?)\)/i,s=/[a-z_0-9]+/gi;module.exports=class extends e{constructor(e){const{type:n,inputs:i,name:r,presicion:c,inputsCode:u,blockCode:d,headerCode:l}=(e=>{const n=(e=e.trim()).indexOf("#pragma main"),i=-1!==n?e.slice(n+"#pragma main".length):e,r=i.match(o);if(null!==r&&5===r.length){const o=r[4],c=[];let u=null;for(;null!==(u=s.exec(o));)c.push(u);const d=[];let l=0;for(;l<c.length;){const e="const"===c[l][0];!0===e&&l++;let o=c[l][0];"in"===o||"out"===o||"inout"===o?l++:o="";const s=c[l++][0];let n=Number.parseInt(c[l][0]);!1===Number.isNaN(n)?l++:n=null;const i=c[l++][0];d.push(new t(s,i,n,o,e))}const h=i.substring(r[0].length),p=void 0!==r[3]?r[3]:"";return{type:r[2],inputs:d,name:p,presicion:void 0!==r[1]?r[1]:"",inputsCode:o,blockCode:h,headerCode:-1!==n?e.slice(0,n):""}}throw new Error("FunctionNode: Function is not a GLSL code.")})(e);super(n,i,r,c),this.inputsCode=u,this.blockCode=d,this.headerCode=l}getCode(e=this.name){const t=this.headerCode,o=this.presicion;let s=`${this.type} ${e} ( ${this.inputsCode.trim()} )`;return""!==o&&(s=`${o} ${s}`),t+s+this.blockCode}};

package/nodes/parsers/GLSLNodeFunction.js

@@ -0,0 +1,101 @@
+import NodeFunction from '../core/NodeFunction.js';
+import NodeFunctionInput from '../core/NodeFunctionInput.js';
+
+const declarationRegexp = /^\s*(highp|mediump|lowp)?\s*([a-z_0-9]+)\s*([a-z_0-9]+)?\s*\(([\s\S]*?)\)/i;
+const propertiesRegexp = /[a-z_0-9]+/gi;
+const pragmaMain = '#pragma main';
+
+const parse = source => {
+  source = source.trim();
+  const pragmaMainIndex = source.indexOf(pragmaMain);
+  const mainCode = pragmaMainIndex !== -1 ? source.slice(pragmaMainIndex + pragmaMain.length) : source;
+  const declaration = mainCode.match(declarationRegexp);
+
+  if (declaration !== null && declaration.length === 5) {
+    // tokenizer
+    const inputsCode = declaration[4];
+    const propsMatches = [];
+    let nameMatch = null;
+
+    while ((nameMatch = propertiesRegexp.exec(inputsCode)) !== null) {
+      propsMatches.push(nameMatch);
+    } // parser
+
+
+    const inputs = [];
+    let i = 0;
+
+    while (i < propsMatches.length) {
+      const isConst = propsMatches[i][0] === 'const';
+
+      if (isConst === true) {
+        i++;
+      }
+
+      let qualifier = propsMatches[i][0];
+
+      if (qualifier === 'in' || qualifier === 'out' || qualifier === 'inout') {
+        i++;
+      } else {
+        qualifier = '';
+      }
+
+      const type = propsMatches[i++][0];
+      let count = Number.parseInt(propsMatches[i][0]);
+      if (Number.isNaN(count) === false) i++;else count = null;
+      const name = propsMatches[i++][0];
+      inputs.push(new NodeFunctionInput(type, name, count, qualifier, isConst));
+    } //
+
+
+    const blockCode = mainCode.substring(declaration[0].length);
+    const name = declaration[3] !== undefined ? declaration[3] : '';
+    const type = declaration[2];
+    const presicion = declaration[1] !== undefined ? declaration[1] : '';
+    const headerCode = pragmaMainIndex !== -1 ? source.slice(0, pragmaMainIndex) : '';
+    return {
+      type,
+      inputs,
+      name,
+      presicion,
+      inputsCode,
+      blockCode,
+      headerCode
+    };
+  } else {
+    throw new Error('FunctionNode: Function is not a GLSL code.');
+  }
+};
+
+class GLSLNodeFunction extends NodeFunction {
+  constructor(source) {
+    const {
+      type,
+      inputs,
+      name,
+      presicion,
+      inputsCode,
+      blockCode,
+      headerCode
+    } = parse(source);
+    super(type, inputs, name, presicion);
+    this.inputsCode = inputsCode;
+    this.blockCode = blockCode;
+    this.headerCode = headerCode;
+  }
+
+  getCode(name = this.name) {
+    const headerCode = this.headerCode;
+    const presicion = this.presicion;
+    let declarationCode = `${this.type} ${name} ( ${this.inputsCode.trim()} )`;
+
+    if (presicion !== '') {
+      declarationCode = `${presicion} ${declarationCode}`;
+    }
+
+    return headerCode + declarationCode + this.blockCode;
+  }
+
+}
+
+export default GLSLNodeFunction;

package/nodes/parsers/GLSLNodeParser.cjs.js

@@ -0,0 +1 @@
+"use strict";var e=require("../core/NodeParser.cjs.js"),r=require("./GLSLNodeFunction.cjs.js");require("../core/NodeFunction.cjs.js"),require("../core/NodeFunctionInput.cjs.js");module.exports=class extends e{parseFunction(e){return new r(e)}};