three-stdlib 2.8.9 → 2.8.12

package/nodes/math/MathNode.js

@@ -1,206 +1,206 @@
-import { TempNode } from '../core/TempNode.js';
-
-function MathNode(a, bOrMethod, cOrMethod, method) {
-  TempNode.call(this);
-  this.a = a;
-  typeof bOrMethod !== 'string' ? this.b = bOrMethod : method = bOrMethod;
-  typeof cOrMethod !== 'string' ? this.c = cOrMethod : method = cOrMethod;
-  this.method = method;
-} // 1 input
-
-
-MathNode.RAD = 'radians';
-MathNode.DEG = 'degrees';
-MathNode.EXP = 'exp';
-MathNode.EXP2 = 'exp2';
-MathNode.LOG = 'log';
-MathNode.LOG2 = 'log2';
-MathNode.SQRT = 'sqrt';
-MathNode.INV_SQRT = 'inversesqrt';
-MathNode.FLOOR = 'floor';
-MathNode.CEIL = 'ceil';
-MathNode.NORMALIZE = 'normalize';
-MathNode.FRACT = 'fract';
-MathNode.SATURATE = 'saturate';
-MathNode.SIN = 'sin';
-MathNode.COS = 'cos';
-MathNode.TAN = 'tan';
-MathNode.ASIN = 'asin';
-MathNode.ACOS = 'acos';
-MathNode.ARCTAN = 'atan';
-MathNode.ABS = 'abs';
-MathNode.SIGN = 'sign';
-MathNode.LENGTH = 'length';
-MathNode.NEGATE = 'negate';
-MathNode.INVERT = 'invert'; // 2 inputs
-
-MathNode.MIN = 'min';
-MathNode.MAX = 'max';
-MathNode.MOD = 'mod';
-MathNode.STEP = 'step';
-MathNode.REFLECT = 'reflect';
-MathNode.DISTANCE = 'distance';
-MathNode.DOT = 'dot';
-MathNode.CROSS = 'cross';
-MathNode.POW = 'pow'; // 3 inputs
-
-MathNode.MIX = 'mix';
-MathNode.CLAMP = 'clamp';
-MathNode.REFRACT = 'refract';
-MathNode.SMOOTHSTEP = 'smoothstep';
-MathNode.FACEFORWARD = 'faceforward';
-MathNode.prototype = Object.create(TempNode.prototype);
-MathNode.prototype.constructor = MathNode;
-MathNode.prototype.nodeType = 'Math';
-MathNode.prototype.hashProperties = ['method'];
-
-MathNode.prototype.getNumInputs = function
-  /*builder*/
-() {
-  switch (this.method) {
-    case MathNode.MIX:
-    case MathNode.CLAMP:
-    case MathNode.REFRACT:
-    case MathNode.SMOOTHSTEP:
-    case MathNode.FACEFORWARD:
-      return 3;
-
-    case MathNode.MIN:
-    case MathNode.MAX:
-    case MathNode.MOD:
-    case MathNode.STEP:
-    case MathNode.REFLECT:
-    case MathNode.DISTANCE:
-    case MathNode.DOT:
-    case MathNode.CROSS:
-    case MathNode.POW:
-      return 2;
-
-    default:
-      return 1;
+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;
+    this.aNode = aNode;
+    this.bNode = bNode;
+    this.cNode = cNode;
   }
-};
 
