three-stdlib 2.15.1 → 2.15.2

package/nodes/accessors/TextureNode.js

@@ -1,68 +1,53 @@
-import UniformNode from '../core/UniformNode.js';
-import UVNode from './UVNode.js';
-
+"use strict";
+const UniformNode = require("../core/UniformNode.js");
+const UVNode = require("./UVNode.js");
 class TextureNode extends UniformNode {
   constructor(value, uvNode = new UVNode(), biasNode = null) {
-    super(value, 'vec4');
+    super(value, "vec4");
     this.uvNode = uvNode;
     this.biasNode = biasNode;
   }
-
   getUniformHash() {
     return this.value.uuid;
   }
-
   getInputType() {
-    return 'texture';
+    return "texture";
   }
-
   generate(builder, output) {
     const texture = this.value;
-
     if (!texture || texture.isTexture !== true) {
-      throw new Error('TextureNode: Need a three.js texture.');
+      throw new Error("TextureNode: Need a three.js texture.");
     }
-
-    const textureProperty = super.generate(builder, 'texture');
-
-    if (output === 'sampler') {
-      return textureProperty + '_sampler';
+    const textureProperty = super.generate(builder, "texture");
+    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, 'vec2');
+      if (snippet === void 0) {
+        const uvSnippet = this.uvNode.build(builder, "vec2");
         const biasNode = this.biasNode;
-
         if (biasNode !== null) {
-          const biasSnippet = biasNode.build(builder, 'float');
+          const biasSnippet = biasNode.build(builder, "float");
           snippet = builder.getTextureBias(textureProperty, uvSnippet, biasSnippet);
         } else {
           snippet = builder.getTexture(textureProperty, uvSnippet);
         }
-
         nodeData.snippet = snippet;
       }
-
-      return builder.format(snippet, 'vec4', output);
+      return builder.format(snippet, "vec4", output);
     }
   }
-
   serialize(data) {
     super.serialize(data);
     data.value = this.value.toJSON(data.meta).uuid;
   }
-
   deserialize(data) {
     super.deserialize(data);
     this.value = data.meta.textures[data.value];
   }
-
 }
-
 TextureNode.prototype.isTextureNode = true;
-
-export default TextureNode;
+module.exports = TextureNode;

package/nodes/accessors/TextureNode.mjs

@@ -0,0 +1,54 @@
+import UniformNode from "../core/UniformNode.mjs";
+import UVNode from "./UVNode.mjs";
+class TextureNode extends UniformNode {
+  constructor(value, uvNode = new UVNode(), biasNode = null) {
+    super(value, "vec4");
+    this.uvNode = uvNode;
+    this.biasNode = biasNode;
+  }
+  getUniformHash() {
+    return this.value.uuid;
+  }
+  getInputType() {
+    return "texture";
+  }
+  generate(builder, output) {
+    const texture = this.value;
+    if (!texture || texture.isTexture !== true) {
+      throw new Error("TextureNode: Need a three.js texture.");
+    }
+    const textureProperty = super.generate(builder, "texture");
+    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 === void 0) {
+        const uvSnippet = this.uvNode.build(builder, "vec2");
+        const biasNode = this.biasNode;
+        if (biasNode !== null) {
+          const biasSnippet = biasNode.build(builder, "float");
+          snippet = builder.getTextureBias(textureProperty, uvSnippet, biasSnippet);
+        } else {
+          snippet = builder.getTexture(textureProperty, uvSnippet);
+        }
+        nodeData.snippet = snippet;
+      }
+      return builder.format(snippet, "vec4", output);
+    }
+  }
+  serialize(data) {
+    super.serialize(data);
+    data.value = this.value.toJSON(data.meta).uuid;
+  }
+  deserialize(data) {
+    super.deserialize(data);
+    this.value = data.meta.textures[data.value];
+  }
+}
+TextureNode.prototype.isTextureNode = true;
+export {
+  TextureNode as default
+};

package/nodes/accessors/UVNode.js

@@ -1,28 +1,22 @@
-import AttributeNode from '../core/AttributeNode.js';
-
+"use strict";
+const AttributeNode = require("../core/AttributeNode.js");
 class UVNode extends AttributeNode {
   constructor(index = 0) {
-    super(null, 'vec2');
+    super(null, "vec2");
     this.index = index;
   }
-
   getAttributeName() {
     const index = this.index;
-    return 'uv' + (index > 0 ? index + 1 : '');
+    return "uv" + (index > 0 ? index + 1 : "");
   }
-
   serialize(data) {
     super.serialize(data);
     data.index = this.index;
   }
-
   deserialize(data) {
     super.deserialize(data);
     this.index = data.index;
   }
-
 }
