super-three 0.170.0 → 0.171.0

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/RenderList.js

@@ -95,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 ];
 
@@ -109,7 +109,8 @@ class RenderList {
 				groupOrder: groupOrder,
 				renderOrder: object.renderOrder,
 				z: z,
-				group: group
+				group: group,
+				clippingContext: clippingContext
 			};
 
 			this.renderItems[ this.renderItemsIndex ] = renderItem;
@@ -124,6 +125,7 @@ class RenderList {
 			renderItem.renderOrder = object.renderOrder;
 			renderItem.z = z;
 			renderItem.group = group;
+			renderItem.clippingContext = clippingContext;
 
 		}
 
@@ -133,9 +135,9 @@ 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 ++;
 
@@ -153,9 +155,9 @@ class RenderList {
 
 	}
 
-	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 );
+		const renderItem = this.getNextRenderItem( object, geometry, material, groupOrder, z, group, clippingContext );
 
 		if ( material.transparent === true || material.transmission > 0 ) {
 
@@ -213,6 +215,7 @@ class RenderList {
 			renderItem.renderOrder = null;
 			renderItem.z = null;
 			renderItem.group = null;
+			renderItem.clippingContext = null;
 
 		}
 

package/src/renderers/common/RenderObject.js

@@ -1,5 +1,4 @@
 import { hashString } from '../../nodes/core/NodeUtils.js';
-import ClippingContext from './ClippingContext.js';
 
 let _id = 0;
 
@@ -39,7 +38,7 @@ function getKeys( obj ) {
 
 export default class RenderObject {
 
-	constructor( nodes, geometries, renderer, object, material, scene, camera, lightsNode, renderContext ) {
+	constructor( nodes, geometries, renderer, object, material, scene, camera, lightsNode, renderContext, clippingContext ) {
 
 		this._nodes = nodes;
 		this._geometries = geometries;
@@ -66,9 +65,8 @@ export default class RenderObject {
 
 		this.bundle = null;
 
-		this.updateClipping( renderContext.clippingContext );
-
-		this.clippingContextVersion = this.clippingContext.version;
+		this.clippingContext = clippingContext;
+		this.clippingContextCacheKey = clippingContext !== null ? clippingContext.cacheKey : '';
 
 		this.initialNodesCacheKey = this.getDynamicCacheKey();
 		this.initialCacheKey = this.getCacheKey();
@@ -93,36 +91,23 @@ export default class RenderObject {
 
 	updateClipping( parent ) {
 
-		const material = this.material;
-
-		let clippingContext = this.clippingContext;
-
-		if ( Array.isArray( material.clippingPlanes ) ) {
+		this.clippingContext = parent;
 
-			if ( clippingContext === parent || ! clippingContext ) {
-
-				clippingContext = new ClippingContext();
-				this.clippingContext = clippingContext;
-
-			}
+	}
 
-			clippingContext.update( parent, material );
+	get clippingNeedsUpdate() {
 
-		} else if ( this.clippingContext !== parent ) {
+		if ( this.clippingContext === null || this.clippingContext.cacheKey === this.clippingContextCacheKey ) return false;
 
-			this.clippingContext = parent;
+		this.clippingContextCacheKey = this.clippingContext.cacheKey;
 
-		}
+		return true;
 
 	}
 
-	get clippingNeedsUpdate() {
-
-		if ( this.clippingContext.version === this.clippingContextVersion ) return false;
+	get hardwareClippingPlanes() {
 
-		this.clippingContextVersion = this.clippingContext.version;
-
-		return true;
+		return this.material.hardwareClipping === true ? this.clippingContext.unionClippingCount : 0;
 
 	}
 
@@ -162,6 +147,13 @@ export default class RenderObject {
 
 	}
 
+	setGeometry( geometry ) {
+
+		this.geometry = geometry;
+		this.attributes = null;
+
+	}
+
 	getAttributes() {
 
 		if ( this.attributes !== null ) return this.attributes;
@@ -347,7 +339,7 @@ export default class RenderObject {
 
 		}
 
-		cacheKey += this.clippingContext.cacheKey + ',';
+		cacheKey += this.clippingContextCacheKey + ',';
 
 		if ( object.geometry ) {
 
@@ -387,10 +379,18 @@ export default class RenderObject {
 
 		}
 
+		cacheKey += object.receiveShadow + ',';
+
 		return hashString( cacheKey );
 
 	}
 
+	get needsGeometryUpdate() {
+
+		return this.geometry.id !== this.object.geometry.id;
+
+	}
+
 	get needsUpdate() {
 
 		return /*this.object.static !== true &&*/ ( this.initialNodesCacheKey !== this.getDynamicCacheKey() || this.clippingNeedsUpdate );

package/src/renderers/common/RenderObjects.js

@@ -18,7 +18,7 @@ class RenderObjects {
 
 	}
 
-	get( object, material, scene, camera, lightsNode, renderContext, passId ) {
+	get( object, material, scene, camera, lightsNode, renderContext, clippingContext, passId ) {
 
 		const chainMap = this.getChainMap( passId );
 
@@ -32,13 +32,19 @@ class RenderObjects {
 
 		if ( renderObject === undefined ) {
 
-			renderObject = this.createRenderObject( this.nodes, this.geometries, this.renderer, object, material, scene, camera, lightsNode, renderContext, passId );
+			renderObject = this.createRenderObject( this.nodes, this.geometries, this.renderer, object, material, scene, camera, lightsNode, renderContext, clippingContext, passId );
 
 			chainMap.set( chainArray, renderObject );
 
 		} else {
 
-			renderObject.updateClipping( renderContext.clippingContext );
+			renderObject.updateClipping( clippingContext );
+
+			if ( renderObject.needsGeometryUpdate ) {
+
+				renderObject.setGeometry( object.geometry );
+
+			}
 
 			if ( renderObject.version !== material.version || renderObject.needsUpdate ) {
 
@@ -46,7 +52,7 @@ class RenderObjects {
 
 					renderObject.dispose();
 
-					renderObject = this.get( object, material, scene, camera, lightsNode, renderContext, passId );
+					renderObject = this.get( object, material, scene, camera, lightsNode, renderContext, clippingContext, passId );
 
 				} else {
 
@@ -74,11 +80,11 @@ class RenderObjects {
 
 	}
 
-	createRenderObject( nodes, geometries, renderer, object, material, scene, camera, lightsNode, renderContext, passId ) {
+	createRenderObject( nodes, geometries, renderer, object, material, scene, camera, lightsNode, renderContext, clippingContext, passId ) {
 
 		const chainMap = this.getChainMap( passId );
 
-		const renderObject = new RenderObject( nodes, geometries, renderer, object, material, scene, camera, lightsNode, renderContext );
+		const renderObject = new RenderObject( nodes, geometries, renderer, object, material, scene, camera, lightsNode, renderContext, clippingContext );
 
 		renderObject.onDispose = () => {