super-three 0.181.0 → 0.185.0

package/src/materials/nodes/manager/NodeMaterialObserver.js

@@ -22,6 +22,7 @@ const refreshUniforms = [
 	'emissiveMap',
 	'envMap',
 	'envMapIntensity',
+	'envMapRotation',
 	'gradientMap',
 	'ior',
 	'iridescence',
@@ -65,6 +66,22 @@ const refreshUniforms = [
  */
 const _lightsCache = new WeakMap();
 
+/**
+ * Holds the material data for comparison.
+ *
+ * @private
+ * @type {WeakMap<Material,Object>}
+ */
+const _materialCache = new WeakMap();
+
+/**
+ * Holds the geometry data for comparison.
+ *
+ * @private
+ * @type {WeakMap<BufferGeometry,Object>}
+ */
+const _geometryCache = new WeakMap();
+
 /**
  * This class is used by {@link WebGPURenderer} as management component.
  * It's primary purpose is to determine whether render objects require a
@@ -166,16 +183,10 @@ class NodeMaterialObserver {
 
 		if ( data === undefined ) {
 
-			const { geometry, material, object } = renderObject;
+			const { geometry, object } = renderObject;
 
 			data = {
-				material: this.getMaterialData( material ),
-				geometry: {
-					id: geometry.id,
-					attributes: this.getAttributesData( geometry.attributes ),
-					indexVersion: geometry.index ? geometry.index.version : null,
-					drawRange: { start: geometry.drawRange.start, count: geometry.drawRange.count }
-				},
+				geometryId: geometry.id,
 				worldMatrix: object.matrixWorld.clone()
 			};
 
@@ -197,7 +208,7 @@ class NodeMaterialObserver {
 
 			}
 
-			if ( data.material.transmission > 0 ) {
+			if ( renderObject.material.transmission > 0 ) {
 
 				const { width, height } = renderObject.context;
 
@@ -206,7 +217,12 @@ class NodeMaterialObserver {
 
 			}
 
-			data.lights = this.getLightsData( renderObject.lightsNode.getLights() );
+			const { environmentIntensity, environmentRotation } = renderObject.scene;
+
+			data.environmentIntensity = environmentIntensity;
+			data.environmentRotation = environmentRotation.clone();
+
+			data.lights = this.getLightsData( renderObject.lightsNode.getLights(), [] );
 
 			this.renderObjects.set( renderObject, data );
 
@@ -232,7 +248,8 @@ class NodeMaterialObserver {
 			const attribute = attributes[ name ];
 
 			attributesData[ name ] = {
-				version: attribute.version
+				id: attribute.isInterleavedBufferAttribute ? attribute.data.uuid : attribute.id,
+				version: attribute.isInterleavedBufferAttribute ? attribute.data.version : attribute.version,
 			};
 
 		}
@@ -259,13 +276,44 @@ class NodeMaterialObserver {
 
 		}
 
-		if ( builder.renderer.overrideNodes.modelViewMatrix !== null || builder.renderer.overrideNodes.modelNormalViewMatrix !== null )
+		if ( builder.context.modelViewMatrix || builder.context.modelNormalViewMatrix || builder.context.getAO || builder.context.getShadow )
 			return true;
 
 		return false;
 
 	}
 
+	/**
+	 * Returns a geometry data structure holding the geometry property values for
+	 * monitoring.
+	 *
+	 * @param {BufferGeometry} geometry - The geometry.
+	 * @return {Object} An object for monitoring geometry properties.
+	 */
+	getGeometryData( geometry ) {
+
+		let data = _geometryCache.get( geometry );
+
+		if ( data === undefined ) {
+
+			data = {
+				_renderId: - 1,
+				_equal: false,
+
+				attributes: this.getAttributesData( geometry.attributes ),
+				indexId: geometry.index ? geometry.index.id : null,
+				indexVersion: geometry.index ? geometry.index.version : null,
+				drawRange: { start: geometry.drawRange.start, count: geometry.drawRange.count }
+			};
+
+			_geometryCache.set( geometry, data );
+
+		}
+
+		return data;
+
+	}
+
 	/**
 	 * Returns a material data structure holding the material property values for
 	 * monitoring.
@@ -275,32 +323,40 @@ class NodeMaterialObserver {
 	 */
 	getMaterialData( material ) {
 
-		const data = {};
+		let data = _materialCache.get( material );
 
-		for ( const property of this.refreshUniforms ) {
+		if ( data === undefined ) {
 
-			const value = material[ property ];
+			data = { _renderId: - 1, _equal: false };
 
-			if ( value === null || value === undefined ) continue;
+			for ( const property of this.refreshUniforms ) {
 
-			if ( typeof value === 'object' && value.clone !== undefined ) {
+				const value = material[ property ];
 
-				if ( value.isTexture === true ) {
+				if ( value === null || value === undefined ) continue;
 
-					data[ property ] = { id: value.id, version: value.version };
+				if ( typeof value === 'object' && value.clone !== undefined ) {
 
-				} else {
+					if ( value.isTexture === true ) {
 
-					data[ property ] = value.clone();
+						data[ property ] = { id: value.id, version: 0 };
 
-				}
+					} else {
+
+						data[ property ] = value.clone();
 
-			} else {
+					}
 
-				data[ property ] = value;
+				} else {
+
+					data[ property ] = value;
+
+				}
 
 			}
 
+			_materialCache.set( material, data );
+
 		}
 
 		return data;
@@ -312,9 +368,10 @@ class NodeMaterialObserver {
 	 *
 	 * @param {RenderObject} renderObject - The render object.
 	 * @param {Array<Light>} lightsData - The current material lights.
-	 * @return {boolean} Whether the given render object has changed its state or not.
+	 * @param {number} renderId - The current render ID.
+	 * @return {boolean} Whether the given render object is equal to its cached state or not.
 	 */
-	equals( renderObject, lightsData ) {
+	equals( renderObject, lightsData, renderId ) {
 
 		const { object, material, geometry } = renderObject;
 
@@ -332,126 +389,183 @@ class NodeMaterialObserver {
 
 		// material
 
-		const materialData = renderObjectData.material;
+		const materialData = this.getMaterialData( renderObject.material );
+
+		// check the material for the "equal" state just once per render for all render objects
+
+		if ( materialData._renderId !== renderId ) {
 
-		for ( const property in materialData ) {
+			materialData._renderId = renderId;
 
-			const value = materialData[ property ];
-			const mtlValue = material[ property ];
+			for ( const property in materialData ) {
 
-			if ( value.equals !== undefined ) {
+				const value = materialData[ property ];
+				const mtlValue = material[ property ];
 
-				if ( value.equals( mtlValue ) === false ) {
+				if ( property === '_renderId' ) continue;
+				if ( property === '_equal' ) continue;
 
-					value.copy( mtlValue );
+				if ( value.equals !== undefined ) {
 
+					if ( value.equals( mtlValue ) === false ) {
+
+						value.copy( mtlValue );
+
+						materialData._equal = false;
+						return false;
+
+					}
+
+				} else if ( mtlValue.isTexture === true ) {
+
+					if ( value.id !== mtlValue.id || value.version !== mtlValue.version ) {
+
+						value.id = mtlValue.id;
+						value.version = mtlValue.version;
+
+						materialData._equal = false;
+						return false;
+
+					}
+
+				} else if ( value !== mtlValue ) {
+
+					materialData[ property ] = mtlValue;
+
+					materialData._equal = false;
 					return false;
 
 				}
 
-			} else if ( mtlValue.isTexture === true ) {
+			}
+
+			if ( materialData.transmission > 0 ) {
 
-				if ( value.id !== mtlValue.id || value.version !== mtlValue.version ) {
+				const { width, height } = renderObject.context;
 
-					value.id = mtlValue.id;
-					value.version = mtlValue.version;
+				if ( renderObjectData.bufferWidth !== width || renderObjectData.bufferHeight !== height ) {
 
+					renderObjectData.bufferWidth = width;
+					renderObjectData.bufferHeight = height;
+
+					materialData._equal = false;
 					return false;
 
 				}
 
-			} else if ( value !== mtlValue ) {
+			}
 
-				materialData[ property ] = mtlValue;
+			materialData._equal = true;
 
-				return false;
+		} else {
 
-			}
+			if ( materialData._equal === false ) return false;
 
 		}
 
-		if ( materialData.transmission > 0 ) {
+		// geometry
 
-			const { width, height } = renderObject.context;
+		if ( renderObjectData.geometryId !== geometry.id ) {
 
-			if ( renderObjectData.bufferWidth !== width || renderObjectData.bufferHeight !== height ) {
+			renderObjectData.geometryId = geometry.id;
+			return false;
 
-				renderObjectData.bufferWidth = width;
-				renderObjectData.bufferHeight = height;
+		}
 
-				return false;
+		const geometryData = this.getGeometryData( renderObject.geometry );
 
-			}
+		// check the geoemtry for the "equal" state just once per render for all render objects
 
-		}
+		if ( geometryData._renderId !== renderId ) {
 
-		// geometry
+			geometryData._renderId = renderId;
 
-		const storedGeometryData = renderObjectData.geometry;
-		const attributes = geometry.attributes;
-		const storedAttributes = storedGeometryData.attributes;
+			// attributes
 
-		const storedAttributeNames = Object.keys( storedAttributes );
-		const currentAttributeNames = Object.keys( attributes );
+			const attributes = geometry.attributes;
+			const storedAttributes = geometryData.attributes;
 
-		if ( storedGeometryData.id !== geometry.id ) {
+			let currentAttributeCount = 0;
+			let storedAttributeCount = 0;
 
-			storedGeometryData.id = geometry.id;
-			return false;
+			for ( const _ in attributes ) currentAttributeCount ++; // eslint-disable-line no-unused-vars
 
-		}
+			for ( const name in storedAttributes ) {
 
-		if ( storedAttributeNames.length !== currentAttributeNames.length ) {
+				storedAttributeCount ++;
 
-			renderObjectData.geometry.attributes = this.getAttributesData( attributes );
-			return false;
+				const storedAttributeData = storedAttributes[ name ];
+				const attribute = attributes[ name ];
 
-		}
+				if ( attribute === undefined ) {
 
-		// compare each attribute
+					// attribute was removed
+					delete storedAttributes[ name ];
 
-		for ( const name of storedAttributeNames ) {
+					geometryData._equal = false;
+					return false;
 
-			const storedAttributeData = storedAttributes[ name ];
-			const attribute = attributes[ name ];
+				}
 
-			if ( attribute === undefined ) {
+				const id = attribute.isInterleavedBufferAttribute ? attribute.data.uuid : attribute.id;
+				const version = attribute.isInterleavedBufferAttribute ? attribute.data.version : attribute.version;
 
-				// attribute was removed
-				delete storedAttributes[ name ];
-				return false;
+				if ( storedAttributeData.id !== id || storedAttributeData.version !== version ) {
+
+					storedAttributeData.id = id;
+					storedAttributeData.version = version;
+
+					geometryData._equal = false;
+					return false;
+
+				}
 
 			}
 
-			if ( storedAttributeData.version !== attribute.version ) {
+			if ( storedAttributeCount !== currentAttributeCount ) {
+
+				geometryData.attributes = this.getAttributesData( attributes );
 
-				storedAttributeData.version = attribute.version;
+				geometryData._equal = false;
 				return false;
 
 			}
 
-		}
+			// check index
 
-		// check index
+			const index = geometry.index;
+			const storedIndexId = geometryData.indexId;
+			const storedIndexVersion = geometryData.indexVersion;
+			const currentIndexId = index ? index.id : null;
+			const currentIndexVersion = index ? index.version : null;
 
-		const index = geometry.index;
-		const storedIndexVersion = storedGeometryData.indexVersion;
-		const currentIndexVersion = index ? index.version : null;
+			if ( storedIndexId !== currentIndexId || storedIndexVersion !== currentIndexVersion ) {
 
-		if ( storedIndexVersion !== currentIndexVersion ) {
+				geometryData.indexId = currentIndexId;
+				geometryData.indexVersion = currentIndexVersion;
 
-			storedGeometryData.indexVersion = currentIndexVersion;
-			return false;
+				geometryData._equal = false;
+				return false;
 
-		}
+			}
 
-		// check drawRange
+			// check drawRange
 
-		if ( storedGeometryData.drawRange.start !== geometry.drawRange.start || storedGeometryData.drawRange.count !== geometry.drawRange.count ) {
+			if ( geometryData.drawRange.start !== geometry.drawRange.start || geometryData.drawRange.count !== geometry.drawRange.count ) {
 
-			storedGeometryData.drawRange.start = geometry.drawRange.start;
-			storedGeometryData.drawRange.count = geometry.drawRange.count;
-			return false;
+				geometryData.drawRange.start = geometry.drawRange.start;
+				geometryData.drawRange.count = geometry.drawRange.count;
+
+				geometryData._equal = false;
+				return false;
+
+			}
+
+			geometryData._equal = true;
+
+		} else {
+
+			if ( geometryData._equal === false ) return false;
 
 		}
 
@@ -492,6 +606,24 @@ class NodeMaterialObserver {
 
 		}
 
+		// scene
+
+		const scene = renderObject.scene;
+
+		if ( scene.environment !== null && material.envMap === null ) {
+
+			if ( renderObjectData.environmentIntensity !== scene.environmentIntensity ||
+					renderObjectData.environmentRotation.equals( scene.environmentRotation ) === false ) {
+
+				renderObjectData.environmentIntensity = scene.environmentIntensity;
+				renderObjectData.environmentRotation.copy( scene.environmentRotation );
+
+				return false;
+
+			}
+
+		}
+
 		// center
 
 		if ( renderObjectData.center ) {
@@ -500,7 +632,7 @@ class NodeMaterialObserver {
 
 				renderObjectData.center.copy( object.center );
 
-				return true;
+				return false;
 
 			}
 
@@ -524,9 +656,9 @@ class NodeMaterialObserver {
 	 * @param {Array<Light>} materialLights - The material lights.
 	 * @return {Array<Object>} The lights data for the given material lights.
 	 */
-	getLightsData( materialLights ) {
+	getLightsData( materialLights, lights ) {
 
-		const lights = [];
+		lights.length = 0;
 
 		for ( const light of materialLights ) {
 
@@ -553,23 +685,25 @@ class NodeMaterialObserver {
 	 */
 	getLights( lightsNode, renderId ) {
 
-		if ( _lightsCache.has( lightsNode ) ) {
+		let cached = _lightsCache.get( lightsNode );
+
+		if ( cached === undefined ) {
 
-			const cached = _lightsCache.get( lightsNode );
+			cached = { renderId: - 1, lightsData: [] };
+			_lightsCache.set( lightsNode, cached );
 
-			if ( cached.renderId === renderId ) {
+		}
 
-				return cached.lightsData;
+		if ( cached.renderId === renderId ) {
 
-			}
+			return cached.lightsData;
 
 		}
 
-		const lightsData = this.getLightsData( lightsNode.getLights() );
-
-		_lightsCache.set( lightsNode, { renderId, lightsData } );
+		cached.renderId = renderId;
+		this.getLightsData( lightsNode.getLights(), cached.lightsData );
 
-		return lightsData;
+		return cached.lightsData;
 
 	}
 
@@ -602,7 +736,7 @@ class NodeMaterialObserver {
 			return false;
 
 		const lightsData = this.getLights( renderObject.lightsNode, renderId );
-		const notEqual = this.equals( renderObject, lightsData ) !== true;
+		const notEqual = this.equals( renderObject, lightsData, renderId ) !== true;
 
 		return notEqual;
 

package/src/math/Box3.js

@@ -142,6 +142,11 @@ class Box3 {
 	 * (including its children), accounting for the object's, and children's,
 	 * world transforms. The function may result in a larger box than strictly necessary.
 	 *
+	 * Note: To compute the correct bounding box, make sure the given 3D object
+	 * has an up-to-date world matrix that reflects the current transformation of its
+	 * ancestor nodes. Call `object.updateWorldMatrix( true, false )` beforehand if
+	 * you're unsure.
+	 *
 	 * @param {Object3D} object - The 3D object to compute the bounding box for.
 	 * @param {boolean} [precise=false] - If set to `true`, the method computes the smallest
 	 * world-axis-aligned bounding box at the expense of more computation.