-MathNode.prototype.getInputType = function (builder) {
-  var a = builder.getTypeLength(this.a.getType(builder));
-  var b = this.b ? builder.getTypeLength(this.b.getType(builder)) : 0;
-  var c = this.c ? builder.getTypeLength(this.c.getType(builder)) : 0;
-
-  if (a > b && a > c) {
-    return this.a.getType(builder);
-  } else if (b > c) {
-    return this.b.getType(builder);
+  getInputType(builder) {
+    const aType = this.aNode.getNodeType(builder);
+    const bType = this.bNode ? this.bNode.getNodeType(builder) : null;
+    const cType = this.cNode ? this.cNode.getNodeType(builder) : null;
+    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) {
+      return bType;
+    } else if (cLen > aLen) {
+      return cType;
+    }
+
+    return aType;
   }
 
-  return this.c.getType(builder);
-};
-
-MathNode.prototype.getType = function (builder) {
-  switch (this.method) {
-    case MathNode.LENGTH:
-    case MathNode.DISTANCE:
-    case MathNode.DOT:
-      return 'f';
+  getNodeType(builder) {
+    const method = this.method;
 
-    case MathNode.CROSS:
-      return 'v3';
+    if (method === MathNode.LENGTH || method === MathNode.DISTANCE || method === MathNode.DOT) {
+      return 'float';
+    } else if (method === MathNode.CROSS) {
+      return 'vec3';
+    } else {
+      return this.getInputType(builder);
+    }
   }
 
-  return this.getInputType(builder);
-};
-
-MathNode.prototype.generate = function (builder, output) {
-  var a,
-      b,
-      c,
-      al = this.a ? builder.getTypeLength(this.a.getType(builder)) : 0,
-      bl = this.b ? builder.getTypeLength(this.b.getType(builder)) : 0,
-      cl = this.c ? builder.getTypeLength(this.c.getType(builder)) : 0,
-      inputType = this.getInputType(builder),
-      nodeType = this.getType(builder);
-
-  switch (this.method) {
-    // 1 input
-    case MathNode.NEGATE:
-      return builder.format('( -' + this.a.build(builder, inputType) + ' )', inputType, output);
-
-    case MathNode.INVERT:
-      return builder.format('( 1.0 - ' + this.a.build(builder, inputType) + ' )', inputType, output);
-    // 2 inputs
-
-    case MathNode.CROSS:
-      a = this.a.build(builder, 'v3');
-      b = this.b.build(builder, 'v3');
-      break;
-
-    case MathNode.STEP:
-      a = this.a.build(builder, al === 1 ? 'f' : inputType);
-      b = this.b.build(builder, inputType);
-      break;
-
-    case MathNode.MIN:
-    case MathNode.MAX:
-    case MathNode.MOD:
-      a = this.a.build(builder, inputType);
-      b = this.b.build(builder, bl === 1 ? 'f' : inputType);
-      break;
-    // 3 inputs
-
-    case MathNode.REFRACT:
-      a = this.a.build(builder, inputType);
-      b = this.b.build(builder, inputType);
-      c = this.c.build(builder, 'f');
-      break;
-
-    case MathNode.MIX:
-      a = this.a.build(builder, inputType);
-      b = this.b.build(builder, inputType);
-      c = this.c.build(builder, cl === 1 ? 'f' : inputType);
-      break;
-    // default
-
-    default:
-      a = this.a.build(builder, inputType);
-      if (this.b) b = this.b.build(builder, inputType);
-      if (this.c) c = this.c.build(builder, inputType);
-      break;
-  } // build function call
-
-
-  var params = [];
-  params.push(a);
-  if (b) params.push(b);
-  if (c) params.push(c);
-  var numInputs = this.getNumInputs(builder);
-
-  if (params.length !== numInputs) {
-    throw Error(`Arguments not match used in "${this.method}". Require ${numInputs}, currently ${params.length}.`);
+  generate(builder, output) {
+    const method = this.method;
+    const type = this.getNodeType(builder);
+    const inputType = this.getInputType(builder);
+    const a = this.aNode;
+    const b = this.bNode;
+    const c = this.cNode;
+    const isWebGL = builder.renderer.isWebGLRenderer === true;
+
+    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');
+      } else {
+        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) {
+      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 {
+      const params = [];
+
+      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 {
+        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(this.method + '( ' + params.join(', ') + ' )', nodeType, output);
-};
-
-MathNode.prototype.copy = function (source) {
-  TempNode.prototype.copy.call(this, source);
-  this.a = source.a;
-  this.b = source.b;
-  this.c = source.c;
-  this.method = source.method;
-  return this;
-};
-
-MathNode.prototype.toJSON = function (meta) {
-  var data = this.getJSONNode(meta);
-
-  if (!data) {
-    data = this.createJSONNode(meta);
-    data.a = this.a.toJSON(meta).uuid;
-    if (this.b) data.b = this.b.toJSON(meta).uuid;
-    if (this.c) data.c = this.c.toJSON(meta).uuid;
+  serialize(data) {
+    super.serialize(data);
     data.method = this.method;
   }
 
-  return data;
-};
+  deserialize(data) {
+    super.deserialize(data);
+    this.method = data.method;
+  }
+
+}
+
+_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 { MathNode };
+export default MathNode;

package/nodes/math/OperatorNode.cjs.js

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var t=require("../core/TempNode.cjs.js");function e(e,o,r){t.TempNode.call(this),this.a=e,this.b=o,this.op=r}require("three"),require("../core/Node.cjs.js"),e.ADD="+",e.SUB="-",e.MUL="*",e.DIV="/",e.prototype=Object.create(t.TempNode.prototype),e.prototype.constructor=e,e.prototype.nodeType="Operator",e.prototype.getType=function(t){var e=this.a.getType(t),o=this.b.getType(t);return t.isTypeMatrix(e)?"v4":t.getTypeLength(o)>t.getTypeLength(e)?o:e},e.prototype.generate=function(t,e){var o=this.getType(t),r=this.a.build(t,o),p=this.b.build(t,o);return t.format("( "+r+" "+this.op+" "+p+" )",o,e)},e.prototype.copy=function(e){return t.TempNode.prototype.copy.call(this,e),this.a=e.a,this.b=e.b,this.op=e.op,this},e.prototype.toJSON=function(t){var e=this.getJSONNode(t);return e||((e=this.createJSONNode(t)).a=this.a.toJSON(t).uuid,e.b=this.b.toJSON(t).uuid,e.op=this.op),e},exports.OperatorNode=e;
+"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,60 +1,124 @@
-import { TempNode } from '../core/TempNode.js';
+import TempNode from '../core/TempNode.js';
 
-function OperatorNode(a, b, op) {
-  TempNode.call(this);
-  this.a = a;
-  this.b = b;
-  this.op = op;
-}
+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]);
+      }
 
-OperatorNode.ADD = '+';
-OperatorNode.SUB = '-';
-OperatorNode.MUL = '*';
-OperatorNode.DIV = '/';
-OperatorNode.prototype = Object.create(TempNode.prototype);
-OperatorNode.prototype.constructor = OperatorNode;
-OperatorNode.prototype.nodeType = 'Operator';
-
-OperatorNode.prototype.getType = function (builder) {
-  var a = this.a.getType(builder),
-      b = this.b.getType(builder);
-
-  if (builder.isTypeMatrix(a)) {
-    return 'v4';
-  } else if (builder.getTypeLength(b) > builder.getTypeLength(a)) {
-    // use the greater length vector
-    return b;
+      bNode = finalBNode;
+    }
+
+    this.aNode = aNode;
+    this.bNode = bNode;
   }
 
-  return a;
-};
-
-OperatorNode.prototype.generate = function (builder, output) {
-  var type = this.getType(builder);
-  var a = this.a.build(builder, type),
-      b = this.b.build(builder, type);
-  return builder.format('( ' + a + ' ' + this.op + ' ' + b + ' )', type, output);
-};
-
-OperatorNode.prototype.copy = function (source) {
-  TempNode.prototype.copy.call(this, source);
-  this.a = source.a;
-  this.b = source.b;
-  this.op = source.op;
-  return this;
-};
-
-OperatorNode.prototype.toJSON = function (meta) {
-  var data = this.getJSONNode(meta);
-
-  if (!data) {
-    data = this.createJSONNode(meta);
-    data.a = this.a.toJSON(meta).uuid;
-    data.b = this.b.toJSON(meta).uuid;
+  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 === '%') {
+      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 === '>=') {
+      const typeLength = builder.getTypeLength(output);
+      return typeLength > 1 ? `bvec${typeLength}` : 'bool';
+    } else {
+      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;
+    const bNode = this.bNode;
+    const type = this.getNodeType(builder, output);
+    let typeA = null;
+    let typeB = null;
+
+    if (type !== 'void') {
+      typeA = aNode.getNodeType(builder);
+      typeB = bNode.getNodeType(builder);
+
+      if (op === '=') {
+        typeB = typeA;
+      } else if (op === '<' || op === '>' || op === '<=' || op === '>=') {
+        if (builder.isVector(typeA)) {
+          typeB = typeA;
+        } else {
+          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 === '=') {
+        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 {
+        return builder.format(`( ${a} ${this.op} ${b} )`, type, output);
+      }
+    } else if (typeA !== 'void') {
+      return builder.format(`${a} ${this.op} ${b}`, type, output);
+    }
+  }
+
+  serialize(data) {
+    super.serialize(data);
     data.op = this.op;
   }
 
-  return data;
-};
+  deserialize(data) {
+    super.deserialize(data);
+    this.op = data.op;
+  }
+
+}
 
-export { 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}};