super-three 0.137.0 → 0.141.0

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

@@ -1,236 +1,67 @@
-import { TempNode } from '../core/TempNode.js';
-import { FunctionNode } from '../core/FunctionNode.js';
-import { FloatNode } from '../inputs/FloatNode.js';
-import { PositionNode } from '../accessors/PositionNode.js';
+import Object3DNode from './Object3DNode.js';
 
-class CameraNode extends TempNode {
+class CameraNode extends Object3DNode {
 
-	constructor( scope, camera ) {
+	static PROJECTION_MATRIX = 'projectionMatrix';
 
-		super( 'v3' );
+	constructor( scope = CameraNode.POSITION ) {
 
-		this.setScope( scope || CameraNode.POSITION );
-		this.setCamera( camera );
+		super( scope );
 
 	}
 
-	setCamera( camera ) {
+	getNodeType( builder ) {
 
-		this.camera = camera;
-		this.updateFrame = camera !== undefined ? this.onUpdateFrame : undefined;
+		const scope = this.scope;
 
-	}
-
-	setScope( scope ) {
-
-		switch ( this.scope ) {
-
-			case CameraNode.DEPTH:
-
-				delete this.near;
-				delete this.far;
-
-				break;
-
-		}
-
-		this.scope = scope;
-
-		switch ( scope ) {
-
-			case CameraNode.DEPTH:
-
-				const camera = this.camera;
-
-				this.near = new FloatNode( camera ? camera.near : 1 );
-				this.far = new FloatNode( camera ? camera.far : 1200 );
-
-				break;
-
-		}
-
-	}
-
-	getType( /* builder */ ) {
-
-		switch ( this.scope ) {
-
-			case CameraNode.DEPTH:
-
-				return 'f';
-
-		}
-
-		return this.type;
-
-	}
-
-	getUnique( /* builder */ ) {
-
-		switch ( this.scope ) {
-
-			case CameraNode.DEPTH:
-			case CameraNode.TO_VERTEX:
-
-				return true;
-
-		}
-
-		return false;
-
-	}
-
-	getShared( /* builder */ ) {
-
-		switch ( this.scope ) {
-
-			case CameraNode.POSITION:
-
-				return false;
-
-		}
-
-		return true;
-
-	}
+		if ( scope === CameraNode.PROJECTION_MATRIX ) {
 
-	generate( builder, output ) {
-
-		let result;
-
-		switch ( this.scope ) {
-
-			case CameraNode.POSITION:
-
-				result = 'cameraPosition';
-
-				break;
-
-			case CameraNode.DEPTH:
-
-				const depthColor = builder.include( CameraNode.Nodes.depthColor );
-
-				result = depthColor + '( ' + this.near.build( builder, 'f' ) + ', ' + this.far.build( builder, 'f' ) + ' )';
-
-				break;
-
-			case CameraNode.TO_VERTEX:
-
-				result = 'normalize( ' + new PositionNode( PositionNode.WORLD ).build( builder, 'v3' ) + ' - cameraPosition )';
-
-				break;
+			return 'mat4';
 
 		}
 
-		return builder.format( result, this.getType( builder ), output );
+		return super.getNodeType( builder );
 
 	}
 
-	onUpdateFrame( /* frame */ ) {
+	update( frame ) {
 
-		switch ( this.scope ) {
+		const camera = frame.camera;
+		const uniformNode = this._uniformNode;
+		const scope = this.scope;
 
-			case CameraNode.DEPTH:
+		if ( scope === CameraNode.PROJECTION_MATRIX ) {
 
-				const camera = this.camera;
+			uniformNode.value = camera.projectionMatrix;
 
-				this.near.value = camera.near;
-				this.far.value = camera.far;
+		} else if ( scope === CameraNode.VIEW_MATRIX ) {
 
-				break;
+			uniformNode.value = camera.matrixWorldInverse;
 
-		}
-
-	}
-
-	copy( source ) {
-
-		super.copy( source );
-
-		this.setScope( source.scope );
+		} else {
 
-		if ( source.camera ) {
+			this.object3d = camera;
 
-			this.setCamera( source.camera );
+			super.update( frame );
 
 		}
 
-		switch ( source.scope ) {
-
-			case CameraNode.DEPTH:
-
-				this.near.number = source.near;
-				this.far.number = source.far;
-
-				break;
-
-		}
-
-		return this;
-
 	}
 
-	toJSON( meta ) {
-
-		let data = this.getJSONNode( meta );
-
-		if ( ! data ) {
-
-			data = this.createJSONNode( meta );
-
-			data.scope = this.scope;
+	generate( builder ) {
 
-			if ( this.camera ) data.camera = this.camera.uuid;
+		const scope = this.scope;
 
-			switch ( this.scope ) {
+		if ( scope === CameraNode.PROJECTION_MATRIX ) {
 
-				case CameraNode.DEPTH:
-
-					data.near = this.near.value;
-					data.far = this.far.value;
-
-					break;
-
-			}
+			this._uniformNode.nodeType = 'mat4';
 
 		}
 
-		return data;
+		return super.generate( builder );
 
 	}
 
 }
 
-CameraNode.Nodes = ( function () {
-
-	const depthColor = new FunctionNode( /* glsl */`
-		float depthColor( float mNear, float mFar ) {
-
-			#ifdef USE_LOGDEPTHBUF_EXT
-
-				float depth = gl_FragDepthEXT / gl_FragCoord.w;
-
-			#else
-
-				float depth = gl_FragCoord.z / gl_FragCoord.w;
-
-			#endif
-
-			return 1.0 - smoothstep( mNear, mFar, depth );
-
-		}`
-	 );
-
-	return {
-		depthColor: depthColor
-	};
-
-} )();
-
-CameraNode.POSITION = 'position';
-CameraNode.DEPTH = 'depth';
-CameraNode.TO_VERTEX = 'toVertex';
-
-CameraNode.prototype.nodeType = 'Camera';
-
-export { CameraNode };
+export default CameraNode;

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

@@ -0,0 +1,103 @@
+import TextureNode from './TextureNode.js';
+import UniformNode from '../core/UniformNode.js';
+import ReflectNode from './ReflectNode.js';
+
+class CubeTextureNode extends TextureNode {
+
+	constructor( value, uvNode = null, levelNode = null ) {
+
+		super( value, uvNode, levelNode );
+
+		this.isCubeTextureNode = true;
+
+	}
+
+	getInputType( /*builder*/ ) {
+
+		return 'cubeTexture';
+
+	}
+
+	getConstructHash( builder ) {
+
+		return `${ this.uuid }-${ builder.context.environmentContext?.uuid || '' }`;
+
+	}
+
+	construct( builder ) {
+
+		const properties = builder.getNodeProperties( this );
+
+		const uvNode = this.uvNode || builder.context.uvNode || new ReflectNode();
+		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;
+
+	}
+
+	generate( builder, output ) {
+
+		const { uvNode, levelNode } = builder.getNodeProperties( this );
+
+		const texture = this.value;
+
+		if ( ! texture || texture.isCubeTexture !== true ) {
+
+			throw new Error( 'CubeTextureNode: Need a three.js cube texture.' );
+
+		}
+
+		const textureProperty = UniformNode.prototype.generate.call( this, builder, 'cubeTexture' );
+
+		if ( output === 'sampler' ) {
+
+			return textureProperty + '_sampler';
+
+		} else if ( builder.isReference( output ) ) {
+
+			return textureProperty;
+
+		} else {
+
+			const nodeData = builder.getDataFromNode( this );
+
+			let snippet = nodeData.snippet;
+
+			if ( builder.context.tempRead === false || snippet === undefined ) {
+
+				const uvSnippet = uvNode.build( builder, 'vec3' );
+
+				if ( levelNode ) {
+
+					const levelSnippet = levelNode.build( builder, 'float' );
+
+					snippet = builder.getCubeTextureLevel( textureProperty, uvSnippet, levelSnippet );
+
+				} else {
+
+					snippet = builder.getCubeTexture( textureProperty, uvSnippet );
+
+				}
+
+				nodeData.snippet = snippet;
+
+			}
+
+			return builder.format( snippet, 'vec4', output );
+
+		}
+
+	}
+
+}
+
+export default CubeTextureNode;

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

@@ -0,0 +1,58 @@
+import Node from '../core/Node.js';
+import {
+	vec3,
+	mat3,
+	mul,
+	assign,
+	buffer,
+	element,
+	dot,
+	div,
+	temp,
+	instanceIndex,
+	positionLocal,
+	normalLocal
+} from '../shadernode/ShaderNodeBaseElements.js';
+
+class InstanceNode extends Node {
+
+	constructor( instanceMesh ) {
+
+		super( 'void' );
+
+		this.instanceMesh = instanceMesh;
+
+		//
+
+		const instanceBufferNode = buffer( instanceMesh.instanceMatrix.array, 'mat4', instanceMesh.count );
+
+		this.instanceMatrixNode = temp( element( instanceBufferNode, instanceIndex ) ); // @TODO: a possible caching issue here?
+
+	}
+
+	generate( builder ) {
+
+		const { instanceMatrixNode } = this;
+
+		// POSITION
+
+		const instancePosition = mul( instanceMatrixNode, 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 instanceNormal = mul( m, transformedNormal ).xyz;
+
+		// ASSIGNS
+
+		assign( positionLocal, instancePosition ).build( builder );
+		assign( normalLocal, instanceNormal ).build( builder );
+
+	}
+
+}
+
+export default InstanceNode;

package/examples/jsm/{renderers/nodes → nodes}/accessors/MaterialNode.js

@@ -1,15 +1,18 @@
 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';
 
 class MaterialNode extends Node {
 
 	static ALPHA_TEST = 'alphaTest';
 	static COLOR = 'color';
 	static OPACITY = 'opacity';
-	static SPECULAR = 'specular';
 	static ROUGHNESS = 'roughness';
 	static METALNESS = 'metalness';
+	static EMISSIVE = 'emissive';
+	static ROTATION = 'rotation';
 
 	constructor( scope = MaterialNode.COLOR ) {
 
@@ -28,11 +31,11 @@ class MaterialNode extends Node {
 
 			return material.map !== null ? 'vec4' : 'vec3';
 
-		} else if ( scope === MaterialNode.OPACITY ) {
+		} else if ( scope === MaterialNode.OPACITY || scope === MaterialNode.ROTATION ) {
 
 			return 'float';
 
-		} else if ( scope === MaterialNode.SPECULAR ) {
+		} else if ( scope === MaterialNode.EMISSIVE ) {
 
 			return 'vec3';
 
@@ -59,9 +62,12 @@ class MaterialNode extends Node {
 
 			const colorNode = new MaterialReferenceNode( 'color', 'color' );
 
-			if ( material.map !== null && material.map !== undefined && material.map.isTexture === true ) {
+			if ( material.map?.isTexture === true ) {
+
+				//new MaterialReferenceNode( 'map', 'texture' )
+				const map = new TextureNode( material.map );
 
-				node = new OperatorNode( '*', colorNode, new MaterialReferenceNode( 'map', 'texture' ) );
+				node = new OperatorNode( '*', colorNode, map );
 
 			} else {
 
@@ -73,7 +79,7 @@ class MaterialNode extends Node {
 
 			const opacityNode = new MaterialReferenceNode( 'opacity', 'float' );
 
-			if ( material.alphaMap !== null && material.alphaMap !== undefined && material.alphaMap.isTexture === true ) {
+			if ( material.alphaMap?.isTexture === true ) {
 
 				node = new OperatorNode( '*', opacityNode, new MaterialReferenceNode( 'alphaMap', 'texture' ) );
 
@@ -83,20 +89,52 @@ class MaterialNode extends Node {
 
 			}
 
-		} else if ( scope === MaterialNode.SPECULAR ) {
+		} else if ( scope === MaterialNode.ROUGHNESS ) {
+
+			const roughnessNode = new MaterialReferenceNode( 'roughness', 'float' );
+
+			if ( material.roughnessMap?.isTexture === true ) {
+
+				node = new OperatorNode( '*', roughnessNode, new SplitNode( new TextureNode( material.roughnessMap ), 'g' ) );
+
+			} else {
+
+				node = roughnessNode;
+
+			}
+
+		} else if ( scope === MaterialNode.METALNESS ) {
 
-			const specularColorNode = new MaterialReferenceNode( 'specularColor', 'color' );
+			const metalnessNode = new MaterialReferenceNode( 'metalness', 'float' );
 
-			if ( material.specularColorMap !== null && material.specularColorMap !== undefined && material.specularColorMap.isTexture === true ) {
+			if ( material.metalnessMap?.isTexture === true ) {
 
-				node = new OperatorNode( '*', specularColorNode, new MaterialReferenceNode( 'specularColorMap', 'texture' ) );
+				node = new OperatorNode( '*', metalnessNode, new SplitNode( new TextureNode( material.metalnessMap ), 'b' ) );
 
 			} else {
 
-				node = specularColorNode;
+				node = metalnessNode;
 
 			}
 
+		} else if ( scope === MaterialNode.EMISSIVE ) {
+
+			const emissiveNode = new MaterialReferenceNode( 'emissive', 'color' );
+
+			if ( material.emissiveMap?.isTexture === true ) {
+
+				node = new OperatorNode( '*', emissiveNode, new TextureNode( material.emissiveMap ) );
+
+			} else {
+
+				node = emissiveNode;
+
+			}
+
+		} else if ( scope === MaterialNode.ROTATION ) {
+
+			node = new MaterialReferenceNode( 'rotation', 'float' );
+
 		} else {
 
 			const outputType = this.getNodeType( builder );

package/examples/jsm/{renderers/nodes → nodes}/accessors/ModelNode.js

@@ -8,6 +8,14 @@ class ModelNode extends Object3DNode {
 
 	}
 
+	update( frame ) {
+
+		this.object3d = frame.object;
+
+		super.update( frame );
+
+	}
+
 }
 
 export default ModelNode;