-
 UVNode.prototype.isUVNode = true;
-
-export default UVNode;
+module.exports = UVNode;

package/nodes/accessors/UVNode.mjs

@@ -0,0 +1,23 @@
+import AttributeNode from "../core/AttributeNode.mjs";
+class UVNode extends AttributeNode {
+  constructor(index = 0) {
+    super(null, "vec2");
+    this.index = index;
+  }
+  getAttributeName() {
+    const index = this.index;
+    return "uv" + (index > 0 ? index + 1 : "");
+  }
+  serialize(data) {
+    super.serialize(data);
+    data.index = this.index;
+  }
+  deserialize(data) {
+    super.deserialize(data);
+    this.index = data.index;
+  }
+}
+UVNode.prototype.isUVNode = true;
+export {
+  UVNode as default
+};

package/nodes/core/ArrayUniformNode.js

@@ -1,17 +1,13 @@
-import UniformNode from './UniformNode.js';
-
+"use strict";
+const UniformNode = require("./UniformNode.js");
 class ArrayUniformNode extends UniformNode {
   constructor(nodes = []) {
     super();
     this.nodes = nodes;
   }
-
   getNodeType(builder) {
     return this.nodes[0].getNodeType(builder);
   }
-
 }
-
 ArrayUniformNode.prototype.isArrayUniformNode = true;
-
-export default ArrayUniformNode;
+module.exports = ArrayUniformNode;

package/nodes/core/ArrayUniformNode.mjs

@@ -0,0 +1,14 @@
+import UniformNode from "./UniformNode.mjs";
+class ArrayUniformNode extends UniformNode {
+  constructor(nodes = []) {
+    super();
+    this.nodes = nodes;
+  }
+  getNodeType(builder) {
+    return this.nodes[0].getNodeType(builder);
+  }
+}
+ArrayUniformNode.prototype.isArrayUniformNode = true;
+export {
+  ArrayUniformNode as default
+};

package/nodes/core/AttributeNode.js

