three-stdlib 2.22.7 → 2.22.8

package/dist/nodes/materials/MeshStandardNodeMaterial.js

@@ -0,0 +1,40 @@
+"use strict";
+const NodeMaterial = require("./NodeMaterial.js");
+const THREE = require("three");
+const defaultValues = new THREE.MeshStandardMaterial();
+class MeshStandardNodeMaterial extends NodeMaterial {
+  constructor(parameters) {
+    super();
+    this.colorNode = null;
+    this.opacityNode = null;
+    this.alphaTestNode = null;
+    this.normalNode = null;
+    this.emissiveNode = null;
+    this.metalnessNode = null;
+    this.roughnessNode = null;
+    this.clearcoatNode = null;
+    this.clearcoatRoughnessNode = null;
+    this.envNode = null;
+    this.lightNode = null;
+    this.positionNode = null;
+    this.setDefaultValues(defaultValues);
+    this.setValues(parameters);
+  }
+  copy(source) {
+    this.colorNode = source.colorNode;
+    this.opacityNode = source.opacityNode;
+    this.alphaTestNode = source.alphaTestNode;
+    this.normalNode = source.normalNode;
+    this.emissiveNode = source.emissiveNode;
+    this.metalnessNode = source.metalnessNode;
+    this.roughnessNode = source.roughnessNode;
+    this.clearcoatNode = source.clearcoatNode;
+    this.clearcoatRoughnessNode = source.clearcoatRoughnessNode;
+    this.envNode = source.envNode;
+    this.lightNode = source.lightNode;
+    this.positionNode = source.positionNode;
+    return super.copy(source);
+  }
+}
+MeshStandardNodeMaterial.prototype.isMeshStandardNodeMaterial = true;
+module.exports = MeshStandardNodeMaterial;

package/dist/nodes/materials/MeshStandardNodeMaterial.mjs

@@ -0,0 +1,41 @@
+import NodeMaterial from "./NodeMaterial.mjs";
+import { MeshStandardMaterial } from "three";
+const defaultValues = new MeshStandardMaterial();
+class MeshStandardNodeMaterial extends NodeMaterial {
+  constructor(parameters) {
+    super();
+    this.colorNode = null;
+    this.opacityNode = null;
+    this.alphaTestNode = null;
+    this.normalNode = null;
+    this.emissiveNode = null;
+    this.metalnessNode = null;
+    this.roughnessNode = null;
+    this.clearcoatNode = null;
+    this.clearcoatRoughnessNode = null;
+    this.envNode = null;
+    this.lightNode = null;
+    this.positionNode = null;
+    this.setDefaultValues(defaultValues);
+    this.setValues(parameters);
+  }
+  copy(source) {
+    this.colorNode = source.colorNode;
+    this.opacityNode = source.opacityNode;
+    this.alphaTestNode = source.alphaTestNode;
+    this.normalNode = source.normalNode;
+    this.emissiveNode = source.emissiveNode;
+    this.metalnessNode = source.metalnessNode;
+    this.roughnessNode = source.roughnessNode;
+    this.clearcoatNode = source.clearcoatNode;
+    this.clearcoatRoughnessNode = source.clearcoatRoughnessNode;
+    this.envNode = source.envNode;
+    this.lightNode = source.lightNode;
+    this.positionNode = source.positionNode;
+    return super.copy(source);
+  }
+}
+MeshStandardNodeMaterial.prototype.isMeshStandardNodeMaterial = true;
+export {
+  MeshStandardNodeMaterial as default
+};

package/dist/nodes/materials/NodeMaterial.js

@@ -0,0 +1,63 @@
+"use strict";
+const THREE = require("three");
+const NodeUtils = require("../core/NodeUtils.js");
+class NodeMaterial extends THREE.ShaderMaterial {
+  constructor() {
+    super();
+    this.type = this.constructor.name;
+    this.lights = true;
+  }
+  setDefaultValues(values) {
+    let value;
+    for (const property in values) {
+      value = values[property];
+      if (this[property] === void 0) {
+        if (value && typeof value.clone === "function") {
+          this[property] = value.clone();
+        } else {
+          this[property] = value;
+        }
+      }
+    }
+    Object.assign(this.defines, values.defines);
+  }
+  toJSON(meta) {
+    const isRoot = meta === void 0 || typeof meta === "string";
+    if (isRoot) {
+      meta = {
+        textures: {},
+        images: {},
+        nodes: {}
+      };
+    }
+    const data = THREE.Material.prototype.toJSON.call(this, meta);
+    const nodeKeys = NodeUtils.getNodesKeys(this);
+    data.inputNodes = {};
+    for (const name of nodeKeys) {
+      data.inputNodes[name] = this[name].toJSON(meta).uuid;
+    }
+    function extractFromCache(cache) {
+      const values = [];
+      for (const key in cache) {
+        const data2 = cache[key];
+        delete data2.metadata;
+        values.push(data2);
+      }
+      return values;
+    }
+    if (isRoot) {
+      const textures = extractFromCache(meta.textures);
+      const images = extractFromCache(meta.images);
+      const nodes = extractFromCache(meta.nodes);
+      if (textures.length > 0)
+        data.textures = textures;
+      if (images.length > 0)
+        data.images = images;
+      if (nodes.length > 0)
+        data.nodes = nodes;
+    }
+    return data;
+  }
+}
+NodeMaterial.prototype.isNodeMaterial = true;
+module.exports = NodeMaterial;

