@needle-tools/three 0.162.12 → 0.169.2

package/src/renderers/common/nodes/NodeBuilderState.js

@@ -0,0 +1,58 @@
+import BindGroup from '../BindGroup.js';
+
+class NodeBuilderState {
+
+	constructor( vertexShader, fragmentShader, computeShader, nodeAttributes, bindings, updateNodes, updateBeforeNodes, updateAfterNodes, monitor, transforms = [] ) {
+
+		this.vertexShader = vertexShader;
+		this.fragmentShader = fragmentShader;
+		this.computeShader = computeShader;
+		this.transforms = transforms;
+
+		this.nodeAttributes = nodeAttributes;
+		this.bindings = bindings;
+
+		this.updateNodes = updateNodes;
+		this.updateBeforeNodes = updateBeforeNodes;
+		this.updateAfterNodes = updateAfterNodes;
+
+		this.monitor = monitor;
+
+		this.usedTimes = 0;
+
+	}
+
+	createBindings() {
+
+		const bindings = [];
+
+		for ( const instanceGroup of this.bindings ) {
+
+			const shared = instanceGroup.bindings[ 0 ].groupNode.shared;
+
+			if ( shared !== true ) {
+
+				const bindingsGroup = new BindGroup( instanceGroup.name, [], instanceGroup.index, instanceGroup );
+				bindings.push( bindingsGroup );
+
+				for ( const instanceBinding of instanceGroup.bindings ) {
+
+					bindingsGroup.bindings.push( instanceBinding.clone() );
+
+				}
+
+			} else {
+
+				bindings.push( instanceGroup );
+
+			}
+
+		}
+
+		return bindings;
+
+	}
+
+}
+
+export default NodeBuilderState;

package/src/renderers/common/nodes/NodeLibrary.js

@@ -0,0 +1,118 @@
+class NodeLibrary {
+
+	constructor() {
+
+		this.lightNodes = new WeakMap();
+		this.materialNodes = new Map();
+		this.toneMappingNodes = new Map();
+		this.colorSpaceNodes = new Map();
+
+	}
+
+	fromMaterial( material ) {
+
+		if ( material.isNodeMaterial ) return material;
+
+		let nodeMaterial = null;
+
+		const nodeMaterialClass = this.getMaterialNodeClass( material.type );
+
+		if ( nodeMaterialClass !== null ) {
+
+			nodeMaterial = new nodeMaterialClass();
+
+			for ( const key in material ) {
+
+				nodeMaterial[ key ] = material[ key ];
+
+			}
+
+		}
+
+		return nodeMaterial;
+
+	}
+
+	addColorSpace( colorSpaceNode, colorSpace ) {
+
+		this.addType( colorSpaceNode, colorSpace, this.colorSpaceNodes );
+
+	}
+
+	getColorSpaceFunction( colorSpace ) {
+
+		return this.colorSpaceNodes.get( colorSpace ) || null;
+
+	}
+
+	addToneMapping( toneMappingNode, toneMapping ) {
+
+		this.addType( toneMappingNode, toneMapping, this.toneMappingNodes );
+
+	}
+
+	getToneMappingFunction( toneMapping ) {
+
+		return this.toneMappingNodes.get( toneMapping ) || null;
+
+	}
+
+	getMaterialNodeClass( materialType ) {
+
+		return this.materialNodes.get( materialType ) || null;
+
+	}
+
+	addMaterial( materialNodeClass, materialClass ) {
+
+		this.addType( materialNodeClass, materialClass.name, this.materialNodes );
+
+	}
+
+	getLightNodeClass( light ) {
+
+		return this.lightNodes.get( light ) || null;
+
+	}
+
+	addLight( lightNodeClass, lightClass ) {
+
+		this.addClass( lightNodeClass, lightClass, this.lightNodes );
+
+	}
+
+	addType( nodeClass, type, library ) {
+
+		if ( library.has( type ) ) {
+
+			console.warn( `Redefinition of node ${ type }` );
+			return;
+
+		}
+
+		if ( typeof nodeClass !== 'function' ) throw new Error( `Node class ${ nodeClass.name } is not a class.` );
+		if ( typeof type === 'function' || typeof type === 'object' ) throw new Error( `Base class ${ type } is not a class.` );
+
+		library.set( type, nodeClass );
+
+	}
+
+	addClass( nodeClass, baseClass, library ) {
+
+		if ( library.has( baseClass ) ) {
+
+			console.warn( `Redefinition of node ${ baseClass.name }` );
+			return;
+
+		}
+
+		if ( typeof nodeClass !== 'function' ) throw new Error( `Node class ${ nodeClass.name } is not a class.` );
+		if ( typeof baseClass !== 'function' ) throw new Error( `Base class ${ baseClass.name } is not a class.` );
+
+		library.set( baseClass, nodeClass );
+
+	}
+
+}
+
+export default NodeLibrary;

