@needle-tools/three 0.153.1 → 0.154.1

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

@@ -1,11 +1,11 @@
 import LightingNode from './LightingNode.js';
 import { cache } from '../core/CacheNode.js';
 import { context } from '../core/ContextNode.js';
-import { roughness } from '../core/PropertyNode.js';
+import { roughness, clearcoatRoughness } 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 { transformedClearcoatNormalView, 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';
@@ -39,113 +39,142 @@ class EnvironmentNode extends LightingNode {
 
 		}
 
-		let reflectVec;
-		let radianceTextureUVNode;
-		let irradianceTextureUVNode;
+		//
 
-		const radianceContext = context( envNode, {
-			getUVNode: ( textureNode ) => {
+		const intensity = reference( 'envMapIntensity', 'float', builder.material ); // @TODO: Add materialEnvIntensity in MaterialNode
 
-				let node = null;
+		const radiance = context( envNode, createRadianceContext( roughness, transformedNormalView ) ).mul( intensity );
+		const irradiance = context( envNode, createIrradianceContext( transformedNormalWorld ) ).mul( Math.PI ).mul( intensity );
 
-				if ( reflectVec === undefined ) {
+		const isolateRadiance = cache( radiance );
 
-					reflectVec = positionViewDirection.negate().reflect( transformedNormalView );
-					reflectVec = roughness.mul( roughness ).mix( reflectVec, transformedNormalView ).normalize();
-					reflectVec = reflectVec.transformDirection( cameraViewMatrix );
+		//
 
-				}
+		builder.context.radiance.addAssign( isolateRadiance );
 
-				if ( textureNode.isCubeTextureNode ) {
+		builder.context.iblIrradiance.addAssign( irradiance );
 
-					node = reflectVec;
+		//
 
-				} else if ( textureNode.isTextureNode ) {
+		let isolateClearcoatRadiance = null;
 
-					if ( radianceTextureUVNode === undefined ) {
+		if ( builder.context.clearcoatRadiance  ) {
 
-						// @TODO: Needed PMREM
+			const clearcoatRadiance = context( envNode, createRadianceContext( clearcoatRoughness, transformedClearcoatNormalView ) ).mul( intensity );
 
-						radianceTextureUVNode = equirectUV( reflectVec );
+			isolateClearcoatRadiance = cache( clearcoatRadiance );
 
-					}
+			builder.context.clearcoatRadiance.addAssign( isolateClearcoatRadiance );
 
-					node = radianceTextureUVNode;
+		}
 
-				}
+		//
 
-				return node;
+		properties.radiance = isolateRadiance;
+		properties.clearcoatRadiance = isolateClearcoatRadiance;
+		properties.irradiance = irradiance;
 
-			},
-			getSamplerLevelNode: () => {
+	}
 
-				return roughness;
+}
 
-			},
-			getMIPLevelAlgorithmNode: ( textureNode, levelNode ) => {
+const createRadianceContext = ( roughnessNode, normalViewNode ) => {
 
-				return specularMIPLevel( textureNode, levelNode );
+	let reflectVec = null;
+	let textureUVNode = null;
 
-			}
-		} );
+	return {
+		getUVNode: ( textureNode ) => {
 
-		const irradianceContext = context( envNode, {
-			getUVNode: ( textureNode ) => {
+			let node = null;
 
-				let node = null;
+			if ( reflectVec === null ) {
 
-				if ( textureNode.isCubeTextureNode ) {
+				reflectVec = positionViewDirection.negate().reflect( normalViewNode );
+				reflectVec = roughnessNode.mul( roughnessNode ).mix( reflectVec, normalViewNode ).normalize();
+				reflectVec = reflectVec.transformDirection( cameraViewMatrix );
 
-					node = transformedNormalWorld;
+			}
 
-				} else if ( textureNode.isTextureNode ) {
+			if ( textureNode.isCubeTextureNode ) {
 
-					if ( irradianceTextureUVNode === undefined ) {
+				node = reflectVec;
 
-						// @TODO: Needed PMREM
+			} else if ( textureNode.isTextureNode ) {
 
-						irradianceTextureUVNode = equirectUV( transformedNormalWorld );
-						irradianceTextureUVNode = vec2( irradianceTextureUVNode.x, irradianceTextureUVNode.y.oneMinus() );
+				if ( textureUVNode === null ) {
 
-					}
+					// @TODO: Needed PMREM
 
-					node = irradianceTextureUVNode;
+					textureUVNode = equirectUV( reflectVec );
 
 				}
 
-				return node;
+				node = textureUVNode;
 
-			},
-			getSamplerLevelNode: () => {
+			}
 
-				return float( 1 );
+			return node;
 
-			},
-			getMIPLevelAlgorithmNode: ( textureNode, levelNode ) => {
+		},
+		getSamplerLevelNode: () => {
 
-				return specularMIPLevel( textureNode, levelNode );
+			return roughnessNode;
 
-			}
-		} );
+		},
+		getMIPLevelAlgorithmNode: ( textureNode, levelNode ) => {
 
-		//
+			return specularMIPLevel( textureNode, levelNode );
 
-		const isolateRadianceFlowContext = cache( radianceContext );
+		}
+	};
 
-		//
+};
 
