three-stdlib 2.16.0 → 2.16.2

package/renderers/nodes/core/NodeBuilder.js

@@ -1,8 +1,8 @@
-"use strict";
-const NodeUniform = require("./NodeUniform.js");
-const NodeAttribute = require("./NodeAttribute.js");
-const NodeVary = require("./NodeVary.js");
-const constants = require("./constants.js");
+import NodeUniform from './NodeUniform.js';
+import NodeAttribute from './NodeAttribute.js';
+import NodeVary from './NodeVary.js';
+import { NodeUpdateType } from './constants.js';
+
 class NodeBuilder {
   constructor(material, renderer) {
     this.material = material;
@@ -11,232 +11,299 @@ class NodeBuilder {
     this.updateNodes = [];
     this.vertexShader = null;
     this.fragmentShader = null;
-    this.slots = { vertex: [], fragment: [] };
-    this.defines = { vertex: {}, fragment: {} };
-    this.uniforms = { vertex: [], fragment: [] };
+    this.slots = {
+      vertex: [],
+      fragment: []
+    };
+    this.defines = {
+      vertex: {},
+      fragment: {}
+    };
+    this.uniforms = {
+      vertex: [],
+      fragment: []
+    };
     this.attributes = [];
     this.varys = [];
-    this.nodesData = /* @__PURE__ */ new WeakMap();
+    this.nodesData = new WeakMap();
     this.shaderStage = null;
   }
+
   addNode(node) {
     if (this.nodes.indexOf(node) === -1) {
       const updateType = node.getUpdateType(this);
-      if (updateType !== constants.NodeUpdateType.None) {
+
+      if (updateType !== NodeUpdateType.None) {
         this.updateNodes.push(node);
       }
+
       this.nodes.push(node);
     }
   }
+
   addSlot(shaderStage, slot) {
     this.slots[shaderStage].push(slot);
   }
-  define(shaderStage, name, value = "") {
+
+  define(shaderStage, name, value = '') {
     this.defines[shaderStage][name] = value;
   }
+
   getTexture() {
-    console.warn("Abstract function.");
+    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} )`;
+    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 attributes = this.attributes; // find attribute
+
+    for (let attribute of attributes) {
+      if (attribute.name === name) {
+        return attribute;
       }
-    }
+    } // create a new if no exist
+
+
     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";
+    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";
+    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;
+    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: {} };
+
+    if (nodeData === undefined) {
+      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) {
+
+    if (nodeUniform === undefined) {
       const uniforms = this.uniforms[shaderStage];
       const index = uniforms.length;
-      nodeUniform = new NodeUniform("nodeU" + index, type, node);
+      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) {
+
+    if (nodeVary === undefined) {
       const varys = this.varys;
       const index = varys.length;
-      nodeVary = new NodeVary("nodeV" + index, type);
+      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 = "";
+    let code = '';
+
     for (let name in defines) {
-      code += `#define ${name} ${defines[name]}
-`;
+      code += `#define ${name} ${defines[name]}\n`;
     }
+
     return code;
   }
+
   getAttributesBodySnippet() {
-    console.warn("Abstract function.");
+    console.warn('Abstract function.');
   }
+
   getAttributesHeaderSnippet() {
-    console.warn("Abstract function.");
+    console.warn('Abstract function.');
   }
+
   getVarysHeaderSnippet() {
-    console.warn("Abstract function.");
+    console.warn('Abstract function.');
   }
+
   getVarysBodySnippet() {
-    console.warn("Abstract function.");
+    console.warn('Abstract function.');
   }
+
   getUniformsHeaderSnippet() {
-    console.warn("Abstract function.");
+    console.warn('Abstract function.');
   }
+
   getHash() {
     return this.vertexShader + this.fragmentShader;
   }
+
   build() {
-    const shaderStages = ["vertex", "fragment"];
+    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));
+      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":
+      case 'float to vec2':
         return `vec2( ${snippet} )`;
-      case "float to vec3":
+
+      case 'float to vec3':
         return `vec3( ${snippet} )`;
-      case "float to vec4":
+
+      case 'float to vec4':
         return `vec4( vec3( ${snippet} ), 1.0 )`;
-      case "vec2 to float":
+
+      case 'vec2 to float':
         return `${snippet}.x`;
-      case "vec2 to vec3":
+
+      case 'vec2 to vec3':
         return `vec3( ${snippet}, 0.0 )`;
