super-three 0.147.1 → 0.152.0

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

@@ -1,15 +1,11 @@
-import { Vector3 } from 'three';
-import Node from '../core/Node.js';
-import UniformNode from '../core/UniformNode.js';
+import Node, { addNodeClass } from '../core/Node.js';
 import { NodeUpdateType } from '../core/constants.js';
+import { uniform } from '../core/UniformNode.js';
+import { nodeProxy } from '../shadernode/ShaderNode.js';
 
-class Object3DNode extends Node {
+import { Vector3 } from 'three';
 
-	static VIEW_MATRIX = 'viewMatrix';
-	static NORMAL_MATRIX = 'normalMatrix';
-	static WORLD_MATRIX = 'worldMatrix';
-	static POSITION = 'position';
-	static VIEW_POSITION = 'viewPosition';
+class Object3DNode extends Node {
 
 	constructor( scope = Object3DNode.VIEW_MATRIX, object3d = null ) {
 
@@ -20,7 +16,7 @@ class Object3DNode extends Node {
 
 		this.updateType = NodeUpdateType.OBJECT;
 
-		this._uniformNode = new UniformNode( null );
+		this._uniformNode = uniform( null );
 
 	}
 
@@ -36,7 +32,7 @@ class Object3DNode extends Node {
 
 			return 'mat3';
 
-		} else if ( scope === Object3DNode.POSITION || scope === Object3DNode.VIEW_POSITION ) {
+		} else if ( scope === Object3DNode.POSITION || scope === Object3DNode.VIEW_POSITION || scope === Object3DNode.DIRECTION ) {
 
 			return 'vec3';
 
@@ -64,8 +60,16 @@ class Object3DNode extends Node {
 
 		} else if ( scope === Object3DNode.POSITION ) {
 
+			uniformNode.value = uniformNode.value || new Vector3();
+
 			uniformNode.value.setFromMatrixPosition( object.matrixWorld );
 
+		} else if ( scope === Object3DNode.DIRECTION ) {
+
+			uniformNode.value = uniformNode.value || new Vector3();
+
+			object.getWorldDirection( uniformNode.value );
+
 		} else if ( scope === Object3DNode.VIEW_POSITION ) {
 
 			const camera = frame.camera;
@@ -91,7 +95,7 @@ class Object3DNode extends Node {
 
 			this._uniformNode.nodeType = 'mat3';
 
-		} else if ( scope === Object3DNode.POSITION || scope === Object3DNode.VIEW_POSITION ) {
+		} else if ( scope === Object3DNode.POSITION || scope === Object3DNode.VIEW_POSITION || scope === Object3DNode.DIRECTION ) {
 
 			this._uniformNode.nodeType = 'vec3';
 
@@ -119,4 +123,20 @@ class Object3DNode extends Node {
 
 }
 
+Object3DNode.VIEW_MATRIX = 'viewMatrix';
+Object3DNode.NORMAL_MATRIX = 'normalMatrix';
+Object3DNode.WORLD_MATRIX = 'worldMatrix';
+Object3DNode.POSITION = 'position';
+Object3DNode.VIEW_POSITION = 'viewPosition';
+Object3DNode.DIRECTION = 'direction';
+
 export default Object3DNode;
+
+export const objectDirection = nodeProxy( Object3DNode, Object3DNode.DIRECTION );
+export const objectViewMatrix = nodeProxy( Object3DNode, Object3DNode.VIEW_MATRIX );
+export const objectNormalMatrix = nodeProxy( Object3DNode, Object3DNode.NORMAL_MATRIX );
+export const objectWorldMatrix = nodeProxy( Object3DNode, Object3DNode.WORLD_MATRIX );
+export const objectPosition = nodeProxy( Object3DNode, Object3DNode.POSITION );
+export const objectViewPosition = nodeProxy( Object3DNode, Object3DNode.VIEW_POSITION );
+
+addNodeClass( Object3DNode );

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

@@ -1,4 +1,5 @@
-import Node from '../core/Node.js';
+import Node, { addNodeClass } from '../core/Node.js';
+import { nodeImmutable } from '../shadernode/ShaderNode.js';
 
 class PointUVNode extends Node {
 
@@ -19,3 +20,7 @@ class PointUVNode extends Node {
 }
 
 export default PointUVNode;
+
+export const pointUV = nodeImmutable( PointUVNode );
+
+addNodeClass( PointUVNode );

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

@@ -1,19 +1,12 @@
-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 MathNode from '../math/MathNode.js';
-import OperatorNode from '../math/OperatorNode.js';
+import Node, { addNodeClass } from '../core/Node.js';
+import { attribute } from '../core/AttributeNode.js';
+import { varying } from '../core/VaryingNode.js';
+import { normalize } from '../math/MathNode.js';
+import { modelWorldMatrix, modelViewMatrix } from './ModelNode.js';
+import { nodeImmutable } from '../shadernode/ShaderNode.js';
 
 class PositionNode extends Node {
 
-	static GEOMETRY = 'geometry';
-	static LOCAL = 'local';
-	static WORLD = 'world';
-	static WORLD_DIRECTION = 'worldDirection';
-	static VIEW = 'view';
-	static VIEW_DIRECTION = 'viewDirection';
-
 	constructor( scope = PositionNode.LOCAL ) {
 
 		super( 'vec3' );
@@ -22,6 +15,12 @@ class PositionNode extends Node {
 
 	}
 
+	isGlobal() {
+
+		return true;
+
+	}
+
 	getHash( /*builder*/ ) {
 
 		return `position-${this.scope}`;
@@ -36,31 +35,31 @@ class PositionNode extends Node {
 
 		if ( scope === PositionNode.GEOMETRY ) {
 
-			outputNode = new AttributeNode( 'position', 'vec3' );
+			outputNode = attribute( 'position', 'vec3' );
 
 		} else if ( scope === PositionNode.LOCAL ) {
 
-			outputNode = new VaryingNode( new PositionNode( PositionNode.GEOMETRY ) );
+			outputNode = varying( positionGeometry );
 
 		} else if ( scope === PositionNode.WORLD ) {
 
-			const vertexPositionNode = new MathNode( MathNode.TRANSFORM_DIRECTION, new ModelNode( ModelNode.WORLD_MATRIX ), new PositionNode( PositionNode.LOCAL ) );
-			outputNode = new VaryingNode( vertexPositionNode );
+			const vertexPositionNode = modelWorldMatrix.mul( positionLocal );
+			outputNode = varying( vertexPositionNode );
 
 		} else if ( scope === PositionNode.VIEW ) {
 
-			const vertexPositionNode = new OperatorNode( '*', new ModelNode( ModelNode.VIEW_MATRIX ), new PositionNode( PositionNode.LOCAL ) );
-			outputNode = new VaryingNode( vertexPositionNode );
+			const vertexPositionNode = modelViewMatrix.mul( positionLocal );
+			outputNode = varying( vertexPositionNode );
 
 		} else if ( scope === PositionNode.VIEW_DIRECTION ) {
 
-			const vertexPositionNode = new MathNode( MathNode.NEGATE, new PositionNode( PositionNode.VIEW ) );
-			outputNode = new MathNode( MathNode.NORMALIZE, new VaryingNode( vertexPositionNode ) );
+			const vertexPositionNode = positionView.negate();
+			outputNode = normalize( varying( vertexPositionNode ) );
 
 		} else if ( scope === PositionNode.WORLD_DIRECTION ) {
 
-			const vertexPositionNode = new MathNode( MathNode.NEGATE, new PositionNode( PositionNode.WORLD ) );
-			outputNode = new MathNode( MathNode.NORMALIZE, new VaryingNode( vertexPositionNode ) );
+			const vertexPositionNode = positionLocal.transformDirection( modelWorldMatrix );
+			outputNode = normalize( varying( vertexPositionNode ) );
 
 		}
 
@@ -86,4 +85,20 @@ class PositionNode extends Node {
 
 }
 
+PositionNode.GEOMETRY = 'geometry';
+PositionNode.LOCAL = 'local';
+PositionNode.WORLD = 'world';
+PositionNode.WORLD_DIRECTION = 'worldDirection';
+PositionNode.VIEW = 'view';
+PositionNode.VIEW_DIRECTION = 'viewDirection';
+
 export default PositionNode;
+
+export const positionGeometry = nodeImmutable( PositionNode, PositionNode.GEOMETRY );
+export const positionLocal = nodeImmutable( PositionNode, PositionNode.LOCAL );
+export const positionWorld = nodeImmutable( PositionNode, PositionNode.WORLD );
+export const positionWorldDirection = nodeImmutable( PositionNode, PositionNode.WORLD_DIRECTION );
+export const positionView = nodeImmutable( PositionNode, PositionNode.VIEW );
+export const positionViewDirection = nodeImmutable( PositionNode, PositionNode.VIEW_DIRECTION );
+
+addNodeClass( PositionNode );

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

@@ -1,6 +1,8 @@
-import Node from '../core/Node.js';
-import UniformNode from '../core/UniformNode.js';
+import Node, { addNodeClass } from '../core/Node.js';
 import { NodeUpdateType } from '../core/constants.js';
+import { uniform } from '../core/UniformNode.js';
+import { texture } from './TextureNode.js';
+import { nodeObject, getConstNodeType } from '../shadernode/ShaderNode.js';
 
 class ReferenceNode extends Node {
 
@@ -24,42 +26,47 @@ class ReferenceNode extends Node {
 
 	setNodeType( uniformType ) {
 
-		this.node = new UniformNode( null, uniformType );
-		this.nodeType = uniformType;
+		let node = null;
 
-		if ( uniformType === 'color' ) {
+		if ( uniformType === 'texture' ) {
 
-			this.nodeType = 'vec3';
+			node = texture( null );
 
-		} else if ( uniformType === 'texture' ) {
+		} else {
 
-			this.nodeType = 'vec4';
+			node = uniform( uniformType );
 
 		}
 
+		this.node = node;
+
 	}
 
-	getNodeType() {
+	getNodeType( builder ) {
 
-		return this.uniformType;
+		return this.node.getNodeType( builder );
 
 	}
 
 	update( frame ) {
 
 		const object = this.object !== null ? this.object : frame.object;
-		const value = object[ this.property ];
+		const property = this.property;
 
-		this.node.value = value;
+		this.node.value = object[ property ];
 
 	}
 
-	generate( builder ) {
+	construct( /*builder*/ ) {
 
-		return this.node.build( builder, this.getNodeType( builder ) );
+		return this.node;
 
 	}
 
 }
 
 export default ReferenceNode;
+
+export const reference = ( name, nodeOrType, object ) => nodeObject( new ReferenceNode( name, getConstNodeType( nodeOrType ), object ) );
+
+addNodeClass( ReferenceNode );

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

@@ -1,8 +1,8 @@
-import Node from '../core/Node.js';
-import {
-	transformedNormalView, positionViewDirection,
-	transformDirection, negate, reflect, cameraViewMatrix
-} from '../shadernode/ShaderNodeBaseElements.js';
+import Node, { addNodeClass } from '../core/Node.js';
+import { cameraViewMatrix } from './CameraNode.js';
+import { transformedNormalView } from './NormalNode.js';
+import { positionViewDirection } from './PositionNode.js';
+import { nodeImmutable } from '../shadernode/ShaderNode.js';
 
 class ReflectVectorNode extends Node {
 
@@ -20,12 +20,16 @@ class ReflectVectorNode extends Node {
 
 	construct() {
 
-		const reflectView = reflect( negate( positionViewDirection ), transformedNormalView );
+		const reflectView = positionViewDirection.negate().reflect( transformedNormalView );
 
-		return transformDirection( reflectView, cameraViewMatrix );
+		return reflectView.transformDirection( cameraViewMatrix );
 
 	}
 
 }
 
 export default ReflectVectorNode;
+
+export const reflectVector = nodeImmutable( ReflectVectorNode );
+
+addNodeClass( ReflectVectorNode );

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

@@ -1,65 +1,57 @@
-import Node from '../core/Node.js';
-import {
-	ShaderNode,
-	attribute,
-	buffer,
-	mat4,
-	uniform,
-	positionLocal,
-	normalLocal,
-	tangentLocal,
-	assign,
-	element,
-	add,
-	mul,
-	transformDirection
-} from '../shadernode/ShaderNodeBaseElements.js';
-
+import Node, { addNodeClass } from '../core/Node.js';
 import { NodeUpdateType } from '../core/constants.js';
+import { ShaderNode, nodeProxy } from '../shadernode/ShaderNode.js';
+import { attribute } from '../core/AttributeNode.js';
+import { uniform } from '../core/UniformNode.js';
+import { add } from '../math/OperatorNode.js';
+import { buffer } from './BufferNode.js';
+import { normalLocal } from './NormalNode.js';
+import { positionLocal } from './PositionNode.js';
+import { tangentLocal } from './TangentNode.js';
 
-const Skinning = new ShaderNode( ( inputs, builder ) => {
+const Skinning = new ShaderNode( ( inputs, {}, builder ) => {
 
 	const { index, weight, bindMatrix, bindMatrixInverse, boneMatrices } = inputs;
 
-	const boneMatX = element( boneMatrices, index.x );
-	const boneMatY = element( boneMatrices, index.y );
-	const boneMatZ = element( boneMatrices, index.z );
-	const boneMatW = element( boneMatrices, index.w );
+	const boneMatX = boneMatrices.element( index.x );
+	const boneMatY = boneMatrices.element( index.y );
+	const boneMatZ = boneMatrices.element( index.z );
+	const boneMatW = boneMatrices.element( index.w );
 
 	// POSITION
 
-	const skinVertex = mul( bindMatrix, positionLocal );
+	const skinVertex = bindMatrix.mul( positionLocal );
 
 	const skinned = add(
-		mul( mul( boneMatX, skinVertex ), weight.x ),
-		mul( mul( boneMatY, skinVertex ), weight.y ),
-		mul( mul( boneMatZ, skinVertex ), weight.z ),
-		mul( mul( boneMatW, skinVertex ), weight.w )
+		boneMatX.mul( skinVertex ).mul( weight.x ),
+		boneMatY.mul( skinVertex ).mul( weight.y ),
+		boneMatZ.mul( skinVertex ).mul( weight.z ),
+		boneMatW.mul( skinVertex ).mul( weight.w )
 	);
 
-	const skinPosition = mul( bindMatrixInverse, skinned ).xyz;
+	const skinPosition = bindMatrixInverse.mul( skinned ).xyz;
 
 	// NORMAL
 
 	let skinMatrix = add(
-		mul( weight.x, boneMatX ),
-		mul( weight.y, boneMatY ),
-		mul( weight.z, boneMatZ ),
-		mul( weight.w, boneMatW )
+		weight.x.mul( boneMatX ),
+		weight.y.mul( boneMatY ),
+		weight.z.mul( boneMatZ ),
+		weight.w.mul( boneMatW )
 	);
 
-	skinMatrix = mul( mul( bindMatrixInverse, skinMatrix ), bindMatrix );
+	skinMatrix = bindMatrixInverse.mul( skinMatrix ).mul( bindMatrix );
 
-	const skinNormal = transformDirection( skinMatrix, normalLocal ).xyz;
+	const skinNormal = skinMatrix.transformDirection( normalLocal ).xyz;
 
 	// ASSIGNS
 
-	assign( positionLocal, skinPosition ).build( builder );
-	assign( normalLocal, skinNormal ).build( builder );
+	positionLocal.assign( skinPosition ).build( builder ); // @TODO: For some reason this doesn't work as stack.assign( positionLocal, skinPosition )?
+	normalLocal.assign( skinNormal ).build( builder );
 
 	if ( builder.hasGeometryAttribute( 'tangent' ) ) {
 
-		assign( tangentLocal, skinNormal ).build( builder );
+		tangentLocal.assign( skinNormal ).build( builder );
 
 	}
 
@@ -80,21 +72,28 @@ class SkinningNode extends Node {
 		this.skinIndexNode = attribute( 'skinIndex', 'uvec4' );
 		this.skinWeightNode = attribute( 'skinWeight', 'vec4' );
 
-		this.bindMatrixNode = uniform( mat4( skinnedMesh.bindMatrix ) );
-		this.bindMatrixInverseNode = uniform( mat4( skinnedMesh.bindMatrixInverse ) );
+		this.bindMatrixNode = uniform( skinnedMesh.bindMatrix, 'mat4' );
+		this.bindMatrixInverseNode = uniform( skinnedMesh.bindMatrixInverse, 'mat4' );
 		this.boneMatricesNode = buffer( skinnedMesh.skeleton.boneMatrices, 'mat4', skinnedMesh.skeleton.bones.length );
 
 	}
 
 	generate( builder ) {
 
+		/*return new ShaderNode( ( {}, stack, builder ) => Skinning.call( {
+			index: this.skinIndexNode,
+			weight: this.skinWeightNode,
+			bindMatrix: this.bindMatrixNode,
+			bindMatrixInverse: this.bindMatrixInverseNode,
+			boneMatrices: this.boneMatricesNode
+		}, stack, builder ) ).build( builder );*/
 		Skinning.call( {
 			index: this.skinIndexNode,
 			weight: this.skinWeightNode,
 			bindMatrix: this.bindMatrixNode,
 			bindMatrixInverse: this.bindMatrixInverseNode,
 			boneMatrices: this.boneMatricesNode
-		}, builder );
+		}, {}, builder );
 
 	}
 
@@ -107,3 +106,7 @@ class SkinningNode extends Node {
 }
 
 export default SkinningNode;
+
+export const skinning = nodeProxy( SkinningNode );
+
+addNodeClass( SkinningNode );

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

@@ -1,4 +1,6 @@
 import BufferNode from './BufferNode.js';
+import { addNodeClass } from '../core/Node.js';
+import { nodeObject, getConstNodeType } from '../shadernode/ShaderNode.js';
 
 class StorageBufferNode extends BufferNode {
 
@@ -19,3 +21,7 @@ class StorageBufferNode extends BufferNode {
 }
 
 export default StorageBufferNode;
+
+export const storage = ( value, nodeOrType, count ) => nodeObject( new StorageBufferNode( value, getConstNodeType( nodeOrType ), count ) );
+
+addNodeClass( StorageBufferNode );

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

@@ -1,19 +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 SplitNode from '../utils/SplitNode.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 { modelViewMatrix } from './ModelNode.js';
+import { nodeImmutable } from '../shadernode/ShaderNode.js';
 
 class TangentNode extends Node {
 
-	static GEOMETRY = 'geometry';
-	static LOCAL = 'local';
-	static VIEW = 'view';
-	static WORLD = 'world';
-
 	constructor( scope = TangentNode.LOCAL ) {
 
 		super();
@@ -51,22 +46,21 @@ class TangentNode extends Node {
 
 		if ( scope === TangentNode.GEOMETRY ) {
 
-			outputNode = new AttributeNode( 'tangent', 'vec4' );
+			outputNode = attribute( 'tangent', 'vec4' );
 
 		} else if ( scope === TangentNode.LOCAL ) {
 
-			outputNode = new VaryingNode( new SplitNode( new TangentNode( TangentNode.GEOMETRY ), 'xyz' ) );
+			outputNode = varying( tangentGeometry.xyz );
 
 		} else if ( scope === TangentNode.VIEW ) {
 
-			const vertexNode = new SplitNode( new OperatorNode( '*', new ModelNode( ModelNode.VIEW_MATRIX ), new TangentNode( TangentNode.LOCAL ) ), 'xyz' );
-
-			outputNode = new MathNode( MathNode.NORMALIZE, new VaryingNode( vertexNode ) );
+			const vertexNode = modelViewMatrix.mul( tangentLocal ).xyz;
+			outputNode = normalize( varying( vertexNode ) );
 
 		} else if ( scope === TangentNode.WORLD ) {
 
-			const vertexNode = new MathNode( MathNode.TRANSFORM_DIRECTION, new TangentNode( TangentNode.VIEW ), new CameraNode( CameraNode.VIEW_MATRIX ) );
-			outputNode = new MathNode( MathNode.NORMALIZE, new VaryingNode( vertexNode ) );
+			const vertexNode = tangentView.transformDirection( cameraViewMatrix );
+			outputNode = normalize( varying( vertexNode ) );
 
 		}
 
@@ -92,4 +86,18 @@ class TangentNode extends Node {
 
 }
 
+TangentNode.GEOMETRY = 'geometry';
+TangentNode.LOCAL = 'local';
+TangentNode.VIEW = 'view';
+TangentNode.WORLD = 'world';
+
 export default TangentNode;
+
+export const tangentGeometry = nodeImmutable( TangentNode, TangentNode.GEOMETRY );
+export const tangentLocal = nodeImmutable( TangentNode, TangentNode.LOCAL );
+export const tangentView = nodeImmutable( TangentNode, TangentNode.VIEW );
+export const tangentWorld = nodeImmutable( TangentNode, TangentNode.WORLD );
+export const transformedTangentView = label( tangentView, 'TransformedTangentView' );
+export const transformedTangentWorld = normalize( transformedTangentView.transformDirection( cameraViewMatrix ) );
+
+addNodeClass( TangentNode );

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

@@ -1,11 +1,15 @@
 import UniformNode from '../core/UniformNode.js';
-import UVNode from './UVNode.js';
+import { uv } from './UVNode.js';
+import { addNodeClass } from '../core/Node.js';
+import { addNodeElement, nodeProxy } from '../shadernode/ShaderNode.js';
+
+let defaultUV;
 
 class TextureNode extends UniformNode {
 
-	constructor( value, uvNode = new UVNode(), levelNode = null ) {
+	constructor( value, uvNode = null, levelNode = null ) {
 
-		super( value, 'vec4' );
+		super( value );
 
 		this.isTextureNode = true;
 
@@ -20,14 +24,63 @@ class TextureNode extends UniformNode {
 
 	}
 
+	getNodeType( /*builder*/ ) {
+
+		if ( this.value.isDepthTexture === true ) return 'float';
+
+		return 'vec4';
+
+	}
+
 	getInputType( /*builder*/ ) {
 
 		return 'texture';
 
 	}
 
+	getDefaultUV() {
+
+		return defaultUV || ( defaultUV = uv() );
+
+	}
+
+	construct( builder ) {
+
+		const properties = builder.getNodeProperties( this );
+
+		//
+
+		let uvNode = this.uvNode;
+
+		if ( uvNode === null && builder.context.getUVNode ) {
+
+			uvNode = builder.context.getUVNode( this );
+
+		}
+
+		uvNode || ( uvNode = this.getDefaultUV() );
+
+		//
+
+		let levelNode = this.levelNode;
+
+		if ( levelNode === null && builder.context.getSamplerLevelNode ) {
+
+			levelNode = builder.context.getSamplerLevelNode( this );
+
+		}
+
+		//
+
+		properties.uvNode = uvNode;
+		properties.levelNode = levelNode ? builder.context.getMIPLevelAlgorithmNode( this, levelNode ) : null;
+
+	}
+
 	generate( builder, output ) {
 
+		const { uvNode, levelNode } = builder.getNodeProperties( this );
+
 		const texture = this.value;
 
 		if ( ! texture || texture.isTexture !== true ) {
@@ -36,7 +89,7 @@ class TextureNode extends UniformNode {
 
 		}
 
-		const textureProperty = super.generate( builder, 'texture' );
+		const textureProperty = super.generate( builder, 'property' );
 
 		if ( output === 'sampler' ) {
 
@@ -48,32 +101,40 @@ class TextureNode extends UniformNode {
 
 		} else {
 
+			const nodeType = this.getNodeType( builder );
 			const nodeData = builder.getDataFromNode( this );
 
-			let snippet = nodeData.snippet;
+			let propertyName = nodeData.propertyName;
+
+			if ( propertyName === undefined ) {
+
+				const uvSnippet = uvNode.build( builder, 'vec2' );
+				const nodeVar = builder.getVarFromNode( this, nodeType );
 
-			if ( snippet === undefined ) {
+				propertyName = builder.getPropertyName( nodeVar );
 
-				const uvSnippet = this.uvNode.build( builder, 'vec2' );
-				const levelNode = this.levelNode;
+				let snippet = null;
 
-				if ( levelNode !== null ) {
+				if ( levelNode && levelNode.isNode === true ) {
 
 					const levelSnippet = levelNode.build( builder, 'float' );
 
-					snippet = builder.getTextureLevel( textureProperty, uvSnippet, levelSnippet );
+					snippet = builder.getTextureLevel( texture, textureProperty, uvSnippet, levelSnippet );
 
 				} else {
 
-					snippet = builder.getTexture( textureProperty, uvSnippet );
+					snippet = builder.getTexture( texture, textureProperty, uvSnippet );
 
 				}
 
+				builder.addLineFlowCode( `${propertyName} = ${snippet}` );
+
 				nodeData.snippet = snippet;
+				nodeData.propertyName = propertyName;
 
 			}
 
-			return builder.format( snippet, 'vec4', output );
+			return builder.format( propertyName, nodeType, output );
 
 		}
 
@@ -98,3 +159,10 @@ class TextureNode extends UniformNode {
 }
 
 export default TextureNode;
+
+export const texture = nodeProxy( TextureNode );
+export const sampler = ( aTexture ) => ( aTexture.isNode === true ? aTexture : texture( aTexture ) ).convert( 'sampler' );
+
+addNodeElement( 'texture', texture );
+
+addNodeClass( TextureNode );