three-stdlib 2.22.7 → 2.22.9

package/dist/renderers/nodes/core/NodeBuilder.js

@@ -0,0 +1,248 @@
+"use strict";
+const NodeUniform = require("./NodeUniform.js");
+const NodeAttribute = require("./NodeAttribute.js");
+const NodeVary = require("./NodeVary.js");
+const constants = require("./constants.js");
+class NodeBuilder {
+  constructor(material, renderer) {
+    this.material = material;
+    this.renderer = renderer;
+    this.nodes = [];
+    this.updateNodes = [];
+    this.vertexShader = null;
+    this.fragmentShader = null;
+    this.slots = { vertex: [], fragment: [] };
+    this.defines = { vertex: {}, fragment: {} };
+    this.uniforms = { vertex: [], fragment: [] };
+    this.attributes = [];
+    this.varys = [];
+    this.nodesData = /* @__PURE__ */ new WeakMap();
+    this.shaderStage = null;
+  }
+  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);
+    }
+  }
+  addSlot(shaderStage, slot) {
+    this.slots[shaderStage].push(slot);
+  }
+  define(shaderStage, name, value = "") {
+    this.defines[shaderStage][name] = value;
+  }
+  getTexture() {
+    console.warn("Abstract function.");
+  }
+  getConst(type, value) {
+    if (type === "float")
+      return value + (value % 1 ? "" : ".0");
+    if (type === "vec2")
+      return `vec2( ${value.x}, ${value.y} )`;
+    if (type === "vec3")
+      return `vec3( ${value.x}, ${value.y}, ${value.z} )`;
+    if (type === "vec4")
+      return `vec4( ${value.x}, ${value.y}, ${value.z}, ${value.w} )`;
+    if (type === "color")
+      return `vec3( ${value.r}, ${value.g}, ${value.b} )`;
+    throw new Error(`Type '${type}' not found in generate constant attempt.`);
+  }
+  getAttribute(name, type) {
+    const attributes = this.attributes;
+    for (let 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);
+  }
+  isShaderStage(shaderStage) {
+    return this.shaderStage === shaderStage;
+  }
+  getVectorType(type) {
+    if (type === "color")
+      return "vec3";
+    else 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) {
+    type = this.getVectorType(type);
+    if (type === "float")
+      return 1;
+    if (type === "vec2")
+      return 2;
+    if (type === "vec3")
+      return 3;
+    if (type === "vec4")
+      return 4;
+    return 0;
+  }
+  getDataFromNode(node, shaderStage = null) {
+    let nodeData = this.nodesData.get(node);
+    if (nodeData === void 0) {
+      nodeData = { vertex: {}, fragment: {} };
+      this.nodesData.set(node, nodeData);
+    }
+    return shaderStage ? nodeData[shaderStage] : nodeData;
+  }
+  getUniformFromNode(node, shaderStage, type) {
+    const nodeData = this.getDataFromNode(node, shaderStage);
+    let nodeUniform = nodeData.uniform;
+    if (nodeUniform === void 0) {
+      const uniforms = this.uniforms[shaderStage];
+      const index = uniforms.length;
+      nodeUniform = new NodeUniform("nodeU" + index, type, node);
+      uniforms.push(nodeUniform);
+      nodeData.uniform = nodeUniform;
+    }
+    return nodeUniform;
+  }
+  getVaryFromNode(node, type) {
+    const nodeData = this.getDataFromNode(node);
+    let nodeVary = nodeData.vary;
+    if (nodeVary === void 0) {
+      const varys = this.varys;
+      const index = varys.length;
+      nodeVary = new NodeVary("nodeV" + index, type);
+      varys.push(nodeVary);
+      nodeData.vary = nodeVary;
+    }
+    return nodeVary;
+  }
+  /*
+  	analyzeNode( node ) {
+  
+  
+  	}
+  	*/
+  flowNode(node, output) {
+    const flowData = {};
+    flowData.result = node.build(this, output);
+    return flowData;
+  }
+  _buildDefines(shader) {
+    const defines = this.defines[shader];
+    let code = "";
+    for (let name in defines) {
+      code += `#define ${name} ${defines[name]}
+`;
+    }
+    return code;
+  }
+  getAttributesBodySnippet() {
+    console.warn("Abstract function.");
+  }
+  getAttributesHeaderSnippet() {
+    console.warn("Abstract function.");
+  }
+  getVarysHeaderSnippet() {
+    console.warn("Abstract function.");
+  }
+  getVarysBodySnippet() {
+    console.warn("Abstract function.");
+  }
+  getUniformsHeaderSnippet() {
+    console.warn("Abstract function.");
+  }
+  getHash() {
+    return this.vertexShader + this.fragmentShader;
+  }
+  build() {
+    const shaderStages = ["vertex", "fragment"];
+    const shaderData = {};
+    for (let shaderStage of shaderStages) {
+      this.shaderStage = shaderStage;
+      const slots = this.slots[shaderStage];
+      for (let slot of slots) {
+        const flowData = this.flowNode(slot.node, slot.output);
+        this.define(shaderStage, `NODE_${slot.name}`, flowData.result);
+      }
+    }
+    this.shaderStage = null;
+    for (let shaderStage of shaderStages) {
+      this.define(shaderStage, "NODE_HEADER_UNIFORMS", this.getUniformsHeaderSnippet(shaderStage));
+      this.define(shaderStage, "NODE_HEADER_ATTRIBUTES", this.getAttributesHeaderSnippet(shaderStage));
+      this.define(shaderStage, "NODE_HEADER_VARYS", this.getVarysHeaderSnippet(shaderStage));
+      this.define(shaderStage, "NODE_BODY_VARYS", this.getVarysBodySnippet(shaderStage));
+      shaderData[shaderStage] = this._buildDefines(shaderStage);
+    }
+    this.vertexShader = shaderData.vertex;
+    this.fragmentShader = shaderData.fragment;
+    return this;
+  }
+  format(snippet, fromType, toType) {
+    fromType = this.getVectorType(fromType);
+    toType = this.getVectorType(toType);
+    const typeToType = `${fromType} to ${toType}`;
+    switch (typeToType) {
+      case "float to vec2":
+        return `vec2( ${snippet} )`;
+      case "float to vec3":
+        return `vec3( ${snippet} )`;
+      case "float to vec4":
+        return `vec4( vec3( ${snippet} ), 1.0 )`;
+      case "vec2 to float":
+        return `${snippet}.x`;
+      case "vec2 to vec3":
+        return `vec3( ${snippet}, 0.0 )`;
+      case "vec2 to vec4":
+        return `vec4( ${snippet}.xy, 0.0, 1.0 )`;
+      case "vec3 to float":
+        return `${snippet}.x`;
+      case "vec3 to vec2":
+        return `${snippet}.xy`;
+      case "vec3 to vec4":
+        return `vec4( ${snippet}, 1.0 )`;
+      case "vec4 to float":
+        return `${snippet}.x`;
+      case "vec4 to vec2":
+        return `${snippet}.xy`;
+      case "vec4 to vec3":
+        return `${snippet}.xyz`;
+      case "mat3 to float":
+        return `( ${snippet} * vec3( 1.0 ) ).x`;
+      case "mat3 to vec2":
+        return `( ${snippet} * vec3( 1.0 ) ).xy`;
+      case "mat3 to vec3":
+        return `( ${snippet} * vec3( 1.0 ) ).xyz`;
+      case "mat3 to vec4":
+        return `vec4( ${snippet} * vec3( 1.0 ), 1.0 )`;
+      case "mat4 to float":
+        return `( ${snippet} * vec4( 1.0 ) ).x`;
+      case "mat4 to vec2":
+        return `( ${snippet} * vec4( 1.0 ) ).xy`;
+      case "mat4 to vec3":
+        return `( ${snippet} * vec4( 1.0 ) ).xyz`;
+      case "mat4 to vec4":
+        return `( ${snippet} * vec4( 1.0 ) )`;
+    }
+    return snippet;
+  }
+}
+module.exports = NodeBuilder;