-      case "vec2 to vec4":
+
+      case 'vec2 to vec4':
         return `vec4( ${snippet}.xy, 0.0, 1.0 )`;
-      case "vec3 to float":
+
+      case 'vec3 to float':
         return `${snippet}.x`;
-      case "vec3 to vec2":
+
+      case 'vec3 to vec2':
         return `${snippet}.xy`;
-      case "vec3 to vec4":
+
+      case 'vec3 to vec4':
         return `vec4( ${snippet}, 1.0 )`;
-      case "vec4 to float":
+
+      case 'vec4 to float':
         return `${snippet}.x`;
-      case "vec4 to vec2":
+
+      case 'vec4 to vec2':
         return `${snippet}.xy`;
-      case "vec4 to vec3":
+
+      case 'vec4 to vec3':
         return `${snippet}.xyz`;
-      case "mat3 to float":
+
+      case 'mat3 to float':
         return `( ${snippet} * vec3( 1.0 ) ).x`;
-      case "mat3 to vec2":
+
+      case 'mat3 to vec2':
         return `( ${snippet} * vec3( 1.0 ) ).xy`;
-      case "mat3 to vec3":
+
+      case 'mat3 to vec3':
         return `( ${snippet} * vec3( 1.0 ) ).xyz`;
-      case "mat3 to vec4":
+
+      case 'mat3 to vec4':
         return `vec4( ${snippet} * vec3( 1.0 ), 1.0 )`;
-      case "mat4 to float":
+
+      case 'mat4 to float':
         return `( ${snippet} * vec4( 1.0 ) ).x`;
-      case "mat4 to vec2":
+
+      case 'mat4 to vec2':
         return `( ${snippet} * vec4( 1.0 ) ).xy`;
-      case "mat4 to vec3":
+
+      case 'mat4 to vec3':
         return `( ${snippet} * vec4( 1.0 ) ).xyz`;
-      case "mat4 to vec4":
+
+      case 'mat4 to vec4':
         return `( ${snippet} * vec4( 1.0 ) )`;
     }
+
     return snippet;
   }
+
 }
-module.exports = NodeBuilder;
+
+export default NodeBuilder;

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

@@ -0,0 +1 @@
+"use strict";var e=require("./constants.cjs.js");module.exports=class{constructor(){this.time=0,this.deltaTime=0,this.frameId=0,this.startTime=null,this.updateMap=new WeakMap,this.renderer=null,this.material=null,this.camera=null,this.object=null}updateNode(t){t.updateType===e.NodeUpdateType.Frame?this.updateMap.get(t)!==this.frameId&&(this.updateMap.set(t,this.frameId),t.update(this)):t.updateType===e.NodeUpdateType.Object&&t.update(this)}update(){this.frameId++,void 0===this.lastTime&&(this.lastTime=performance.now()),this.deltaTime=(performance.now()-this.lastTime)/1e3,this.lastTime=performance.now(),this.time+=this.deltaTime}};

package/renderers/nodes/core/NodeFrame.js

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

package/renderers/nodes/core/NodeSlot.cjs.js

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

package/renderers/nodes/core/NodeSlot.js

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

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

@@ -0,0 +1 @@
+"use strict";module.exports=class{constructor(e,t,s,i){this.name=e,this.type=t,this.node=s,this.needsUpdate=i,Object.defineProperty(this,"isNodeUniform",{value:!0})}get value(){return this.node.value}set value(e){this.node.value=e}};

package/renderers/nodes/core/NodeUniform.js

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

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

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

package/renderers/nodes/core/NodeVary.js

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

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

@@ -0,0 +1 @@
+"use strict";var e=require("./Node.cjs.js"),t=require("./constants.cjs.js");module.exports=class extends e{constructor(e){super(),this.value=e}getType(e){return this.value.getType(e)}generate(e,r){const s=this.getType(e),a=this.value.buildStage(e,t.NodeShaderStage.Vertex,s),o=e.getVaryFromNode(this,s);o.snippet=a;const u=e.getPropertyName(o);return e.format(u,s,r)}};

package/renderers/nodes/core/VaryNode.js

