super-three 0.167.0 → 0.169.0

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

@@ -0,0 +1,302 @@
+const refreshUniforms = [
+	'alphaMap',
+	'alphaTest',
+	'anisotropy',
+	'anisotropyMap',
+	'anisotropyRotation',
+	'aoMap',
+	'attenuationColor',
+	'attenuationDistance',
+	'bumpMap',
+	'clearcoat',
+	'clearcoatMap',
+	'clearcoatNormalMap',
+	'clearcoatNormalScale',
+	'clearcoatRoughness',
+	'color',
+	'dispersion',
+	'displacementMap',
+	'emissive',
+	'emissiveMap',
+	'envMap',
+	'gradientMap',
+	'ior',
+	'iridescence',
+	'iridescenceIOR',
+	'iridescenceMap',
+	'iridescenceThicknessMap',
+	'lightMap',
+	'map',
+	'matcap',
+	'metalness',
+	'metalnessMap',
+	'normalMap',
+	'normalScale',
+	'opacity',
+	'roughness',
+	'roughnessMap',
+	'sheen',
+	'sheenColor',
+	'sheenColorMap',
+	'sheenRoughnessMap',
+	'shininess',
+	'specular',
+	'specularColor',
+	'specularColorMap',
+	'specularIntensity',
+	'specularIntensityMap',
+	'specularMap',
+	'thickness',
+	'transmission',
+	'transmissionMap'
+];
+
+class NodeMaterialObserver {
+
+	constructor( builder ) {
+
+		this.renderObjects = new WeakMap();
+		this.hasNode = this.containsNode( builder );
+		this.hasAnimation = builder.object.isSkinnedMesh === true;
+		this.refreshUniforms = refreshUniforms;
+		this.renderId = 0;
+
+	}
+
+	firstInitialization( renderObject ) {
+
+		const hasInitialized = this.renderObjects.has( renderObject );
+
+		if ( hasInitialized === false ) {
+
+			this.getRenderObjectData( renderObject );
+
+			return true;
+
+		}
+
+		return false;
+
+	}
+
+	getRenderObjectData( renderObject ) {
+
+		let data = this.renderObjects.get( renderObject );
+
+		if ( data === undefined ) {
+
+			data = {
+				material: this.getMaterialData( renderObject.material ),
+				worldMatrix: renderObject.object.matrixWorld.clone()
+			};
+
+			if ( renderObject.object.center ) {
+
+				data.center = renderObject.object.center.clone();
+
+			}
+
+			if ( renderObject.object.morphTargetInfluences ) {
+
+				data.morphTargetInfluences = renderObject.object.morphTargetInfluences.slice();
+
+			}
+
+			if ( renderObject.bundle !== null ) {
+
+				data.version = renderObject.bundle.version;
+
+			}
+
+			this.renderObjects.set( renderObject, data );
+
+		}
+
+		return data;
+
+	}
+
+	containsNode( builder ) {
+
+		const material = builder.material;
+
+		for ( const property in material ) {
+
+			if ( material[ property ] && material[ property ].isNode )
+				return true;
+
+		}
+
+		if ( builder.renderer.nodes.modelViewMatrix !== null || builder.renderer.nodes.modelNormalViewMatrix !== null )
+			return true;
+
+		return false;
+
+	}
+
+	getMaterialData( material ) {
+
+		const data = {};
+
+		for ( const property of this.refreshUniforms ) {
+
+			const value = material[ property ];
+
+			if ( value === null || value === undefined ) continue;
+
+			if ( typeof value === 'object' && value.clone !== undefined ) {
+
+				if ( value.isTexture === true ) {
+
+					data[ property ] = { id: value.id, version: value.version };
+
+				} else {
+
+					data[ property ] = value.clone();
+
+				}
+
+			} else {
+
+				data[ property ] = value;
+
+			}
+
+		}
+
+		return data;
+
+	}
+
+	equals( renderObject ) {
+
+		const { object, material } = renderObject;
+
+		const renderObjectData = this.getRenderObjectData( renderObject );
+
+		// world matrix
+
+		if ( renderObjectData.worldMatrix.equals( object.matrixWorld ) !== true ) {
+
+			renderObjectData.worldMatrix.copy( object.matrixWorld );
+
+			return false;
+
+		}
+
+		// material
+
+		const materialData = renderObjectData.material;
+
+		for ( const property in materialData ) {
+
+			const value = materialData[ property ];
+			const mtlValue = material[ property ];
+
+			if ( value.equals !== undefined ) {
+
+				if ( value.equals( mtlValue ) === false ) {
+
+					value.copy( mtlValue );
+
+					return false;
+
+				}
+
+			} else if ( mtlValue.isTexture === true ) {
+
+				if ( value.id !== mtlValue.id || value.version !== mtlValue.version ) {
+
+					value.id = mtlValue.id;
+					value.version = mtlValue.version;
+
+					return false;
+
+				}
+
+			} else if ( value !== mtlValue ) {
+
+				materialData[ property ] = mtlValue;
+
+				return false;
+
+			}
+
+		}
+
+		// morph targets
+
+		if ( renderObjectData.morphTargetInfluences ) {
+
+			let morphChanged = false;
+
+			for ( let i = 0; i < renderObjectData.morphTargetInfluences.length; i ++ ) {
+
+				if ( renderObjectData.morphTargetInfluences[ i ] !== object.morphTargetInfluences[ i ] ) {
+
+					morphChanged = true;
+
+				}
+
+			}
+
+			if ( morphChanged ) return true;
+
+		}
+
+		// center
+
+		if ( renderObjectData.center ) {
+
+			if ( renderObjectData.center.equals( object.center ) === false ) {
+
+				renderObjectData.center.copy( object.center );
+
+				return true;
+
+			}
+
+		}
+
+		// bundle
+
+		if ( renderObject.bundle !== null ) {
+
+			renderObjectData.version = renderObject.bundle.version;
+
+		}
+
+		return true;
+
+	}
+
+	needsRefresh( renderObject, nodeFrame ) {
+
+		if ( this.hasNode || this.hasAnimation || this.firstInitialization( renderObject ) )
+			return true;
+
+		const { renderId } = nodeFrame;
+
+		if ( this.renderId !== renderId ) {
+
+			this.renderId = renderId;
+
+			return true;
+
+		}
+
+		const isStatic = renderObject.object.static === true;
+		const isBundle = renderObject.bundle !== null && renderObject.bundle.static === true && this.getRenderObjectData( renderObject ).version === renderObject.bundle.version;
+
+		if ( isStatic || isBundle )
+			return false;
+
+		const notEqual = this.equals( renderObject ) !== true;
+
+		return notEqual;
+
+	}
+
+}
+
+export default NodeMaterialObserver;