package/dist/renderers/nodes/core/NodeBuilder.mjs

@@ -0,0 +1,249 @@
+import NodeUniform from "./NodeUniform.mjs";
+import NodeAttribute from "./NodeAttribute.mjs";
+import NodeVary from "./NodeVary.mjs";
+import { NodeUpdateType } from "./constants.mjs";
+class NodeBuilder {
+  constructor(material, renderer) {
+    this.material = material;
+    this.renderer = renderer;
+    this.nodes = [];
+    this.updateNodes = [];
+    this.vertexShader = null;
+    this.fragmentShader = null;
+    this.slots = { vertex: [], fragment: [] };
+    this.defines = { vertex: {}, fragment: {} };
+    this.uniforms = { vertex: [], fragment: [] };
+    this.attributes = [];
+    this.varys = [];
+    this.nodesData = /* @__PURE__ */ new WeakMap();
+    this.shaderStage = null;
+  }
+  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);
+    }
+  }
+  addSlot(shaderStage, slot) {
+    this.slots[shaderStage].push(slot);
+  }
+  define(shaderStage, name, value = "") {
+    this.defines[shaderStage][name] = value;
+  }
+  getTexture() {
+    console.warn("Abstract function.");
+  }
+  getConst(type, value) {
+    if (type === "float")
+      return value + (value % 1 ? "" : ".0");
+    if (type === "vec2")
+      return `vec2( ${value.x}, ${value.y} )`;
+    if (type === "vec3")
+      return `vec3( ${value.x}, ${value.y}, ${value.z} )`;
+    if (type === "vec4")
+      return `vec4( ${value.x}, ${value.y}, ${value.z}, ${value.w} )`;
+    if (type === "color")
+      return `vec3( ${value.r}, ${value.g}, ${value.b} )`;
+    throw new Error(`Type '${type}' not found in generate constant attempt.`);
+  }
+  getAttribute(name, type) {
+    const attributes = this.attributes;
+    for (let 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);
+  }
+  isShaderStage(shaderStage) {
+    return this.shaderStage === shaderStage;
+  }
+  getVectorType(type) {
+    if (type === "color")
+      return "vec3";
+    else 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) {
+    type = this.getVectorType(type);
+    if (type === "float")
+      return 1;
+    if (type === "vec2")
+      return 2;
+    if (type === "vec3")
+      return 3;
+    if (type === "vec4")
+      return 4;
+    return 0;
+  }
+  getDataFromNode(node, shaderStage = null) {
+    let nodeData = this.nodesData.get(node);
+    if (nodeData === void 0) {
+      nodeData = { vertex: {}, fragment: {} };
+      this.nodesData.set(node, nodeData);
+    }
+    return shaderStage ? nodeData[shaderStage] : nodeData;
+  }
+  getUniformFromNode(node, shaderStage, type) {
+    const nodeData = this.getDataFromNode(node, shaderStage);
+    let nodeUniform = nodeData.uniform;
+    if (nodeUniform === void 0) {
+      const uniforms = this.uniforms[shaderStage];
+      const index = uniforms.length;
+      nodeUniform = new NodeUniform("nodeU" + index, type, node);
+      uniforms.push(nodeUniform);
+      nodeData.uniform = nodeUniform;
+    }
+    return nodeUniform;
+  }
+  getVaryFromNode(node, type) {
+    const nodeData = this.getDataFromNode(node);
+    let nodeVary = nodeData.vary;
+    if (nodeVary === void 0) {
+      const varys = this.varys;
+      const index = varys.length;
+      nodeVary = new NodeVary("nodeV" + index, type);
+      varys.push(nodeVary);
+      nodeData.vary = nodeVary;
+    }
+    return nodeVary;
+  }
+  /*
+  	analyzeNode( node ) {
+  
+  
+  	}
+  	*/
+  flowNode(node, output) {
+    const flowData = {};
+    flowData.result = node.build(this, output);
+    return flowData;
+  }
+  _buildDefines(shader) {
+    const defines = this.defines[shader];
+    let code = "";
+    for (let name in defines) {
+      code += `#define ${name} ${defines[name]}
+`;
+    }
+    return code;
+  }
+  getAttributesBodySnippet() {
+    console.warn("Abstract function.");
+  }
+  getAttributesHeaderSnippet() {
+    console.warn("Abstract function.");
+  }
+  getVarysHeaderSnippet() {
+    console.warn("Abstract function.");
+  }
+  getVarysBodySnippet() {
+    console.warn("Abstract function.");
+  }
+  getUniformsHeaderSnippet() {
+    console.warn("Abstract function.");
+  }
+  getHash() {
+    return this.vertexShader + this.fragmentShader;
+  }
+  build() {
+    const shaderStages = ["vertex", "fragment"];
+    const shaderData = {};
+    for (let shaderStage of shaderStages) {
+      this.shaderStage = shaderStage;
+      const slots = this.slots[shaderStage];
+      for (let slot of slots) {
+        const flowData = this.flowNode(slot.node, slot.output);
+        this.define(shaderStage, `NODE_${slot.name}`, flowData.result);
+      }
+    }
+    this.shaderStage = null;
+    for (let shaderStage of shaderStages) {
+      this.define(shaderStage, "NODE_HEADER_UNIFORMS", this.getUniformsHeaderSnippet(shaderStage));
+      this.define(shaderStage, "NODE_HEADER_ATTRIBUTES", this.getAttributesHeaderSnippet(shaderStage));
+      this.define(shaderStage, "NODE_HEADER_VARYS", this.getVarysHeaderSnippet(shaderStage));
+      this.define(shaderStage, "NODE_BODY_VARYS", this.getVarysBodySnippet(shaderStage));
+      shaderData[shaderStage] = this._buildDefines(shaderStage);
+    }
+    this.vertexShader = shaderData.vertex;
+    this.fragmentShader = shaderData.fragment;
+    return this;
+  }
+  format(snippet, fromType, toType) {
+    fromType = this.getVectorType(fromType);
+    toType = this.getVectorType(toType);
+    const typeToType = `${fromType} to ${toType}`;
+    switch (typeToType) {
+      case "float to vec2":
+        return `vec2( ${snippet} )`;
+      case "float to vec3":
+        return `vec3( ${snippet} )`;
+      case "float to vec4":
+        return `vec4( vec3( ${snippet} ), 1.0 )`;
+      case "vec2 to float":
+        return `${snippet}.x`;
+      case "vec2 to vec3":
+        return `vec3( ${snippet}, 0.0 )`;
+      case "vec2 to vec4":
+        return `vec4( ${snippet}.xy, 0.0, 1.0 )`;
+      case "vec3 to float":
+        return `${snippet}.x`;
+      case "vec3 to vec2":
+        return `${snippet}.xy`;
+      case "vec3 to vec4":
+        return `vec4( ${snippet}, 1.0 )`;
+      case "vec4 to float":
+        return `${snippet}.x`;
+      case "vec4 to vec2":
+        return `${snippet}.xy`;
+      case "vec4 to vec3":
+        return `${snippet}.xyz`;
+      case "mat3 to float":
+        return `( ${snippet} * vec3( 1.0 ) ).x`;
+      case "mat3 to vec2":
+        return `( ${snippet} * vec3( 1.0 ) ).xy`;
+      case "mat3 to vec3":
+        return `( ${snippet} * vec3( 1.0 ) ).xyz`;
+      case "mat3 to vec4":
+        return `vec4( ${snippet} * vec3( 1.0 ), 1.0 )`;
+      case "mat4 to float":
+        return `( ${snippet} * vec4( 1.0 ) ).x`;
+      case "mat4 to vec2":
+        return `( ${snippet} * vec4( 1.0 ) ).xy`;
+      case "mat4 to vec3":
+        return `( ${snippet} * vec4( 1.0 ) ).xyz`;
+      case "mat4 to vec4":
+        return `( ${snippet} * vec4( 1.0 ) )`;
+    }
+    return snippet;
+  }
+}
+export {
+  NodeBuilder as default
+};