@@ -1,36 +1,29 @@
-import Node from './Node.js';
-import VaryNode from './VaryNode.js';
-
+"use strict";
+const Node = require("./Node.js");
+const VaryNode = require("./VaryNode.js");
 class AttributeNode extends Node {
   constructor(attributeName, nodeType) {
     super(nodeType);
     this._attributeName = attributeName;
   }
-
   getHash(builder) {
     return this.getAttributeName(builder);
   }
-
   setAttributeName(attributeName) {
     this._attributeName = attributeName;
     return this;
   }
-
   getAttributeName() {
     return this._attributeName;
   }
-
   generate(builder) {
     const attribute = builder.getAttribute(this.getAttributeName(builder), this.getNodeType(builder));
-
-    if (builder.isShaderStage('vertex')) {
+    if (builder.isShaderStage("vertex")) {
       return attribute.name;
     } else {
       const nodeVary = new VaryNode(this);
       return nodeVary.build(builder, attribute.type);
     }
   }
-
 }
-
-export default AttributeNode;
+module.exports = AttributeNode;

package/nodes/core/AttributeNode.mjs

@@ -0,0 +1,30 @@
+import Node from "./Node.mjs";
+import VaryNode from "./VaryNode.mjs";
+class AttributeNode extends Node {
+  constructor(attributeName, nodeType) {
+    super(nodeType);
+    this._attributeName = attributeName;
+  }
+  getHash(builder) {
+    return this.getAttributeName(builder);
+  }
+  setAttributeName(attributeName) {
+    this._attributeName = attributeName;
+    return this;
+  }
+  getAttributeName() {
+    return this._attributeName;
+  }
+  generate(builder) {
+    const attribute = builder.getAttribute(this.getAttributeName(builder), this.getNodeType(builder));
+    if (builder.isShaderStage("vertex")) {
+      return attribute.name;
+    } else {
+      const nodeVary = new VaryNode(this);
+      return nodeVary.build(builder, attribute.type);
+    }
+  }
+}
+export {
+  AttributeNode as default
+};

package/nodes/core/BypassNode.js

@@ -1,28 +1,21 @@
-import Node from './Node.js';
-
+"use strict";
+const Node = require("./Node.js");
 class BypassNode extends Node {
   constructor(returnNode, callNode) {
     super();
     this.outputNode = returnNode;
     this.callNode = callNode;
   }
-
   getNodeType(builder) {
     return this.outputNode.getNodeType(builder);
   }
-
   generate(builder, output) {
-    const snippet = this.callNode.build(builder, 'void');
-
-    if (snippet !== '') {
+    const snippet = this.callNode.build(builder, "void");
+    if (snippet !== "") {
       builder.addFlowCode(snippet);
     }
-
     return this.outputNode.build(builder, output);
   }
-
 }
-
 BypassNode.prototype.isBypassNode = true;
-
-export default BypassNode;
+module.exports = BypassNode;

package/nodes/core/BypassNode.mjs

@@ -0,0 +1,22 @@
+import Node from "./Node.mjs";
+class BypassNode extends Node {
+  constructor(returnNode, callNode) {
+    super();
+    this.outputNode = returnNode;
+    this.callNode = callNode;
+  }
+  getNodeType(builder) {
+    return this.outputNode.getNodeType(builder);
+  }
+  generate(builder, output) {
+    const snippet = this.callNode.build(builder, "void");
+    if (snippet !== "") {
+      builder.addFlowCode(snippet);
+    }
+    return this.outputNode.build(builder, output);
+  }
+}
+BypassNode.prototype.isBypassNode = true;
+export {
+  BypassNode as default
+};

package/nodes/core/CodeNode.js

@@ -1,35 +1,27 @@
-import Node from './Node.js';
-
+"use strict";
+const Node = require("./Node.js");
 class CodeNode extends Node {
-  constructor(code = '', nodeType = 'code') {
+  constructor(code = "", nodeType = "code") {
     super(nodeType);
     this.code = code;
     this._includes = [];
   }
-
   setIncludes(includes) {
     this._includes = includes;
     return this;
   }
-
   getIncludes() {
     return this._includes;
   }
-
   generate(builder) {
     const includes = this.getIncludes(builder);
-
     for (const include of includes) {
       include.build(builder);
     }
-
     const nodeCode = builder.getCodeFromNode(this, this.getNodeType(builder));
     nodeCode.code = this.code;
     return nodeCode.code;
   }
-
 }
-
 CodeNode.prototype.isCodeNode = true;
-
-export default CodeNode;
+module.exports = CodeNode;

package/nodes/core/CodeNode.mjs

@@ -0,0 +1,28 @@
+import Node from "./Node.mjs";
+class CodeNode extends Node {
+  constructor(code = "", nodeType = "code") {
+    super(nodeType);
+    this.code = code;
+    this._includes = [];
+  }
+  setIncludes(includes) {
+    this._includes = includes;
+    return this;
+  }
+  getIncludes() {
+    return this._includes;
+  }
+  generate(builder) {
+    const includes = this.getIncludes(builder);
+    for (const include of includes) {
+      include.build(builder);
+    }
+    const nodeCode = builder.getCodeFromNode(this, this.getNodeType(builder));
+    nodeCode.code = this.code;
+    return nodeCode.code;
+  }
+}
+CodeNode.prototype.isCodeNode = true;
+export {
+  CodeNode as default
+};

package/nodes/core/ConstNode.js

@@ -1,17 +1,13 @@
-import InputNode from './InputNode.js';
-
+"use strict";
+const InputNode = require("./InputNode.js");
 class ConstNode extends InputNode {
   generateConst(builder) {
     return builder.getConst(this.getNodeType(builder), this.value);
   }
-
   generate(builder, output) {
     const type = this.getNodeType(builder);
     return builder.format(this.generateConst(builder), type, output);
   }
-
 }
-
 ConstNode.prototype.isConstNode = true;
-
-export default ConstNode;
+module.exports = ConstNode;

package/nodes/core/ConstNode.mjs

@@ -0,0 +1,14 @@
+import InputNode from "./InputNode.mjs";
+class ConstNode extends InputNode {
+  generateConst(builder) {
+    return builder.getConst(this.getNodeType(builder), this.value);
+  }
+  generate(builder, output) {
+    const type = this.getNodeType(builder);
+    return builder.format(this.generateConst(builder), type, output);
+  }
+}
+ConstNode.prototype.isConstNode = true;
+export {
+  ConstNode as default
+};

package/nodes/core/ContextNode.js

@@ -1,16 +1,14 @@
-import Node from './Node.js';
-
+"use strict";
+const Node = require("./Node.js");
 class ContextNode extends Node {
   constructor(node, context = {}) {
     super();
     this.node = node;
     this.context = context;
   }
-
   getNodeType(builder) {
     return this.node.getNodeType(builder);
   }
-
   generate(builder, output) {
     const previousContext = builder.getContext();
     builder.setContext(Object.assign({}, builder.context, this.context));
@@ -18,9 +16,6 @@ class ContextNode extends Node {
     builder.setContext(previousContext);
     return snippet;
   }
-
 }
-
 ContextNode.prototype.isContextNode = true;
-
-export default ContextNode;
+module.exports = ContextNode;

package/nodes/core/ContextNode.mjs

@@ -0,0 +1,22 @@
+import Node from "./Node.mjs";
+class ContextNode extends Node {
+  constructor(node, context = {}) {
+    super();
+    this.node = node;
+    this.context = context;
+  }
+  getNodeType(builder) {
+    return this.node.getNodeType(builder);
+  }
+  generate(builder, output) {
+    const previousContext = builder.getContext();
+    builder.setContext(Object.assign({}, builder.context, this.context));
+    const snippet = this.node.build(builder, output);
+    builder.setContext(previousContext);
+    return snippet;
+  }
+}
+ContextNode.prototype.isContextNode = true;
+export {
+  ContextNode as default
+};

package/nodes/core/ExpressionNode.js

@@ -1,22 +1,18 @@
-import TempNode from './TempNode.js';
-
+"use strict";
+const TempNode = require("./TempNode.js");
 class ExpressionNode extends TempNode {
-  constructor(snipped = '', nodeType = 'void') {
+  constructor(snipped = "", nodeType = "void") {
     super(nodeType);
     this.snipped = snipped;
   }
-
   generate(builder) {
     const type = this.getNodeType(builder);
     const snipped = this.snipped;
-
-    if (type === 'void') {
+    if (type === "void") {
       builder.addFlowCode(snipped);
     } else {
       return `( ${snipped} )`;
     }
   }
-
 }
-
-export default ExpressionNode;
+module.exports = ExpressionNode;

package/nodes/core/ExpressionNode.mjs

@@ -0,0 +1,19 @@
+import TempNode from "./TempNode.mjs";
+class ExpressionNode extends TempNode {
+  constructor(snipped = "", nodeType = "void") {
+    super(nodeType);
+    this.snipped = snipped;
+  }
+  generate(builder) {
+    const type = this.getNodeType(builder);
+    const snipped = this.snipped;
+    if (type === "void") {
+      builder.addFlowCode(snipped);
+    } else {
+      return `( ${snipped} )`;
+    }
+  }
+}
+export {
+  ExpressionNode as default
+};

package/nodes/core/FunctionCallNode.js

@@ -1,45 +1,36 @@
-import TempNode from './TempNode.js';
-
+"use strict";
+const TempNode = require("./TempNode.js");
 class FunctionCallNode extends TempNode {
   constructor(functionNode = null, parameters = {}) {
     super();
     this.functionNode = functionNode;
     this.parameters = parameters;
   }
-
   setParameters(parameters) {
     this.parameters = parameters;
     return this;
   }
-
   getParameters() {
     return this.parameters;
   }
-
   getNodeType(builder) {
     return this.functionNode.getNodeType(builder);
   }
-
   generate(builder) {
     const params = [];
     const functionNode = this.functionNode;
     const inputs = functionNode.getInputs(builder);
     const parameters = this.parameters;
-
     for (const inputNode of inputs) {
       const node = parameters[inputNode.name];
-
-      if (node !== undefined) {
+      if (node !== void 0) {
         params.push(node.build(builder, inputNode.type));
       } else {
         throw new Error(`FunctionCallNode: Input '${inputNode.name}' not found in FunctionNode.`);
       }
     }
-
-    const functionName = functionNode.build(builder, 'property');
-    return `${functionName}( ${params.join(', ')} )`;
+    const functionName = functionNode.build(builder, "property");
+    return `${functionName}( ${params.join(", ")} )`;
   }
-
 }
-
-export default FunctionCallNode;
+module.exports = FunctionCallNode;

package/nodes/core/FunctionCallNode.mjs

@@ -0,0 +1,37 @@
+import TempNode from "./TempNode.mjs";
+class FunctionCallNode extends TempNode {
+  constructor(functionNode = null, parameters = {}) {
+    super();
+    this.functionNode = functionNode;
+    this.parameters = parameters;
+  }
+  setParameters(parameters) {
+    this.parameters = parameters;
+    return this;
+  }
+  getParameters() {
+    return this.parameters;
+  }
+  getNodeType(builder) {
+    return this.functionNode.getNodeType(builder);
+  }
+  generate(builder) {
+    const params = [];
+    const functionNode = this.functionNode;
+    const inputs = functionNode.getInputs(builder);
+    const parameters = this.parameters;
+    for (const inputNode of inputs) {
+      const node = parameters[inputNode.name];
+      if (node !== void 0) {
+        params.push(node.build(builder, inputNode.type));
+      } else {
+        throw new Error(`FunctionCallNode: Input '${inputNode.name}' not found in FunctionNode.`);
+      }
+    }
+    const functionName = functionNode.build(builder, "property");
+    return `${functionName}( ${params.join(", ")} )`;
+  }
+}
+export {
+  FunctionCallNode as default
+};