@needle-tools/three 0.162.12 → 0.169.2

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

@@ -18,6 +18,8 @@ class Animation {
 
 			this.requestId = self.requestAnimationFrame( update );
 
+			if ( this.info.autoReset === true ) this.info.reset();
+
 			this.nodes.nodeFrame.update();
 
 			this.info.frame = this.nodes.nodeFrame.frameId;
@@ -33,6 +35,7 @@ class Animation {
 	dispose() {
 
 		self.cancelAnimationFrame( this.requestId );
+		this.requestId = null;
 
 	}
 

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

@@ -1,6 +1,7 @@
 import DataMap from './DataMap.js';
 import { AttributeType } from './Constants.js';
-import { DynamicDrawUsage } from 'three';
+
+import { DynamicDrawUsage } from '../../constants.js';
 
 class Attributes extends DataMap {
 
@@ -22,6 +23,8 @@ class Attributes extends DataMap {
 
 		}
 
+		return attributeData;
+
 	}
 
 	update( attribute, type ) {

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

@@ -3,7 +3,10 @@ let vector4 = null;
 let color4 = null;
 
 import Color4 from './Color4.js';
-import { Vector2, Vector4, REVISION, createCanvasElement } from 'three';
+import { Vector2 } from '../../math/Vector2.js';
+import { Vector4 } from '../../math/Vector4.js';
+import { createCanvasElement } from '../../utils.js';
+import { REVISION } from '../../constants.js';
 
 class Backend {
 
@@ -24,63 +27,63 @@ class Backend {
 
 	// render context
 
-	begin( renderContext ) { }
+	begin( /*renderContext*/ ) { }
 
-	finish( renderContext ) { }
+	finish( /*renderContext*/ ) { }
 
 	// render object
 
-	draw( renderObject, info ) { }
+	draw( /*renderObject, info*/ ) { }
 
 	// program
 
-	createProgram( program ) { }
+	createProgram( /*program*/ ) { }
 
-	destroyProgram( program ) { }
+	destroyProgram( /*program*/ ) { }
 
 	// bindings
 
-	createBindings( renderObject ) { }
+	createBindings( /*bingGroup, bindings*/ ) { }
 
-	updateBindings( renderObject ) { }
+	updateBindings( /*bingGroup, bindings*/ ) { }
 
 	// pipeline
 
-	createRenderPipeline( renderObject ) { }
+	createRenderPipeline( /*renderObject*/ ) { }
 
-	createComputePipeline( computeNode, pipeline ) { }
+	createComputePipeline( /*computeNode, pipeline*/ ) { }
 
-	destroyPipeline( pipeline ) { }
+	destroyPipeline( /*pipeline*/ ) { }
 
 	// cache key
 
-	needsRenderUpdate( renderObject ) { } // return Boolean ( fast test )
+	needsRenderUpdate( /*renderObject*/ ) { } // return Boolean ( fast test )
 
-	getRenderCacheKey( renderObject ) { } // return String
+	getRenderCacheKey( /*renderObject*/ ) { } // return String
 
 	// node builder
 
-	createNodeBuilder( renderObject ) { } // return NodeBuilder (ADD IT)
+	createNodeBuilder( /*renderObject*/ ) { } // return NodeBuilder (ADD IT)
 
 	// textures
 
-	createSampler( texture ) { }
+	createSampler( /*texture*/ ) { }
 
-	createDefaultTexture( texture ) { }
+	createDefaultTexture( /*texture*/ ) { }
 
-	createTexture( texture ) { }
+	createTexture( /*texture*/ ) { }
 
-	copyTextureToBuffer( texture, x, y, width, height ) {}
+	copyTextureToBuffer( /*texture, x, y, width, height*/ ) {}
 
 	// attributes
 
-	createAttribute( attribute ) { }
+	createAttribute( /*attribute*/ ) { }
 
-	createIndexAttribute( attribute ) { }
+	createIndexAttribute( /*attribute*/ ) { }
 
-	updateAttribute( attribute ) { }
+	updateAttribute( /*attribute*/ ) { }
 
-	destroyAttribute( attribute ) { }
+	destroyAttribute( /*attribute*/ ) { }
 
 	// canvas
 
@@ -90,17 +93,17 @@ class Backend {
 
 	// utils
 
-	resolveTimestampAsync( renderContext, type ) { }
+	resolveTimestampAsync( /*renderContext, type*/ ) { }
 
-	hasFeatureAsync( name ) { } // return Boolean
+	hasFeatureAsync( /*name*/ ) { } // return Boolean
 
-	hasFeature( name ) { } // return Boolean
+	hasFeature( /*name*/ ) { } // return Boolean
 
 	getInstanceCount( renderObject ) {
 
 		const { object, geometry } = renderObject;
 
-		return geometry.isInstancedBufferGeometry ? geometry.instanceCount : ( object.isInstancedMesh ? object.count : 1 );
+		return geometry.isInstancedBufferGeometry ? geometry.instanceCount : ( object.count > 1 ? object.count : 1 );
 
 	}
 
@@ -120,7 +123,7 @@ class Backend {
 
 	}
 
-	setScissorTest( boolean ) { }
+	setScissorTest( /*boolean*/ ) { }
 
 	getClearColor() {
 

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

@@ -1,9 +1,13 @@
 import DataMap from './DataMap.js';
 import Color4 from './Color4.js';
-import { Mesh, SphereGeometry, BackSide } from 'three';
-import { vec4, context, normalWorld, backgroundBlurriness, backgroundIntensity, NodeMaterial, modelViewProjection, maxMipLevel } from '../../nodes/Nodes.js';
+import { vec4, context, normalWorld, backgroundBlurriness, backgroundIntensity, modelViewProjection } from '../../nodes/TSL.js';
+import NodeMaterial from '../../materials/nodes/NodeMaterial.js';
 
-const _clearColor = new Color4();
+import { Mesh } from '../../objects/Mesh.js';
+import { SphereGeometry } from '../../geometries/SphereGeometry.js';
+import { BackSide, LinearSRGBColorSpace } from '../../constants.js';
+
+const _clearColor = /*@__PURE__*/ new Color4();
 
 class Background extends DataMap {
 
@@ -27,14 +31,14 @@ class Background extends DataMap {
 
 			// no background settings, use clear color configuration from the renderer
 
-			renderer._clearColor.getRGB( _clearColor, this.renderer.currentColorSpace );
+			renderer._clearColor.getRGB( _clearColor, LinearSRGBColorSpace );
 			_clearColor.a = renderer._clearColor.a;
 
 		} else if ( background.isColor === true ) {
 
 			// background is an opaque color
 
-			background.getRGB( _clearColor, this.renderer.currentColorSpace );
+			background.getRGB( _clearColor, LinearSRGBColorSpace );
 			_clearColor.a = 1;
 
 			forceClear = true;
@@ -50,26 +54,29 @@ class Background extends DataMap {
 
 			if ( backgroundMesh === undefined ) {
 
-				const backgroundMeshNode = context( vec4( backgroundNode ), {
+				const backgroundMeshNode = context( vec4( backgroundNode ).mul( backgroundIntensity ), {
 					// @TODO: Add Texture2D support using node context
 					getUV: () => normalWorld,
-					getTextureLevel: ( textureNode ) => backgroundBlurriness.mul( maxMipLevel( textureNode ) )
-				} ).mul( backgroundIntensity );
+					getTextureLevel: () => backgroundBlurriness
+				} );
 
 				let viewProj = modelViewProjection();
 				viewProj = viewProj.setZ( viewProj.w );
 
 				const nodeMaterial = new NodeMaterial();
+				nodeMaterial.name = 'Background.material';
 				nodeMaterial.side = BackSide;
 				nodeMaterial.depthTest = false;
 				nodeMaterial.depthWrite = false;
 				nodeMaterial.fog = false;
+				nodeMaterial.lights = false;
 				nodeMaterial.vertexNode = viewProj;
-				nodeMaterial.fragmentNode = backgroundMeshNode;
+				nodeMaterial.colorNode = backgroundMeshNode;
 
 				sceneData.backgroundMeshNode = backgroundMeshNode;
 				sceneData.backgroundMesh = backgroundMesh = new Mesh( new SphereGeometry( 1, 32, 32 ), nodeMaterial );
 				backgroundMesh.frustumCulled = false;
+				backgroundMesh.name = 'Background.mesh';
 
 				backgroundMesh.onBeforeRender = function ( renderer, scene, camera ) {
 
@@ -83,7 +90,8 @@ class Background extends DataMap {
 
 			if ( sceneData.backgroundCacheKey !== backgroundCacheKey ) {
 
-				sceneData.backgroundMeshNode.node = vec4( backgroundNode );
+				sceneData.backgroundMeshNode.node = vec4( backgroundNode ).mul( backgroundIntensity );
+				sceneData.backgroundMeshNode.needsUpdate = true;
 
 				backgroundMesh.material.needsUpdate = true;
 

package/src/renderers/common/BindGroup.js

@@ -0,0 +1,18 @@
+let _id = 0;
+
+class BindGroup {
+
+	constructor( name = '', bindings = [], index = 0, bindingsReference = [] ) {
+
+		this.name = name;
+		this.bindings = bindings;
+		this.index = index;
+		this.bindingsReference = bindingsReference;
+
+		this.id = _id ++;
+
+	}
+
+}
+
+export default BindGroup;

package/src/renderers/common/Bindings.js

@@ -0,0 +1,203 @@
+import DataMap from './DataMap.js';
+import { AttributeType } from './Constants.js';
+
+class Bindings extends DataMap {
+
+	constructor( backend, nodes, textures, attributes, pipelines, info ) {
+
+		super();
+
+		this.backend = backend;
+		this.textures = textures;
+		this.pipelines = pipelines;
+		this.attributes = attributes;
+		this.nodes = nodes;
+		this.info = info;
+
+		this.pipelines.bindings = this; // assign bindings to pipelines
+
+	}
+
+	getForRender( renderObject ) {
+
+		const bindings = renderObject.getBindings();
+
+		for ( const bindGroup of bindings ) {
+
+			const groupData = this.get( bindGroup );
+
+			if ( groupData.bindGroup === undefined ) {
+
+				// each object defines an array of bindings (ubos, textures, samplers etc.)
+
+				this._init( bindGroup );
+
+				this.backend.createBindings( bindGroup, bindings );
+
+				groupData.bindGroup = bindGroup;
+
+			}
+
+		}
+
+		return bindings;
+
+	}
+
+	getForCompute( computeNode ) {
+
+		const bindings = this.nodes.getForCompute( computeNode ).bindings;
+
+		for ( const bindGroup of bindings ) {
+
+			const groupData = this.get( bindGroup );
+
+			if ( groupData.bindGroup === undefined ) {
+
+				this._init( bindGroup );
+
+				this.backend.createBindings( bindGroup, bindings );
+
+				groupData.bindGroup = bindGroup;
+
+			}
+
+		}
+
+		return bindings;
+
+	}
+
+	updateForCompute( computeNode ) {
+
+		this._updateBindings( this.getForCompute( computeNode ) );
+
+	}
+
+	updateForRender( renderObject ) {
+
+		this._updateBindings( this.getForRender( renderObject ) );
+
+	}
+
+	_updateBindings( bindings ) {
+
+		for ( const bindGroup of bindings ) {
+
+			this._update( bindGroup, bindings );
+
+		}
+
+	}
+
+	_init( bindGroup ) {
+
+		for ( const binding of bindGroup.bindings ) {
+
+			if ( binding.isSampledTexture ) {
+
+				this.textures.updateTexture( binding.texture );
+
+			} else if ( binding.isStorageBuffer ) {
+
+				const attribute = binding.attribute;
+
+				this.attributes.update( attribute, AttributeType.STORAGE );
+
+			}
+
+		}
+
+	}
+
+	_update( bindGroup, bindings ) {
+
+		const { backend } = this;
+
+		let needsBindingsUpdate = false;
+
+		// iterate over all bindings and check if buffer updates or a new binding group is required
+
+		for ( const binding of bindGroup.bindings ) {
+
+			if ( binding.isNodeUniformsGroup ) {
+
+				const updated = this.nodes.updateGroup( binding );
+
+				if ( ! updated ) continue;
+
+			}
+
+			if ( binding.isUniformBuffer ) {
+
+				const updated = binding.update();
+
+				if ( updated ) {
+
+					backend.updateBinding( binding );
+
+				}
+
+			} else if ( binding.isSampler ) {
+
+				binding.update();
+
+			} else if ( binding.isSampledTexture ) {
+
+				if ( binding.needsBindingsUpdate( this.textures.get( binding.texture ).generation ) ) needsBindingsUpdate = true;
+
+				const updated = binding.update();
+
+				const texture = binding.texture;
+
+				if ( updated ) {
+
+					this.textures.updateTexture( texture );
+
+				}
+
+				const textureData = backend.get( texture );
+
+				if ( backend.isWebGPUBackend === true && textureData.texture === undefined && textureData.externalTexture === undefined ) {
+
+					// TODO: Remove this once we found why updated === false isn't bound to a texture in the WebGPU backend
+					console.error( 'Bindings._update: binding should be available:', binding, updated, texture, binding.textureNode.value, needsBindingsUpdate );
+
+					this.textures.updateTexture( texture );
+					needsBindingsUpdate = true;
+
+				}
+
+				if ( texture.isStorageTexture === true ) {
+
+					const textureData = this.get( texture );
+
+					if ( binding.store === true ) {
+
+						textureData.needsMipmap = true;
+
+					} else if ( texture.generateMipmaps === true && this.textures.needsMipmaps( texture ) && textureData.needsMipmap === true ) {
+
+						this.backend.generateMipmaps( texture );
+
+						textureData.needsMipmap = false;
+
+					}
+
+				}
+
+			}
+
+		}
+
+		if ( needsBindingsUpdate === true ) {
+
+			this.backend.updateBindings( bindGroup, bindings );
+
+		}
+
+	}
+
+}
+
+export default Bindings;

package/src/renderers/common/BundleGroup.js

@@ -0,0 +1,26 @@
+import { Group } from '../../objects/Group.js';
+
+class BundleGroup extends Group {
+
+	constructor() {
+
+		super();
+
+		this.isBundleGroup = true;
+
+		this.type = 'BundleGroup';
+
+		this.static = true;
+		this.version = 0;
+
+	}
+
+	set needsUpdate( value ) {
+
+		if ( value === true ) this.version ++;
+
+	}
+
+}
+
+export default BundleGroup;

package/src/renderers/common/ChainMap.js

@@ -0,0 +1,59 @@
+export default class ChainMap {
+
+	constructor() {
+
+		this.weakMap = new WeakMap();
+
+	}
+
+	get( keys ) {
+
+		let map = this.weakMap;
+
+		for ( let i = 0; i < keys.length; i ++ ) {
+
+			map = map.get( keys[ i ] );
+
+			if ( map === undefined ) return undefined;
+
+		}
+
+		return map.get( keys[ keys.length - 1 ] );
+
+	}
+
+	set( keys, value ) {
+
+		let map = this.weakMap;
+
+		for ( let i = 0; i < keys.length; i ++ ) {
+
+			const key = keys[ i ];
+
+			if ( map.has( key ) === false ) map.set( key, new WeakMap() );
+
+			map = map.get( key );
+
+		}
+
+		return map.set( keys[ keys.length - 1 ], value );
+
+	}
+
+	delete( keys ) {
+
+		let map = this.weakMap;
+
+		for ( let i = 0; i < keys.length; i ++ ) {
+
+			map = map.get( keys[ i ] );
+
+			if ( map === undefined ) return false;
+
+		}
+
+		return map.delete( keys[ keys.length - 1 ] );
+
+	}
+
+}

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

@@ -1,15 +1,15 @@
-import { Matrix3, Plane, Vector4 } from 'three';
+import { Matrix3 } from '../../math/Matrix3.js';
+import { Plane } from '../../math/Plane.js';
+import { Vector4 } from '../../math/Vector4.js';
+import { hash } from '../../nodes/core/NodeUtils.js';
 
-const _plane = new Plane();
-const _viewNormalMatrix = new Matrix3();
-
-let _clippingContextVersion = 0;
+const _plane = /*@__PURE__*/ new Plane();
 
 class ClippingContext {
 
 	constructor() {
 
-		this.version = ++ _clippingContextVersion;
+		this.version = 0;
 
 		this.globalClippingCount = 0;
 
@@ -20,6 +20,8 @@ class ClippingContext {
 		this.planes = [];
 
 		this.parentVersion = 0;
+		this.viewNormalMatrix = new Matrix3();
+		this.cacheKey = 0;
 
 	}
 
@@ -30,7 +32,7 @@ class ClippingContext {
 
 		for ( let i = 0; i < l; i ++ ) {
 
-			_plane.copy( source[ i ] ).applyMatrix4( this.viewMatrix, _viewNormalMatrix );
+			_plane.copy( source[ i ] ).applyMatrix4( this.viewMatrix, this.viewNormalMatrix );
 
 			const v = planes[ offset + i ];
 			const normal = _plane.normal;
@@ -49,7 +51,7 @@ class ClippingContext {
 		const rendererClippingPlanes = renderer.clippingPlanes;
 		this.viewMatrix = camera.matrixWorldInverse;
 
-		_viewNormalMatrix.getNormalMatrix( this.viewMatrix );
+		this.viewNormalMatrix.getNormalMatrix( this.viewMatrix );
 
 		let update = false;
 
@@ -91,7 +93,12 @@ class ClippingContext {
 
 		}
 
-		if ( update ) this.version = _clippingContextVersion ++;
+		if ( update ) {
+
+			this.version ++;
+			this.cacheKey = hash( this.globalClippingCount, this.localClippingEnabled === true ? 1 : 0 );
+
+		}
 
 	}
 
@@ -101,12 +108,12 @@ class ClippingContext {
 
 		if ( this !== parent && parent.version !== this.parentVersion ) {
 
-			this.globalClippingCount =  material.isShadowNodeMaterial ? 0 : parent.globalClippingCount;
+			this.globalClippingCount = material.isShadowNodeMaterial ? 0 : parent.globalClippingCount;
 			this.localClippingEnabled = parent.localClippingEnabled;
 			this.planes = Array.from( parent.planes );
 			this.parentVersion = parent.version;
 			this.viewMatrix = parent.viewMatrix;
-
+			this.viewNormalMatrix = parent.viewNormalMatrix;
 
 			update = true;
 
@@ -156,7 +163,12 @@ class ClippingContext {
 
 		}
 
-		if ( update ) this.version = _clippingContextVersion ++;
+		if ( update ) {
+
+			this.version += parent.version;
+			this.cacheKey = hash( parent.cacheKey, this.localClippingCount, this.localClipIntersection === true ? 1 : 0 );
+
+		}
 
 	}
 

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

@@ -1,4 +1,4 @@
-import { Color } from 'three';
+import { Color } from '../../math/Color.js';
 
 class Color4 extends Color {
 

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

@@ -1,8 +1,14 @@
-import { WebGLCubeRenderTarget, Scene, CubeCamera, BoxGeometry, Mesh, BackSide, NoBlending, LinearFilter, LinearMipmapLinearFilter } from 'three';
 import { equirectUV } from '../../nodes/utils/EquirectUVNode.js';
 import { texture as TSL_Texture } from '../../nodes/accessors/TextureNode.js';
-import { positionWorldDirection } from '../../nodes/accessors/PositionNode.js';
-import { createNodeMaterialFromType } from '../../nodes/materials/NodeMaterial.js';
+import { positionWorldDirection } from '../../nodes/accessors/Position.js';
+import NodeMaterial from '../../materials/nodes/NodeMaterial.js';
+
+import { WebGLCubeRenderTarget } from '../../renderers/WebGLCubeRenderTarget.js';
+import { Scene } from '../../scenes/Scene.js';
+import { CubeCamera } from '../../cameras/CubeCamera.js';
+import { BoxGeometry } from '../../geometries/BoxGeometry.js';
+import { Mesh } from '../../objects/Mesh.js';
+import { BackSide, NoBlending, LinearFilter, LinearMipmapLinearFilter } from '../../constants.js';
 
 // @TODO: Consider rename WebGLCubeRenderTarget to just CubeRenderTarget
 
@@ -34,7 +40,7 @@ class CubeRenderTarget extends WebGLCubeRenderTarget {
 
 		const uvNode = equirectUV( positionWorldDirection );
 
-		const material = createNodeMaterialFromType( 'MeshBasicNodeMaterial' );
+		const material = new NodeMaterial();
 		material.colorNode = TSL_Texture( texture, uvNode, 0 );
 		material.side = BackSide;
 		material.blending = NoBlending;
@@ -48,8 +54,14 @@ class CubeRenderTarget extends WebGLCubeRenderTarget {
 		if ( texture.minFilter === LinearMipmapLinearFilter ) texture.minFilter = LinearFilter;
 
 		const camera = new CubeCamera( 1, 10, this );
+
+		const currentMRT = renderer.getMRT();
+		renderer.setMRT( null );
+
 		camera.update( renderer, scene );
 
+		renderer.setMRT( currentMRT );
+
 		texture.minFilter = currentMinFilter;
 		texture.currentGenerateMipmaps = currentGenerateMipmaps;