three-stdlib 2.8.9 → 2.8.12

package/nodes/core/NodeBuilder.js

@@ -1,631 +1,505 @@
-import { CubeUVRefractionMapping, CubeUVReflectionMapping, CubeRefractionMapping, CubeReflectionMapping, LinearEncoding, sRGBEncoding } from 'three';
-import { NodeUniform } from './NodeUniform.js';
-import { NodeUtils } from './NodeUtils.js';
-import { NodeLib } from './NodeLib.js';
-import { FunctionNode } from './FunctionNode.js';
-import { ConstNode } from './ConstNode.js';
-import { StructNode } from './StructNode.js';
-import { Vector2Node } from '../inputs/Vector2Node.js';
-import { Vector3Node } from '../inputs/Vector3Node.js';
-import { Vector4Node } from '../inputs/Vector4Node.js';
-import { TextureNode } from '../inputs/TextureNode.js';
-import { CubeTextureNode } from '../inputs/CubeTextureNode.js';
-import { TextureCubeNode } from '../misc/TextureCubeNode.js';
-
-var elements = NodeUtils.elements,
-    constructors = ['float', 'vec2', 'vec3', 'vec4'],
-    convertFormatToType = {
-  float: 'f',
-  vec2: 'v2',
-  vec3: 'v3',
-  vec4: 'v4',
-  mat4: 'v4',
-  int: 'i',
-  bool: 'b'
-},
-    convertTypeToFormat = {
-  t: 'sampler2D',
-  tc: 'samplerCube',
-  b: 'bool',
-  i: 'int',
-  f: 'float',
-  c: 'vec3',
-  v2: 'vec2',
-  v3: 'vec3',
-  v4: 'vec4',
-  m3: 'mat3',
-  m4: 'mat4'
+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');
 };
 
-function NodeBuilder() {
-  this.slots = [];
-  this.caches = [];
-  this.contexts = [];
-  this.keywords = {};
-  this.nodeData = {};
-  this.requires = {
-    uv: [],
-    color: [],
-    lights: false,
-    fog: false,
-    transparent: false,
-    irradiance: false
-  };
-  this.includes = {
-    consts: [],
-    functions: [],
-    structs: []
-  };
-  this.attributes = {};
-  this.prefixCode = ['#ifdef TEXTURE_LOD_EXT', '	#define texCube(a, b) textureCube(a, b)', '	#define texCubeBias(a, b, c) textureCubeLodEXT(a, b, c)', '	#define tex2D(a, b) texture2D(a, b)', '	#define tex2DBias(a, b, c) texture2DLodEXT(a, b, c)', '#else', '	#define texCube(a, b) textureCube(a, b)', '	#define texCubeBias(a, b, c) textureCube(a, b, c)', '	#define tex2D(a, b) texture2D(a, b)', '	#define tex2DBias(a, b, c) texture2D(a, b, c)', '#endif', '#include <packing>', '#include <common>'].join('\n');
-  this.parsCode = {
-    vertex: '',
-    fragment: ''
-  };
-  this.code = {
-    vertex: '',
-    fragment: ''
-  };
-  this.nodeCode = {
-    vertex: '',
-    fragment: ''
-  };
-  this.resultCode = {
-    vertex: '',
-    fragment: ''
-  };
-  this.finalCode = {
-    vertex: '',
-    fragment: ''
-  };
-  this.inputs = {
-    uniforms: {
-      list: [],
+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: []
-    },
-    vars: {
-      varying: [],
+    };
+    this.attributes = [];
+    this.varys = [];
+    this.vars = {
       vertex: [],
       fragment: []
-    }
-  }; // send to material
+    };
+    this.flow = {
+      code: ''
+    };
+    this.stack = [];
+    this.context = {
+      keywords: new NodeKeywords(),
+      material: object.material
+    };
+    this.nodesData = new WeakMap();
+    this.flowsData = new WeakMap();
+    this.shaderStage = null;
+    this.node = null;
+  }
 
-  this.defines = {};
-  this.uniforms = {};
-  this.extensions = {};
-  this.updaters = [];
-  this.nodes = []; // --
+  addStack(node) {
+    /*
+    if ( this.stack.indexOf( node ) !== - 1 ) {
+    console.warn( 'Recursive node: ', node );
+    }
+    */
+    this.stack.push(node);
+  }
 