package/src/renderers/common/nodes/NodeSampledTexture.js

@@ -0,0 +1,64 @@
+import { SampledTexture } from '../SampledTexture.js';
+
+class NodeSampledTexture extends SampledTexture {
+
+	constructor( name, textureNode, groupNode, access = null ) {
+
+		super( name, textureNode ? textureNode.value : null );
+
+		this.textureNode = textureNode;
+		this.groupNode = groupNode;
+
+		this.access = access;
+
+	}
+
+	needsBindingsUpdate( generation ) {
+
+		return this.textureNode.value !== this.texture || super.needsBindingsUpdate( generation );
+
+	}
+
+	update() {
+
+		const { textureNode } = this;
+
+		if ( this.texture !== textureNode.value ) {
+
+			this.texture = textureNode.value;
+
+			return true;
+
+		}
+
+		return super.update();
+
+	}
+
+}
+
+class NodeSampledCubeTexture extends NodeSampledTexture {
+
+	constructor( name, textureNode, groupNode, access ) {
+
+		super( name, textureNode, groupNode, access );
+
+		this.isSampledCubeTexture = true;
+
+	}
+
+}
+
+class NodeSampledTexture3D extends NodeSampledTexture {
+
+	constructor( name, textureNode, groupNode, access ) {
+
+		super( name, textureNode, groupNode, access );
+
+		this.isSampledTexture3D = true;
+
+	}
+
+}
+
+export { NodeSampledTexture, NodeSampledCubeTexture, NodeSampledTexture3D };

package/{examples/jsm → src}/renderers/common/nodes/NodeSampler.js

