super-three 0.164.0 → 0.167.0

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( /*renderObject*/ ) { }
 
-	updateBindings( renderObject ) { }
+	updateBindings( /*renderObject*/ ) { }
 
 	// 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,12 @@
 import DataMap from './DataMap.js';
 import Color4 from './Color4.js';
-import { Mesh, SphereGeometry, BackSide, LinearSRGBColorSpace } from 'three';
 import { vec4, context, normalWorld, backgroundBlurriness, backgroundIntensity, NodeMaterial, modelViewProjection } from '../../nodes/Nodes.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 {
 
@@ -60,16 +63,19 @@ class Background extends DataMap {
 				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 ) {
 

package/src/renderers/common/BindGroup.js

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

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

@@ -22,61 +22,77 @@ class Bindings extends DataMap {
 
 		const bindings = renderObject.getBindings();
 
-		const data = this.get( renderObject );
+		for ( const bindGroup of bindings ) {
 
-		if ( data.bindings !== bindings ) {
+			const groupData = this.get( bindGroup );
 
-			// each object defines an array of bindings (ubos, textures, samplers etc.)
+			if ( groupData.bindGroup === undefined ) {
 
-			data.bindings = bindings;
+				// each object defines an array of bindings (ubos, textures, samplers etc.)
 
-			this._init( bindings );
+				this._init( bindGroup );
 
-			this.backend.createBindings( bindings );
+				this.backend.createBindings( bindGroup, bindings );
+
+				groupData.bindGroup = bindGroup;
+
+			}
 
 		}
 
-		return data.bindings;
+		return bindings;
 
 	}
 
 	getForCompute( computeNode ) {
 
-		const data = this.get( computeNode );
+		const bindings = this.nodes.getForCompute( computeNode ).bindings;
 
-		if ( data.bindings === undefined ) {
+		for ( const bindGroup of bindings ) {
 
-			const nodeBuilderState = this.nodes.getForCompute( computeNode );
+			const groupData = this.get( bindGroup );
 
-			const bindings = nodeBuilderState.bindings;
+			if ( groupData.bindGroup === undefined ) {
 
-			data.bindings = bindings;
+				this._init( bindGroup );
 
-			this._init( bindings );
+				this.backend.createBindings( bindGroup, bindings );
 
-			this.backend.createBindings( bindings );
+				groupData.bindGroup = bindGroup;
+
+			}
 
 		}
 
-		return data.bindings;
+		return bindings;
 
 	}
 
 	updateForCompute( computeNode ) {
 
-		this._update( computeNode, this.getForCompute( computeNode ) );
+		this._updateBindings( computeNode, this.getForCompute( computeNode ) );
 
 	}
 
 	updateForRender( renderObject ) {
 
-		this._update( renderObject, this.getForRender( renderObject ) );
+		this._updateBindings( renderObject, this.getForRender( renderObject ) );
 
 	}
 
-	_init( bindings ) {
+	_updateBindings( object, bindings ) {
+
+		for ( const bindGroup of bindings ) {
+
+			this._update( object, bindGroup, bindings );
+
+		}
+
+	}
 
-		for ( const binding of bindings ) {
+	_init( bindGroup ) {
+
+		for ( const binding of bindGroup.bindings ) {
 
 			if ( binding.isSampledTexture ) {
 
@@ -94,7 +110,7 @@ class Bindings extends DataMap {
 
 	}
 
-	_update( object, bindings ) {
+	_update( object, bindGroup, bindings ) {
 
 		const { backend } = this;
 
@@ -102,7 +118,7 @@ class Bindings extends DataMap {
 
 		// iterate over all bindings and check if buffer updates or a new binding group is required
 
-		for ( const binding of bindings ) {
+		for ( const binding of bindGroup.bindings ) {
 
 			if ( binding.isNodeUniformsGroup ) {
 
@@ -122,6 +138,10 @@ class Bindings extends DataMap {
 
 				}
 
+			} else if ( binding.isSampler ) {
+
+				binding.update();
+
 			} else if ( binding.isSampledTexture ) {
 
 				const texture = binding.texture;
@@ -136,6 +156,18 @@ class Bindings extends DataMap {
 
 				}
 
+				const textureData = backend.get( binding.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, binding.texture, binding.textureNode.value );
+
+					this.textures.updateTexture( binding.texture );
+					needsBindingsUpdate = true;
+
+				}
+
 				if ( texture.isStorageTexture === true ) {
 
 					const textureData = this.get( texture );
@@ -162,7 +194,7 @@ class Bindings extends DataMap {
 
 			const pipeline = this.pipelines.getForRender( object );
 
-			this.backend.updateBindings( bindings, pipeline );
+			this.backend.updateBindings( bindGroup, bindings, pipeline );
 
 		}
 

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,7 +1,8 @@
-import { Matrix3, Plane, Vector4 } from 'three';
+import { Matrix3 } from '../../math/Matrix3.js';
+import { Plane } from '../../math/Plane.js';
+import { Vector4 } from '../../math/Vector4.js';
 
-const _plane = new Plane();
-const _viewNormalMatrix = new Matrix3();
+const _plane = /*@__PURE__*/ new Plane();
 
 let _clippingContextVersion = 0;
 
@@ -20,6 +21,7 @@ class ClippingContext {
 		this.planes = [];
 
 		this.parentVersion = 0;
+		this.viewNormalMatrix = new Matrix3();
 
 	}
 
@@ -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;
 
@@ -106,7 +108,7 @@ class ClippingContext {
 			this.planes = Array.from( parent.planes );
 			this.parentVersion = parent.version;
 			this.viewMatrix = parent.viewMatrix;
-
+			this.viewNormalMatrix = parent.viewNormalMatrix;
 
 			update = true;
 

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,9 +1,15 @@
-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 { 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
 
 class CubeRenderTarget extends WebGLCubeRenderTarget {

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

@@ -1,6 +1,7 @@
 import DataMap from './DataMap.js';
 import { AttributeType } from './Constants.js';
-import { Uint32BufferAttribute, Uint16BufferAttribute } from 'three';
+
+import { Uint16BufferAttribute, Uint32BufferAttribute } from '../../core/BufferAttribute.js';
 
 function arrayNeedsUint32( array ) {
 
@@ -76,6 +77,7 @@ class Geometries extends DataMap {
 		this.info = info;
 
 		this.wireframes = new WeakMap();
+
 		this.attributeCall = new WeakMap();
 
 	}
@@ -146,7 +148,15 @@ class Geometries extends DataMap {
 
 		for ( const attribute of attributes ) {
 
-			this.updateAttribute( attribute, AttributeType.VERTEX );
+			if ( attribute.isStorageBufferAttribute || attribute.isStorageInstancedBufferAttribute ) {
+
+				this.updateAttribute( attribute, AttributeType.STORAGE );
+
+			} else {
+
+				this.updateAttribute( attribute, AttributeType.VERTEX );
+
+			}
 
 		}
 
@@ -164,11 +174,33 @@ class Geometries extends DataMap {
 
 		const callId = this.info.render.calls;
 
-		if ( this.attributeCall.get( attribute ) !== callId ) {
+		if ( ! attribute.isInterleavedBufferAttribute ) {
+
+			if ( this.attributeCall.get( attribute ) !== callId ) {
+
+				this.attributes.update( attribute, type );
+
+				this.attributeCall.set( attribute, callId );
 
-			this.attributes.update( attribute, type );
+			}
+
+		} else {
+
+			if ( this.attributeCall.get( attribute ) === undefined ) {
+
+				this.attributes.update( attribute, type );
+
+				this.attributeCall.set( attribute, callId );
 
-			this.attributeCall.set( attribute, callId );
+			} else if ( this.attributeCall.get( attribute.data ) !== callId ) {
+
+				this.attributes.update( attribute, type );
+
+				this.attributeCall.set( attribute.data, callId );
+
+				this.attributeCall.set( attribute, callId );
+
+			}
 
 		}
 

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

@@ -9,17 +9,22 @@ class Info {
 
 		this.render = {
 			calls: 0,
+			frameCalls: 0,
 			drawCalls: 0,
 			triangles: 0,
 			points: 0,
 			lines: 0,
-			timestamp: 0
+			timestamp: 0,
+			previousFrameCalls: 0,
+			timestampCalls: 0
 		};
 
 		this.compute = {
 			calls: 0,
-			computeCalls: 0,
-			timestamp: 0
+			frameCalls: 0,
+			timestamp: 0,
+			previousFrameCalls: 0,
+			timestampCalls: 0
 		};
 
 		this.memory = {
@@ -59,21 +64,44 @@ class Info {
 
 	updateTimestamp( type, time ) {
 
+		if ( this[ type ].timestampCalls === 0 ) {
+
+			this[ type ].timestamp = 0;
+
+		}
+
+
 		this[ type ].timestamp += time;
 
+		this[ type ].timestampCalls ++;
+
+
+		if ( this[ type ].timestampCalls >= this[ type ].previousFrameCalls ) {
+
+			this[ type ].timestampCalls = 0;
+
+		}
+
+
 	}
 
 	reset() {
 
+		const previousRenderFrameCalls = this.render.frameCalls;
+		this.render.previousFrameCalls = previousRenderFrameCalls;
+
+		const previousComputeFrameCalls = this.compute.frameCalls;
+		this.compute.previousFrameCalls = previousComputeFrameCalls;
+
+
 		this.render.drawCalls = 0;
-		this.compute.computeCalls = 0;
+		this.render.frameCalls = 0;
+		this.compute.frameCalls = 0;
 
 		this.render.triangles = 0;
 		this.render.points = 0;
 		this.render.lines = 0;
 
-		this.render.timestamp = 0;
-		this.compute.timestamp = 0;
 
 	}
 

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

@@ -67,7 +67,7 @@ class Pipelines extends DataMap {
 
 			if ( pipeline === undefined ) {
 
-				if ( previousPipeline && previousPipeline.usedTimes === 0 ) this._releasePipeline( computeNode );
+				if ( previousPipeline && previousPipeline.usedTimes === 0 ) this._releasePipeline( previousPipeline );
 
 				pipeline = this._getComputePipeline( computeNode, stageCompute, cacheKey, bindings );
 
@@ -205,7 +205,7 @@ class Pipelines extends DataMap {
 
 		}
 
-		super.delete( object );
+		return super.delete( object );
 
 	}