three-stdlib 2.15.1 → 2.16.0

package/nodes/core/NodeBuilder.mjs

@@ -0,0 +1,395 @@
+import NodeUniform from "./NodeUniform.mjs";
+import NodeAttribute from "./NodeAttribute.mjs";
+import NodeVary from "./NodeVary.mjs";
+import NodeVar from "./NodeVar.mjs";
+import NodeCode from "./NodeCode.mjs";
+import NodeKeywords from "./NodeKeywords.mjs";
+import { NodeUpdateType } from "./constants.mjs";
+import { LinearEncoding, REVISION } from "three";
+const shaderStages = ["fragment", "vertex"];
+const vector = ["x", "y", "z", "w"];
+const toFloat = (value) => {
+  value = Number(value);
+  return value + (value % 1 ? "" : ".0");
+};
+class NodeBuilder {
+  constructor(object, renderer, parser) {
+    this.object = object;
+    this.material = object.material;
+    this.renderer = renderer;
+    this.parser = parser;
+    this.nodes = [];
+    this.updateNodes = [];
+    this.hashNodes = {};
+    this.vertexShader = null;
+    this.fragmentShader = null;
+    this.flowNodes = { vertex: [], fragment: [] };
+    this.flowCode = { vertex: "", fragment: "" };
+    this.uniforms = { vertex: [], fragment: [], index: 0 };
+    this.codes = { vertex: [], fragment: [] };
+    this.attributes = [];
+    this.varys = [];
+    this.vars = { vertex: [], fragment: [] };
+    this.flow = { code: "" };
+    this.stack = [];
+    this.context = {
+      keywords: new NodeKeywords(),
+      material: object.material
+    };
+    this.nodesData = /* @__PURE__ */ new WeakMap();
+    this.flowsData = /* @__PURE__ */ new WeakMap();
+    this.shaderStage = null;
+    this.node = null;
+  }
+  addStack(node) {
+    this.stack.push(node);
+  }
+  removeStack(node) {
+    const lastStack = this.stack.pop();
+    if (lastStack !== node) {
+      throw new Error("NodeBuilder: Invalid node stack!");
+    }
+  }
+  setHashNode(node, hash) {
+    this.hashNodes[hash] = node;
+  }
+  addNode(node) {
+    if (this.nodes.indexOf(node) === -1) {
+      const updateType = node.getUpdateType(this);
+      if (updateType !== NodeUpdateType.None) {
+        this.updateNodes.push(node);
+      }
+      this.nodes.push(node);
+      this.setHashNode(node, node.getHash(this));
+    }
+  }
+  getMethod(method) {
+    return method;
+  }
+  getNodeFromHash(hash) {
+    return this.hashNodes[hash];
+  }
+  addFlow(shaderStage, node) {
+    this.flowNodes[shaderStage].push(node);
+    return node;
+  }
+  setContext(context) {
+    this.context = context;
+  }
+  getContext() {
+    return this.context;
+  }
+  getTexture() {
+    console.warn("Abstract function.");
+  }
+  getTextureBias() {
+    console.warn("Abstract function.");
+  }
+  getCubeTexture() {
+    console.warn("Abstract function.");
+  }
+  getCubeTextureBias() {
+    console.warn("Abstract function.");
+  }
+  getConst(type, value) {
+    if (type === "float")
+      return toFloat(value);
+    if (type === "int")
+      return `${Math.round(value)}`;
+    if (type === "uint")
+      return value >= 0 ? `${Math.round(value)}u` : "0u";
+    if (type === "bool")
+      return value ? "true" : "false";
+    if (type === "color") {
+      return `${this.getType("vec3")}( ${toFloat(value.r)}, ${toFloat(value.g)}, ${toFloat(value.b)} )`;
+    }
+    const typeLength = this.getTypeLength(type);
+    const componentType = this.getComponentType(type);
+    const getConst = (value2) => this.getConst(componentType, value2);
+    if (typeLength === 2) {
+      return `${this.getType(type)}( ${getConst(value.x)}, ${getConst(value.y)} )`;
+    } else if (typeLength === 3) {
+      return `${this.getType(type)}( ${getConst(value.x)}, ${getConst(value.y)}, ${getConst(value.z)} )`;
+    } else if (typeLength === 4) {
+      return `${this.getType(type)}( ${getConst(value.x)}, ${getConst(value.y)}, ${getConst(value.z)}, ${getConst(
+        value.w
+      )} )`;
+    }
+    throw new Error(`NodeBuilder: Type '${type}' not found in generate constant attempt.`);
+  }
+  getType(type) {
+    return type;
+  }
+  generateMethod(method) {
+    return method;
+  }
+  getAttribute(name, type) {
+    const attributes = this.attributes;
+    for (const attribute2 of attributes) {
+      if (attribute2.name === name) {
+        return attribute2;
+      }
+    }
+    const attribute = new NodeAttribute(name, type);
+    attributes.push(attribute);
+    return attribute;
+  }
+  getPropertyName(node) {
+    return node.name;
+  }
+  isVector(type) {
+    return /vec\d/.test(type);
+  }
+  isMatrix(type) {
+    return /mat\d/.test(type);
+  }
+  isReference(type) {
+    return type === "void" || type === "property" || type === "sampler";
+  }
+  isShaderStage(shaderStage) {
+    return this.shaderStage === shaderStage;
+  }
+  getTextureEncodingFromMap(map) {
+    let encoding;
+    if (map && map.isTexture) {
+      encoding = map.encoding;
+    } else if (map && map.isWebGLRenderTarget) {
+      encoding = map.texture.encoding;
+    } else {
+      encoding = LinearEncoding;
+    }
+    return encoding;
+  }
+  getComponentType(type) {
+    type = this.getVectorType(type);
+    const componentType = /(b|i|u|)(vec|mat)([2-4])/.exec(type);
+    if (componentType === null)
+      return null;
+    if (componentType[1] === "b")
+      return "bool";
+    if (componentType[1] === "i")
+      return "int";
+    if (componentType[1] === "u")
+      return "uint";
+    return "float";
+  }
+  getVectorType(type) {
+    if (type === "color")
+      return "vec3";
+    if (type === "texture")
+      return "vec4";
+    return type;
+  }
+  getTypeFromLength(type) {
+    if (type === 1)
+      return "float";
+    if (type === 2)
+      return "vec2";
+    if (type === 3)
+      return "vec3";
+    if (type === 4)
+      return "vec4";
+    return 0;
+  }
+  getTypeLength(type) {
+    const vecType = this.getVectorType(type);
+    const vecNum = /vec([2-4])/.exec(vecType);
+    if (vecNum !== null)
+      return Number(vecNum[1]);
+    if (vecType === "float" || vecType === "bool" || vecType === "int" || vecType === "uint")
+      return 1;
+    return 0;
+  }
+  getVectorFromMatrix(type) {
+    return type.replace("mat", "vec");
+  }
+  getDataFromNode(node, shaderStage = this.shaderStage) {
+    let nodeData = this.nodesData.get(node);
+    if (nodeData === void 0) {
+      nodeData = { vertex: {}, fragment: {} };
+      this.nodesData.set(node, nodeData);
+    }
+    return shaderStage !== null ? nodeData[shaderStage] : nodeData;
+  }
+  getUniformFromNode(node, shaderStage, type) {
+    const nodeData = this.getDataFromNode(node, shaderStage);
+    let nodeUniform = nodeData.uniform;
+    if (nodeUniform === void 0) {
+      const index = this.uniforms.index++;
+      nodeUniform = new NodeUniform("nodeUniform" + index, type, node);
+      this.uniforms[shaderStage].push(nodeUniform);
+      nodeData.uniform = nodeUniform;
+    }
+    return nodeUniform;
+  }
+  getVarFromNode(node, type, shaderStage = this.shaderStage) {
+    const nodeData = this.getDataFromNode(node, shaderStage);
+    let nodeVar = nodeData.variable;
+    if (nodeVar === void 0) {
+      const vars = this.vars[shaderStage];
+      const index = vars.length;
+      nodeVar = new NodeVar("nodeVar" + index, type);
+      vars.push(nodeVar);
+      nodeData.variable = nodeVar;
+    }
+    return nodeVar;
+  }
+  getVaryFromNode(node, type) {
+    const nodeData = this.getDataFromNode(node, null);
+    let nodeVary = nodeData.vary;
+    if (nodeVary === void 0) {
+      const varys = this.varys;
+      const index = varys.length;
+      nodeVary = new NodeVary("nodeVary" + index, type);
+      varys.push(nodeVary);
+      nodeData.vary = nodeVary;
+    }
+    return nodeVary;
+  }
+  getCodeFromNode(node, type, shaderStage = this.shaderStage) {
+    const nodeData = this.getDataFromNode(node);
+    let nodeCode = nodeData.code;
+    if (nodeCode === void 0) {
+      const codes = this.codes[shaderStage];
+      const index = codes.length;
+      nodeCode = new NodeCode("nodeCode" + index, type);
+      codes.push(nodeCode);
+      nodeData.code = nodeCode;
+    }
+    return nodeCode;
+  }
+  addFlowCode(code) {
+    this.flow.code += code;
+  }
+  getFlowData(shaderStage, node) {
+    return this.flowsData.get(node);
+  }
+  flowNode(node) {
+    this.node = node;
+    const output = node.getNodeType(this);
+    const flowData = this.flowChildNode(node, output);
+    this.flowsData.set(node, flowData);
+    this.node = null;
+    return flowData;
+  }
+  flowChildNode(node, output = null) {
+    const previousFlow = this.flow;
+    const flow = {
+      code: ""
+    };
+    this.flow = flow;
+    flow.result = node.build(this, output);
+    this.flow = previousFlow;
+    return flow;
+  }
+  flowNodeFromShaderStage(shaderStage, node, output = null, propertyName = null) {
+    const previousShaderStage = this.shaderStage;
+    this.setShaderStage(shaderStage);
+    const flowData = this.flowChildNode(node, output);
+    if (propertyName !== null) {
+      flowData.code += `${propertyName} = ${flowData.result};
+	`;
+    }
+    this.flowCode[shaderStage] = this.flowCode[shaderStage] + flowData.code;
+    this.setShaderStage(previousShaderStage);
+    return flowData;
+  }
+  getAttributes() {
+    console.warn("Abstract function.");
+  }
+  getVarys() {
+    console.warn("Abstract function.");
+  }
+  getVars(shaderStage) {
+    let snippet = "";
+    const vars = this.vars[shaderStage];
+    for (let index = 0; index < vars.length; index++) {
+      const variable = vars[index];
+      snippet += `${variable.type} ${variable.name}; `;
+    }
+    return snippet;
+  }
+  getUniforms() {
+    console.warn("Abstract function.");
+  }
+  getCodes(shaderStage) {
+    const codes = this.codes[shaderStage];
+    let code = "";
+    for (const nodeCode of codes) {
+      code += nodeCode.code + "\n";
+    }
+    return code;
+  }
+  getHash() {
+    return this.vertexShader + this.fragmentShader;
+  }
+  getShaderStage() {
+    return this.shaderStage;
+  }
+  setShaderStage(shaderStage) {
+    this.shaderStage = shaderStage;
+  }
+  buildCode() {
+    console.warn("Abstract function.");
+  }
+  build() {
+    for (const shaderStage of shaderStages) {
+      this.setShaderStage(shaderStage);
+      const flowNodes = this.flowNodes[shaderStage];
+      for (const node of flowNodes) {
+        node.analyze(this);
+      }
+    }
+    if (this.context.vertex && this.context.vertex.isNode) {
+      this.flowNodeFromShaderStage("vertex", this.context.vertex);
+    }
+    for (const shaderStage of shaderStages) {
+      this.setShaderStage(shaderStage);
+      const flowNodes = this.flowNodes[shaderStage];
+      for (const node of flowNodes) {
+        this.flowNode(node, shaderStage);
+      }
+    }
+    this.setShaderStage(null);
+    this.buildCode();
+    return this;
+  }
+  format(snippet, fromType, toType) {
+    fromType = this.getVectorType(fromType);
+    toType = this.getVectorType(toType);
+    if (fromType === toType || toType === null || this.isReference(toType)) {
+      return snippet;
+    }
+    const fromTypeLength = this.getTypeLength(fromType);
+    const toTypeLength = this.getTypeLength(toType);
+    if (fromTypeLength === 0) {
+      const vectorType = this.getVectorFromMatrix(fromType);
+      return this.format(`( ${snippet} * ${this.getType(vectorType)}( 1.0 ) )`, vectorType, toType);
+    }
+    if (toTypeLength === 0) {
+      return snippet;
+    }
+    if (fromTypeLength === toTypeLength) {
+      return `${this.getType(toType)}( ${snippet} )`;
+    }
+    if (fromTypeLength > toTypeLength) {
+      return this.format(`${snippet}.${"xyz".slice(0, toTypeLength)}`, this.getTypeFromLength(toTypeLength), toType);
+    }
+    if (toTypeLength === 4) {
+      return `${this.getType(toType)}( ${this.format(snippet, fromType, "vec3")}, 1.0 )`;
+    }
+    if (fromTypeLength === 2) {
+      return `${this.getType(toType)}( ${this.format(snippet, fromType, "vec2")}, 0.0 )`;
+    }
+    return `${this.getType(toType)}( ${snippet} )`;
+  }
+  getSignature() {
+    return `// Three.js r${REVISION} - NodeMaterial System
+`;
+  }
+}
+export {
+  NodeBuilder as default,
+  shaderStages,
+  vector
+};