-		const intensity = reference( 'envMapIntensity', 'float', builder.material );
+const createIrradianceContext = ( normalWorldNode ) => {
 
-		builder.context.radiance.addAssign( isolateRadianceFlowContext.mul( intensity ) );
+	let textureUVNode = null;
 
-		builder.context.iblIrradiance.addAssign( irradianceContext.mul( Math.PI ).mul( intensity ) );
+	return {
+		getUVNode: ( textureNode ) => {
 
-		properties.radianceContext = isolateRadianceFlowContext;
-		properties.irradianceContext = irradianceContext;
+			let node = null;
 
-	}
+			if ( textureNode.isCubeTextureNode ) {
 
-}
+				node = normalWorldNode;
+
+			} else if ( textureNode.isTextureNode ) {
+
+				if ( textureUVNode === null ) {
+
+					// @TODO: Needed PMREM
+
+					textureUVNode = equirectUV( normalWorldNode );
+					textureUVNode = vec2( textureUVNode.x, textureUVNode.y.oneMinus() );
+
+				}
+
+				node = textureUVNode;
+
+			}
+
+			return node;
+
+		},
+		getSamplerLevelNode: () => {
+
+			return float( 1 );
+
+		},
+		getMIPLevelAlgorithmNode: ( textureNode, levelNode ) => {
+
+			return specularMIPLevel( textureNode, levelNode );
+
+		}
+	};
+
+};
 
 export default EnvironmentNode;
 

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

@@ -1,6 +1,6 @@
-import { ShaderNode } from '../shadernode/ShaderNode.js';
+import { tslFn } from '../shadernode/ShaderNode.js';
 
