super-three 0.136.0 → 0.141.0

package/examples/jsm/nodes/core/NodeBuilder.js

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