super-three 0.169.1 → 0.170.1

package/src/renderers/common/Bindings.js

@@ -32,7 +32,7 @@ class Bindings extends DataMap {
 
 				this._init( bindGroup );
 
-				this.backend.createBindings( bindGroup, bindings );
+				this.backend.createBindings( bindGroup, bindings, 0 );
 
 				groupData.bindGroup = bindGroup;
 
@@ -56,7 +56,7 @@ class Bindings extends DataMap {
 
 				this._init( bindGroup );
 
-				this.backend.createBindings( bindGroup, bindings );
+				this.backend.createBindings( bindGroup, bindings, 0 );
 
 				groupData.bindGroup = bindGroup;
 
@@ -101,8 +101,9 @@ class Bindings extends DataMap {
 			} else if ( binding.isStorageBuffer ) {
 
 				const attribute = binding.attribute;
+				const attributeType = attribute.isIndirectStorageBufferAttribute ? AttributeType.INDIRECT : AttributeType.STORAGE;
 
-				this.attributes.update( attribute, AttributeType.STORAGE );
+				this.attributes.update( attribute, attributeType );
 
 			}
 
@@ -115,6 +116,9 @@ class Bindings extends DataMap {
 		const { backend } = this;
 
 		let needsBindingsUpdate = false;
+		let cacheBindings = true;
+		let cacheIndex = 0;
+		let version = 0;
 
 		// iterate over all bindings and check if buffer updates or a new binding group is required
 
@@ -144,7 +148,9 @@ class Bindings extends DataMap {
 
 			} else if ( binding.isSampledTexture ) {
 
-				if ( binding.needsBindingsUpdate( this.textures.get( binding.texture ).generation ) ) needsBindingsUpdate = true;
+				const texturesTextureData = this.textures.get( binding.texture );
+
+				if ( binding.needsBindingsUpdate( texturesTextureData.generation ) ) needsBindingsUpdate = true;
 
 				const updated = binding.update();
 
@@ -158,6 +164,17 @@ class Bindings extends DataMap {
 
 				const textureData = backend.get( texture );
 
+				if ( textureData.externalTexture !== undefined || texturesTextureData.isDefaultTexture ) {
+
+					cacheBindings = false;
+
+				} else {
+
+					cacheIndex = cacheIndex * 10 + texture.id;
+					version += texture.version;
+
+				}
+
 				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
@@ -176,7 +193,7 @@ class Bindings extends DataMap {
 
 						textureData.needsMipmap = true;
 
-					} else if ( texture.generateMipmaps === true && this.textures.needsMipmaps( texture ) && textureData.needsMipmap === true ) {
+					} else if ( this.textures.needsMipmaps( texture ) && textureData.needsMipmap === true ) {
 
 						this.backend.generateMipmaps( texture );
 
@@ -192,7 +209,7 @@ class Bindings extends DataMap {
 
 		if ( needsBindingsUpdate === true ) {
 
-			this.backend.updateBindings( bindGroup, bindings );
+			this.backend.updateBindings( bindGroup, bindings, cacheBindings ? cacheIndex : 0, version );
 
 		}
 

package/src/renderers/common/ClippingContext.js

@@ -1,40 +1,53 @@
 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 = /*@__PURE__*/ new Plane();
 
 class ClippingContext {
 
-	constructor() {
+	constructor( parentContext = null ) {
 
 		this.version = 0;
 
-		this.globalClippingCount = 0;
+		this.clipIntersection = null;
+		this.cacheKey = '';
 
-		this.localClippingCount = 0;
-		this.localClippingEnabled = false;
-		this.localClipIntersection = false;
 
-		this.planes = [];
+		if ( parentContext === null ) {
 
-		this.parentVersion = 0;
-		this.viewNormalMatrix = new Matrix3();
-		this.cacheKey = 0;
+			this.intersectionPlanes = [];
+			this.unionPlanes = [];
+
+			this.viewNormalMatrix = new Matrix3();
+			this.clippingGroupContexts = new WeakMap();
+
+			this.shadowPass = false;
+
+		} else {
+
+			this.viewNormalMatrix = parentContext.viewNormalMatrix;
+			this.clippingGroupContexts = parentContext.clippingGroupContexts;
+
+			this.shadowPass = parentContext.shadowPass;
+
+			this.viewMatrix = parentContext.viewMatrix;
+
+		}
+
+		this.parentVersion = null;
 
 	}
 
-	projectPlanes( source, offset ) {
+	projectPlanes( source, destination, offset ) {
 
 		const l = source.length;
-		const planes = this.planes;
 
 		for ( let i = 0; i < l; i ++ ) {
 
 			_plane.copy( source[ i ] ).applyMatrix4( this.viewMatrix, this.viewNormalMatrix );
 
-			const v = planes[ offset + i ];
+			const v = destination[ offset + i ];
 			const normal = _plane.normal;
 
 			v.x = - normal.x;
@@ -46,129 +59,108 @@ class ClippingContext {
 
 	}
 
-	updateGlobal( renderer, camera ) {
+	updateGlobal( scene, camera ) {
 
-		const rendererClippingPlanes = renderer.clippingPlanes;
+		this.shadowPass = ( scene.overrideMaterial !== null && scene.overrideMaterial.isShadowNodeMaterial );
 		this.viewMatrix = camera.matrixWorldInverse;
 
 		this.viewNormalMatrix.getNormalMatrix( this.viewMatrix );
 
-		let update = false;
-
-		if ( Array.isArray( rendererClippingPlanes ) && rendererClippingPlanes.length !== 0 ) {
+	}
 
-			const l = rendererClippingPlanes.length;
+	update( parentContext, clippingGroup ) {
 
-			if ( l !== this.globalClippingCount ) {
+		let update = false;
 
-				const planes = [];
+		if ( parentContext.version !== this.parentVersion ) {
 
-				for ( let i = 0; i < l; i ++ ) {
+			this.intersectionPlanes = Array.from( parentContext.intersectionPlanes );
+			this.unionPlanes = Array.from( parentContext.unionPlanes );
+			this.parentVersion = parentContext.version;
 
-					planes.push( new Vector4() );
+		}
 
-				}
+		if ( this.clipIntersection !== clippingGroup.clipIntersection ) {
 
-				this.globalClippingCount = l;
-				this.planes = planes;
+			this.clipIntersection = clippingGroup.clipIntersection;
 
-				update = true;
+			if ( this.clipIntersection ) {
 
-			}
+				this.unionPlanes.length = parentContext.unionPlanes.length;
 
-			this.projectPlanes( rendererClippingPlanes, 0 );
+			} else {
 
-		} else if ( this.globalClippingCount !== 0 ) {
+				this.intersectionPlanes.length = parentContext.intersectionPlanes.length;
 
-			this.globalClippingCount = 0;
-			this.planes = [];
-			update = true;
+			}
 
 		}
 
-		if ( renderer.localClippingEnabled !== this.localClippingEnabled ) {
+		const srcClippingPlanes = clippingGroup.clippingPlanes;
+		const l = srcClippingPlanes.length;
 
-			this.localClippingEnabled = renderer.localClippingEnabled;
-			update = true;
+		let dstClippingPlanes;
+		let offset;
 
-		}
+		if ( this.clipIntersection ) {
 
-		if ( update ) {
+			dstClippingPlanes = this.intersectionPlanes;
+			offset = parentContext.intersectionPlanes.length;
 
-			this.version ++;
-			this.cacheKey = hash( this.globalClippingCount, this.localClippingEnabled === true ? 1 : 0 );
+		} else {
+
+			dstClippingPlanes = this.unionPlanes;
+			offset = parentContext.unionPlanes.length;
 
 		}
 
-	}
+		if ( dstClippingPlanes.length !== offset + l ) {
 
-	update( parent, material ) {
+			dstClippingPlanes.length = offset + l;
 
-		let update = false;
+			for ( let i = 0; i < l; i ++ ) {
 
-		if ( this !== parent && parent.version !== this.parentVersion ) {
+				dstClippingPlanes[ offset + i ] = new Vector4();
 
-			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;
 
 		}
 
-		if ( this.localClippingEnabled ) {
-
-			const localClippingPlanes = material.clippingPlanes;
-
-			if ( ( Array.isArray( localClippingPlanes ) && localClippingPlanes.length !== 0 ) ) {
-
-				const l = localClippingPlanes.length;
-				const planes = this.planes;
-				const offset = this.globalClippingCount;
+		this.projectPlanes( srcClippingPlanes, dstClippingPlanes, offset );
 
-				if ( update || l !== this.localClippingCount ) {
-
-					planes.length = offset + l;
-
-					for ( let i = 0; i < l; i ++ ) {
-
-						planes[ offset + i ] = new Vector4();
-
-					}
+		if ( update ) {
 
-					this.localClippingCount = l;
-					update = true;
+			this.version ++;
+			this.cacheKey = `${ this.intersectionPlanes.length }:${ this.unionPlanes.length }`;
 
-				}
+		}
 
-				this.projectPlanes( localClippingPlanes, offset );
+	}
 
+	getGroupContext( clippingGroup ) {
 
-			} else if ( this.localClippingCount !== 0 ) {
+		if ( this.shadowPass && ! clippingGroup.clipShadows ) return this;
 
-				this.localClippingCount = 0;
-				update = true;
+		let context = this.clippingGroupContexts.get( clippingGroup );
 
-			}
+		if ( context === undefined ) {
 
-			if ( this.localClipIntersection !== material.clipIntersection ) {
+			context = new ClippingContext( this );
+			this.clippingGroupContexts.set( clippingGroup, context );
 
-				this.localClipIntersection = material.clipIntersection;
-				update = true;
+		}
 
-			}
+		context.update( this, clippingGroup );
 
-		}
+		return context;
 
-		if ( update ) {
+	}
 
-			this.version += parent.version;
-			this.cacheKey = hash( parent.cacheKey, this.localClippingCount, this.localClipIntersection === true ? 1 : 0 );
+	get unionClippingCount() {
 
-		}
+		return this.unionPlanes.length;
 
 	}
 

package/src/renderers/common/Constants.js

@@ -1,7 +1,8 @@
 export const AttributeType = {
 	VERTEX: 1,
 	INDEX: 2,
-	STORAGE: 4
+	STORAGE: 3,
+	INDIRECT: 4
 };
 
 // size of a chunk in bytes (STD140 layout)

package/src/renderers/common/Geometries.js

@@ -144,6 +144,8 @@ class Geometries extends DataMap {
 
 	updateAttributes( renderObject ) {
 
+		// attributes
+
 		const attributes = renderObject.getAttributes();
 
 		for ( const attribute of attributes ) {
@@ -160,6 +162,8 @@ class Geometries extends DataMap {
 
 		}
 
+		// indexes
+
 		const index = this.getIndex( renderObject );
 
 		if ( index !== null ) {
@@ -168,6 +172,16 @@ class Geometries extends DataMap {
 
 		}
 
+		// indirect
+
+		const indirect = renderObject.geometry.indirect;
+
+		if ( indirect !== null ) {
+
+			this.updateAttribute( indirect, AttributeType.INDIRECT );
+
+		}
+
 	}
 
 	updateAttribute( attribute, type ) {
@@ -206,6 +220,12 @@ class Geometries extends DataMap {
 
 	}
 
+	getIndirect( renderObject ) {
+
+		return renderObject.geometry.indirect;
+
+	}
+
 	getIndex( renderObject ) {
 
 		const { geometry, material } = renderObject;

package/src/renderers/common/IndirectStorageBufferAttribute.js

@@ -0,0 +1,15 @@
+import StorageBufferAttribute from './StorageBufferAttribute.js';
+
+class IndirectStorageBufferAttribute extends StorageBufferAttribute {
+
+	constructor( array, itemSize ) {
+
+		super( array, itemSize, Uint32Array );
+
+		this.isIndirectStorageBufferAttribute = true;
+
+	}
+
+}
+
+export default IndirectStorageBufferAttribute;

package/src/renderers/common/Lighting.js

@@ -0,0 +1,45 @@
+import { LightsNode } from '../../nodes/Nodes.js';
+import ChainMap from './ChainMap.js';
+
+const _defaultLights = /*@__PURE__*/ new LightsNode();
+
+class Lighting extends ChainMap {
+
+	constructor() {
+
+		super();
+
+	}
+
+	createNode( lights = [] ) {
+
+		return new LightsNode().setLights( lights );
+
+	}
+
+	getNode( scene, camera ) {
+
+		// ignore post-processing
+
+		if ( scene.isQuadMesh ) return _defaultLights;
+
+		// tiled lighting
+
+		const keys = [ scene, camera ];
+
+		let node = this.get( keys );
+
+		if ( node === undefined ) {
+
+			node = this.createNode();
+			this.set( keys, node );
+
+		}
+
+		return node;
+
+	}
+
+}
+
+export default Lighting;

package/src/renderers/common/PostProcessingUtils.js

@@ -0,0 +1,86 @@
+import { Color } from '../../math/Color.js';
+
+// renderer state
+
+export function saveRendererState( renderer, state = {} ) {
+
+	state.toneMapping = renderer.toneMapping;
+	state.toneMappingExposure = renderer.toneMappingExposure;
+	state.outputColorSpace = renderer.outputColorSpace;
+	state.renderTarget = renderer.getRenderTarget();
+	state.activeCubeFace = renderer.getActiveCubeFace();
+	state.activeMipmapLevel = renderer.getActiveMipmapLevel();
+	state.renderObjectFunction = renderer.getRenderObjectFunction();
+	state.pixelRatio = renderer.getPixelRatio();
+	state.mrt = renderer.getMRT();
+	state.clearColor = renderer.getClearColor( state.clearColor || new Color() );
+	state.clearAlpha = renderer.getClearAlpha();
+	state.autoClear = renderer.autoClear;
+	state.scissorTest = renderer.getScissorTest();
+
+	return state;
+
+}
+
+export function resetRendererState( renderer, state ) {
+
+	state = saveRendererState( renderer, state );
+
+	renderer.setMRT( null );
+	renderer.setRenderObjectFunction( null );
+	renderer.setClearColor( 0x000000, 1 );
+	renderer.autoClear = true;
+
+	return state;
+
+}
+
+export function restoreRendererState( renderer, state ) {
+
+	renderer.toneMapping = state.toneMapping;
+	renderer.toneMappingExposure = state.toneMappingExposure;
+	renderer.outputColorSpace = state.outputColorSpace;
+	renderer.setRenderTarget( state.renderTarget, state.activeCubeFace, state.activeMipmapLevel );
+	renderer.setRenderObjectFunction( state.renderObjectFunction );
+	renderer.setPixelRatio( state.pixelRatio );
+	renderer.setMRT( state.mrt );
+	renderer.setClearColor( state.clearColor, state.clearAlpha );
+	renderer.autoClear = state.autoClear;
+	renderer.setScissorTest( state.scissorTest );
+
+}
+
+// renderer and scene state
+
+export function saveRendererAndSceneState( renderer, scene, state = {} ) {
+
+	state = saveRendererState( renderer, state );
+	state.background = scene.background;
+	state.backgroundNode = scene.backgroundNode;
+	state.overrideMaterial = scene.overrideMaterial;
+
+	return state;
+
+}
+
+export function resetRendererAndSceneState( renderer, scene, state ) {
+
+	state = saveRendererAndSceneState( renderer, scene, state );
+
+	scene.background = null;
+	scene.backgroundNode = null;
+	scene.overrideMaterial = null;
+
+	return state;
+
+}
+
+export function restoreRendererAndSceneState( renderer, scene, state ) {
+
+	restoreRendererState( renderer, state );
+
+	scene.background = state.background;
+	scene.backgroundNode = state.backgroundNode;
+	scene.overrideMaterial = state.overrideMaterial;
+
+}

package/src/renderers/common/RenderList.js

@@ -1,4 +1,4 @@
-import { LightsNode } from '../../nodes/Nodes.js';
+import { DoubleSide } from '../../constants.js';
 
 function painterSortStable( a, b ) {
 
@@ -48,20 +48,32 @@ function reversePainterSortStable( a, b ) {
 
 }
 
+function needsDoublePass( material ) {
+
+	const hasTransmission = material.transmission > 0 || material.transmissionNode;
+
+	return hasTransmission && material.side === DoubleSide && material.forceSinglePass === false;
+
+}
+
 class RenderList {
 
-	constructor() {
+	constructor( lighting, scene, camera ) {
 
 		this.renderItems = [];
 		this.renderItemsIndex = 0;
 
 		this.opaque = [];
+		this.transparentDoublePass = [];
 		this.transparent = [];
 		this.bundles = [];
 
-		this.lightsNode = new LightsNode( [] );
+		this.lightsNode = lighting.getNode( scene, camera );
 		this.lightsArray = [];
 
+		this.scene = scene;
+		this.camera = camera;
+
 		this.occlusionQueryCount = 0;
 
 	}
@@ -71,6 +83,7 @@ class RenderList {
 		this.renderItemsIndex = 0;
 
 		this.opaque.length = 0;
+		this.transparentDoublePass.length = 0;
 		this.transparent.length = 0;
 		this.bundles.length = 0;
 
@@ -82,7 +95,7 @@ class RenderList {
 
 	}
 
-	getNextRenderItem( object, geometry, material, groupOrder, z, group ) {
+	getNextRenderItem( object, geometry, material, groupOrder, z, group, clippingContext ) {
 
 		let renderItem = this.renderItems[ this.renderItemsIndex ];
 
@@ -96,7 +109,8 @@ class RenderList {
 				groupOrder: groupOrder,
 				renderOrder: object.renderOrder,
 				z: z,
-				group: group
+				group: group,
+				clippingContext: clippingContext
 			};
 
 			this.renderItems[ this.renderItemsIndex ] = renderItem;
@@ -111,6 +125,7 @@ class RenderList {
 			renderItem.renderOrder = object.renderOrder;
 			renderItem.z = z;
 			renderItem.group = group;
+			renderItem.clippingContext = clippingContext;
 
 		}
 
@@ -120,21 +135,41 @@ class RenderList {
 
 	}
 
-	push( object, geometry, material, groupOrder, z, group ) {
+	push( object, geometry, material, groupOrder, z, group, clippingContext ) {
 
-		const renderItem = this.getNextRenderItem( object, geometry, material, groupOrder, z, group );
+		const renderItem = this.getNextRenderItem( object, geometry, material, groupOrder, z, group, clippingContext );
 
 		if ( object.occlusionTest === true ) this.occlusionQueryCount ++;
 
-		( material.transparent === true || material.transmission > 0 ? this.transparent : this.opaque ).push( renderItem );
+		if ( material.transparent === true || material.transmission > 0 ) {
+
+			if ( needsDoublePass( material ) ) this.transparentDoublePass.push( renderItem );
+
+			this.transparent.push( renderItem );
+
+		} else {
+
+			this.opaque.push( renderItem );
+
+		}
 
 	}
 
-	unshift( object, geometry, material, groupOrder, z, group ) {
+	unshift( object, geometry, material, groupOrder, z, group, clippingContext ) {
+
+		const renderItem = this.getNextRenderItem( object, geometry, material, groupOrder, z, group, clippingContext );
+
+		if ( material.transparent === true || material.transmission > 0 ) {
+
+			if ( needsDoublePass( material ) ) this.transparentDoublePass.unshift( renderItem );
+
+			this.transparent.unshift( renderItem );
+
+		} else {
 
-		const renderItem = this.getNextRenderItem( object, geometry, material, groupOrder, z, group );
+			this.opaque.unshift( renderItem );
 
-		( material.transparent === true ? this.transparent : this.opaque ).unshift( renderItem );
+		}
 
 	}
 
@@ -150,15 +185,10 @@ class RenderList {
 
 	}
 
-	getLightsNode() {
-
-		return this.lightsNode.fromLights( this.lightsArray );
-
-	}
-
 	sort( customOpaqueSort, customTransparentSort ) {
 
 		if ( this.opaque.length > 1 ) this.opaque.sort( customOpaqueSort || painterSortStable );
+		if ( this.transparentDoublePass.length > 1 ) this.transparentDoublePass.sort( customTransparentSort || reversePainterSortStable );
 		if ( this.transparent.length > 1 ) this.transparent.sort( customTransparentSort || reversePainterSortStable );
 
 	}
@@ -185,6 +215,7 @@ class RenderList {
 			renderItem.renderOrder = null;
 			renderItem.z = null;
 			renderItem.group = null;
+			renderItem.clippingContext = null;
 
 		}