@needle-tools/three 0.162.12 → 0.169.2

package/{examples/jsm/nodes/materials → src/materials/nodes}/NodeMaterial.js

@@ -1,30 +1,36 @@
-import { Material, ShaderMaterial, NoColorSpace, LinearSRGBColorSpace } from 'three';
-import { getNodeChildren, getCacheKey } from '../core/NodeUtils.js';
-import { attribute } from '../core/AttributeNode.js';
-import { output, diffuseColor } from '../core/PropertyNode.js';
-import { materialAlphaTest, materialColor, materialOpacity, materialEmissive, materialNormal } from '../accessors/MaterialNode.js';
-import { modelViewProjection } from '../accessors/ModelViewProjectionNode.js';
-import { transformedNormalView } from '../accessors/NormalNode.js';
-import { instance } from '../accessors/InstanceNode.js';
-import { positionLocal, positionView } from '../accessors/PositionNode.js';
-import { skinningReference } from '../accessors/SkinningNode.js';
-import { morphReference } from '../accessors/MorphNode.js';
-import { texture } from '../accessors/TextureNode.js';
-import { cubeTexture } from '../accessors/CubeTextureNode.js';
-import { lightsNode } from '../lighting/LightsNode.js';
-import { mix } from '../math/MathNode.js';
-import { float, vec3, vec4 } from '../shadernode/ShaderNode.js';
-import AONode from '../lighting/AONode.js';
-import { lightingContext } from '../lighting/LightingContextNode.js';
-import EnvironmentNode from '../lighting/EnvironmentNode.js';
-import { depthPixel } from '../display/ViewportDepthNode.js';
-import { cameraLogDepth } from '../accessors/CameraNode.js';
-import { clipping, clippingAlpha } from '../accessors/ClippingNode.js';
-import { faceDirection } from '../display/FrontFacingNode.js';
-
-const NodeMaterials = new Map();
-
-class NodeMaterial extends ShaderMaterial {
+import { Material } from '../Material.js';
+import { NormalBlending } from '../../constants.js';
+
+import { getNodeChildren, getCacheKey } from '../../nodes/core/NodeUtils.js';
+import { attribute } from '../../nodes/core/AttributeNode.js';
+import { output, diffuseColor, emissive, varyingProperty } from '../../nodes/core/PropertyNode.js';
+import { materialAlphaTest, materialColor, materialOpacity, materialEmissive, materialNormal, materialLightMap, materialAOMap } from '../../nodes/accessors/MaterialNode.js';
+import { modelViewProjection } from '../../nodes/accessors/ModelViewProjectionNode.js';
+import { normalLocal } from '../../nodes/accessors/Normal.js';
+import { instance } from '../../nodes/accessors/InstanceNode.js';
+import { batch } from '../../nodes/accessors/BatchNode.js';
+import { materialReference } from '../../nodes/accessors/MaterialReferenceNode.js';
+import { positionLocal } from '../../nodes/accessors/Position.js';
+import { skinningReference } from '../../nodes/accessors/SkinningNode.js';
+import { morphReference } from '../../nodes/accessors/MorphNode.js';
+import { lights } from '../../nodes/lighting/LightsNode.js';
+import { mix } from '../../nodes/math/MathNode.js';
+import { float, vec3, vec4 } from '../../nodes/tsl/TSLBase.js';
+import AONode from '../../nodes/lighting/AONode.js';
+import { lightingContext } from '../../nodes/lighting/LightingContextNode.js';
+import IrradianceNode from '../../nodes/lighting/IrradianceNode.js';
+import { depth } from '../../nodes/display/ViewportDepthNode.js';
+import { cameraLogDepth } from '../../nodes/accessors/Camera.js';
+import { clipping, clippingAlpha } from '../../nodes/accessors/ClippingNode.js';
+import NodeMaterialObserver from './manager/NodeMaterialObserver.js';
+
+class NodeMaterial extends Material {
+
+	static get type() {
+
+		return 'NodeMaterial';
+
+	}
 
 	constructor() {
 
@@ -37,13 +43,11 @@ class NodeMaterial extends ShaderMaterial {
 		this.forceSinglePass = false;
 
 		this.fog = true;
-		this.lights = true;
-		this.normals = true;
-
-		this.colorSpaced = true;
+		this.lights = false;
 
 		this.lightsNode = null;
 		this.envNode = null;
+		this.aoNode = null;
 
 		this.colorNode = null;
 		this.normalNode = null;
@@ -56,8 +60,10 @@ class NodeMaterial extends ShaderMaterial {
 
 		this.depthNode = null;
 		this.shadowNode = null;
+		this.shadowPositionNode = null;
 
 		this.outputNode = null;
+		this.mrtNode = null;
 
 		this.fragmentNode = null;
 		this.vertexNode = null;
@@ -76,8 +82,16 @@ class NodeMaterial extends ShaderMaterial {
 
 	}
 
+	setupObserver( builder ) {
+
+		return new NodeMaterialObserver( builder );
+
+	}
+
 	setup( builder ) {
 
+		builder.context.setupNormal = () => this.setupNormal( builder );
+
 		// < VERTEX STAGE >
 
 		builder.addStack();
@@ -94,11 +108,9 @@ class NodeMaterial extends ShaderMaterial {
 
 		const clippingNode = this.setupClipping( builder );
 
-		if ( this.fragmentNode === null ) {
-
-			if ( this.depthWrite === true ) this.setupDepth( builder );
+		if ( this.depthWrite === true ) this.setupDepth( builder );
 
-			if ( this.normals === true ) this.setupNormal( builder );
+		if ( this.fragmentNode === null ) {
 
 			this.setupDiffuseColor( builder );
 			this.setupVariants( builder );
@@ -107,7 +119,11 @@ class NodeMaterial extends ShaderMaterial {
 
 			if ( clippingNode !== null ) builder.stack.add( clippingNode );
 
-			resultNode = this.setupOutput( builder, vec4( outgoingLightNode, diffuseColor.a ) );
+			// force unsigned floats - useful for RenderTargets
+
+			const basicOutput = vec4( outgoingLightNode, diffuseColor.a ).max( 0 );
+
+			resultNode = this.setupOutput( builder, basicOutput );
 
 			// OUTPUT NODE
 
@@ -117,9 +133,44 @@ class NodeMaterial extends ShaderMaterial {
 
 			if ( this.outputNode !== null ) resultNode = this.outputNode;
 
+			// MRT
+
+			const renderTarget = builder.renderer.getRenderTarget();
+
+			if ( renderTarget !== null ) {
+
+				const mrt = builder.renderer.getMRT();
+				const materialMRT = this.mrtNode;
+
+				if ( mrt !== null ) {
+
+					resultNode = mrt;
+
+					if ( materialMRT !== null ) {
+
+						resultNode = mrt.merge( materialMRT );
+
+					}
+
+				} else if ( materialMRT !== null ) {
+
+					resultNode = materialMRT;
+
+				}
+
+			}
+
 		} else {
 
-			resultNode = this.setupOutput( builder, this.fragmentNode );
+			let fragmentNode = this.fragmentNode;
+
+			if ( fragmentNode.isOutputStructNode !== true ) {
+
+				fragmentNode = vec4( fragmentNode );
+
+			}
+
+			resultNode = this.setupOutput( builder, fragmentNode );
 
 		}
 
@@ -127,17 +178,25 @@ class NodeMaterial extends ShaderMaterial {
 
 		builder.addFlow( 'fragment', builder.removeStack() );
 
+		// < MONITOR >
+
+		builder.monitor = this.setupObserver( builder );
+
 	}
 
 	setupClipping( builder ) {
 
+		if ( builder.clippingContext === null ) return null;
+
 		const { globalClippingCount, localClippingCount } = builder.clippingContext;
 
 		let result = null;
 
 		if ( globalClippingCount || localClippingCount ) {
 
-			if ( this.alphaToCoverage ) {
+			const samples = builder.renderer.samples;
+
+			if ( this.alphaToCoverage && samples > 1 ) {
 
 				// to be added to flow when the color/alpha value has been determined
 				result = clippingAlpha();
@@ -162,17 +221,27 @@ class NodeMaterial extends ShaderMaterial {
 
 		let depthNode = this.depthNode;
 
-		if ( depthNode === null && renderer.logarithmicDepthBuffer === true ) {
+		if ( depthNode === null ) {
+
+			const mrt = 'getMRT' in renderer && renderer.getMRT();
 
-			const fragDepth = modelViewProjection().w.add( 1 );
+			if ( mrt && mrt.has( 'depth' ) ) {
 
-			depthNode = fragDepth.log2().mul( cameraLogDepth ).mul( 0.5 );
+				depthNode = mrt.get( 'depth' );
+
+			} else if ( renderer.logarithmicDepthBuffer === true ) {
+
+				const fragDepth = modelViewProjection().w.add( 1 );
+
+				depthNode = fragDepth.log2().mul( cameraLogDepth ).mul( 0.5 );
+
+			}
 
 		}
 
 		if ( depthNode !== null ) {
 
-			depthPixel.assign( depthNode ).append();
+			depth.assign( depthNode ).append();
 
 		}
 
@@ -199,7 +268,23 @@ class NodeMaterial extends ShaderMaterial {
 
 		}
 
-		if ( ( object.instanceMatrix && object.instanceMatrix.isInstancedBufferAttribute === true ) && builder.isAvailable( 'instance' ) === true ) {
+		if ( this.displacementMap ) {
+
+			const displacementMap = materialReference( 'displacementMap', 'texture' );
+			const displacementScale = materialReference( 'displacementScale', 'float' );
+			const displacementBias = materialReference( 'displacementBias', 'float' );
+
+			positionLocal.addAssign( normalLocal.normalize().mul( ( displacementMap.x.mul( displacementScale ).add( displacementBias ) ) ) );
+
+		}
+
+		if ( object.isBatchedMesh ) {
+
+			batch( object ).append();
+
+		}
+
+		if ( ( object.instanceMatrix && object.instanceMatrix.isInstancedBufferAttribute === true ) ) {
 
 			instance( object ).append();
 
@@ -220,7 +305,7 @@ class NodeMaterial extends ShaderMaterial {
 
 	}
 
-	setupDiffuseColor( { geometry } ) {
+	setupDiffuseColor( { object, geometry } ) {
 
 		let colorNode = this.colorNode ? vec4( this.colorNode ) : materialColor;
 
@@ -232,6 +317,25 @@ class NodeMaterial extends ShaderMaterial {
 
 		}
 
+		// Instanced colors
+
+		if ( object.instanceColor ) {
+
+			const instanceColor = varyingProperty( 'vec3', 'vInstanceColor' );
+
+			colorNode = instanceColor.mul( colorNode );
+
+		}
+
+		if ( object.isBatchedMesh && object._colorsTexture ) {
+
+			const batchColor = varyingProperty( 'vec3', 'vBatchColor' );
+
+			colorNode = batchColor.mul( colorNode );
+
+		}
+
+
 		// COLOR
 
 		diffuseColor.assign( colorNode );
@@ -251,35 +355,33 @@ class NodeMaterial extends ShaderMaterial {
 
 		}
 
-	}
+		if ( this.transparent === false && this.blending === NormalBlending && this.alphaToCoverage === false ) {
 
-	setupVariants( /*builder*/ ) {
+			diffuseColor.a.assign( 1.0 );
 
-		// Interface function.
+		}
 
 	}
 
-	setupNormal() {
-
-		// NORMAL VIEW
+	setupVariants( /*builder*/ ) {
 
-		if ( this.flatShading === true ) {
+		// Interface function.
 
-			const normalNode = positionView.dFdx().cross( positionView.dFdy() ).normalize();
+	}
 
-			transformedNormalView.assign( normalNode.mul( faceDirection ) );
+	setupOutgoingLight() {
 
-		} else {
+		return ( this.lights === true ) ? vec3( 0 ) : diffuseColor.rgb;
 
-			const normalNode = this.normalNode ? vec3( this.normalNode ) : materialNormal;
+	}
 
-			transformedNormalView.assign( normalNode.mul( faceDirection ) );
+	setupNormal() {
 
-		}
+		return this.normalNode ? vec3( this.normalNode ) : materialNormal;
 
 	}
 
-	getEnvNode( builder ) {
+	setupEnvironment( /*builder*/ ) {
 
 		let node = null;
 
@@ -289,11 +391,21 @@ class NodeMaterial extends ShaderMaterial {
 
 		} else if ( this.envMap ) {
 
-			node = this.envMap.isCubeTexture ? cubeTexture( this.envMap ) : texture( this.envMap );
+			node = this.envMap.isCubeTexture ? materialReference( 'envMap', 'cubeTexture' ) : materialReference( 'envMap', 'texture' );
+
+		}
+
+		return node;
 
-		} else if ( builder.environmentNode ) {
+	}
 
-			node = builder.environmentNode;
+	setupLightMap( builder ) {
+
+		let node = null;
+
+		if ( builder.material.lightMap ) {
+
+			node = new IrradianceNode( materialLightMap );
 
 		}
 
@@ -303,21 +415,31 @@ class NodeMaterial extends ShaderMaterial {
 
 	setupLights( builder ) {
 
-		const envNode = this.getEnvNode( builder );
+		const materialLightsNode = [];
 
 		//
 
-		const materialLightsNode = [];
+		const envNode = this.setupEnvironment( builder );
 
-		if ( envNode ) {
+		if ( envNode && envNode.isLightingNode ) {
 
-			materialLightsNode.push( new EnvironmentNode( envNode ) );
+			materialLightsNode.push( envNode );
 
 		}
 
-		if ( builder.material.aoMap ) {
+		const lightMapNode = this.setupLightMap( builder );
+
+		if ( lightMapNode && lightMapNode.isLightingNode ) {
 
-			materialLightsNode.push( new AONode( texture( builder.material.aoMap ) ) );
+			materialLightsNode.push( lightMapNode );
+
+		}
+
+		if ( this.aoNode !== null || builder.material.aoMap ) {
+
+			const aoNode = this.aoNode !== null ? this.aoNode : materialAOMap;
+
+			materialLightsNode.push( new AONode( aoNode ) );
 
 		}
 
@@ -325,7 +447,7 @@ class NodeMaterial extends ShaderMaterial {
 
 		if ( materialLightsNode.length > 0 ) {
 
-			lightsN = lightsNode( [ ...lightsN.lightNodes, ...materialLightsNode ] );
+			lightsN = lights( [ ...lightsN.getLights(), ...materialLightsNode ] );
 
 		}
 
@@ -350,9 +472,9 @@ class NodeMaterial extends ShaderMaterial {
 
 		const lightsNode = lights ? this.setupLights( builder ) : null;
 
-		let outgoingLightNode = diffuseColor.rgb;
+		let outgoingLightNode = this.setupOutgoingLight( builder );
 
-		if ( lightsNode && lightsNode.hasLight !== false ) {
+		if ( lightsNode && lightsNode.getScope().getLights().length > 0 ) {
 
 			const lightingModel = this.setupLightingModel( builder );
 
@@ -368,7 +490,9 @@ class NodeMaterial extends ShaderMaterial {
 
 		if ( ( emissiveNode && emissiveNode.isNode === true ) || ( material.emissive && material.emissive.isColor === true ) ) {
 
-			outgoingLightNode = outgoingLightNode.add( vec3( emissiveNode ? emissiveNode : materialEmissive ) );
+			emissive.assign( vec3( emissiveNode ? emissiveNode : materialEmissive ) );
+
+			outgoingLightNode = outgoingLightNode.add( emissive );
 
 		}
 
@@ -378,39 +502,13 @@ class NodeMaterial extends ShaderMaterial {
 
 	setupOutput( builder, outputNode ) {
 
-		const renderer = builder.renderer;
-
-		// TONE MAPPING
-
-		const toneMappingNode = builder.toneMappingNode;
-
-		if ( this.toneMapped === true && toneMappingNode ) {
-
-			outputNode = vec4( toneMappingNode.context( { color: outputNode.rgb } ), outputNode.a );
-
-		}
-
 		// FOG
 
 		if ( this.fog === true ) {
 
 			const fogNode = builder.fogNode;
 
-			if ( fogNode ) outputNode = vec4( fogNode.mixAssign( outputNode.rgb ), outputNode.a );
-
-		}
-
-		// ENCODING
-
-		if ( this.colorSpaced === true ) {
-
-			const outputColorSpace = renderer.currentColorSpace;
-
-			if ( outputColorSpace !== LinearSRGBColorSpace && outputColorSpace !== NoColorSpace ) {
-
-				outputNode = outputNode.linearToColorSpace( outputColorSpace );
-
-			}
+			if ( fogNode ) outputNode = vec4( fogNode.mix( outputNode.rgb, fogNode.colorNode ), outputNode.a );
 
 		}
 
@@ -437,8 +535,6 @@ class NodeMaterial extends ShaderMaterial {
 
 		}
 
-		Object.assign( this.defines, material.defines );
-
 		const descriptors = Object.getOwnPropertyDescriptors( material.constructor.prototype );
 
 		for ( const key in descriptors ) {
@@ -529,8 +625,10 @@ class NodeMaterial extends ShaderMaterial {
 
 		this.depthNode = source.depthNode;
 		this.shadowNode = source.shadowNode;
+		this.shadowPositionNode = source.shadowPositionNode;
 
 		this.outputNode = source.outputNode;
+		this.mrtNode = source.mrtNode;
 
 		this.fragmentNode = source.fragmentNode;
 		this.vertexNode = source.vertexNode;
@@ -539,63 +637,6 @@ class NodeMaterial extends ShaderMaterial {
 
 	}
 
-	static fromMaterial( material ) {
-
-		if ( material.isNodeMaterial === true ) { // is already a node material
-
-			return material;
-
-		}
-
-		const type = material.type.replace( 'Material', 'NodeMaterial' );
-
-		const nodeMaterial = createNodeMaterialFromType( type );
-
-		if ( nodeMaterial === undefined ) {
-
-			throw new Error( `NodeMaterial: Material "${ material.type }" is not compatible.` );
-
-		}
-
-		for ( const key in material ) {
-
-			nodeMaterial[ key ] = material[ key ];
-
-		}
-
-		return nodeMaterial;
-
-	}
-
 }
 
 export default NodeMaterial;
-
-export function addNodeMaterial( type, nodeMaterial ) {
-
-	if ( typeof nodeMaterial !== 'function' || ! type ) throw new Error( `Node material ${ type } is not a class` );
-	if ( NodeMaterials.has( type ) ) {
-
-		console.warn( `Redefinition of node material ${ type }` );
-		return;
-
-	}
-
-	NodeMaterials.set( type, nodeMaterial );
-	nodeMaterial.type = type;
-
-}
-
-export function createNodeMaterialFromType( type ) {
-
-	const Material = NodeMaterials.get( type );
-
-	if ( Material !== undefined ) {
-
-		return new Material();
-
-	}
-
-}
-
-addNodeMaterial( 'NodeMaterial', NodeMaterial );

package/{examples/jsm/nodes/materials/Materials.js → src/materials/nodes/NodeMaterials.js}

@@ -1,6 +1,8 @@
 // @TODO: We can simplify "export { default as SomeNode, other, exports } from '...'" to just "export * from '...'" if we will use only named exports
 
-export { default as NodeMaterial, addNodeMaterial, createNodeMaterialFromType } from './NodeMaterial.js';
+export { default as NodeMaterialObserver } from './manager/NodeMaterialObserver.js';
+
+export { default as NodeMaterial } from './NodeMaterial.js';
 export { default as InstancedPointsNodeMaterial } from './InstancedPointsNodeMaterial.js';
 export { default as LineBasicNodeMaterial } from './LineBasicNodeMaterial.js';
 export { default as LineDashedNodeMaterial } from './LineDashedNodeMaterial.js';
@@ -12,5 +14,9 @@ export { default as MeshPhongNodeMaterial } from './MeshPhongNodeMaterial.js';
 export { default as MeshStandardNodeMaterial } from './MeshStandardNodeMaterial.js';
 export { default as MeshPhysicalNodeMaterial } from './MeshPhysicalNodeMaterial.js';
 export { default as MeshSSSNodeMaterial } from './MeshSSSNodeMaterial.js';
+export { default as MeshToonNodeMaterial } from './MeshToonNodeMaterial.js';
+export { default as MeshMatcapNodeMaterial } from './MeshMatcapNodeMaterial.js';
 export { default as PointsNodeMaterial } from './PointsNodeMaterial.js';
 export { default as SpriteNodeMaterial } from './SpriteNodeMaterial.js';
+export { default as ShadowNodeMaterial } from './ShadowNodeMaterial.js';
+export { default as VolumeNodeMaterial } from './VolumeNodeMaterial.js';

package/{examples/jsm/nodes/materials → src/materials/nodes}/PointsNodeMaterial.js

@@ -1,11 +1,17 @@
-import NodeMaterial, { addNodeMaterial } from './NodeMaterial.js';
+import NodeMaterial from './NodeMaterial.js';
 
-import { PointsMaterial } from 'three';
+import { PointsMaterial } from '../PointsMaterial.js';
 
-const defaultValues = new PointsMaterial();
+const _defaultValues = /*@__PURE__*/ new PointsMaterial();
 
 class PointsNodeMaterial extends NodeMaterial {
 
+	static get type() {
+
+		return 'PointsNodeMaterial';
+
+	}
+
 	constructor( parameters ) {
 
 		super();
@@ -13,12 +19,11 @@ class PointsNodeMaterial extends NodeMaterial {
 		this.isPointsNodeMaterial = true;
 
 		this.lights = false;
-		this.normals = false;
 		this.transparent = true;
 
 		this.sizeNode = null;
 
-		this.setDefaultValues( defaultValues );
+		this.setDefaultValues( _defaultValues );
 
 		this.setValues( parameters );
 
@@ -35,5 +40,3 @@ class PointsNodeMaterial extends NodeMaterial {
 }
 
 export default PointsNodeMaterial;
-
-addNodeMaterial( 'PointsNodeMaterial', PointsNodeMaterial );

package/src/materials/nodes/ShadowNodeMaterial.js

@@ -0,0 +1,38 @@
+import NodeMaterial from './NodeMaterial.js';
+import ShadowMaskModel from '../../nodes/functions/ShadowMaskModel.js';
+
+import { ShadowMaterial } from '../ShadowMaterial.js';
+
+const _defaultValues = /*@__PURE__*/ new ShadowMaterial();
+
+class ShadowNodeMaterial extends NodeMaterial {
+
+	static get type() {
+
+		return 'ShadowNodeMaterial';
+
+	}
+
+	constructor( parameters ) {
+
+		super();
+
+		this.isShadowNodeMaterial = true;
+
+		this.lights = true;
+
+		this.setDefaultValues( _defaultValues );
+
+		this.setValues( parameters );
+
+	}
+
+	setupLightingModel( /*builder*/ ) {
+
+		return new ShadowMaskModel();
+
+	}
+
+}
+
+export default ShadowNodeMaterial;