package/dist/renderers/nodes/core/NodeFrame.js

@@ -0,0 +1,34 @@
+"use strict";
+const constants = require("./constants.js");
+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 === constants.NodeUpdateType.Frame) {
+      if (this.updateMap.get(node) !== this.frameId) {
+        this.updateMap.set(node, this.frameId);
+        node.update(this);
+      }
+    } else if (node.updateType === constants.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;
+  }
+}
+module.exports = NodeFrame;

package/dist/renderers/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/dist/renderers/nodes/core/NodeSlot.js

@@ -0,0 +1,9 @@
+"use strict";
+class NodeSlot {
+  constructor(node, name, output) {
+    this.node = node;
+    this.name = name;
+    this.output = output;
+  }
+}
+module.exports = NodeSlot;

package/dist/renderers/nodes/core/NodeSlot.mjs

@@ -0,0 +1,10 @@
+class NodeSlot {
+  constructor(node, name, output) {
+    this.node = node;
+    this.name = name;
+    this.output = output;
+  }
+}
+export {
+  NodeSlot as default
+};

package/dist/renderers/nodes/core/NodeUniform.js

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

package/dist/renderers/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;
+    Object.defineProperty(this, "isNodeUniform", { value: true });
+  }
+  get value() {
+    return this.node.value;
+  }
+  set value(val) {
+    this.node.value = val;
+  }
+}
+export {
+  NodeUniform as default
+};

