super-three 0.147.0 → 0.152.0

package/examples/jsm/nodes/accessors/CubeTextureNode.js

@@ -1,8 +1,8 @@
 import TextureNode from './TextureNode.js';
 import UniformNode from '../core/UniformNode.js';
-import ReflectVectorNode from './ReflectVectorNode.js';
-
-import { negate, vec3, nodeObject } from '../shadernode/ShaderNodeBaseElements.js';
+import { reflectVector } from './ReflectVectorNode.js';
+import { addNodeClass } from '../core/Node.js';
+import { addNodeElement, nodeProxy, vec3 } from '../shadernode/ShaderNode.js';
 
 class CubeTextureNode extends TextureNode {
 
@@ -20,29 +20,9 @@ class CubeTextureNode extends TextureNode {
 
 	}
 
-	getConstructHash( builder ) {
+	getDefaultUV() {
 
-		return `${ this.uuid } / ${ builder.context.environmentContext?.uuid || '' }`;
-
-	}
-
-	construct( builder ) {
-
-		const properties = builder.getNodeProperties( this );
-
-		const uvNode = this.uvNode || builder.context.uvNode || new ReflectVectorNode();
-		let levelNode = this.levelNode || builder.context.levelNode;
-
-		if ( levelNode?.isNode === true ) {
-
-			const texture = this.value;
-
-			levelNode = builder.context.levelShaderNode ? builder.context.levelShaderNode.call( { texture, levelNode }, builder ) : levelNode;
-
-		}
-
-		properties.uvNode = uvNode;
-		properties.levelNode = levelNode;
+		return reflectVector;
 
 	}
 
@@ -72,31 +52,39 @@ class CubeTextureNode extends TextureNode {
 
 			const nodeData = builder.getDataFromNode( this );
 
-			let snippet = nodeData.snippet;
+			let propertyName = nodeData.propertyName;
 
-			if ( snippet === undefined || builder.context.tempRead === false ) {
+			if ( propertyName === undefined ) {
 
-				const uvNodeObject = nodeObject( uvNode );
-				const cubeUV = vec3( negate( uvNodeObject.x ), uvNodeObject.yz );
+				const cubeUV = vec3( uvNode.x.negate(), uvNode.yz );
 				const uvSnippet = cubeUV.build( builder, 'vec3' );
 
-				if ( levelNode ) {
+				const nodeVar = builder.getVarFromNode( this, 'vec4' );
+
+				propertyName = builder.getPropertyName( nodeVar );
+
+				let snippet = null;
+
+				if ( levelNode && levelNode.isNode === true ) {
 
 					const levelSnippet = levelNode.build( builder, 'float' );
 
-					snippet = builder.getCubeTextureLevel( textureProperty, uvSnippet, levelSnippet );
+					snippet = builder.getTextureLevel( this, textureProperty, uvSnippet, levelSnippet );
 
 				} else {
 
-					snippet = builder.getCubeTexture( textureProperty, uvSnippet );
+					snippet = builder.getTexture( this, textureProperty, uvSnippet );
 
 				}
 
+				builder.addLineFlowCode( `${propertyName} = ${snippet}` );
+
 				nodeData.snippet = snippet;
+				nodeData.propertyName = propertyName;
 
 			}
 
-			return builder.format( snippet, 'vec4', output );
+			return builder.format( propertyName, 'vec4', output );
 
 		}
 
@@ -105,3 +93,9 @@ class CubeTextureNode extends TextureNode {
 }
 
 export default CubeTextureNode;
+
+export const cubeTexture = nodeProxy( CubeTextureNode );
+
+addNodeElement( 'cubeTexture', cubeTexture );
+
+addNodeClass( CubeTextureNode );

package/examples/jsm/nodes/accessors/ExtendedMaterialNode.js

@@ -0,0 +1,58 @@
+// @TODO: Is this needed? Can it be moved in MaterialNode?
+
+import MaterialNode from './MaterialNode.js';
+import { materialReference } from './MaterialReferenceNode.js';
+import { normalView } from './NormalNode.js';
+import { normalMap } from '../display/NormalMapNode.js';
+import { addNodeClass } from '../core/Node.js';
+import { nodeImmutable } from '../shadernode/ShaderNode.js';
+
+class ExtendedMaterialNode extends MaterialNode {
+
+	constructor( scope ) {
+
+		super( scope );
+
+	}
+
+	getNodeType( builder ) {
+
+		const scope = this.scope;
+		let type = null;
+
+		if ( scope === ExtendedMaterialNode.NORMAL ) {
+
+			type = 'vec3';
+
+		}
+
+		return type || super.getNodeType( builder );
+
+	}
+
+	construct( builder ) {
+
+		const material = builder.material;
+		const scope = this.scope;
+
+		let node = null;
+
+		if ( scope === ExtendedMaterialNode.NORMAL ) {
+
+			node = material.normalMap ? normalMap( this.getTexture( 'normalMap' ), materialReference( 'normalScale', 'vec2' ) ) : normalView;
+
+		}
+
+		return node || super.construct( builder );
+
+	}
+
+}
+
+ExtendedMaterialNode.NORMAL = 'normal';
+
+export default ExtendedMaterialNode;
+
+export const materialNormal = nodeImmutable( ExtendedMaterialNode, ExtendedMaterialNode.NORMAL );
+
+addNodeClass( ExtendedMaterialNode );

package/examples/jsm/nodes/accessors/InstanceNode.js

@@ -1,18 +1,10 @@
-import Node from '../core/Node.js';
-import {
-	vec3,
-	mat3,
-	mul,
-	assign,
-	buffer,
-	element,
-	dot,
-	div,
-	temp,
-	instanceIndex,
-	positionLocal,
-	normalLocal
-} from '../shadernode/ShaderNodeBaseElements.js';
+import Node, { addNodeClass } from '../core/Node.js';
+import { instanceIndex } from '../core/InstanceIndexNode.js';
+import { temp } from '../core/VarNode.js';
+import { buffer } from './BufferNode.js';
+import { normalLocal } from './NormalNode.js';
+import { positionLocal } from './PositionNode.js';
+import { nodeProxy, vec3, mat3 } from '../shadernode/ShaderNode.js';
 
 class InstanceNode extends Node {
 
@@ -26,7 +18,7 @@ class InstanceNode extends Node {
 
 		const instanceBufferNode = buffer( instanceMesh.instanceMatrix.array, 'mat4', instanceMesh.count );
 
-		this.instanceMatrixNode = temp( element( instanceBufferNode, instanceIndex ) ); // @TODO: a possible caching issue here?
+		this.instanceMatrixNode = temp( instanceBufferNode.element( instanceIndex ) ); // @TODO: a possible caching issue here?
 
 	}
 
@@ -36,23 +28,27 @@ class InstanceNode extends Node {
 
 		// POSITION
 
-		const instancePosition = mul( instanceMatrixNode, positionLocal ).xyz;
+		const instancePosition = instanceMatrixNode.mul( positionLocal ).xyz;
 
 		// NORMAL
 
 		const m = mat3( instanceMatrixNode[ 0 ].xyz, instanceMatrixNode[ 1 ].xyz, instanceMatrixNode[ 2 ].xyz );
 
-		const transformedNormal = div( normalLocal, vec3( dot( m[ 0 ], m[ 0 ] ), dot( m[ 1 ], m[ 1 ] ), dot( m[ 2 ], m[ 2 ] ) ) );
+		const transformedNormal = normalLocal.div( vec3( m[ 0 ].dot( m[ 0 ] ), m[ 1 ].dot( m[ 1 ] ), m[ 2 ].dot( m[ 2 ] ) ) );
 
-		const instanceNormal = mul( m, transformedNormal ).xyz;
+		const instanceNormal = m.mul( transformedNormal ).xyz;
 
 		// ASSIGNS
 
-		assign( positionLocal, instancePosition ).build( builder );
-		assign( normalLocal, instanceNormal ).build( builder );
+		positionLocal.assign( instancePosition ).build( builder );
+		normalLocal.assign( instanceNormal ).build( builder );
 
 	}
 
 }
 
 export default InstanceNode;
+
+export const instance = nodeProxy( InstanceNode );
+
+addNodeClass( InstanceNode );

package/examples/jsm/nodes/accessors/MaterialNode.js

@@ -1,20 +1,12 @@
-import Node from '../core/Node.js';
-import OperatorNode from '../math/OperatorNode.js';
-import MaterialReferenceNode from './MaterialReferenceNode.js';
-import TextureNode from './TextureNode.js';
-import SplitNode from '../utils/SplitNode.js';
+import Node, { addNodeClass } from '../core/Node.js';
+import { uniform } from '../core/UniformNode.js';
+import { materialReference } from './MaterialReferenceNode.js';
+import { uv } from './UVNode.js';
+import { nodeImmutable, vec3 } from '../shadernode/ShaderNode.js';
 
 class MaterialNode extends Node {
 
-	static ALPHA_TEST = 'alphaTest';
-	static COLOR = 'color';
-	static OPACITY = 'opacity';
-	static ROUGHNESS = 'roughness';
-	static METALNESS = 'metalness';
-	static EMISSIVE = 'emissive';
-	static ROTATION = 'rotation';
-
-	constructor( scope = MaterialNode.COLOR ) {
+	constructor( scope ) {
 
 		super();
 
@@ -35,11 +27,15 @@ class MaterialNode extends Node {
 
 			return 'float';
 
+		} else if ( scope === MaterialNode.UV ) {
+
+			return 'vec2';
+
 		} else if ( scope === MaterialNode.EMISSIVE ) {
 
 			return 'vec3';
 
-		} else if ( scope === MaterialNode.ROUGHNESS || scope === MaterialNode.METALNESS ) {
+		} else if ( scope === MaterialNode.ROUGHNESS || scope === MaterialNode.METALNESS || scope === MaterialNode.SPECULAR || scope === MaterialNode.SHININESS ) {
 
 			return 'float';
 
@@ -47,7 +43,34 @@ class MaterialNode extends Node {
 
 	}
 
-	generate( builder, output ) {
+	getFloat( property ) {
+
+		//@TODO: Check if it can be cached by property name.
+
+		return materialReference( property, 'float' );
+
+	}
+
+	getColor( property ) {
+
+		//@TODO: Check if it can be cached by property name.
+
+		return materialReference( property, 'color' );
+
+	}
+
+	getTexture( property ) {
+
+		//@TODO: Check if it can be cached by property name.
+
+		const textureRefNode = materialReference( property, 'texture' );
+		textureRefNode.node.uvNode = materialUV;
+
+		return textureRefNode;
+
+	}
+
+	construct( builder ) {
 
 		const material = builder.context.material;
 		const scope = this.scope;
@@ -56,18 +79,15 @@ class MaterialNode extends Node {
 
 		if ( scope === MaterialNode.ALPHA_TEST ) {
 
-			node = new MaterialReferenceNode( 'alphaTest', 'float' );
+			node = this.getFloat( 'alphaTest' );
 
 		} else if ( scope === MaterialNode.COLOR ) {
 
-			const colorNode = new MaterialReferenceNode( 'color', 'color' );
-
-			if ( material.map?.isTexture === true ) {
+			const colorNode = this.getColor( 'color' );
 
-				//new MaterialReferenceNode( 'map', 'texture' )
-				const map = new TextureNode( material.map );
+			if ( material.map && material.map.isTexture === true ) {
 
-				node = new OperatorNode( '*', colorNode, map );
+				node = colorNode.mul( this.getTexture( 'map' ) );
 
 			} else {
 
@@ -77,11 +97,11 @@ class MaterialNode extends Node {
 
 		} else if ( scope === MaterialNode.OPACITY ) {
 
-			const opacityNode = new MaterialReferenceNode( 'opacity', 'float' );
+			const opacityNode = this.getFloat( 'opacity' );
 
-			if ( material.alphaMap?.isTexture === true ) {
+			if ( material.alphaMap && material.alphaMap.isTexture === true ) {
 
-				node = new OperatorNode( '*', opacityNode, new MaterialReferenceNode( 'alphaMap', 'texture' ) );
+				node = opacityNode.mul( this.getTexture( 'alphaMap' ) );
 
 			} else {
 
@@ -89,13 +109,35 @@ class MaterialNode extends Node {
 
 			}
 
+		} else if ( scope === MaterialNode.SHININESS ) {
+
+			node = this.getFloat( 'shininess' );
+
+		} else if ( scope === MaterialNode.SPECULAR_COLOR ) {
+
+			node = this.getColor( 'specular' );
+
+		} else if ( scope === MaterialNode.REFLECTIVITY ) {
+
+			const reflectivityNode = this.getFloat( 'reflectivity' );
+
+			if ( material.specularMap && material.specularMap.isTexture === true ) {
+
+				node = reflectivityNode.mul( this.getTexture( 'specularMap' ).r );
+
+			} else {
+
+				node = reflectivityNode;
+
+			}
+
 		} else if ( scope === MaterialNode.ROUGHNESS ) {
 
-			const roughnessNode = new MaterialReferenceNode( 'roughness', 'float' );
+			const roughnessNode = this.getFloat( 'roughness' );
 
-			if ( material.roughnessMap?.isTexture === true ) {
+			if ( material.roughnessMap && material.roughnessMap.isTexture === true ) {
 
-				node = new OperatorNode( '*', roughnessNode, new SplitNode( new TextureNode( material.roughnessMap ), 'g' ) );
+				node = roughnessNode.mul( this.getTexture( 'roughnessMap' ).g );
 
 			} else {
 
@@ -105,11 +147,11 @@ class MaterialNode extends Node {
 
 		} else if ( scope === MaterialNode.METALNESS ) {
 
-			const metalnessNode = new MaterialReferenceNode( 'metalness', 'float' );
+			const metalnessNode = this.getFloat( 'metalness' );
 
-			if ( material.metalnessMap?.isTexture === true ) {
+			if ( material.metalnessMap && material.metalnessMap.isTexture === true ) {
 
-				node = new OperatorNode( '*', metalnessNode, new SplitNode( new TextureNode( material.metalnessMap ), 'b' ) );
+				node = metalnessNode.mul( this.getTexture( 'metalnessMap' ).b );
 
 			} else {
 
@@ -119,11 +161,11 @@ class MaterialNode extends Node {
 
 		} else if ( scope === MaterialNode.EMISSIVE ) {
 
-			const emissiveNode = new MaterialReferenceNode( 'emissive', 'color' );
+			const emissiveNode = this.getColor( 'emissive' );
 
-			if ( material.emissiveMap?.isTexture === true ) {
+			if ( material.emissiveMap && material.emissiveMap.isTexture === true ) {
 
-				node = new OperatorNode( '*', emissiveNode, new TextureNode( material.emissiveMap ) );
+				node = emissiveNode.mul( this.getTexture( 'emissiveMap' ) );
 
 			} else {
 
@@ -133,20 +175,95 @@ class MaterialNode extends Node {
 
 		} else if ( scope === MaterialNode.ROTATION ) {
 
-			node = new MaterialReferenceNode( 'rotation', 'float' );
+			node = this.getFloat( 'rotation' );
+
+		} else if ( scope === MaterialNode.UV ) {
+
+			// uv repeat and offset setting priorities
+
+			let uvScaleMap =
+				material.map ||
+				material.specularMap ||
+				material.displacementMap ||
+				material.normalMap ||
+				material.bumpMap ||
+				material.roughnessMap ||
+				material.metalnessMap ||
+				material.alphaMap ||
+				material.emissiveMap ||
+				material.clearcoatMap ||
+				material.clearcoatNormalMap ||
+				material.clearcoatRoughnessMap ||
+				material.iridescenceMap ||
+				material.iridescenceThicknessMap ||
+				material.specularIntensityMap ||
+				material.specularColorMap ||
+				material.transmissionMap ||
+				material.thicknessMap ||
+				material.sheenColorMap ||
+				material.sheenRoughnessMap;
+
+			if ( uvScaleMap ) {
+
+				// backwards compatibility
+				if ( uvScaleMap.isWebGLRenderTarget ) {
+
+					uvScaleMap = uvScaleMap.texture;
+
+				}
+
+				if ( uvScaleMap.matrixAutoUpdate === true ) {
+
+					uvScaleMap.updateMatrix();
+
+				}
+
+				node = uniform( uvScaleMap.matrix ).mul( vec3( uv(), 1 ) );
+
+			} else {
+
+				node = uv();
+
+			}
 
 		} else {
 
 			const outputType = this.getNodeType( builder );
 
-			node = new MaterialReferenceNode( scope, outputType );
+			node = materialReference( scope, outputType );
 
 		}
 
-		return node.build( builder, output );
+		return node;
 
 	}
 
 }
 
+MaterialNode.ALPHA_TEST = 'alphaTest';
+MaterialNode.COLOR = 'color';
+MaterialNode.OPACITY = 'opacity';
+MaterialNode.SHININESS = 'shininess';
+MaterialNode.SPECULAR_COLOR = 'specularColor';
+MaterialNode.REFLECTIVITY = 'reflectivity';
+MaterialNode.ROUGHNESS = 'roughness';
+MaterialNode.METALNESS = 'metalness';
+MaterialNode.EMISSIVE = 'emissive';
+MaterialNode.ROTATION = 'rotation';
+MaterialNode.UV = 'uv';
+
 export default MaterialNode;
+
+export const materialUV = nodeImmutable( MaterialNode, MaterialNode.UV );
+export const materialAlphaTest = nodeImmutable( MaterialNode, MaterialNode.ALPHA_TEST );
+export const materialColor = nodeImmutable( MaterialNode, MaterialNode.COLOR );
+export const materialShininess = nodeImmutable( MaterialNode, MaterialNode.SHININESS );
+export const materialEmissive = nodeImmutable( MaterialNode, MaterialNode.EMISSIVE );
+export const materialOpacity = nodeImmutable( MaterialNode, MaterialNode.OPACITY );
+export const materialSpecularColor = nodeImmutable( MaterialNode, MaterialNode.SPECULAR_COLOR );
+export const materialReflectivity = nodeImmutable( MaterialNode, MaterialNode.REFLECTIVITY );
+export const materialRoughness = nodeImmutable( MaterialNode, MaterialNode.ROUGHNESS );
+export const materialMetalness = nodeImmutable( MaterialNode, MaterialNode.METALNESS );
+export const materialRotation = nodeImmutable( MaterialNode, MaterialNode.ROTATION );
+
+addNodeClass( MaterialNode );

package/examples/jsm/nodes/accessors/MaterialReferenceNode.js

@@ -1,4 +1,6 @@
 import ReferenceNode from './ReferenceNode.js';
+import { addNodeClass } from '../core/Node.js';
+import { nodeObject, getConstNodeType } from '../shadernode/ShaderNode.js';
 
 class MaterialReferenceNode extends ReferenceNode {
 
@@ -10,6 +12,16 @@ class MaterialReferenceNode extends ReferenceNode {
 
 	}
 
+	construct( builder ) {
+
+		const material = this.material !== null ? this.material : builder.material;
+
+		this.node.value = material[ this.property ];
+
+		return super.construct( builder );
+
+	}
+
 	update( frame ) {
 
 		this.object = this.material !== null ? this.material : frame.material;
@@ -21,3 +33,7 @@ class MaterialReferenceNode extends ReferenceNode {
 }
 
 export default MaterialReferenceNode;
+
+export const materialReference = ( name, nodeOrType, material ) => nodeObject( new MaterialReferenceNode( name, getConstNodeType( nodeOrType ), material ) );
+
+addNodeClass( MaterialReferenceNode );

package/examples/jsm/nodes/accessors/ModelNode.js

@@ -1,4 +1,6 @@
 import Object3DNode from './Object3DNode.js';
+import { addNodeClass } from '../core/Node.js';
+import { nodeImmutable } from '../shadernode/ShaderNode.js';
 
 class ModelNode extends Object3DNode {
 
@@ -19,3 +21,12 @@ class ModelNode extends Object3DNode {
 }
 
 export default ModelNode;
+
+export const modelDirection = nodeImmutable( ModelNode, ModelNode.DIRECTION );
+export const modelViewMatrix = nodeImmutable( ModelNode, ModelNode.VIEW_MATRIX );
+export const modelNormalMatrix = nodeImmutable( ModelNode, ModelNode.NORMAL_MATRIX );
+export const modelWorldMatrix = nodeImmutable( ModelNode, ModelNode.WORLD_MATRIX );
+export const modelPosition = nodeImmutable( ModelNode, ModelNode.POSITION );
+export const modelViewPosition = nodeImmutable( ModelNode, ModelNode.VIEW_POSITION );
+
+addNodeClass( ModelNode );

package/examples/jsm/nodes/accessors/ModelViewProjectionNode.js

@@ -1,12 +1,12 @@
-import Node from '../core/Node.js';
-import CameraNode from '../accessors/CameraNode.js';
-import ModelNode from '../accessors/ModelNode.js';
-import OperatorNode from '../math/OperatorNode.js';
-import PositionNode from '../accessors/PositionNode.js';
+import Node, { addNodeClass } from '../core/Node.js';
+import { cameraProjectionMatrix } from './CameraNode.js';
+import { modelViewMatrix } from './ModelNode.js';
+import { positionLocal } from './PositionNode.js';
+import { nodeProxy } from '../shadernode/ShaderNode.js';
 
 class ModelViewProjectionNode extends Node {
 
-	constructor( position = new PositionNode() ) {
+	constructor( position = positionLocal ) {
 
 		super( 'vec4' );
 
@@ -18,8 +18,8 @@ class ModelViewProjectionNode extends Node {
 
 		const position = this.position;
 
-		const mvpMatrix = new OperatorNode( '*', new CameraNode( CameraNode.PROJECTION_MATRIX ), new ModelNode( ModelNode.VIEW_MATRIX ) );
-		const mvpNode = new OperatorNode( '*', mvpMatrix, position );
+		const mvpMatrix = cameraProjectionMatrix.mul( modelViewMatrix );
+		const mvpNode = mvpMatrix.mul( position );
 
 		return mvpNode.build( builder );
 
@@ -28,3 +28,7 @@ class ModelViewProjectionNode extends Node {
 }
 
 export default ModelViewProjectionNode;
+
+export const modelViewProjection = nodeProxy( ModelViewProjectionNode );
+
+addNodeClass( ModelViewProjectionNode );

package/examples/jsm/nodes/accessors/NormalNode.js

@@ -1,18 +1,14 @@
-import Node from '../core/Node.js';
-import AttributeNode from '../core/AttributeNode.js';
-import VaryingNode from '../core/VaryingNode.js';
-import ModelNode from '../accessors/ModelNode.js';
-import CameraNode from '../accessors/CameraNode.js';
-import OperatorNode from '../math/OperatorNode.js';
-import MathNode from '../math/MathNode.js';
+import Node, { addNodeClass } from '../core/Node.js';
+import { attribute } from '../core/AttributeNode.js';
+import { label } from '../core/VarNode.js';
+import { varying } from '../core/VaryingNode.js';
+import { normalize } from '../math/MathNode.js';
+import { cameraViewMatrix } from './CameraNode.js';
+import { modelNormalMatrix } from './ModelNode.js';
+import { nodeImmutable } from '../shadernode/ShaderNode.js';
 
 class NormalNode extends Node {
 
-	static GEOMETRY = 'geometry';
-	static LOCAL = 'local';
-	static VIEW = 'view';
-	static WORLD = 'world';
-
 	constructor( scope = NormalNode.LOCAL ) {
 
 		super( 'vec3' );
@@ -21,6 +17,12 @@ class NormalNode extends Node {
 
 	}
 
+	isGlobal() {
+
+		return true;
+
+	}
+
 	getHash( /*builder*/ ) {
 
 		return `normal-${this.scope}`;
@@ -35,22 +37,22 @@ class NormalNode extends Node {
 
 		if ( scope === NormalNode.GEOMETRY ) {
 
-			outputNode = new AttributeNode( 'normal', 'vec3' );
+			outputNode = attribute( 'normal', 'vec3' );
 
 		} else if ( scope === NormalNode.LOCAL ) {
 
-			outputNode = new VaryingNode( new NormalNode( NormalNode.GEOMETRY ) );
+			outputNode = varying( normalGeometry );
 
 		} else if ( scope === NormalNode.VIEW ) {
 
-			const vertexNode = new OperatorNode( '*', new ModelNode( ModelNode.NORMAL_MATRIX ), new NormalNode( NormalNode.LOCAL ) );
-			outputNode = new MathNode( MathNode.NORMALIZE, new VaryingNode( vertexNode ) );
+			const vertexNode = modelNormalMatrix.mul( normalLocal );
+			outputNode = normalize( varying( vertexNode ) );
 
 		} else if ( scope === NormalNode.WORLD ) {
 
-			// To use INVERSE_TRANSFORM_DIRECTION only inverse the param order like this: MathNode( ..., Vector, Matrix );
-			const vertexNode = new MathNode( MathNode.TRANSFORM_DIRECTION, new NormalNode( NormalNode.VIEW ), new CameraNode( CameraNode.VIEW_MATRIX ) );
-			outputNode = new MathNode( MathNode.NORMALIZE, new VaryingNode( vertexNode ) );
+			// To use inverseTransformDirection only inverse the param order like this: cameraViewMatrix.transformDirection( normalView )
+			const vertexNode = normalView.transformDirection( cameraViewMatrix );
+			outputNode = normalize( varying( vertexNode ) );
 
 		}
 
@@ -76,4 +78,18 @@ class NormalNode extends Node {
 
 }
 
+NormalNode.GEOMETRY = 'geometry';
+NormalNode.LOCAL = 'local';
+NormalNode.VIEW = 'view';
+NormalNode.WORLD = 'world';
+
 export default NormalNode;
+
+export const normalGeometry = nodeImmutable( NormalNode, NormalNode.GEOMETRY );
+export const normalLocal = nodeImmutable( NormalNode, NormalNode.LOCAL );
+export const normalView = nodeImmutable( NormalNode, NormalNode.VIEW );
+export const normalWorld = nodeImmutable( NormalNode, NormalNode.WORLD );
+export const transformedNormalView = label( normalView, 'TransformedNormalView' );
+export const transformedNormalWorld = transformedNormalView.transformDirection( cameraViewMatrix ).normalize();
+
+addNodeClass( NormalNode );