-export const getDistanceAttenuation = new ShaderNode( ( inputs ) => {
+export const getDistanceAttenuation = tslFn( ( inputs ) => {
 
 	const { lightDistance, cutoffDistance, decayExponent } = inputs;
 

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

@@ -1,5 +1,4 @@
 import ContextNode from '../core/ContextNode.js';
-import { temp } from '../core/VarNode.js';
 import { add } from '../math/OperatorNode.js';
 import { mix } from '../math/MathNode.js';
 import { addNodeClass } from '../core/Node.js';
@@ -30,10 +29,10 @@ class LightingContextNode extends ContextNode {
 		const context = this.context = {}; // reset context
 		const properties = builder.getNodeProperties( this );
 
-		const directDiffuse = temp( vec3() ),
-			directSpecular = temp( vec3() ),
-			indirectDiffuse = temp( vec3() ),
-			indirectSpecular = temp( vec3() );
+		const directDiffuse = vec3().temp(),
+			directSpecular = vec3().temp(),
+			indirectDiffuse = vec3().temp(),
+			indirectSpecular = vec3().temp();
 
 		let totalDiffuse = add( directDiffuse, indirectDiffuse );
 
@@ -44,7 +43,7 @@ class LightingContextNode extends ContextNode {
 		}
 
 		const totalSpecular = add( directSpecular, indirectSpecular );
-		const total = add( totalDiffuse, totalSpecular );
+		const total = add( totalDiffuse, totalSpecular ).temp();
 
 		const reflectedLight = {
 			directDiffuse,
@@ -55,21 +54,24 @@ class LightingContextNode extends ContextNode {
 		};
 
 		const lighting = {
-			radiance: temp( vec3() ),
-			irradiance: temp( vec3() ),
-			iblIrradiance: temp( vec3() ),
-			ambientOcclusion: temp( float( 1 ) )
+			radiance: vec3().temp(),
+			irradiance: vec3().temp(),
+			iblIrradiance: vec3().temp(),
+			ambientOcclusion: float( 1 ).temp()
 		};
 
+		context.reflectedLight = reflectedLight;
+		context.lightingModelNode = lightingModelNode || context.lightingModelNode;
+
 		Object.assign( properties, reflectedLight, lighting );
 		Object.assign( context, lighting );
 
-		context.reflectedLight = reflectedLight;
-		context.lightingModelNode = lightingModelNode || context.lightingModelNode;
+		// @TODO: Call needed return a new node ( or rename the ShaderNodeInternal.call() function ), it's not moment to run
+		if ( lightingModelNode && lightingModelNode.init ) lightingModelNode.init( context, builder.stack, builder );
 
-		if ( lightingModelNode && lightingModelNode.indirectDiffuse ) lightingModelNode.indirectDiffuse.call( context );
-		if ( lightingModelNode && lightingModelNode.indirectSpecular ) lightingModelNode.indirectSpecular.call( context );
-		if ( lightingModelNode && lightingModelNode.ambientOcclusion ) lightingModelNode.ambientOcclusion.call( context );
+		if ( lightingModelNode && lightingModelNode.indirectDiffuse ) lightingModelNode.indirectDiffuse( context, builder.stack, builder );
+		if ( lightingModelNode && lightingModelNode.indirectSpecular ) lightingModelNode.indirectSpecular( context, builder.stack, builder );
+		if ( lightingModelNode && lightingModelNode.ambientOcclusion ) lightingModelNode.ambientOcclusion( context, builder.stack, builder );
 
 		return super.construct( builder );
 

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

@@ -39,7 +39,7 @@ class PointLightNode extends AnalyticLightNode {
 		const lightDirection = lVector.normalize();
 		const lightDistance = lVector.length();
 
-		const lightAttenuation = getDistanceAttenuation.call( {
+		const lightAttenuation = getDistanceAttenuation( {
 			lightDistance,
 			cutoffDistance: cutoffDistanceNode,
 			decayExponent: decayExponentNode
@@ -52,11 +52,11 @@ class PointLightNode extends AnalyticLightNode {
 
 		if ( lightingModelFunctionNode && lightingModelFunctionNode.direct ) {
 
-			lightingModelFunctionNode.direct.call( {
+			lightingModelFunctionNode.direct( {
 				lightDirection,
 				lightColor,
 				reflectedLight
-			}, builder );
+			} );
 
 		}
 

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

@@ -60,7 +60,7 @@ class SpotLightNode extends AnalyticLightNode {
 
 		const lightDistance = lVector.length();
 
-		const lightAttenuation = getDistanceAttenuation.call( {
+		const lightAttenuation = getDistanceAttenuation( {
 			lightDistance,
 			cutoffDistance: cutoffDistanceNode,
 			decayExponent: decayExponentNode
@@ -73,11 +73,11 @@ class SpotLightNode extends AnalyticLightNode {
 
 		if ( lightingModelFunctionNode && lightingModelFunctionNode.direct ) {
 
-			lightingModelFunctionNode.direct.call( {
+			lightingModelFunctionNode.direct( {
 				lightDirection,
 				lightColor,
 				reflectedLight
-			}, builder );
+			} );
 
 		}
 

package/examples/jsm/nodes/materials/LineBasicNodeMaterial.js

@@ -21,21 +21,6 @@ class LineBasicNodeMaterial extends NodeMaterial {
 
 	}
 
-	copy( source ) {
-
-		this.colorNode = source.colorNode;
-		this.opacityNode = source.opacityNode;
-
-		this.alphaTestNode = source.alphaTestNode;
-
-		this.lightNode = source.lightNode;
-
-		this.positionNode = source.positionNode;
-
-		return super.copy( source );
-
-	}
-
 }
 
 export default LineBasicNodeMaterial;

package/examples/jsm/nodes/materials/MeshBasicNodeMaterial.js

@@ -20,21 +20,6 @@ class MeshBasicNodeMaterial extends NodeMaterial {
 
 	}
 
-	copy( source ) {
-
-		this.colorNode = source.colorNode;
-		this.opacityNode = source.opacityNode;
-
-		this.alphaTestNode = source.alphaTestNode;
-
-		this.lightNode = source.lightNode;
-
-		this.positionNode = source.positionNode;
-
-		return super.copy( source );
-
-	}
-
 }
 
 export default MeshBasicNodeMaterial;

package/examples/jsm/nodes/materials/MeshNormalNodeMaterial.js

@@ -31,16 +31,6 @@ class MeshNormalNodeMaterial extends NodeMaterial {
 
 	}
 
-	copy( source ) {
-
-		this.opacityNode = source.opacityNode;
-
-		this.positionNode = source.positionNode;
-
-		return super.copy( source );
-
-	}
-
 }
 
 export default MeshNormalNodeMaterial;

package/examples/jsm/nodes/materials/MeshPhongNodeMaterial.js

@@ -51,18 +51,9 @@ class MeshPhongNodeMaterial extends NodeMaterial {
 
 	copy( source ) {
 
-		this.colorNode = source.colorNode;
-		this.opacityNode = source.opacityNode;
-
-		this.alphaTestNode = source.alphaTestNode;
-
 		this.shininessNode = source.shininessNode;
 		this.specularNode = source.specularNode;
 
-		this.lightNode = source.lightNode;
-
-		this.positionNode = source.positionNode;
-
 		return super.copy( source );
 
 	}

package/examples/jsm/nodes/materials/MeshPhysicalNodeMaterial.js

@@ -1,4 +1,9 @@
 import { addNodeMaterial } from './NodeMaterial.js';
+import { transformedClearcoatNormalView } from '../accessors/NormalNode.js';
+import { clearcoat, clearcoatRoughness, sheen, sheenRoughness } from '../core/PropertyNode.js';
+import { materialClearcoatNormal } from '../accessors/ExtendedMaterialNode.js';
+import { materialClearcoat, materialClearcoatRoughness, materialSheen, materialSheenRoughness } from '../accessors/MaterialNode.js';
+import { float, vec3 } from '../shadernode/ShaderNode.js';
 import MeshStandardNodeMaterial from './MeshStandardNodeMaterial.js';
 
 import { MeshPhysicalMaterial } from 'three';
@@ -38,6 +43,42 @@ class MeshPhysicalNodeMaterial extends MeshStandardNodeMaterial {
 
 	}
 
+	constructVariants( builder ) {
+
+		super.constructVariants( builder );
+
+		const { stack } = builder;
+
+		// CLEARCOAT
+
+		const clearcoatNode = this.clearcoatNode ? float( this.clearcoatNode ) : materialClearcoat;
+		const clearcoatRoughnessNode = this.clearcoatRoughnessNode ? float( this.clearcoatRoughnessNode ) : materialClearcoatRoughness;
+
+		stack.assign( clearcoat, clearcoatNode );
+		stack.assign( clearcoatRoughness, clearcoatRoughnessNode );
+
+		// SHEEN
+
+		const sheenNode = this.sheenNode ? vec3( this.sheenNode ) : materialSheen;
+		const sheenRoughnessNode = this.sheenRoughnessNode ? float( this.sheenRoughnessNode ) : materialSheenRoughness;
+
+		stack.assign( sheen, sheenNode );
+		stack.assign( sheenRoughness, sheenRoughnessNode );
+
+	}
+
+	constructNormal( builder ) {
+
+		super.constructNormal( builder );
+
+		// CLEARCOAT NORMAL
+
+		const clearcoatNormalNode = this.clearcoatNormalNode ? vec3( this.clearcoatNormalNode ) : materialClearcoatNormal;
+
+		builder.stack.assign( transformedClearcoatNormalView, clearcoatNormalNode );
+
+	}
+
 	copy( source ) {
 
 		this.clearcoatNode = source.clearcoatNode;

package/examples/jsm/nodes/materials/MeshStandardNodeMaterial.js

@@ -46,7 +46,7 @@ class MeshStandardNodeMaterial extends NodeMaterial {
 		// ROUGHNESS
 
 		let roughnessNode = this.roughnessNode ? float( this.roughnessNode ) : materialRoughness;
-		roughnessNode = getRoughness.call( { roughness: roughnessNode } );
+		roughnessNode = getRoughness( { roughness: roughnessNode } );
 
 		stack.assign( roughness, roughnessNode );
 
@@ -64,24 +64,11 @@ class MeshStandardNodeMaterial extends NodeMaterial {
 
 	copy( source ) {
 
-		this.colorNode = source.colorNode;
-		this.opacityNode = source.opacityNode;
-
-		this.alphaTestNode = source.alphaTestNode;
-
-		this.normalNode = source.normalNode;
-
 		this.emissiveNode = source.emissiveNode;
 
 		this.metalnessNode = source.metalnessNode;
 		this.roughnessNode = source.roughnessNode;
 
-		this.envNode = source.envNode;
-
-		this.lightsNode = source.lightsNode;
-
-		this.positionNode = source.positionNode;
-
 		return super.copy( source );
 
 	}