three-stdlib 2.16.0 → 2.16.2

package/nodes/core/NodeBuilder.js

@@ -1,19 +1,20 @@
-"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) => {
+import NodeUniform from './NodeUniform.js';
+import NodeAttribute from './NodeAttribute.js';
+import NodeVary from './NodeVary.js';
+import NodeVar from './NodeVar.js';
+import NodeCode from './NodeCode.js';
+import NodeKeywords from './NodeKeywords.js';
+import { NodeUpdateType } from './constants.js';
+import { REVISION, LinearEncoding } from 'three';
+
+const shaderStages = ['fragment', 'vertex'];
+const vector = ['x', 'y', 'z', 'w'];
+
+const toFloat = value => {
   value = Number(value);
-  return value + (value % 1 ? "" : ".0");
+  return value + (value % 1 ? '' : '.0');
 };
+
 class NodeBuilder {
   constructor(object, renderer, parser) {
     this.object = object;
@@ -25,247 +26,317 @@ class NodeBuilder {
     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.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.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.nodesData = new WeakMap();
+    this.flowsData = new WeakMap();
     this.shaderStage = null;
     this.node = null;
   }
+
   addStack(node) {
+    /*
+    if ( this.stack.indexOf( node ) !== - 1 ) {
+    console.warn( 'Recursive node: ', node );
+    }
+    */
     this.stack.push(node);
   }
+
   removeStack(node) {
     const lastStack = this.stack.pop();
+
     if (lastStack !== node) {
-      throw new Error("NodeBuilder: Invalid node stack!");
+      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) {
+
+      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.");
+    console.warn('Abstract function.');
   }
+
   getTextureBias() {
-    console.warn("Abstract function.");
+    console.warn('Abstract function.');
   }
+
   getCubeTexture() {
-    console.warn("Abstract function.");
+    console.warn('Abstract function.');
   }
+
   getCubeTextureBias() {
-    console.warn("Abstract function.");
-  }
+    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)} )`;
+    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);
+
+    const getConst = value => this.getConst(componentType, value);
+
     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
-      )} )`;
+      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 attributes = this.attributes; // find attribute
+
+    for (const 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) {
+
+  getPropertyName(node
+  /*, shaderStage*/
+  ) {
     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";
+    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 = THREE.LinearEncoding;
+      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";
+    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";
+    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";
+    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;
+    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");
+    return type.replace('mat', 'vec');
   }
+
   getDataFromNode(node, shaderStage = this.shaderStage) {
     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 !== null ? 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 index = this.uniforms.index++;
-      nodeUniform = new NodeUniform("nodeUniform" + index, type, node);
+      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) {
+
+    if (nodeVar === undefined) {
       const vars = this.vars[shaderStage];
       const index = vars.length;
-      nodeVar = new NodeVar("nodeVar" + index, type);
+      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) {
+
+    if (nodeVary === undefined) {
       const varys = this.varys;
       const index = varys.length;
-      nodeVary = new NodeVary("nodeVary" + index, type);
+      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) {
+
+    if (nodeCode === undefined) {
       const codes = this.codes[shaderStage];
       const index = codes.length;
-      nodeCode = new NodeCode("nodeCode" + index, type);
+      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);
@@ -274,122 +345,165 @@ class NodeBuilder {
     this.node = null;
     return flowData;
   }
+
   flowChildNode(node, output = null) {
     const previousFlow = this.flow;
     const flow = {
-      code: ""
+      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};
-	`;
+      flowData.code += `${propertyName} = ${flowData.result};\n\t`;
     }
+
     this.flowCode[shaderStage] = this.flowCode[shaderStage] + flowData.code;
     this.setShaderStage(previousShaderStage);
     return flowData;
   }
+
   getAttributes() {
-    console.warn("Abstract function.");
+    console.warn('Abstract function.');
   }
+
   getVarys() {
-    console.warn("Abstract function.");
+    console.warn('Abstract function.');
   }
+
   getVars(shaderStage) {
-    let snippet = "";
+    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.");
+    console.warn('Abstract function.');
   }
+
   getCodes(shaderStage) {
     const codes = this.codes[shaderStage];
-    let code = "";
+    let code = '';
+
     for (const nodeCode of codes) {
-      code += nodeCode.code + "\n";
+      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.");
+    console.warn('Abstract function.');
   }
+
   build() {
+    // stage 1: analyze nodes to possible optimization and validation
     for (const shaderStage of shaderStages) {
       this.setShaderStage(shaderStage);
       const flowNodes = this.flowNodes[shaderStage];
+
       for (const node of flowNodes) {
         node.analyze(this);
       }
-    }
+    } // stage 2: pre-build vertex code used in fragment shader
+
+
     if (this.context.vertex && this.context.vertex.isNode) {
-      this.flowNodeFromShaderStage("vertex", this.context.vertex);
-    }
+      this.flowNodeFromShaderStage('vertex', this.context.vertex);
+    } // stage 3: generate shader
+
+
     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.setShaderStage(null); // stage 4: build code for a specific output
+
     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) {
+      // fromType is matrix-like
       const vectorType = this.getVectorFromMatrix(fromType);
       return this.format(`( ${snippet} * ${this.getType(vectorType)}( 1.0 ) )`, vectorType, toType);
     }
+
     if (toTypeLength === 0) {
+      // toType is matrix-like
+      // ignore for now
+      //return `${ this.getType( toType ) }( ${ snippet } )`;
       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);
+      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 )`;
+      // toType is vec4-like
+      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 )`;
+      // fromType is vec2-like and toType is vec3-like
+      return `${this.getType(toType)}( ${this.format(snippet, fromType, 'vec2')}, 0.0 )`;
     }
-    return `${this.getType(toType)}( ${snippet} )`;
+
+    return `${this.getType(toType)}( ${snippet} )`; // fromType is float-like
   }
+
   getSignature() {
-    return `// Three.js r${THREE.REVISION} - NodeMaterial System
-`;
+    return `// Three.js r${REVISION} - NodeMaterial System\n`;
   }
+
 }
-exports.default = NodeBuilder;
-exports.shaderStages = shaderStages;
-exports.vector = vector;
+
+export default NodeBuilder;
+export { shaderStages, vector };

package/nodes/core/NodeCode.cjs.js

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

package/nodes/core/NodeCode.js

@@ -1,10 +1,13 @@
-"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
+    });
   }
+
 }
-module.exports = NodeCode;
+
+export default NodeCode;

package/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/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;