super-three 0.165.0 → 0.167.0

package/src/objects/InstancedMesh.js

@@ -207,7 +207,7 @@ class InstancedMesh extends Mesh {
 
 		if ( this.instanceColor === null ) {
 
-			this.instanceColor = new InstancedBufferAttribute( new Float32Array( this.instanceMatrix.count * 3 ), 3 );
+			this.instanceColor = new InstancedBufferAttribute( new Float32Array( this.instanceMatrix.count * 3 ).fill( 1 ), 3 );
 
 		}
 

package/src/renderers/WebGLRenderer.js

@@ -56,7 +56,7 @@ import { WebVRManager } from './webvr/WebVRManager.js';
 import { WebXRManager } from './webxr/WebXRManager.js';
 import { WebGLMaterials } from './webgl/WebGLMaterials.js';
 import { WebGLUniformsGroups } from './webgl/WebGLUniformsGroups.js';
-import { createCanvasElement, probeAsync } from '../utils.js';
+import { createCanvasElement, probeAsync, warnOnce } from '../utils.js';
 import { ColorManagement } from '../math/ColorManagement.js';
 
 class WebGLRenderer {
@@ -203,6 +203,8 @@ class WebGLRenderer {
 
 		const _vector3 = new Vector3();
 
+		const _vector4 = new Vector4();
+
 		const _emptyScene = { background: null, fog: null, environment: null, overrideMaterial: null, isScene: true };
 
 		let _renderBackground = false;
@@ -862,7 +864,25 @@ class WebGLRenderer {
 
 				} else {
 
-					renderer.renderMultiDraw( object._multiDrawStarts, object._multiDrawCounts, object._multiDrawCount );
+					if ( ! extensions.get( 'WEBGL_multi_draw' ) ) {
+
+						const starts = object._multiDrawStarts;
+						const counts = object._multiDrawCounts;
+						const drawCount = object._multiDrawCount;
+						const bytesPerElement = index ? attributes.get( index ).bytesPerElement : 1;
+						const uniforms = properties.get( material ).currentProgram.getUniforms();
+						for ( let i = 0; i < drawCount; i ++ ) {
+
+							uniforms.setValue( _gl, '_gl_DrawID', i );
+							renderer.render( starts[ i ] / bytesPerElement, counts[ i ] );
+
+						}
+
+					} else {
+
+						renderer.renderMultiDraw( object._multiDrawStarts, object._multiDrawCounts, object._multiDrawCount );
+
+					}
 
 				}
 
@@ -1335,7 +1355,7 @@ class WebGLRenderer {
 
 						if ( sortObjects ) {
 
-							_vector3.setFromMatrixPosition( object.matrixWorld )
+							_vector4.setFromMatrixPosition( object.matrixWorld )
 								.applyMatrix4( _projScreenMatrix );
 
 						}
@@ -1345,7 +1365,7 @@ class WebGLRenderer {
 
 						if ( material.visible ) {
 
-							currentRenderList.push( object, geometry, material, groupOrder, _vector3.z, null );
+							currentRenderList.push( object, geometry, material, groupOrder, _vector4.z, null );
 
 						}
 
@@ -1363,16 +1383,16 @@ class WebGLRenderer {
 							if ( object.boundingSphere !== undefined ) {
 
 								if ( object.boundingSphere === null ) object.computeBoundingSphere();
-								_vector3.copy( object.boundingSphere.center );
+								_vector4.copy( object.boundingSphere.center );
 
 							} else {
 
 								if ( geometry.boundingSphere === null ) geometry.computeBoundingSphere();
-								_vector3.copy( geometry.boundingSphere.center );
+								_vector4.copy( geometry.boundingSphere.center );
 
 							}
 
-							_vector3
+							_vector4
 								.applyMatrix4( object.matrixWorld )
 								.applyMatrix4( _projScreenMatrix );
 
@@ -1389,7 +1409,7 @@ class WebGLRenderer {
 
 								if ( groupMaterial && groupMaterial.visible ) {
 
-									currentRenderList.push( object, geometry, groupMaterial, groupOrder, _vector3.z, group );
+									currentRenderList.push( object, geometry, groupMaterial, groupOrder, _vector4.z, group );
 
 								}
 
@@ -1397,7 +1417,7 @@ class WebGLRenderer {
 
 						} else if ( material.visible ) {
 
-							currentRenderList.push( object, geometry, material, groupOrder, _vector3.z, null );
+							currentRenderList.push( object, geometry, material, groupOrder, _vector4.z, null );
 
 						}
 
@@ -1492,15 +1512,9 @@ class WebGLRenderer {
 			_currentClearAlpha = _this.getClearAlpha();
 			if ( _currentClearAlpha < 1 ) _this.setClearColor( 0xffffff, 0.5 );
 
-			if ( _renderBackground ) {
-
-				background.render( scene );
+			_this.clear();
 
-			} else {
-
-				_this.clear();
-
-			}
+			if ( _renderBackground ) background.render( scene );
 
 			// Turn off the features which can affect the frag color for opaque objects pass.
 			// Otherwise they are applied twice in opaque objects pass and transmission objects pass.
@@ -1601,8 +1615,6 @@ class WebGLRenderer {
 			object.modelViewMatrix.multiplyMatrices( camera.matrixWorldInverse, object.matrixWorld );
 			object.normalMatrix.getNormalMatrix( object.modelViewMatrix );
 
-			material.onBeforeRender( _this, scene, camera, geometry, object, group );
-
 			if ( material.transparent === true && material.side === DoubleSide && material.forceSinglePass === false ) {
 
 				material.side = BackSide;
@@ -1677,8 +1689,6 @@ class WebGLRenderer {
 
 				parameters.uniforms = programCache.getUniforms( material );
 
-				material.onBuild( object, parameters, _this );
-
 				material.onBeforeCompile( parameters, _this );
 
 				program = programCache.acquireProgram( parameters, programCacheKey );
@@ -2063,6 +2073,9 @@ class WebGLRenderer {
 				p_uniforms.setOptional( _gl, object, 'batchingTexture' );
 				p_uniforms.setValue( _gl, 'batchingTexture', object._matricesTexture, textures );
 
+				p_uniforms.setOptional( _gl, object, 'batchingIdTexture' );
+				p_uniforms.setValue( _gl, 'batchingIdTexture', object._indirectTexture, textures );
+
 				p_uniforms.setOptional( _gl, object, 'batchingColorTexture' );
 				if ( object._colorsTexture !== null ) {
 
@@ -2550,7 +2563,7 @@ class WebGLRenderer {
 			if ( texture.isTexture !== true ) {
 
 				// @deprecated, r165
-				console.warn( 'WebGLRenderer: copyFramebufferToTexture function signature has changed.' );
+				warnOnce( 'WebGLRenderer: copyFramebufferToTexture function signature has changed.' );
 
 				position = arguments[ 0 ] || null;
 				texture = arguments[ 1 ];
@@ -2578,7 +2591,7 @@ class WebGLRenderer {
 			if ( srcTexture.isTexture !== true ) {
 
 				// @deprecated, r165
-				console.warn( 'WebGLRenderer: copyTextureToTexture function signature has changed.' );
+				warnOnce( 'WebGLRenderer: copyTextureToTexture function signature has changed.' );
 
 				dstPosition = arguments[ 0 ] || null;
 				srcTexture = arguments[ 1 ];
@@ -2654,7 +2667,7 @@ class WebGLRenderer {
 
 				} else {
 
-					_gl.texSubImage2D( _gl.TEXTURE_2D, level, dstX, dstY, glFormat, glType, image );
+					_gl.texSubImage2D( _gl.TEXTURE_2D, level, dstX, dstY, width, height, glFormat, glType, image );
 
 				}
 
@@ -2679,7 +2692,7 @@ class WebGLRenderer {
 			if ( srcTexture.isTexture !== true ) {
 
 				// @deprecated, r165
-				console.warn( 'WebGLRenderer: copyTextureToTexture3D function signature has changed.' );
+				warnOnce( 'WebGLRenderer: copyTextureToTexture3D function signature has changed.' );
 
 				srcRegion = arguments[ 0 ] || null;
 				dstPosition = arguments[ 1 ] || 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 {
 

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 ) {
 
-		for ( const binding of bindings ) {
+			this._update( object, bindGroup, 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 ) {
 
@@ -152,7 +168,6 @@ class Bindings extends DataMap {
 
 				}
 
-
 				if ( texture.isStorageTexture === true ) {
 
 					const textureData = this.get( texture );
@@ -179,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/{examples/jsm → src}/renderers/common/ClippingContext.js

@@ -1,6 +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 _plane = /*@__PURE__*/ new Plane();
 
 let _clippingContextVersion = 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,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 );
+
+			}
 
 		}