package/dist/nodes/materials/NodeMaterial.mjs

@@ -0,0 +1,64 @@
+import { ShaderMaterial, Material } from "three";
+import { getNodesKeys } from "../core/NodeUtils.mjs";
+class NodeMaterial extends ShaderMaterial {
+  constructor() {
+    super();
+    this.type = this.constructor.name;
+    this.lights = true;
+  }
+  setDefaultValues(values) {
+    let value;
+    for (const property in values) {
+      value = values[property];
+      if (this[property] === void 0) {
+        if (value && typeof value.clone === "function") {
+          this[property] = value.clone();
+        } else {
+          this[property] = value;
+        }
+      }
+    }
+    Object.assign(this.defines, values.defines);
+  }
+  toJSON(meta) {
+    const isRoot = meta === void 0 || typeof meta === "string";
+    if (isRoot) {
+      meta = {
+        textures: {},
+        images: {},
+        nodes: {}
+      };
+    }
+    const data = Material.prototype.toJSON.call(this, meta);
+    const nodeKeys = getNodesKeys(this);
+    data.inputNodes = {};
+    for (const name of nodeKeys) {
+      data.inputNodes[name] = this[name].toJSON(meta).uuid;
+    }
+    function extractFromCache(cache) {
+      const values = [];
+      for (const key in cache) {
+        const data2 = cache[key];
+        delete data2.metadata;
+        values.push(data2);
+      }
+      return values;
+    }
+    if (isRoot) {
+      const textures = extractFromCache(meta.textures);
+      const images = extractFromCache(meta.images);
+      const nodes = extractFromCache(meta.nodes);
+      if (textures.length > 0)
+        data.textures = textures;
+      if (images.length > 0)
+        data.images = images;
+      if (nodes.length > 0)
+        data.nodes = nodes;
+    }
+    return data;
+  }
+}
+NodeMaterial.prototype.isNodeMaterial = true;
+export {
+  NodeMaterial as default
+};

package/dist/nodes/materials/PointsNodeMaterial.js

@@ -0,0 +1,29 @@
+"use strict";
+const NodeMaterial = require("./NodeMaterial.js");
+const THREE = require("three");
+const defaultValues = new THREE.PointsMaterial();
+class PointsNodeMaterial extends NodeMaterial {
+  constructor(parameters) {
+    super();
+    this.transparent = true;
+    this.colorNode = null;
+    this.opacityNode = null;
+    this.alphaTestNode = null;
+    this.lightNode = null;
+    this.sizeNode = null;
+    this.positionNode = null;
+    this.setDefaultValues(defaultValues);
+    this.setValues(parameters);
+  }
+  copy(source) {
+    this.colorNode = source.colorNode;
+    this.opacityNode = source.opacityNode;
+    this.alphaTestNode = source.alphaTestNode;
+    this.lightNode = source.lightNode;
+    this.sizeNode = source.sizeNode;
+    this.positionNode = source.positionNode;
+    return super.copy(source);
+  }
+}
+PointsNodeMaterial.prototype.isPointsNodeMaterial = true;
+module.exports = PointsNodeMaterial;

package/dist/nodes/materials/PointsNodeMaterial.mjs

