three-stdlib 2.22.7 → 2.22.8

package/dist/nodes/core/NodeBuilder.js

@@ -0,0 +1,402 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const NodeUniform = require("./NodeUniform.js");
+const NodeAttribute = require("./NodeAttribute.js");
+const NodeVary = require("./NodeVary.js");
+const NodeVar = require("./NodeVar.js");
+const NodeCode = require("./NodeCode.js");
+const NodeKeywords = require("./NodeKeywords.js");
+const constants = require("./constants.js");
+const THREE = require("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 !== constants.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.");
+  }
+  // @TODO: rename to .generateConst()
+  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) {
+      if ("colorSpace" in map)
+        encoding = map.colorSpace === "srgb" ? 3001 : 3e3;
+      else
+        encoding = map.encoding;
+    } else if (map && map.isWebGLRenderTarget) {
+      if ("colorSpace" in map.texture)
+        encoding = map.texture.colorSpace === "srgb" ? 3001 : 3e3;
+      else
+        encoding = map.texture.encoding;
+    } else {
+      encoding = 3e3;
+    }
+    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${THREE.REVISION} - NodeMaterial System
+`;
+  }
+}
+exports.default = NodeBuilder;
+exports.shaderStages = shaderStages;
+exports.vector = vector;