-  this.analyzing = false;
-}
+  removeStack(node) {
+    const lastStack = this.stack.pop();
 
-NodeBuilder.prototype = {
-  constructor: NodeBuilder,
-  build: function (vertex, fragment) {
-    this.buildShader('vertex', vertex);
-    this.buildShader('fragment', fragment);
+    if (lastStack !== node) {
+      throw new Error('NodeBuilder: Invalid node stack!');
+    }
+  }
 
-    for (let i = 0; i < this.requires.uv.length; i++) {
-      if (this.requires.uv[i]) {
-        var uvIndex = i > 0 ? i + 1 : '';
-        this.addVaryCode('varying vec2 vUv' + uvIndex + ';');
+  setHashNode(node, hash) {
+    this.hashNodes[hash] = node;
+  }
 
-        if (i > 0) {
-          this.addVertexParsCode('attribute vec2 uv' + uvIndex + ';');
-        }
+  addNode(node) {
+    if (this.nodes.indexOf(node) === -1) {
+      const updateType = node.getUpdateType(this);
 
-        this.addVertexFinalCode('vUv' + uvIndex + ' = uv' + uvIndex + ';');
+      if (updateType !== NodeUpdateType.None) {
+        this.updateNodes.push(node);
       }
-    }
 
-    if (this.requires.color[0]) {
-      this.addVaryCode('varying vec4 vColor;');
-      this.addVertexParsCode('attribute vec4 color;');
-      this.addVertexFinalCode('vColor = color;');
+      this.nodes.push(node);
+      this.setHashNode(node, node.getHash(this));
     }
+  }
 
-    if (this.requires.color[1]) {
-      this.addVaryCode('varying vec4 vColor2;');
-      this.addVertexParsCode('attribute vec4 color2;');
-      this.addVertexFinalCode('vColor2 = color2;');
-    }
+  getMethod(method) {
+    return method;
+  }
 
-    if (this.requires.position) {
-      this.addVaryCode('varying vec3 vPosition;');
-      this.addVertexFinalCode('vPosition = transformed;');
-    }
+  getNodeFromHash(hash) {
+    return this.hashNodes[hash];
+  }
 
-    if (this.requires.worldPosition) {
-      this.addVaryCode('varying vec3 vWPosition;');
-      this.addVertexFinalCode('vWPosition = ( modelMatrix * vec4( transformed, 1.0 ) ).xyz;');
-    }
+  addFlow(shaderStage, node) {
+    this.flowNodes[shaderStage].push(node);
+    return node;
+  }
 
-    if (this.requires.normal) {
-      this.addVaryCode('varying vec3 vObjectNormal;');
-      this.addVertexFinalCode('vObjectNormal = normal;');
-    }
+  setContext(context) {
+    this.context = context;
+  }
 
-    if (this.requires.worldNormal) {
-      this.addVaryCode('varying vec3 vWNormal;');
-      this.addVertexFinalCode('vWNormal = inverseTransformDirection( transformedNormal, viewMatrix ).xyz;');
-    }
+  getContext() {
+    return this.context;
+  }
 
-    return this;
-  },
-  buildShader: function (shader, node) {
-    this.resultCode[shader] = node.build(this.setShader(shader), 'v4');
-  },
-  setMaterial: function (material, renderer) {
-    this.material = material;
-    this.renderer = renderer;
-    this.requires.lights = material.lights;
-    this.requires.fog = material.fog;
-    this.mergeDefines(material.defines);
-    return this;
-  },
-  addFlow: function (slot, cache, context) {
-    return this.addSlot(slot).addCache(cache).addContext(context);
-  },
-  removeFlow: function () {
-    return this.removeSlot().removeCache().removeContext();
-  },
-  addCache: function (name) {
-    this.cache = name || '';
-    this.caches.push(this.cache);
-    return this;
-  },
-  removeCache: function () {
-    this.caches.pop();
-    this.cache = this.caches[this.caches.length - 1] || '';
-    return this;
-  },
-  addContext: function (context) {
-    this.context = Object.assign({}, this.context, context);
-    this.context.extra = this.context.extra || {};
-    this.contexts.push(this.context);
-    return this;
-  },
-  removeContext: function () {
-    this.contexts.pop();
-    this.context = this.contexts[this.contexts.length - 1] || {};
-    return this;
-  },
-  addSlot: function (name) {
-    this.slot = name || '';
-    this.slots.push(this.slot);
-    return this;
-  },
-  removeSlot: function () {
-    this.slots.pop();
-    this.slot = this.slots[this.slots.length - 1] || '';
-    return this;
-  },
-  addVertexCode: function (code) {
-    this.addCode(code, 'vertex');
-  },
-  addFragmentCode: function (code) {
-    this.addCode(code, 'fragment');
-  },
-  addCode: function (code, shader) {
-    this.code[shader || this.shader] += code + '\n';
-  },
-  addVertexNodeCode: function (code) {
-    this.addNodeCode(code, 'vertex');
-  },
-  addFragmentNodeCode: function (code) {
-    this.addNodeCode(code, 'fragment');
-  },
-  addNodeCode: function (code, shader) {
-    this.nodeCode[shader || this.shader] += code + '\n';
-  },
-  clearNodeCode: function (shader) {
-    shader = shader || this.shader;
-    var code = this.nodeCode[shader];
-    this.nodeCode[shader] = '';
-    return code;
-  },
-  clearVertexNodeCode: function () {
-    return this.clearNodeCode('vertex');
-  },
-  clearFragmentNodeCode: function () {
-    return this.clearNodeCode('fragment');
-  },
-  addVertexFinalCode: function (code) {
-    this.addFinalCode(code, 'vertex');
-  },
-  addFragmentFinalCode: function (code) {
-    this.addFinalCode(code, 'fragment');
-  },
-  addFinalCode: function (code, shader) {
-    this.finalCode[shader || this.shader] += code + '\n';
-  },
-  addVertexParsCode: function (code) {
-    this.addParsCode(code, 'vertex');
-  },
-  addFragmentParsCode: function (code) {
-    this.addParsCode(code, 'fragment');
-  },
-  addParsCode: function (code, shader) {
-    this.parsCode[shader || this.shader] += code + '\n';
-  },
-  addVaryCode: function (code) {
-    this.addVertexParsCode(code);
-    this.addFragmentParsCode(code);
-  },
-  isCache: function (name) {
-    return this.caches.indexOf(name) !== -1;
-  },
-  isSlot: function (name) {
-    return this.slots.indexOf(name) !== -1;
-  },
-  define: function (name, value) {
-    this.defines[name] = value === undefined ? 1 : value;
-  },
-  require: function (name) {
-    this.requires[name] = true;
-  },
-  isDefined: function (name) {
-    return this.defines[name] !== undefined;
-  },
-  getVar: function (uuid, type, ns, shader = 'varying', prefix = 'V', label = '') {
-    var vars = this.getVars(shader),
-        data = vars[uuid];
-
-    if (!data) {
-      var index = vars.length,
-          name = ns ? ns : 'node' + prefix + index + (label ? '_' + label : '');
-      data = {
-        name: name,
-        type: type
-      };
-      vars.push(data);
-      vars[uuid] = data;
-    }
+  getTexture() {
+    console.warn('Abstract function.');
+  }
 
-    return data;
-  },
-  getTempVar: function (uuid, type, ns, label) {
-    return this.getVar(uuid, type, ns, this.shader, 'T', label);
-  },
-  getAttribute: function (name, type) {
-    if (!this.attributes[name]) {
-      var varying = this.getVar(name, type);
-      this.addVertexParsCode('attribute ' + type + ' ' + name + ';');
-      this.addVertexFinalCode(varying.name + ' = ' + name + ';');
-      this.attributes[name] = {
-        varying: varying,
-        name: name,
-        type: type
-      };
-    }
+  getTextureBias() {
+    console.warn('Abstract function.');
+  }
 
-    return this.attributes[name];
-  },
-  getCode: function (shader) {
-    return [this.prefixCode, this.parsCode[shader], this.getVarListCode(this.getVars('varying'), 'varying'), this.getVarListCode(this.inputs.uniforms[shader], 'uniform'), this.getIncludesCode('consts', shader), this.getIncludesCode('structs', shader), this.getIncludesCode('functions', shader), 'void main() {', this.getVarListCode(this.getVars(shader)), this.code[shader], this.resultCode[shader], this.finalCode[shader], '}'].join('\n');
-  },
-  getVarListCode: function (vars, prefix) {
-    prefix = prefix || '';
-    var code = '';
-
-    for (let i = 0, l = vars.length; i < l; ++i) {
-      var nVar = vars[i],
-          type = nVar.type,
-          name = nVar.name;
-      var formatType = this.getFormatByType(type);
-
-      if (formatType === undefined) {
-        throw new Error('Node pars ' + formatType + ' not found.');
-      }
+  getCubeTexture() {
+    console.warn('Abstract function.');
+  }
 
-      code += prefix + ' ' + formatType + ' ' + name + ';\n';
-    }
+  getCubeTextureBias() {
+    console.warn('Abstract function.');
+  } // @TODO: rename to .generateConst()
 
-    return code;
-  },
-  getVars: function (shader) {
-    return this.inputs.vars[shader || this.shader];
-  },
-  getNodeData: function (node) {
-    var uuid = node.isNode ? node.uuid : node;
-    return this.nodeData[uuid] = this.nodeData[uuid] || {};
-  },
-  createUniform: function (shader, type, node, ns, needsUpdate, label) {
-    var uniforms = this.inputs.uniforms,
-        index = uniforms.list.length;
-    var uniform = new NodeUniform({
-      type: type,
-      name: ns ? ns : 'nodeU' + index + (label ? '_' + label : ''),
-      node: node,
-      needsUpdate: needsUpdate
-    });
-    uniforms.list.push(uniform);
-    uniforms[shader].push(uniform);
-    uniforms[shader][uniform.name] = uniform;
-    this.uniforms[uniform.name] = uniform;
-    return uniform;
-  },
-  createVertexUniform: function (type, node, ns, needsUpdate, label) {
-    return this.createUniform('vertex', type, node, ns, needsUpdate, label);
-  },
-  createFragmentUniform: function (type, node, ns, needsUpdate, label) {
-    return this.createUniform('fragment', type, node, ns, needsUpdate, label);
-  },
-  include: function (node, parent, source) {
-    var includesStruct;
-    node = typeof node === 'string' ? NodeLib.get(node) : node;
-
-    if (this.context.include === false) {
-      return node.name;
-    }
 
-    if (node instanceof FunctionNode) {
-      includesStruct = this.includes.functions;
-    } else if (node instanceof ConstNode) {
-      includesStruct = this.includes.consts;
-    } else if (node instanceof StructNode) {
-      includesStruct = this.includes.structs;
+  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 = 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)} )`;
     }
 
-    var includes = includesStruct[this.shader] = includesStruct[this.shader] || [];
+    throw new Error(`NodeBuilder: Type '${type}' not found in generate constant attempt.`);
+  }
+
+  getType(type) {
+    return type;
+  }
+
+  generateMethod(method) {
+    return method;
+  }
 
-    if (node) {
-      var included = includes[node.name];
+  getAttribute(name, type) {
+    const attributes = this.attributes; // find attribute
 
-      if (!included) {
-        included = includes[node.name] = {
-          node: node,
-          deps: []
-        };
-        includes.push(included);
-        included.src = node.build(this, 'source');
+    for (const attribute of attributes) {
+      if (attribute.name === name) {
+        return attribute;
       }
+    } // create a new if no exist
 
-      if (node instanceof FunctionNode && parent && includes[parent.name] && includes[parent.name].deps.indexOf(node) == -1) {
-        includes[parent.name].deps.push(node);
 
-        if (node.includes && node.includes.length) {
-          var i = 0;
+    const attribute = new NodeAttribute(name, type);
+    attributes.push(attribute);
+    return attribute;
+  }
 
-          do {
-            this.include(node.includes[i++], parent);
-          } while (i < node.includes.length);
-        }
-      }
+  getPropertyName(node
+  /*, shaderStage*/
+  ) {
+    return node.name;
+  }
 
-      if (source) {
-        included.src = source;
-      }
+  isVector(type) {
+    return /vec\d/.test(type);
+  }
+
+  isMatrix(type) {
+    return /mat\d/.test(type);
+  }
+
+  isReference(type) {
+    return type === 'void' || type === 'property' || type === 'sampler';
+  }
 
-      return node.name;
+  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 {
-      throw new Error('Include not found.');
-    }
-  },
-  colorToVectorProperties: function (color) {
-    return color.replace('r', 'x').replace('g', 'y').replace('b', 'z').replace('a', 'w');
-  },
-  colorToVector: function (color) {
-    return color.replace(/c/g, 'v3');
-  },
-  getIncludes: function (type, shader) {
-    return this.includes[type][shader || this.shader];
-  },
-  getIncludesCode: function () {
-    function sortByPosition(a, b) {
-      return a.deps.length - b.deps.length;
+      encoding = LinearEncoding;
     }
 
-    return function getIncludesCode(type, shader) {
-      var includes = this.getIncludes(type, shader);
-      if (!includes) return '';
-      var code = '',
-          includes = includes.sort(sortByPosition);
+    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';
+  }
 
-      for (let i = 0; i < includes.length; i++) {
-        if (includes[i].src) code += includes[i].src + '\n';
-      }
+  getVectorType(type) {
+    if (type === 'color') return 'vec3';
+    if (type === 'texture') return 'vec4';
+    return type;
+  }
 
-      return code;
-    };
-  }(),
-  getConstructorFromLength: function (len) {
-    return constructors[len - 1];
-  },
-  isTypeMatrix: function (format) {
-    return /^m/.test(format);
-  },
-  getTypeLength: function (type) {
-    if (type === 'f') return 1;
-    return parseInt(this.colorToVector(type).substr(1));
-  },
-  getTypeFromLength: function (len) {
-    if (len === 1) return 'f';
-    return 'v' + len;
-  },
-  findNode: function () {
-    for (let i = 0; i < arguments.length; i++) {
-      var nodeCandidate = arguments[i];
-
-      if (nodeCandidate !== undefined && nodeCandidate.isNode) {
-        return nodeCandidate;
-      }
+  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 === undefined) {
+      nodeData = {
+        vertex: {},
+        fragment: {}
+      };
+      this.nodesData.set(node, nodeData);
     }
-  },
-  resolve: function () {
-    for (let i = 0; i < arguments.length; i++) {
-      var nodeCandidate = arguments[i];
-
-      if (nodeCandidate !== undefined) {
-        if (nodeCandidate.isNode) {
-          return nodeCandidate;
-        } else if (nodeCandidate.isTexture) {
-          switch (nodeCandidate.mapping) {
-            case CubeReflectionMapping:
-            case CubeRefractionMapping:
-              return new CubeTextureNode(nodeCandidate);
-
-            case CubeUVReflectionMapping:
-            case CubeUVRefractionMapping:
-              return new TextureCubeNode(new TextureNode(nodeCandidate));
-
-            default:
-              return new TextureNode(nodeCandidate);
-          }
-        } else if (nodeCandidate.isVector2) {
-          return new Vector2Node(nodeCandidate);
-        } else if (nodeCandidate.isVector3) {
-          return new Vector3Node(nodeCandidate);
-        } else if (nodeCandidate.isVector4) {
-          return new Vector4Node(nodeCandidate);
-        }
-      }
+
+    return shaderStage !== null ? nodeData[shaderStage] : nodeData;
+  }
+
+  getUniformFromNode(node, shaderStage, type) {
+    const nodeData = this.getDataFromNode(node, shaderStage);
+    let nodeUniform = nodeData.uniform;
+
+    if (nodeUniform === undefined) {
+      const index = this.uniforms.index++;
+      nodeUniform = new NodeUniform('nodeUniform' + index, type, node);
+      this.uniforms[shaderStage].push(nodeUniform);
+      nodeData.uniform = nodeUniform;
     }
-  },
-  format: function (code, from, to) {
-    var typeToType = this.colorToVector(to + ' <- ' + from);
 
-    switch (typeToType) {
-      case 'f <- v2':
-        return code + '.x';
+    return nodeUniform;
+  }
 
-      case 'f <- v3':
-        return code + '.x';
+  getVarFromNode(node, type, shaderStage = this.shaderStage) {
+    const nodeData = this.getDataFromNode(node, shaderStage);
+    let nodeVar = nodeData.variable;
 
-      case 'f <- v4':
-        return code + '.x';
+    if (nodeVar === undefined) {
+      const vars = this.vars[shaderStage];
+      const index = vars.length;
+      nodeVar = new NodeVar('nodeVar' + index, type);
+      vars.push(nodeVar);
+      nodeData.variable = nodeVar;
+    }
 
-      case 'f <- i':
-      case 'f <- b':
-        return 'float( ' + code + ' )';
+    return nodeVar;
+  }
 
-      case 'v2 <- f':
-        return 'vec2( ' + code + ' )';
+  getVaryFromNode(node, type) {
+    const nodeData = this.getDataFromNode(node, null);
+    let nodeVary = nodeData.vary;
 
-      case 'v2 <- v3':
-        return code + '.xy';
+    if (nodeVary === undefined) {
+      const varys = this.varys;
+      const index = varys.length;
+      nodeVary = new NodeVary('nodeVary' + index, type);
+      varys.push(nodeVary);
+      nodeData.vary = nodeVary;
+    }
 
-      case 'v2 <- v4':
-        return code + '.xy';
+    return nodeVary;
+  }
 
-      case 'v2 <- i':
-      case 'v2 <- b':
-        return 'vec2( float( ' + code + ' ) )';
+  getCodeFromNode(node, type, shaderStage = this.shaderStage) {
+    const nodeData = this.getDataFromNode(node);
+    let nodeCode = nodeData.code;
 
-      case 'v3 <- f':
-        return 'vec3( ' + code + ' )';
+    if (nodeCode === undefined) {
+      const codes = this.codes[shaderStage];
+      const index = codes.length;
+      nodeCode = new NodeCode('nodeCode' + index, type);
+      codes.push(nodeCode);
+      nodeData.code = nodeCode;
+    }
 
-      case 'v3 <- v2':
-        return 'vec3( ' + code + ', 0.0 )';
+    return nodeCode;
+  }
 
-      case 'v3 <- v4':
-        return code + '.xyz';
+  addFlowCode(code) {
+    this.flow.code += code;
+  }
 
-      case 'v3 <- i':
-      case 'v3 <- b':
-        return 'vec2( float( ' + code + ' ) )';
+  getFlowData(shaderStage, node) {
+    return this.flowsData.get(node);
+  }
 
-      case 'v4 <- f':
-        return 'vec4( ' + code + ' )';
+  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;
+  }
 
-      case 'v4 <- v2':
-        return 'vec4( ' + code + ', 0.0, 1.0 )';
+  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;
+  }
 
-      case 'v4 <- v3':
-        return 'vec4( ' + code + ', 1.0 )';
+  flowNodeFromShaderStage(shaderStage, node, output = null, propertyName = null) {
+    const previousShaderStage = this.shaderStage;
+    this.setShaderStage(shaderStage);
+    const flowData = this.flowChildNode(node, output);
 
-      case 'v4 <- i':
-      case 'v4 <- b':
-        return 'vec4( float( ' + code + ' ) )';
+    if (propertyName !== null) {
+      flowData.code += `${propertyName} = ${flowData.result};\n\t`;
+    }
 
-      case 'i <- f':
-      case 'i <- b':
-        return 'int( ' + code + ' )';
+    this.flowCode[shaderStage] = this.flowCode[shaderStage] + flowData.code;
+    this.setShaderStage(previousShaderStage);
+    return flowData;
+  }
 
-      case 'i <- v2':
-        return 'int( ' + code + '.x )';
+  getAttributes() {
+    console.warn('Abstract function.');
+  }
 
-      case 'i <- v3':
-        return 'int( ' + code + '.x )';
+  getVarys() {
+    console.warn('Abstract function.');
+  }
 
-      case 'i <- v4':
-        return 'int( ' + code + '.x )';
+  getVars(shaderStage) {
+    let snippet = '';
+    const vars = this.vars[shaderStage];
 
-      case 'b <- f':
-        return '( ' + code + ' != 0.0 )';
+    for (let index = 0; index < vars.length; index++) {
+      const variable = vars[index];
+      snippet += `${variable.type} ${variable.name}; `;
+    }
 
-      case 'b <- v2':
-        return '( ' + code + ' != vec2( 0.0 ) )';
+    return snippet;
+  }
 
-      case 'b <- v3':
-        return '( ' + code + ' != vec3( 0.0 ) )';
+  getUniforms() {
+    console.warn('Abstract function.');
+  }
 
-      case 'b <- v4':
-        return '( ' + code + ' != vec4( 0.0 ) )';
+  getCodes(shaderStage) {
+    const codes = this.codes[shaderStage];
+    let code = '';
 
-      case 'b <- i':
-        return '( ' + code + ' != 0 )';
+    for (const nodeCode of codes) {
+      code += nodeCode.code + '\n';
     }
 
     return code;
-  },
-  getTypeByFormat: function (format) {
-    return convertFormatToType[format] || format;
-  },
-  getFormatByType: function (type) {
-    return convertTypeToFormat[type] || type;
-  },
-  getUuid: function (uuid, useCache) {
-    useCache = useCache !== undefined ? useCache : true;
-    if (useCache && this.cache) uuid = this.cache + '-' + uuid;
-    return uuid;
-  },
-  getElementByIndex: function (index) {
-    return elements[index];
-  },
-  getIndexByElement: function (elm) {
-    return elements.indexOf(elm);
-  },
-  isShader: function (shader) {
-    return this.shader === shader;
-  },
-  setShader: function (shader) {
-    this.shader = shader;
+  }
+
+  getHash() {
+    return this.vertexShader + this.fragmentShader;
+  }
+
+  getShaderStage() {
+    return this.shaderStage;
+  }
+
+  setShaderStage(shaderStage) {
+    this.shaderStage = shaderStage;
+  }
+
+  buildCode() {
+    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);
+    } // 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); // stage 4: build code for a specific output
+
+    this.buildCode();
     return this;
-  },
-  mergeDefines: function (defines) {
-    for (let name in defines) {
-      this.defines[name] = defines[name];
+  }
+
+  format(snippet, fromType, toType) {
+    fromType = this.getVectorType(fromType);
+    toType = this.getVectorType(toType);
+
+    if (fromType === toType || toType === null || this.isReference(toType)) {
+      return snippet;
     }
 
-    return this.defines;
-  },
-  mergeUniform: function (uniforms) {
-    for (let name in uniforms) {
-      this.uniforms[name] = uniforms[name];
+    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);
     }
 
-    return this.uniforms;
-  },
-  getTextureEncodingFromMap: function (map) {
-    var encoding;
+    if (toTypeLength === 0) {
+      // toType is matrix-like
+      // ignore for now
+      //return `${ this.getType( toType ) }( ${ snippet } )`;
+      return snippet;
+    }
 
-    if (!map) {
-      encoding = LinearEncoding;
-    } else if (map.isTexture) {
-      encoding = map.encoding;
-    } else if (map.isWebGLRenderTarget) {
-      console.warn("THREE.WebGLPrograms.getTextureEncodingFromMap: don't use render targets as textures. Use their .texture property instead.");
-      encoding = map.texture.encoding;
+    if (fromTypeLength === toTypeLength) {
+      return `${this.getType(toType)}( ${snippet} )`;
     }
 
-    if (encoding === LinearEncoding && this.context.gamma) {
-      encoding = sRGBEncoding;
+    if (fromTypeLength > toTypeLength) {
+      return this.format(`${snippet}.${'xyz'.slice(0, toTypeLength)}`, this.getTypeFromLength(toTypeLength), toType);
     }
 
-    return encoding;
+    if (toTypeLength === 4) {
+      // toType is vec4-like
+      return `${this.getType(toType)}( ${this.format(snippet, fromType, 'vec3')}, 1.0 )`;
+    }
+
+    if (fromTypeLength === 2) {
+      // 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} )`; // fromType is float-like
   }
-};
 
-export { NodeBuilder };
+  getSignature() {
+    return `// Three.js r${REVISION} - NodeMaterial System\n`;
+  }
+
+}
+
+export default NodeBuilder;
+export { shaderStages, vector };