@@ -1,21 +1,27 @@
-"use strict";
-const Node = require("./Node.js");
-const constants = require("./constants.js");
+import Node from './Node.js';
+import { NodeShaderStage } from './constants.js';
+
 class VaryNode extends Node {
   constructor(value) {
     super();
     this.value = value;
   }
+
   getType(builder) {
+    // VaryNode is auto type
     return this.value.getType(builder);
   }
+
   generate(builder, output) {
-    const type = this.getType(builder);
-    const snippet = this.value.buildStage(builder, constants.NodeShaderStage.Vertex, type);
+    const type = this.getType(builder); // force nodeVary.snippet work in vertex stage
+
+    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);
   }
+
 }
-module.exports = VaryNode;
+
+export default VaryNode;

package/renderers/nodes/core/constants.cjs.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});exports.NodeShaderStage={Vertex:"vertex",Fragment:"fragment"},exports.NodeType={Float:"float",Vector2:"vec2",Vector3:"vec3",Vector4:"vec4",Matrix3:"mat3",Matrix4:"mat4"},exports.NodeUpdateType={None:"none",Frame:"frame",Object:"object"};

package/renderers/nodes/core/constants.js

@@ -1,22 +1,19 @@
-"use strict";
-Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
 const NodeShaderStage = {
-  Vertex: "vertex",
-  Fragment: "fragment"
+  Vertex: 'vertex',
+  Fragment: 'fragment'
 };
 const NodeUpdateType = {
-  None: "none",
-  Frame: "frame",
-  Object: "object"
+  None: 'none',
+  Frame: 'frame',
+  Object: 'object'
 };
 const NodeType = {
-  Float: "float",
-  Vector2: "vec2",
-  Vector3: "vec3",
-  Vector4: "vec4",
-  Matrix3: "mat3",
-  Matrix4: "mat4"
+  Float: 'float',
+  Vector2: 'vec2',
+  Vector3: 'vec3',
+  Vector4: 'vec4',
+  Matrix3: 'mat3',
+  Matrix4: 'mat4'
 };
-exports.NodeShaderStage = NodeShaderStage;
-exports.NodeType = NodeType;
-exports.NodeUpdateType = NodeUpdateType;
+
+export { NodeShaderStage, NodeType, NodeUpdateType };

package/renderers/nodes/inputs/ColorNode.cjs.js

@@ -0,0 +1 @@
+"use strict";var e=require("../core/InputNode.cjs.js");require("../core/Node.cjs.js"),require("../core/constants.cjs.js");module.exports=class extends e{constructor(e){super("color"),this.value=e,Object.defineProperty(this,"isColorNode",{value:!0})}};

package/renderers/nodes/inputs/ColorNode.js

@@ -1,10 +1,16 @@
-"use strict";
-const InputNode = require("../core/InputNode.js");
+import InputNode from '../core/InputNode.js';
+import '../core/Node.js';
+import '../core/constants.js';
+
 class ColorNode extends InputNode {
   constructor(value) {
-    super("color");
+    super('color');
     this.value = value;
-    Object.defineProperty(this, "isColorNode", { value: true });
+    Object.defineProperty(this, 'isColorNode', {
+      value: true
+    });
   }
+
 }
-module.exports = ColorNode;
+
+export default ColorNode;

package/renderers/nodes/inputs/FloatNode.cjs.js

@@ -0,0 +1 @@
+"use strict";var e=require("../core/InputNode.cjs.js");require("../core/Node.cjs.js"),require("../core/constants.cjs.js");module.exports=class extends e{constructor(e=0){super("float"),this.value=e,Object.defineProperty(this,"isFloatNode",{value:!0})}};

package/renderers/nodes/inputs/FloatNode.js

@@ -1,10 +1,16 @@
-"use strict";
-const InputNode = require("../core/InputNode.js");
+import InputNode from '../core/InputNode.js';
+import '../core/Node.js';
+import '../core/constants.js';
+
 class FloatNode extends InputNode {
   constructor(value = 0) {
-    super("float");
+    super('float');
     this.value = value;
-    Object.defineProperty(this, "isFloatNode", { value: true });
+    Object.defineProperty(this, 'isFloatNode', {
+      value: true
+    });
   }
+
 }
-module.exports = FloatNode;
+
+export default FloatNode;

package/renderers/nodes/inputs/Matrix3Node.cjs.js

@@ -0,0 +1 @@
+"use strict";var e=require("../core/InputNode.cjs.js"),r=require("three");require("../core/Node.cjs.js"),require("../core/constants.cjs.js");module.exports=class extends e{constructor(e=new r.Matrix3){super("mat3"),this.value=e,Object.defineProperty(this,"isMatrix3Node",{value:!0})}};