package/dist/renderers/nodes/core/NodeVary.js

@@ -0,0 +1,10 @@
+"use strict";
+class NodeVary {
+  constructor(name, type, snippet = "") {
+    this.name = name;
+    this.type = type;
+    this.snippet = snippet;
+    Object.defineProperty(this, "isNodeVary", { value: true });
+  }
+}
+module.exports = NodeVary;

package/dist/renderers/nodes/core/NodeVary.mjs

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

package/dist/renderers/nodes/core/VaryNode.js

@@ -0,0 +1,21 @@
+"use strict";
+const Node = require("./Node.js");
+const constants = require("./constants.js");
+class VaryNode extends Node {
+  constructor(value) {
+    super();
+    this.value = value;
+  }
+  getType(builder) {
+    return this.value.getType(builder);
+  }
+  generate(builder, output) {
+    const type = this.getType(builder);
+    const snippet = this.value.buildStage(builder, constants.NodeShaderStage.Vertex, type);
+    const nodeVary = builder.getVaryFromNode(this, type);
+    nodeVary.snippet = snippet;
+    const propertyName = builder.getPropertyName(nodeVary);
+    return builder.format(propertyName, type, output);
+  }
+}
+module.exports = VaryNode;

package/dist/renderers/nodes/core/VaryNode.mjs

@@ -0,0 +1,22 @@
+import Node from "./Node.mjs";
+import { NodeShaderStage } from "./constants.mjs";
+class VaryNode extends Node {
+  constructor(value) {
+    super();
+    this.value = value;
+  }
+  getType(builder) {
+    return this.value.getType(builder);
+  }
+  generate(builder, output) {
+    const type = this.getType(builder);
+    const snippet = this.value.buildStage(builder, NodeShaderStage.Vertex, type);
+    const nodeVary = builder.getVaryFromNode(this, type);
+    nodeVary.snippet = snippet;
+    const propertyName = builder.getPropertyName(nodeVary);
+    return builder.format(propertyName, type, output);
+  }
+}
+export {
+  VaryNode as default
+};