package/src/math/Triangle.js

@@ -1,4 +1,5 @@
 import { Vector3 } from './Vector3.js';
+import { Vector4 } from './Vector4.js';
 
 const _v0 = /*@__PURE__*/ new Vector3();
 const _v1 = /*@__PURE__*/ new Vector3();
@@ -12,6 +13,10 @@ const _vap = /*@__PURE__*/ new Vector3();
 const _vbp = /*@__PURE__*/ new Vector3();
 const _vcp = /*@__PURE__*/ new Vector3();
 
+const _v40 = /*@__PURE__*/ new Vector4();
+const _v41 = /*@__PURE__*/ new Vector4();
+const _v42 = /*@__PURE__*/ new Vector4();
+
 class Triangle {
 
 	constructor( a = new Vector3(), b = new Vector3(), c = new Vector3() ) {
@@ -106,6 +111,25 @@ class Triangle {
 
 	}
 
+	static getInterpolatedAttribute( attr, i1, i2, i3, barycoord, target ) {
+
+		_v40.setScalar( 0 );
+		_v41.setScalar( 0 );
+		_v42.setScalar( 0 );
+
+		_v40.fromBufferAttribute( attr, i1 );
+		_v41.fromBufferAttribute( attr, i2 );
+		_v42.fromBufferAttribute( attr, i3 );
+
+		target.setScalar( 0 );
+		target.addScaledVector( _v40, barycoord.x );
+		target.addScaledVector( _v41, barycoord.y );
+		target.addScaledVector( _v42, barycoord.z );
+
+		return target;
+
+	}
+
 	static isFrontFacing( a, b, c, direction ) {
 
 		_v0.subVectors( c, b );