@@ -0,0 +1,30 @@
+import NodeMaterial from "./NodeMaterial.mjs";
+import { PointsMaterial } from "three";
+const defaultValues = new PointsMaterial();
+class PointsNodeMaterial extends NodeMaterial {
+  constructor(parameters) {
+    super();
+    this.transparent = true;
+    this.colorNode = null;
+    this.opacityNode = null;
+    this.alphaTestNode = null;
+    this.lightNode = null;
+    this.sizeNode = null;
+    this.positionNode = null;
+    this.setDefaultValues(defaultValues);
+    this.setValues(parameters);
+  }
+  copy(source) {
+    this.colorNode = source.colorNode;
+    this.opacityNode = source.opacityNode;
+    this.alphaTestNode = source.alphaTestNode;
+    this.lightNode = source.lightNode;
+    this.sizeNode = source.sizeNode;
+    this.positionNode = source.positionNode;
+    return super.copy(source);
+  }
+}
+PointsNodeMaterial.prototype.isPointsNodeMaterial = true;
+export {
+  PointsNodeMaterial as default
+};

package/dist/nodes/math/CondNode.js

@@ -0,0 +1,40 @@
+"use strict";
+const Node = require("../core/Node.js");
+const PropertyNode = require("../core/PropertyNode.js");
+const ContextNode = require("../core/ContextNode.js");
+class CondNode extends Node {
+  constructor(node, ifNode, elseNode) {
+    super();
+    this.node = 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 nodeProperty = new PropertyNode(null, type).build(builder);
+    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};
+
+	} else {
+
+		${nodeProperty} = ${elseSnippet};
+
+	}`);
+    return nodeProperty;
+  }
+}
+module.exports = CondNode;

package/dist/nodes/math/CondNode.mjs

@@ -0,0 +1,41 @@
+import Node from "../core/Node.mjs";
+import PropertyNode from "../core/PropertyNode.mjs";
+import ContextNode from "../core/ContextNode.mjs";
+class CondNode extends Node {
+  constructor(node, ifNode, elseNode) {
+    super();
+    this.node = 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 nodeProperty = new PropertyNode(null, type).build(builder);
+    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};
+
+	} else {
+
+		${nodeProperty} = ${elseSnippet};
+
+	}`);
+    return nodeProperty;
+  }
+}
+export {
+  CondNode as default
+};

package/dist/nodes/math/MathNode.js

@@ -0,0 +1,165 @@
+"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 {
+  constructor(method, aNode, bNode = null, cNode = null) {
+    super();
+    this.method = method;
+    this.aNode = aNode;
+    this.bNode = bNode;
+    this.cNode = cNode;
+  }
+  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;
+  }
+  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";
+    } else {
+      return this.getInputType(builder);
+    }
+  }
+  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") {
+      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) {
+      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);
+    }
+  }
+  serialize(data) {
+    super.serialize(data);
+    data.method = this.method;
+  }
+  deserialize(data) {
+    super.deserialize(data);
+    this.method = data.method;
+  }
+};
+let MathNode = _MathNode;
+// 1 input
+__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");
+// 2 inputs
+__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");
+// 3 inputs
+__publicField(MathNode, "MIX", "mix");
+__publicField(MathNode, "CLAMP", "clamp");
+__publicField(MathNode, "REFRACT", "refract");
+__publicField(MathNode, "SMOOTHSTEP", "smoothstep");
+__publicField(MathNode, "FACEFORWARD", "faceforward");
+module.exports = MathNode;

package/dist/nodes/math/MathNode.mjs

@@ -0,0 +1,166 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+import TempNode from "../core/TempNode.mjs";
+import ExpressionNode from "../core/ExpressionNode.mjs";
+import JoinNode from "../utils/JoinNode.mjs";
+import SplitNode from "../utils/SplitNode.mjs";
+import OperatorNode from "./OperatorNode.mjs";
+const _MathNode = class extends TempNode {
+  constructor(method, aNode, bNode = null, cNode = null) {
+    super();
+    this.method = method;
+    this.aNode = aNode;
+    this.bNode = bNode;
+    this.cNode = cNode;
+  }
+  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;
+  }
+  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";
+    } else {
+      return this.getInputType(builder);
+    }
+  }
+  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") {
+      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) {
+      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);
+    }
+  }
+  serialize(data) {
+    super.serialize(data);
+    data.method = this.method;
+  }
+  deserialize(data) {
+    super.deserialize(data);
+    this.method = data.method;
+  }
+};
+let MathNode = _MathNode;
+// 1 input
+__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");
+// 2 inputs
+__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");
+// 3 inputs
+__publicField(MathNode, "MIX", "mix");
+__publicField(MathNode, "CLAMP", "clamp");
+__publicField(MathNode, "REFRACT", "refract");
+__publicField(MathNode, "SMOOTHSTEP", "smoothstep");
+__publicField(MathNode, "FACEFORWARD", "faceforward");
+export {
+  MathNode as default
+};