@needle-tools/three 0.146.10 → 0.153.1

package/examples/jsm/nodes/geometry/RangeNode.js

@@ -1,98 +1,89 @@
-import Node from '../core/Node.js';
-import { attribute, float } from '../shadernode/ShaderNodeBaseElements.js';
-import { MathUtils, InstancedBufferAttribute } from 'three';
+import Node, { addNodeClass } from '../core/Node.js';
+import { getValueType } from '../core/NodeUtils.js';
+import { buffer } from '../accessors/BufferNode.js';
+//import { bufferAttribute } from '../accessors/BufferAttributeNode.js';
+import { instanceIndex } from '../core/InstanceIndexNode.js';
+import { nodeProxy, float } from '../shadernode/ShaderNode.js';
+
+import { Vector4, MathUtils } from 'three';
+
+let min = null;
+let max = null;
 
 class RangeNode extends Node {
 
-	constructor( min, max ) {
+	constructor( minNode = float(), maxNode = float() ) {
 
 		super();
 
-		this.min = min;
-		this.max = max;
+		this.minNode = minNode;
+		this.maxNode = maxNode;
 
 	}
 
-	getVectorLength() {
-
-		const min = this.min;
+	getVectorLength( builder ) {
 
-		let length = 1;
+		const minLength = builder.getTypeLength( getValueType( this.minNode.value ) );
+		const maxLength = builder.getTypeLength( getValueType( this.maxNode.value ) );
 
-		if ( min.isVector2 ) length = 2;
-		else if ( min.isVector3 ) length = 3;
-		else if ( min.isVector4 ) length = 4;
-		else if ( min.isColor ) length = 3;
-
-		return length;
+		return minLength > maxLength ? minLength : maxLength;
 
 	}
 
 	getNodeType( builder ) {
 
-		return ( builder.object.isInstancedMesh === true ) ? builder.getTypeFromLength( this.getVectorLength() ) : 'float';
+		return builder.object.isInstancedMesh === true ? builder.getTypeFromLength( this.getVectorLength( builder ) ) : 'float';
 
 	}
 
 	construct( builder ) {
 
-		const { min, max } = this;
-		const { object, geometry } = builder;
+		const object = builder.object;
 
 		let output = null;
 
 		if ( object.isInstancedMesh === true ) {
 
-			const vectorLength = this.getVectorLength();
-			const attributeName = 'node' + this.id;
-
-			const length = vectorLength * object.count;
-			const array = new Float32Array( length );
-
-			const attributeGeometry = geometry.getAttribute( attributeName );
-
-			if ( attributeGeometry === undefined || attributeGeometry.array.length < length ) {
-
-				if ( vectorLength === 1 ) {
+			let minValue = this.minNode.value;
+			let maxValue = this.maxNode.value;
 
-					for ( let i = 0; i < length; i ++ ) {
+			const minLength = builder.getTypeLength( getValueType( minValue ) );
+			const maxLength = builder.getTypeLength( getValueType( maxValue ) );
 
-						array[ i ] = MathUtils.lerp( min, max, Math.random() );
+			min = min || new Vector4();
+			max = max || new Vector4();
 
-					}
+			min.setScalar( 0 );
+			max.setScalar( 0 );
 
-				} else if ( min.isColor ) {
+			if ( minLength === 1 ) min.setScalar( minValue );
+			else if ( minValue.isColor ) min.set( minValue.r, minValue.g, minValue.b );
+			else min.set( minValue.x, minValue.y, minValue.z || 0, minValue.w || 0 );
 
-					for ( let i = 0; i < length; i += 3 ) {
+			if ( maxLength === 1 ) max.setScalar( maxValue );
+			else if ( maxValue.isColor ) max.set( maxValue.r, maxValue.g, maxValue.b );
+			else max.set( maxValue.x, maxValue.y, maxValue.z || 0, maxValue.w || 0 );
 
-						array[ i ] = MathUtils.lerp( min.r, max.r, Math.random() );
-						array[ i + 1 ] = MathUtils.lerp( min.g, max.g, Math.random() );
-						array[ i + 2 ] = MathUtils.lerp( min.b, max.b, Math.random() );
+			const stride = 4;
 
-					}
-
-				} else {
-
-					for ( let i = 0; i < length; i ++ ) {
-
-						const index = i % vectorLength;
-
-						const minValue = min.getComponent( index );
-						const maxValue = max.getComponent( index );
-
-						array[ i ] = MathUtils.lerp( minValue, maxValue, Math.random() );
+			const length = stride * object.count;
+			const array = new Float32Array( length );
 
-					}
+			for ( let i = 0; i < length; i ++ ) {
 
-				}
+				const index = i % stride;
 
-				geometry.setAttribute( attributeName, new InstancedBufferAttribute( array, vectorLength ) );
+				const minElementValue = min.getComponent( index );
+				const maxElementValue = max.getComponent( index );
 
-				geometry.dispose();
+				array[ i ] = MathUtils.lerp( minElementValue, maxElementValue, Math.random() );
 
 			}
 
-			output = attribute( attributeName, builder.getTypeFromLength( vectorLength ) );
+			const nodeType = this.getNodeType( builder );
+
+			output = buffer( array, 'vec4', object.count ).element( instanceIndex ).convert( nodeType );
+			//output = bufferAttribute( array, 'vec4', 4, 0 ).convert( nodeType );
 
 		} else {
 
@@ -107,3 +98,7 @@ class RangeNode extends Node {
 }
 
 export default RangeNode;
+
+export const range = nodeProxy( RangeNode );
+
+addNodeClass( RangeNode );

package/examples/jsm/nodes/gpgpu/ComputeNode.js

@@ -1,5 +1,6 @@
-import Node from '../core/Node.js';
+import Node, { addNodeClass } from '../core/Node.js';
 import { NodeUpdateType } from '../core/constants.js';
+import { addNodeElement, nodeObject } from '../shadernode/ShaderNode.js';
 
 class ComputeNode extends Node {
 
@@ -52,7 +53,7 @@ class ComputeNode extends Node {
 
 			if ( snippet !== '' ) {
 
-				builder.addFlowCode( snippet );
+				builder.addLineFlowCode( snippet );
 
 			}
 
@@ -63,3 +64,9 @@ class ComputeNode extends Node {
 }
 
 export default ComputeNode;
+
+export const compute = ( node, count, workgroupSize ) => nodeObject( new ComputeNode( nodeObject( node ), count, workgroupSize ) );
+
+addNodeElement( 'compute', compute );
+
+addNodeClass( ComputeNode );

package/examples/jsm/nodes/lighting/AONode.js

@@ -1,5 +1,5 @@
 import LightingNode from './LightingNode.js';
-import { float, add, mul, sub } from '../shadernode/ShaderNodeElements.js';
+import { addNodeClass } from '../core/Node.js';
 
 class AONode extends LightingNode {
 
@@ -14,12 +14,14 @@ class AONode extends LightingNode {
 	construct( builder ) {
 
 		const aoIntensity = 1;
-		const aoNode = add( mul( sub( float( this.aoNode ), 1.0 ), aoIntensity ), 1.0 );
+		const aoNode = this.aoNode.sub( 1.0 ).mul( aoIntensity ).add( 1.0 );
 
-		builder.context.ambientOcclusion.mul( aoNode );
+		builder.context.ambientOcclusion.mulAssign( aoNode );
 
 	}
 
 }
 
 export default AONode;
+
+addNodeClass( AONode );

package/examples/jsm/nodes/lighting/AmbientLightNode.js

@@ -0,0 +1,27 @@
+import AnalyticLightNode from './AnalyticLightNode.js';
+import { addLightNode } from './LightsNode.js';
+import { addNodeClass } from '../core/Node.js';
+
+import { AmbientLight } from 'three';
+
+class AmbientLightNode extends AnalyticLightNode {
+
+	constructor( light = null ) {
+
+		super( light );
+
+	}
+
+	construct( { context } ) {
+
+		context.irradiance.addAssign( this.colorNode );
+
+	}
+
+}
+
+export default AmbientLightNode;
+
+addLightNode( AmbientLight, AmbientLightNode );
+
+addNodeClass( AmbientLightNode );

package/examples/jsm/nodes/lighting/AnalyticLightNode.js

@@ -1,8 +1,17 @@
 import LightingNode from './LightingNode.js';
 import { NodeUpdateType } from '../core/constants.js';
-import { uniform } from '../shadernode/ShaderNodeElements.js';
+import { uniform } from '../core/UniformNode.js';
+import { addNodeClass } from '../core/Node.js';
+import { vec3 } from '../shadernode/ShaderNode.js';
+import { reference } from '../accessors/ReferenceNode.js';
+import { texture } from '../accessors/TextureNode.js';
+import { positionWorld } from '../accessors/PositionNode.js';
+//import { step } from '../math/MathNode.js';
+import { cond } from '../math/CondNode.js';
 
-import { Color } from 'three';
+import { Color, DepthTexture, NearestFilter } from 'three';
+
+let depthMaterial = null;
 
 class AnalyticLightNode extends LightingNode {
 
@@ -10,11 +19,15 @@ class AnalyticLightNode extends LightingNode {
 
 		super();
 
-		this.updateType = NodeUpdateType.OBJECT;
+		this.updateType = NodeUpdateType.FRAME;
 
 		this.light = light;
 
-		this.colorNode = uniform( new Color() );
+		this.rtt = null;
+		this.shadowNode = null;
+
+		this.color = new Color();
+		this.colorNode = uniform( this.color );
 
 	}
 
@@ -24,14 +37,110 @@ class AnalyticLightNode extends LightingNode {
 
 	}
 
+	constructShadow( builder ) {
+
+		let shadowNode = this.shadowNode;
+
+		if ( shadowNode === null ) {
+
+			if ( depthMaterial === null ) depthMaterial = builder.createNodeMaterial( 'MeshBasicNodeMaterial' );
+
+			const shadow = this.light.shadow;
+			const rtt = builder.getRenderTarget( shadow.mapSize.width, shadow.mapSize.height );
+
+			const depthTexture = new DepthTexture();
+			depthTexture.minFilter = NearestFilter;
+			depthTexture.magFilter = NearestFilter;
+			depthTexture.image.width = shadow.mapSize.width;
+			depthTexture.image.height = shadow.mapSize.height;
+			//depthTexture.compareFunction = THREE.LessCompare;
+
+			rtt.depthTexture = depthTexture;
+
+			shadow.camera.updateProjectionMatrix();
+
+			//
+
+			const bias = reference( 'bias', 'float', shadow );
+
+			//const diffuseFactor = normalView.dot( objectViewPosition( this.light ).sub( positionView ).normalize().negate() );
+			//bias = mix( bias, 0, diffuseFactor );
+
+			let shadowCoord = uniform( shadow.matrix ).mul( positionWorld );
+			shadowCoord = shadowCoord.xyz.div( shadowCoord.w );
+
+			shadowCoord = vec3(
+				shadowCoord.x,
+				shadowCoord.y.oneMinus(),
+				shadowCoord.z
+			);
+
+			// @TODO: Optimize using WebGPU compare-sampler
+
+			let depth = texture( depthTexture, shadowCoord.xy );
+			depth = depth.mul( .5 ).add( .5 ).add( bias );
+
+			shadowNode = cond( shadowCoord.z.lessThan( depth ).or( shadowCoord.y.lessThan( .000001 ) /*@TODO: find the cause and remove it soon */ ), 1, 0 );
+			//shadowNode = step( shadowCoord.z, depth );
+
+			//
+
+			this.rtt = rtt;
+			this.colorNode = this.colorNode.mul( shadowNode );
+
+			this.shadowNode = shadowNode;
+
+			//
+
+			this.updateBeforeType = NodeUpdateType.RENDER;
+
+		}
+
+	}
+
+	construct( builder ) {
+
+		if ( this.light.castShadow ) this.constructShadow( builder );
+
+	}
+
+	updateShadow( frame ) {
+
+		const { rtt, light } = this;
+		const { renderer, scene } = frame;
+
+		scene.overrideMaterial = depthMaterial;
+
+		rtt.setSize( light.shadow.mapSize.width, light.shadow.mapSize.height );
+
+		light.shadow.updateMatrices( light );
+
+		renderer.setRenderTarget( rtt );
+		renderer.render( scene, light.shadow.camera );
+		renderer.setRenderTarget( null );
+
+		scene.overrideMaterial = null;
+
+	}
+
+	updateBefore( frame ) {
+
+		const { light } = this;
+
+		if ( light.castShadow ) this.updateShadow( frame );
+
+	}
+
 	update( /*frame*/ ) {
 
 		const { light } = this;
 
-		this.colorNode.value.copy( light.color ).multiplyScalar( light.intensity );
+		this.color.copy( light.color ).multiplyScalar( light.intensity );
 
 	}
 
 }
 
 export default AnalyticLightNode;
+
+addNodeClass( AnalyticLightNode );

package/examples/jsm/nodes/lighting/DirectionalLightNode.js

@@ -0,0 +1,43 @@
+import AnalyticLightNode from './AnalyticLightNode.js';
+import { lightTargetDirection } from './LightNode.js';
+import { addLightNode } from './LightsNode.js';
+import { addNodeClass } from '../core/Node.js';
+
+import { DirectionalLight } from 'three';
+
+class DirectionalLightNode extends AnalyticLightNode {
+
+	constructor( light = null ) {
+
+		super( light );
+
+	}
+
+	construct( builder ) {
+
+		super.construct( builder );
+
+		const lightColor = this.colorNode;
+		const lightDirection = lightTargetDirection( this.light );
+		const lightingModelFunctionNode = builder.context.lightingModelNode;
+		const reflectedLight = builder.context.reflectedLight;
+
+		if ( lightingModelFunctionNode && lightingModelFunctionNode.direct ) {
+
+			lightingModelFunctionNode.direct.call( {
+				lightDirection,
+				lightColor,
+				reflectedLight
+			}, builder );
+
+		}
+
+	}
+
+}
+
+export default DirectionalLightNode;
+
+addLightNode( DirectionalLight, DirectionalLightNode );
+
+addNodeClass( DirectionalLightNode );

package/examples/jsm/nodes/lighting/EnvironmentNode.js

@@ -1,19 +1,16 @@
 import LightingNode from './LightingNode.js';
-import ContextNode from '../core/ContextNode.js';
-import MaxMipLevelNode from '../utils/MaxMipLevelNode.js';
-import { ShaderNode, float, add, mul, div, log2, clamp, roughness, reflect, mix, positionViewDirection, negate, normalize, transformedNormalView, transformedNormalWorld, transformDirection, cameraViewMatrix } from '../shadernode/ShaderNodeElements.js';
-
-// taken from here: http://casual-effects.blogspot.ca/2011/08/plausible-environment-lighting-in-two.html
-const getSpecularMIPLevel = new ShaderNode( ( { texture, levelNode } ) => {
-
-	const maxMIPLevelScalar = new MaxMipLevelNode( texture );
-
-	const sigma = div( mul( Math.PI, mul( levelNode, levelNode ) ), add( 1.0, levelNode ) );
-	const desiredMIPLevel = add( maxMIPLevelScalar, log2( sigma ) );
-
-	return clamp( desiredMIPLevel, 0.0, maxMIPLevelScalar );
-
-} );
+import { cache } from '../core/CacheNode.js';
+import { context } from '../core/ContextNode.js';
+import { roughness } from '../core/PropertyNode.js';
+import { equirectUV } from '../utils/EquirectUVNode.js';
+import { specularMIPLevel } from '../utils/SpecularMIPLevelNode.js';
+import { cameraViewMatrix } from '../accessors/CameraNode.js';
+import { transformedNormalView, transformedNormalWorld } from '../accessors/NormalNode.js';
+import { positionViewDirection } from '../accessors/PositionNode.js';
+import { addNodeClass } from '../core/Node.js';
+import { float, vec2 } from '../shadernode/ShaderNode.js';
+import { cubeTexture } from '../accessors/CubeTextureNode.js';
+import { reference } from '../accessors/ReferenceNode.js';
 
 class EnvironmentNode extends LightingNode {
 
@@ -27,36 +24,123 @@ class EnvironmentNode extends LightingNode {
 
 	construct( builder ) {
 
-		const envNode = this.envNode;
+		let envNode = this.envNode;
 		const properties = builder.getNodeProperties( this );
 
-		let reflectVec = reflect( negate( positionViewDirection ), transformedNormalView );
-		reflectVec = normalize( mix( reflectVec, transformedNormalView, mul( roughness, roughness ) ) );
-		reflectVec = transformDirection( reflectVec, cameraViewMatrix );
+		if ( envNode.isTextureNode && envNode.value.isCubeTexture !== true ) {
+
+			const texture = envNode.value;
+			const renderer = builder.renderer;
+
+			// @TODO: Add dispose logic here
+			const cubeRTT = builder.getCubeRenderTarget( 512 ).fromEquirectangularTexture( renderer, texture );
+
+			envNode = cubeTexture( cubeRTT.texture );
+
+		}
+
+		let reflectVec;
+		let radianceTextureUVNode;
+		let irradianceTextureUVNode;
+
+		const radianceContext = context( envNode, {
+			getUVNode: ( textureNode ) => {
+
+				let node = null;
+
+				if ( reflectVec === undefined ) {
+
+					reflectVec = positionViewDirection.negate().reflect( transformedNormalView );
+					reflectVec = roughness.mul( roughness ).mix( reflectVec, transformedNormalView ).normalize();
+					reflectVec = reflectVec.transformDirection( cameraViewMatrix );
+
+				}
+
+				if ( textureNode.isCubeTextureNode ) {
+
+					node = reflectVec;
+
+				} else if ( textureNode.isTextureNode ) {
+
+					if ( radianceTextureUVNode === undefined ) {
+
+						// @TODO: Needed PMREM
+
+						radianceTextureUVNode = equirectUV( reflectVec );
+
+					}
+
+					node = radianceTextureUVNode;
+
+				}
+
+				return node;
 
-		const radianceContext = new ContextNode( envNode, {
-			tempRead: false,
-			uvNode: reflectVec,
-			levelNode: roughness,
-			levelShaderNode: getSpecularMIPLevel
+			},
+			getSamplerLevelNode: () => {
+
+				return roughness;
+
+			},
+			getMIPLevelAlgorithmNode: ( textureNode, levelNode ) => {
+
+				return specularMIPLevel( textureNode, levelNode );
+
+			}
 		} );
 
-		const irradianceContext = new ContextNode( envNode, {
-			tempRead: false,
-			uvNode: transformedNormalWorld,
-			levelNode: float( 1 ),
-			levelShaderNode: getSpecularMIPLevel
+		const irradianceContext = context( envNode, {
+			getUVNode: ( textureNode ) => {
+
+				let node = null;
+
+				if ( textureNode.isCubeTextureNode ) {
+
+					node = transformedNormalWorld;
+
+				} else if ( textureNode.isTextureNode ) {
+
+					if ( irradianceTextureUVNode === undefined ) {
+
+						// @TODO: Needed PMREM
+
+						irradianceTextureUVNode = equirectUV( transformedNormalWorld );
+						irradianceTextureUVNode = vec2( irradianceTextureUVNode.x, irradianceTextureUVNode.y.oneMinus() );
+
+					}
+
+					node = irradianceTextureUVNode;
+
+				}
+
+				return node;
+
+			},
+			getSamplerLevelNode: () => {
+
+				return float( 1 );
+
+			},
+			getMIPLevelAlgorithmNode: ( textureNode, levelNode ) => {
+
+				return specularMIPLevel( textureNode, levelNode );
+
+			}
 		} );
 
-		// it's used to cache the construct only if necessary: See `CubeTextureNode.getConstructReference()`
-		radianceContext.context.environmentContext = radianceContext;
-		irradianceContext.context.environmentContext = irradianceContext;
+		//
+
+		const isolateRadianceFlowContext = cache( radianceContext );
 
-		builder.context.radiance.add( radianceContext );
+		//
 
-		builder.context.iblIrradiance.add( mul( Math.PI, irradianceContext ) );
+		const intensity = reference( 'envMapIntensity', 'float', builder.material );
 
-		properties.radianceContext = radianceContext;
+		builder.context.radiance.addAssign( isolateRadianceFlowContext.mul( intensity ) );
+
+		builder.context.iblIrradiance.addAssign( irradianceContext.mul( Math.PI ).mul( intensity ) );
+
+		properties.radianceContext = isolateRadianceFlowContext;
 		properties.irradianceContext = irradianceContext;
 
 	}
@@ -64,3 +148,5 @@ class EnvironmentNode extends LightingNode {
 }
 
 export default EnvironmentNode;
+
+addNodeClass( EnvironmentNode );

package/examples/jsm/nodes/lighting/HemisphereLightNode.js

@@ -1,7 +1,10 @@
 import AnalyticLightNode from './AnalyticLightNode.js';
-import LightsNode from './LightsNode.js';
-import Object3DNode from '../accessors/Object3DNode.js';
-import { uniform, add, mul, dot, mix, normalize, normalView } from '../shadernode/ShaderNodeElements.js';
+import { addLightNode } from './LightsNode.js';
+import { uniform } from '../core/UniformNode.js';
+import { mix } from '../math/MathNode.js';
+import { normalView } from '../accessors/NormalNode.js';
+import { objectPosition } from '../accessors/Object3DNode.js';
+import { addNodeClass } from '../core/Node.js';
 
 import { Color, HemisphereLight } from 'three';
 
@@ -11,8 +14,8 @@ class HemisphereLightNode extends AnalyticLightNode {
 
 		super( light );
 
-		this.lightPositionNode = new Object3DNode( Object3DNode.POSITION );
-		this.lightDirectionNode = normalize( this.lightPositionNode );
+		this.lightPositionNode = objectPosition( light );
+		this.lightDirectionNode = this.lightPositionNode.normalize();
 
 		this.groundColorNode = uniform( new Color() );
 
@@ -34,17 +37,19 @@ class HemisphereLightNode extends AnalyticLightNode {
 
 		const { colorNode, groundColorNode, lightDirectionNode } = this;
 
-		const dotNL = dot( normalView, lightDirectionNode );
-		const hemiDiffuseWeight = add( mul( 0.5, dotNL ), 0.5 );
+		const dotNL = normalView.dot( lightDirectionNode );
+		const hemiDiffuseWeight = dotNL.mul( 0.5 ).add( 0.5 );
 
 		const irradiance = mix( groundColorNode, colorNode, hemiDiffuseWeight );
 
-		builder.context.irradiance.add( irradiance );
+		builder.context.irradiance.addAssign( irradiance );
 
 	}
 
 }
 
-LightsNode.setReference( HemisphereLight, HemisphereLightNode );
-
 export default HemisphereLightNode;
+
+addLightNode( HemisphereLight, HemisphereLightNode );
+
+addNodeClass( HemisphereLightNode );