package/nodes/core/NodeCode.js

@@ -1,13 +1,10 @@
+"use strict";
 class NodeCode {
-  constructor(name, type, code = '') {
+  constructor(name, type, code = "") {
     this.name = name;
     this.type = type;
     this.code = code;
-    Object.defineProperty(this, 'isNodeCode', {
-      value: true
-    });
+    Object.defineProperty(this, "isNodeCode", { value: true });
   }
-
 }
-
-export default NodeCode;
+module.exports = NodeCode;

package/nodes/core/NodeCode.mjs

@@ -0,0 +1,11 @@
+class NodeCode {
+  constructor(name, type, code = "") {
+    this.name = name;
+    this.type = type;
+    this.code = code;
+    Object.defineProperty(this, "isNodeCode", { value: true });
+  }
+}
+export {
+  NodeCode as default
+};

package/nodes/core/NodeFrame.js

@@ -1,37 +1,34 @@
-import { NodeUpdateType } from './constants.js';
-
+"use strict";
+const constants = require("./constants.js");
 class NodeFrame {
   constructor() {
     this.time = 0;
     this.deltaTime = 0;
     this.frameId = 0;
     this.startTime = null;
-    this.updateMap = new WeakMap();
+    this.updateMap = /* @__PURE__ */ new WeakMap();
     this.renderer = null;
     this.material = null;
     this.camera = null;
     this.object = null;
   }
-
   updateNode(node) {
-    if (node.updateType === NodeUpdateType.Frame) {
+    if (node.updateType === constants.NodeUpdateType.Frame) {
       if (this.updateMap.get(node) !== this.frameId) {
         this.updateMap.set(node, this.frameId);
         node.update(this);
       }
-    } else if (node.updateType === NodeUpdateType.Object) {
+    } else if (node.updateType === constants.NodeUpdateType.Object) {
       node.update(this);
     }
   }
-
   update() {
     this.frameId++;
-    if (this.lastTime === undefined) this.lastTime = performance.now();
-    this.deltaTime = (performance.now() - this.lastTime) / 1000;
+    if (this.lastTime === void 0)
+      this.lastTime = performance.now();
+    this.deltaTime = (performance.now() - this.lastTime) / 1e3;
     this.lastTime = performance.now();
     this.time += this.deltaTime;
   }
-
 }
-
-export default NodeFrame;
+module.exports = NodeFrame;

package/nodes/core/NodeFrame.mjs

@@ -0,0 +1,35 @@
+import { NodeUpdateType } from "./constants.mjs";
+class NodeFrame {
+  constructor() {
+    this.time = 0;
+    this.deltaTime = 0;
+    this.frameId = 0;
+    this.startTime = null;
+    this.updateMap = /* @__PURE__ */ new WeakMap();
+    this.renderer = null;
+    this.material = null;
+    this.camera = null;
+    this.object = null;
+  }
+  updateNode(node) {
+    if (node.updateType === NodeUpdateType.Frame) {
+      if (this.updateMap.get(node) !== this.frameId) {
+        this.updateMap.set(node, this.frameId);
+        node.update(this);
+      }
+    } else if (node.updateType === NodeUpdateType.Object) {
+      node.update(this);
+    }
+  }
+  update() {
+    this.frameId++;
+    if (this.lastTime === void 0)
+      this.lastTime = performance.now();
+    this.deltaTime = (performance.now() - this.lastTime) / 1e3;
+    this.lastTime = performance.now();
+    this.time += this.deltaTime;
+  }
+}
+export {
+  NodeFrame as default
+};

package/nodes/core/NodeFunctionInput.js

@@ -1,14 +1,12 @@
+"use strict";
 class NodeFunctionInput {
-  constructor(type, name, count = null, qualifier = '', isConst = false) {
+  constructor(type, name, count = null, qualifier = "", isConst = false) {
     this.type = type;
     this.name = name;
     this.count = count;
     this.qualifier = qualifier;
     this.isConst = isConst;
   }
-
 }
-
 NodeFunctionInput.isNodeFunctionInput = true;
-
-export default NodeFunctionInput;
+module.exports = NodeFunctionInput;

package/nodes/core/NodeFunctionInput.mjs

@@ -0,0 +1,13 @@
+class NodeFunctionInput {
+  constructor(type, name, count = null, qualifier = "", isConst = false) {
+    this.type = type;
+    this.name = name;
+    this.count = count;
+    this.qualifier = qualifier;
+    this.isConst = isConst;
+  }
+}
+NodeFunctionInput.isNodeFunctionInput = true;
+export {
+  NodeFunctionInput as default
+};

package/nodes/core/NodeKeywords.js

@@ -1,54 +1,43 @@
+"use strict";
 class NodeKeywords {
   constructor() {
     this.keywords = [];
     this.nodes = [];
     this.keywordsCallback = {};
   }
-
   getNode(name) {
     let node = this.nodes[name];
-
-    if (node === undefined && this.keywordsCallback[name] !== undefined) {
+    if (node === void 0 && this.keywordsCallback[name] !== void 0) {
       node = this.keywordsCallback[name](name);
       this.nodes[name] = node;
     }
-
     return node;
   }
-
   addKeyword(name, callback) {
     this.keywords.push(name);
     this.keywordsCallback[name] = callback;
     return this;
   }
-
   parse(code) {
     const keywordNames = this.keywords;
-    const regExp = new RegExp(`\\b${keywordNames.join('\\b|\\b')}\\b`, 'g');
+    const regExp = new RegExp(`\\b${keywordNames.join("\\b|\\b")}\\b`, "g");
     const codeKeywords = code.match(regExp);
     const keywordNodes = [];
-
     if (codeKeywords !== null) {
       for (const keyword of codeKeywords) {
         const node = this.getNode(keyword);
-
-        if (node !== undefined && keywordNodes.indexOf(node) === -1) {
+        if (node !== void 0 && keywordNodes.indexOf(node) === -1) {
           keywordNodes.push(node);
         }
       }
     }
-
     return keywordNodes;
   }
-
   include(builder, code) {
     const keywordNodes = this.parse(code);
-
     for (const keywordNode of keywordNodes) {
       keywordNode.build(builder);
     }
   }
-
 }
-
-export default NodeKeywords;
+module.exports = NodeKeywords;

package/nodes/core/NodeKeywords.mjs

@@ -0,0 +1,44 @@
+class NodeKeywords {
+  constructor() {
+    this.keywords = [];
+    this.nodes = [];
+    this.keywordsCallback = {};
+  }
+  getNode(name) {
+    let node = this.nodes[name];
+    if (node === void 0 && this.keywordsCallback[name] !== void 0) {
+      node = this.keywordsCallback[name](name);
+      this.nodes[name] = node;
+    }
+    return node;
+  }
+  addKeyword(name, callback) {
+    this.keywords.push(name);
+    this.keywordsCallback[name] = callback;
+    return this;
+  }
+  parse(code) {
+    const keywordNames = this.keywords;
+    const regExp = new RegExp(`\\b${keywordNames.join("\\b|\\b")}\\b`, "g");
+    const codeKeywords = code.match(regExp);
+    const keywordNodes = [];
+    if (codeKeywords !== null) {
+      for (const keyword of codeKeywords) {
+        const node = this.getNode(keyword);
+        if (node !== void 0 && keywordNodes.indexOf(node) === -1) {
+          keywordNodes.push(node);
+        }
+      }
+    }
+    return keywordNodes;
+  }
+  include(builder, code) {
+    const keywordNodes = this.parse(code);
+    for (const keywordNode of keywordNodes) {
+      keywordNode.build(builder);
+    }
+  }
+}
+export {
+  NodeKeywords as default
+};

package/nodes/core/NodeUniform.js

@@ -1,21 +1,17 @@
+"use strict";
 class NodeUniform {
-  constructor(name, type, node, needsUpdate = undefined) {
+  constructor(name, type, node, needsUpdate = void 0) {
     this.name = name;
     this.type = type;
     this.node = node;
     this.needsUpdate = needsUpdate;
   }
-
   get value() {
     return this.node.value;
   }
-
   set value(val) {
     this.node.value = val;
   }
-
 }
-
 NodeUniform.prototype.isNodeUniform = true;
-
-export default NodeUniform;
+module.exports = NodeUniform;

package/nodes/core/NodeUniform.mjs

@@ -0,0 +1,18 @@
+class NodeUniform {
+  constructor(name, type, node, needsUpdate = void 0) {
+    this.name = name;
+    this.type = type;
+    this.node = node;
+    this.needsUpdate = needsUpdate;
+  }
+  get value() {
+    return this.node.value;
+  }
+  set value(val) {
+    this.node.value = val;
+  }
+}
+NodeUniform.prototype.isNodeUniform = true;
+export {
+  NodeUniform as default
+};