@@ -2,11 +2,18 @@ import Sampler from '../Sampler.js';
 
 class NodeSampler extends Sampler {
 
-	constructor( name, textureNode ) {
+	constructor( name, textureNode, groupNode ) {
 
 		super( name, textureNode ? textureNode.value : null );
 
 		this.textureNode = textureNode;
+		this.groupNode = groupNode;
+
+	}
+
+	update() {
+
+		this.texture = this.textureNode.value;
 
 	}
 

package/{examples/jsm → src}/renderers/common/nodes/NodeStorageBuffer.js

@@ -1,14 +1,18 @@
 import StorageBuffer from '../StorageBuffer.js';
+import { GPUBufferBindingType } from '../../webgpu/utils/WebGPUConstants.js';
 
 let _id = 0;
 
 class NodeStorageBuffer extends StorageBuffer {
 
-	constructor( nodeUniform ) {
+	constructor( nodeUniform, groupNode ) {
 
 		super( 'StorageBuffer_' + _id ++, nodeUniform ? nodeUniform.value : null );
 
 		this.nodeUniform = nodeUniform;
+		this.access = nodeUniform ? nodeUniform.access : GPUBufferBindingType.Storage;
+		this.groupNode = groupNode;
+
 
 	}
 

package/{examples/jsm → src}/renderers/common/nodes/NodeUniform.js

@@ -1,9 +1,9 @@
 import {
-	FloatUniform, Vector2Uniform, Vector3Uniform, Vector4Uniform,
+	NumberUniform, Vector2Uniform, Vector3Uniform, Vector4Uniform,
 	ColorUniform, Matrix3Uniform, Matrix4Uniform
 } from '../Uniform.js';
 
-class FloatNodeUniform extends FloatUniform {
+class NumberNodeUniform extends NumberUniform {
 
 	constructor( nodeUniform ) {
 
@@ -130,6 +130,6 @@ class Matrix4NodeUniform extends Matrix4Uniform {
 }
 
 export {
-	FloatNodeUniform, Vector2NodeUniform, Vector3NodeUniform, Vector4NodeUniform,
+	NumberNodeUniform, Vector2NodeUniform, Vector3NodeUniform, Vector4NodeUniform,
 	ColorNodeUniform, Matrix3NodeUniform, Matrix4NodeUniform
 };

package/{examples/jsm → src}/renderers/common/nodes/NodeUniformBuffer.js

@@ -4,11 +4,12 @@ let _id = 0;
 
 class NodeUniformBuffer extends UniformBuffer {
 
-	constructor( nodeUniform ) {
+	constructor( nodeUniform, groupNode ) {
 
 		super( 'UniformBuffer_' + _id ++, nodeUniform ? nodeUniform.value : null );
 
 		this.nodeUniform = nodeUniform;
+		this.groupNode = groupNode;
 
 	}
 

package/{examples/jsm → src}/renderers/common/nodes/NodeUniformsGroup.js

@@ -1,6 +1,6 @@
 import UniformsGroup from '../UniformsGroup.js';
 
-let id = 0;
+let _id = 0;
 
 class NodeUniformsGroup extends UniformsGroup {
 
@@ -8,19 +8,13 @@ class NodeUniformsGroup extends UniformsGroup {
 
 		super( name );
 
-		this.id = id ++;
+		this.id = _id ++;
 		this.groupNode = groupNode;
 
 		this.isNodeUniformsGroup = true;
 
 	}
 
-	get shared() {
-
-		return this.groupNode.shared;
-
-	}
-
 	getNodes() {
 
 		const nodes = [];

package/{examples/jsm → src}/renderers/common/nodes/Nodes.js

@@ -1,8 +1,14 @@
 import DataMap from '../DataMap.js';
 import ChainMap from '../ChainMap.js';
 import NodeBuilderState from './NodeBuilderState.js';
-import { NoToneMapping, EquirectangularReflectionMapping, EquirectangularRefractionMapping } from 'three';
-import { NodeFrame, objectGroup, renderGroup, frameGroup, cubeTexture, texture, rangeFog, densityFog, reference, toneMapping, equirectUV, viewportBottomLeft, normalWorld } from '../../../nodes/Nodes.js';
+import { cubeMapNode } from '../../../nodes/utils/CubeMapNode.js';
+import { NodeFrame } from '../../../nodes/Nodes.js';
+import { objectGroup, renderGroup, frameGroup, cubeTexture, texture, rangeFog, densityFog, reference, normalWorld, pmremTexture, screenUV } from '../../../nodes/TSL.js';
+
+import { CubeUVReflectionMapping, EquirectangularReflectionMapping, EquirectangularRefractionMapping } from '../../../constants.js';
+import { hashArray } from '../../../nodes/core/NodeUtils.js';
+
+const outputNodeMap = new WeakMap();
 
 class Nodes extends DataMap {
 
@@ -107,13 +113,14 @@ class Nodes extends DataMap {
 
 			if ( nodeBuilderState === undefined ) {
 
-				const nodeBuilder = this.backend.createNodeBuilder( renderObject.object, this.renderer, renderObject.scene );
+				const nodeBuilder = this.backend.createNodeBuilder( renderObject.object, this.renderer );
+				nodeBuilder.scene = renderObject.scene;
 				nodeBuilder.material = renderObject.material;
+				nodeBuilder.camera = renderObject.camera;
 				nodeBuilder.context.material = renderObject.material;
 				nodeBuilder.lightsNode = renderObject.lightsNode;
 				nodeBuilder.environmentNode = this.getEnvironmentNode( renderObject.scene );
 				nodeBuilder.fogNode = this.getFogNode( renderObject.scene );
-				nodeBuilder.toneMappingNode = this.getToneMappingNode();
 				nodeBuilder.clippingContext = renderObject.clippingContext;
 				nodeBuilder.build();
 
@@ -183,6 +190,8 @@ class Nodes extends DataMap {
 			nodeBuilder.getBindings(),
 			nodeBuilder.updateNodes,
 			nodeBuilder.updateBeforeNodes,
+			nodeBuilder.updateAfterNodes,
+			nodeBuilder.monitor,
 			nodeBuilder.transforms
 		);
 
@@ -206,14 +215,6 @@ class Nodes extends DataMap {
 
 	}
 
-	getToneMappingNode() {
-
-		if ( this.isToneMappingState === false ) return null;
-
-		return this.renderer.toneMappingNode || this.get( this.renderer ).toneMappingNode || null;
-
-	}
-
 	getCacheKey( scene, lightsNode ) {
 
 		const chain = [ scene, lightsNode ];
@@ -225,18 +226,18 @@ class Nodes extends DataMap {
 
 			const environmentNode = this.getEnvironmentNode( scene );
 			const fogNode = this.getFogNode( scene );
-			const toneMappingNode = this.getToneMappingNode();
 
-			const cacheKey = [];
+			const values = [];
+
+			if ( lightsNode ) values.push( lightsNode.getCacheKey( true ) );
+			if ( environmentNode ) values.push( environmentNode.getCacheKey() );
+			if ( fogNode ) values.push( fogNode.getCacheKey() );
 
-			if ( lightsNode ) cacheKey.push( lightsNode.getCacheKey() );
-			if ( environmentNode ) cacheKey.push( environmentNode.getCacheKey() );
-			if ( fogNode ) cacheKey.push( fogNode.getCacheKey() );
-			if ( toneMappingNode ) cacheKey.push( toneMappingNode.getCacheKey() );
+			values.push( this.renderer.shadowMap.enabled ? 1 : 0 );
 
 			cacheKeyData = {
 				callId,
-				cacheKey: cacheKey.join( ',' )
+				cacheKey: hashArray( values )
 			};
 
 			this.callHashCache.set( chain, cacheKeyData );
@@ -252,45 +253,12 @@ class Nodes extends DataMap {
 		this.updateEnvironment( scene );
 		this.updateFog( scene );
 		this.updateBackground( scene );
-		this.updateToneMapping();
 
 	}
 
 	get isToneMappingState() {
 
-		const renderer = this.renderer;
-		const renderTarget = renderer.getRenderTarget();
-
-		return renderTarget && renderTarget.isCubeRenderTarget ? false : true;
-
-	}
-
-	updateToneMapping() {
-
-		const renderer = this.renderer;
-		const rendererData = this.get( renderer );
-		const rendererToneMapping = renderer.toneMapping;
-
-		if ( this.isToneMappingState && rendererToneMapping !== NoToneMapping ) {
-
-			if ( rendererData.toneMapping !== rendererToneMapping ) {
-
-				const rendererToneMappingNode = rendererData.rendererToneMappingNode || toneMapping( rendererToneMapping, reference( 'toneMappingExposure', 'float', renderer ) );
-				rendererToneMappingNode.toneMapping = rendererToneMapping;
-
-				rendererData.rendererToneMappingNode = rendererToneMappingNode;
-				rendererData.toneMappingNode = rendererToneMappingNode;
-				rendererData.toneMapping = rendererToneMapping;
-
-			}
-
-		} else {
-
-			// Don't delete rendererData.rendererToneMappingNode
-			delete rendererData.toneMappingNode;
-			delete rendererData.toneMapping;
-
-		}
+		return this.renderer.getRenderTarget() ? false : true;
 
 	}
 
@@ -301,30 +269,39 @@ class Nodes extends DataMap {
 
 		if ( background ) {
 
-			if ( sceneData.background !== background ) {
+			const forceUpdate = ( scene.backgroundBlurriness === 0 && sceneData.backgroundBlurriness > 0 ) || ( scene.backgroundBlurriness > 0 && sceneData.backgroundBlurriness === 0 );
+
+			if ( sceneData.background !== background || forceUpdate ) {
 
 				let backgroundNode = null;
 
-				if ( background.isCubeTexture === true ) {
+				if ( background.isCubeTexture === true || ( background.mapping === EquirectangularReflectionMapping || background.mapping === EquirectangularRefractionMapping || background.mapping === CubeUVReflectionMapping ) ) {
 
-					backgroundNode = cubeTexture( background, normalWorld );
+					if ( scene.backgroundBlurriness > 0 || background.mapping === CubeUVReflectionMapping ) {
 
-				} else if ( background.isTexture === true ) {
+						backgroundNode = pmremTexture( background, normalWorld );
 
-					let nodeUV = null;
+					} else {
 
-					if ( background.mapping === EquirectangularReflectionMapping || background.mapping === EquirectangularRefractionMapping ) {
+						let envMap;
 
-						nodeUV = equirectUV();
-						background.flipY = false;
+						if ( background.isCubeTexture === true ) {
 
-					} else {
+							envMap = cubeTexture( background );
+
+						} else {
+
+							envMap = texture( background );
+
+						}
 
-						nodeUV = viewportBottomLeft;
+						backgroundNode = cubeMapNode( envMap );
 
 					}
 
-					backgroundNode = texture( background, nodeUV ).setUpdateMatrix( true );
+				} else if ( background.isTexture === true ) {
+
+					backgroundNode = texture( background, screenUV.flipY() ).setUpdateMatrix( true );
 
 				} else if ( background.isColor !== true ) {
 
@@ -334,6 +311,7 @@ class Nodes extends DataMap {
 
 				sceneData.backgroundNode = backgroundNode;
 				sceneData.background = background;
+				sceneData.backgroundBlurriness = scene.backgroundBlurriness;
 
 			}
 
@@ -359,11 +337,18 @@ class Nodes extends DataMap {
 
 				if ( fog.isFogExp2 ) {
 
-					fogNode = densityFog( reference( 'color', 'color', fog ), reference( 'density', 'float', fog ) );
+					const color = reference( 'color', 'color', fog ).setGroup( renderGroup );
+					const density = reference( 'density', 'float', fog ).setGroup( renderGroup );
+
+					fogNode = densityFog( color, density );
 
 				} else if ( fog.isFog ) {
 
-					fogNode = rangeFog( reference( 'color', 'color', fog ), reference( 'near', 'float', fog ), reference( 'far', 'float', fog ) );
+					const color = reference( 'color', 'color', fog ).setGroup( renderGroup );
+					const near = reference( 'near', 'float', fog ).setGroup( renderGroup );
+					const far = reference( 'far', 'float', fog ).setGroup( renderGroup );
+
+					fogNode = rangeFog( color, near, far );
 
 				} else {
 
@@ -443,14 +428,58 @@ class Nodes extends DataMap {
 
 	}
 
+	getOutputCacheKey() {
+
+		const renderer = this.renderer;
+
+		return renderer.toneMapping + ',' + renderer.currentColorSpace;
+
+	}
+
+	hasOutputChange( outputTarget ) {
+
+		const cacheKey = outputNodeMap.get( outputTarget );
+
+		return cacheKey !== this.getOutputCacheKey();
+
+	}
+
+	getOutputNode( outputTexture ) {
+
+		const renderer = this.renderer;
+		const cacheKey = this.getOutputCacheKey();
+
+		const output = texture( outputTexture, screenUV ).renderOutput( renderer.toneMapping, renderer.currentColorSpace );
+
+		outputNodeMap.set( outputTexture, cacheKey );
+
+		return output;
+
+	}
+
 	updateBefore( renderObject ) {
 
-		const nodeFrame = this.getNodeFrameForRender( renderObject );
 		const nodeBuilder = renderObject.getNodeBuilderState();
 
 		for ( const node of nodeBuilder.updateBeforeNodes ) {
 
-			nodeFrame.updateBeforeNode( node );
+			// update frame state for each node
+
+			this.getNodeFrameForRender( renderObject ).updateBeforeNode( node );
+
+		}
+
+	}
+
+	updateAfter( renderObject ) {
+
+		const nodeBuilder = renderObject.getNodeBuilderState();
+
+		for ( const node of nodeBuilder.updateAfterNodes ) {
+
+			// update frame state for each node
+
+			this.getNodeFrameForRender( renderObject ).updateAfterNode( node );
 
 		}
 
@@ -482,6 +511,15 @@ class Nodes extends DataMap {
 
 	}
 
+	needsRefresh( renderObject ) {
+
+		const nodeFrame = this.getNodeFrameForRender( renderObject );
+		const monitor = renderObject.getMonitor();
+
+		return monitor.needsRefresh( renderObject, nodeFrame );
+
+	}
+
 	dispose() {
 
 		super.dispose();

package/src/renderers/shaders/ShaderChunk/batching_pars_vertex.glsl.js

@@ -1,7 +1,12 @@
 export default /* glsl */`
 #ifdef USE_BATCHING
-	attribute float batchId;
+	#if ! defined( GL_ANGLE_multi_draw )
+	#define gl_DrawID _gl_DrawID
+	uniform int _gl_DrawID;
+	#endif
+
 	uniform highp sampler2D batchingTexture;
+	uniform highp usampler2D batchingIdTexture;
 	mat4 getBatchingMatrix( const in float i ) {
 
 		int size = textureSize( batchingTexture, 0 ).x;
@@ -15,5 +20,30 @@ export default /* glsl */`
 		return mat4( v1, v2, v3, v4 );
 
 	}
+
+	float getIndirectIndex( const in int i ) {
+
+		int size = textureSize( batchingIdTexture, 0 ).x;
+		int x = i % size;
+		int y = i / size;
+		return float( texelFetch( batchingIdTexture, ivec2( x, y ), 0 ).r );
+
+	}
+
+#endif
+
+#ifdef USE_BATCHING_COLOR
+
+	uniform sampler2D batchingColorTexture;
+	vec3 getBatchingColor( const in float i ) {
+
+		int size = textureSize( batchingColorTexture, 0 ).x;
+		int j = int( i );
+		int x = j % size;
+		int y = j / size;
+		return texelFetch( batchingColorTexture, ivec2( x, y ), 0 ).rgb;
+
+	}
+
 #endif
 `;

package/src/renderers/shaders/ShaderChunk/batching_vertex.glsl.js

@@ -1,5 +1,5 @@
 export default /* glsl */`
 #ifdef USE_BATCHING
-	mat4 batchingMatrix = getBatchingMatrix( batchId );
+	mat4 batchingMatrix = getBatchingMatrix( getIndirectIndex( gl_DrawID ) );
 #endif
 `;

package/src/renderers/shaders/ShaderChunk/color_pars_vertex.glsl.js

@@ -3,7 +3,7 @@ export default /* glsl */`
 
 	varying vec4 vColor;
 
-#elif defined( USE_COLOR ) || defined( USE_INSTANCING_COLOR )
+#elif defined( USE_COLOR ) || defined( USE_INSTANCING_COLOR ) || defined( USE_BATCHING_COLOR )
 
 	varying vec3 vColor;