three-gpu-pathtracer 0.0.20 → 0.0.21

package/src/core/utils/MeshDiff.js

@@ -0,0 +1,102 @@
+import { Matrix4 } from 'three';
+import { bufferToHash } from '../../utils/bufferToHash.js';
+
+function attributeSort( a, b ) {
+
+	if ( a.uuid > b.uuid ) return 1;
+	if ( a.uuid < b.uuid ) return - 1;
+	return 0;
+
+}
+
+function getGeometryHash( geometry ) {
+
+	let hash = '';
+	const attributes = Object.values( geometry.attributes );
+	if ( geometry.index ) {
+
+		attributes.push( geometry.index );
+
+	}
+
+	attributes.sort( attributeSort );
+
+	for ( const attr of attributes ) {
+
+		hash += `${ attr.uuid }_${ attr.version }|`;
+
+	}
+
+	return hash;
+
+}
+
+function getSkeletonHash( mesh ) {
+
+	const skeleton = mesh.skeleton;
+	if ( skeleton ) {
+
+		if ( ! skeleton.boneTexture ) {
+
+			skeleton.computeBoneTexture();
+
+		}
+
+		// we can't use the texture version here because it will change even
+		// when the bones haven't
+		const dataHash = bufferToHash( skeleton.boneTexture.image.data.buffer );
+		return `${ dataHash }_${ skeleton.boneTexture.uuid }`;
+
+	} else {
+
+		return null;
+
+	}
+
+}
+
+// Checks whether the geometry changed between this and last evaluation
+export class MeshDiff {
+
+	constructor( mesh = null ) {
+
+		this.matrixWorld = new Matrix4();
+		this.geometryHash = null;
+		this.skeletonHash = null;
+		this.primitiveCount = - 1;
+
+		if ( mesh !== null ) {
+
+			this.updateFrom( mesh );
+
+		}
+
+	}
+
+	updateFrom( mesh ) {
+
+		const geometry = mesh.geometry;
+		const primitiveCount = ( geometry.index ? geometry.index.count : geometry.attributes.position.count ) / 3;
+		this.matrixWorld.copy( mesh.matrixWorld );
+		this.geometryHash = getGeometryHash( geometry );
+		this.primitiveCount = primitiveCount;
+		this.skeletonHash = getSkeletonHash( mesh );
+
+	}
+
+	didChange( mesh ) {
+
+		const geometry = mesh.geometry;
+		const primitiveCount = ( geometry.index ? geometry.index.count : geometry.attributes.position.count ) / 3;
+
+		const identical =
+			this.matrixWorld.equals( mesh.matrixWorld ) &&
+			this.geometryHash === getGeometryHash( geometry ) &&
+			this.skeletonHash === getSkeletonHash( mesh ) &&
+			this.primitiveCount === primitiveCount;
+
+		return ! identical;
+
+	}
+
+}

package/src/core/utils/StaticGeometryGenerator.js

@@ -0,0 +1,285 @@
+import { BufferAttribute, BufferGeometry, Mesh, MeshBasicMaterial } from 'three';
+import { mergeGeometries } from './mergeGeometries.js';
+import { setCommonAttributes } from './GeometryPreparationUtils.js';
+import { BakedGeometry } from './BakedGeometry.js';
+
+export const NO_CHANGE = 0;
+export const GEOMETRY_ADJUSTED = 1;
+export const GEOMETRY_REBUILT = 2;
+
+// iterate over only the meshes in the provided objects
+function flatTraverseMeshes( objects, cb ) {
+
+	for ( let i = 0, l = objects.length; i < l; i ++ ) {
+
+		const object = objects[ i ];
+		object.traverse( o => {
+
+			if ( o.isMesh ) {
+
+				cb( o );
+
+			}
+
+		} );
+
+	}
+
+}
+
+// return the set of materials used by the provided meshes
+function getMaterials( meshes ) {
+
+	const materials = [];
+	for ( let i = 0, l = meshes.length; i < l; i ++ ) {
+
+		const mesh = meshes[ i ];
+		if ( Array.isArray( mesh.material ) ) {
+
+			materials.push( ...mesh.material );
+
+		} else {
+
+			materials.push( mesh.material );
+
+		}
+
+	}
+
+	return materials;
+
+}
+
+function mergeGeometryList( geometries, target, options ) {
+
+	// If we have no geometry to merge then provide an empty geometry.
+	if ( geometries.length === 0 ) {
+
+		// if there are no geometries then just create a fake empty geometry to provide
+		target.setIndex( null );
+
+		// remove all geometry
+		const attrs = target.attributes;
+		for ( const key in attrs ) {
+
+			target.deleteAttribute( key );
+
+		}
+
+		// create dummy attributes
+		for ( const key in options.attributes ) {
+
+			target.setAttribute( options.attributes[ key ], new BufferAttribute( new Float32Array( 0 ), 4, false ) );
+
+		}
+
+	} else {
+
+		mergeGeometries( geometries, options, target );
+
+	}
+
+	// Mark all attributes as needing an update
+	for ( const key in target.attributes ) {
+
+		target.attributes[ key ].needsUpdate = true;
+
+	}
+
+}
+
+
+export class StaticGeometryGenerator {
+
+	constructor( objects ) {
+
+		this.objects = null;
+		this.useGroups = true;
+		this.applyWorldTransforms = true;
+		this.generateMissingAttributes = true;
+		this.overwriteIndex = true;
+		this.attributes = [ 'position', 'normal', 'color', 'tangent', 'uv', 'uv2' ];
+		this._intermediateGeometry = new Map();
+		this._geometryMergeSets = new WeakMap();
+		this._mergeOrder = [];
+		this._dummyMesh = null;
+
+		this.setObjects( objects || [] );
+
+	}
+
+	_getDummyMesh() {
+
+		// return a consistent dummy mesh
+		if ( ! this._dummyMesh ) {
+
+			const dummyMaterial = new MeshBasicMaterial();
+			const emptyGeometry = new BufferGeometry();
+			emptyGeometry.setAttribute( 'position', new BufferAttribute( new Float32Array( 9 ), 3 ) );
+			this._dummyMesh = new Mesh( emptyGeometry, dummyMaterial );
+
+		}
+
+		return this._dummyMesh;
+
+	}
+
+	_getMeshes() {
+
+		// iterate over only the meshes in the provided objects
+		const meshes = [];
+		flatTraverseMeshes( this.objects, mesh => {
+
+			meshes.push( mesh );
+
+		} );
+
+		// Sort the geometry so it's in a reliable order
+		meshes.sort( ( a, b ) => {
+
+			if ( a.uuid > b.uuid ) return 1;
+			if ( a.uuid < b.uuid ) return - 1;
+			return 0;
+
+		} );
+
+		if ( meshes.length === 0 ) {
+
+			meshes.push( this._getDummyMesh() );
+
+		}
+
+		return meshes;
+
+	}
+
+	_updateIntermediateGeometries() {
+
+		const { _intermediateGeometry } = this;
+
+		const meshes = this._getMeshes();
+		const unusedMeshKeys = new Set( _intermediateGeometry.keys() );
+		const convertOptions = {
+			attributes: this.attributes,
+			applyWorldTransforms: this.applyWorldTransforms,
+		};
+
+		for ( let i = 0, l = meshes.length; i < l; i ++ ) {
+
+			const mesh = meshes[ i ];
+			const meshKey = mesh.uuid;
+			unusedMeshKeys.delete( meshKey );
+
+			// initialize the intermediate geometry
+			if ( ! _intermediateGeometry.has( meshKey ) ) {
+
+				_intermediateGeometry.set( meshKey, new BakedGeometry() );
+
+			}
+
+			// transform the geometry into the intermediate buffer geometry, saving whether
+			// or not it changed.
+			const geom = _intermediateGeometry.get( meshKey );
+			if ( geom.updateFrom( mesh, convertOptions ) ) {
+
+				// TODO: provide option for only generating the set of attributes that are present
+				// and are in the attributes array
+				if ( this.generateMissingAttributes ) {
+
+					setCommonAttributes( geom, this.attributes );
+
+				}
+
+			}
+
+		}
+
+		unusedMeshKeys.forEach( key => {
+
+			_intermediateGeometry.delete( key );
+
+		} );
+
+	}
+
+	setObjects( objects ) {
+
+		if ( Array.isArray( objects ) ) {
+
+			this.objects = [ ...objects ];
+
+		} else {
+
+			this.objects = [ objects ];
+
+		}
+
+	}
+
+	generate( targetGeometry = new BufferGeometry() ) {
+
+		// track which attributes have been updated and which to skip to avoid unnecessary attribute copies
+		const { useGroups, overwriteIndex, _intermediateGeometry, _geometryMergeSets } = this;
+
+		const meshes = this._getMeshes();
+		const skipAssigningAttributes = [];
+		const mergeGeometry = [];
+		const previousMergeInfo = _geometryMergeSets.get( targetGeometry ) || [];
+
+		// update all the intermediate static geometry representations
+		this._updateIntermediateGeometries();
+
+		// get the list of geometries to merge
+		let forceUpdate = false;
+		for ( let i = 0, l = meshes.length; i < l; i ++ ) {
+
+			const mesh = meshes[ i ];
+			const geom = _intermediateGeometry.get( mesh.uuid );
+			mergeGeometry.push( geom );
+
+			const info = previousMergeInfo[ i ];
+			if ( ! info || info.uuid !== geom.uuid ) {
+
+				skipAssigningAttributes.push( false );
+				forceUpdate = true;
+
+			} else if ( info.version !== geom.version ) {
+
+				skipAssigningAttributes.push( false );
+
+			} else {
+
+				skipAssigningAttributes.push( true );
+
+			}
+
+		}
+
+		// If we have no geometry to merge then provide an empty geometry.
+		mergeGeometryList( mergeGeometry, targetGeometry, { useGroups, forceUpdate, skipAssigningAttributes, overwriteIndex } );
+
+		// force update means the attribute buffer lengths have changed
+		if ( forceUpdate ) {
+
+			targetGeometry.dispose();
+
+		}
+
+		_geometryMergeSets.set( targetGeometry, mergeGeometry.map( g => ( {
+			version: g.version,
+			uuid: g.uuid,
+		} ) ) );
+
+		let changeType = NO_CHANGE;
+		if ( forceUpdate ) changeType = GEOMETRY_REBUILT;
+		else if ( skipAssigningAttributes.includes( false ) ) changeType = GEOMETRY_ADJUSTED;
+
+		return {
+			changeType,
+			materials: getMaterials( meshes ),
+			geometry: targetGeometry,
+		};
+
+	}
+
+}

package/src/core/utils/convertToStaticGeometry.js

@@ -0,0 +1,344 @@
+import { BufferGeometry, Matrix3, Matrix4, Vector3, Vector4 } from 'three';
+import { copyAttributeContents, createAttributeClone, validateAttributes } from './BufferAttributeUtils.js';
+
+const _positionVector = /*@__PURE__*/ new Vector3();
+const _normalVector = /*@__PURE__*/ new Vector3();
+const _tangentVector = /*@__PURE__*/ new Vector3();
+const _tangentVector4 = /*@__PURE__*/ new Vector4();
+
+const _morphVector = /*@__PURE__*/ new Vector3();
+const _temp = /*@__PURE__*/ new Vector3();
+
+const _skinIndex = /*@__PURE__*/ new Vector4();
+const _skinWeight = /*@__PURE__*/ new Vector4();
+const _matrix = /*@__PURE__*/ new Matrix4();
+const _boneMatrix = /*@__PURE__*/ new Matrix4();
+
+// A version of "SkinnedMesh.boneTransform" for normals
+function boneNormalTransform( mesh, index, target ) {
+
+	const skeleton = mesh.skeleton;
+	const geometry = mesh.geometry;
+	const bones = skeleton.bones;
+	const boneInverses = skeleton.boneInverses;
+
+	_skinIndex.fromBufferAttribute( geometry.attributes.skinIndex, index );
+	_skinWeight.fromBufferAttribute( geometry.attributes.skinWeight, index );
+
+	_matrix.elements.fill( 0 );
+
+	for ( let i = 0; i < 4; i ++ ) {
+
+		const weight = _skinWeight.getComponent( i );
+
+		if ( weight !== 0 ) {
+
+			const boneIndex = _skinIndex.getComponent( i );
+			_boneMatrix.multiplyMatrices( bones[ boneIndex ].matrixWorld, boneInverses[ boneIndex ] );
+
+			addScaledMatrix( _matrix, _boneMatrix, weight );
+
+		}
+
+	}
+
+	_matrix.multiply( mesh.bindMatrix ).premultiply( mesh.bindMatrixInverse );
+	target.transformDirection( _matrix );
+
+	return target;
+
+}
+
+// Applies the morph target data to the target vector
+function applyMorphTarget( morphData, morphInfluences, morphTargetsRelative, i, target ) {
+
+	_morphVector.set( 0, 0, 0 );
+	for ( let j = 0, jl = morphData.length; j < jl; j ++ ) {
+
+		const influence = morphInfluences[ j ];
+		const morphAttribute = morphData[ j ];
+
+		if ( influence === 0 ) continue;
+
+		_temp.fromBufferAttribute( morphAttribute, i );
+
+		if ( morphTargetsRelative ) {
+
+			_morphVector.addScaledVector( _temp, influence );
+
+		} else {
+
+			_morphVector.addScaledVector( _temp.sub( target ), influence );
+
+		}
+
+	}
+
+	target.add( _morphVector );
+
+}
+
+// Adds the "matrix" multiplied by "scale" to "target"
+function addScaledMatrix( target, matrix, scale ) {
+
+	const targetArray = target.elements;
+	const matrixArray = matrix.elements;
+	for ( let i = 0, l = matrixArray.length; i < l; i ++ ) {
+
+		targetArray[ i ] += matrixArray[ i ] * scale;
+
+	}
+
+}
+
+// inverts the geometry in place
+function invertGeometry( geometry ) {
+
+	const { index, attributes } = geometry;
+	if ( index ) {
+
+		for ( let i = 0, l = index.count; i < l; i += 3 ) {
+
+			const v0 = index.getX( i );
+			const v2 = index.getX( i + 2 );
+			index.setX( i, v2 );
+			index.setX( i + 2, v0 );
+
+		}
+
+	} else {
+
+		for ( const key in attributes ) {
+
+			const attr = attributes[ key ];
+			const itemSize = attr.itemSize;
+			for ( let i = 0, l = attr.count; i < l; i += 3 ) {
+
+				for ( let j = 0; j < itemSize; j ++ ) {
+
+					const v0 = attr.getComponent( i, j );
+					const v2 = attr.getComponent( i + 2, j );
+					attr.setComponent( i, j, v2 );
+					attr.setComponent( i + 2, j, v0 );
+
+				}
+
+			}
+
+		}
+
+	}
+
+	return geometry;
+
+}
+
+export function convertToStaticGeometry( mesh, options = {}, targetGeometry = new BufferGeometry() ) {
+
+	options = {
+		applyWorldTransforms: true,
+		attributes: [],
+		...options
+	};
+
+	const geometry = mesh.geometry;
+	const applyWorldTransforms = options.applyWorldTransforms;
+	const includeNormal = options.attributes.includes( 'normal' );
+	const includeTangent = options.attributes.includes( 'tangent' );
+	const attributes = geometry.attributes;
+	const targetAttributes = targetGeometry.attributes;
+
+	// strip any unused and unneeded attributes
+	for ( const key in targetGeometry.attributes ) {
+
+		if ( ! options.attributes.includes( key ) || ! ( key in geometry.attributes ) ) {
+
+			targetGeometry.deleteAttribute( key );
+
+		}
+
+	}
+
+	// initialize the attributes if they don't exist
+	if ( ! targetGeometry.index && geometry.index ) {
+
+		targetGeometry.index = geometry.index.clone();
+
+	}
+
+	if ( ! targetAttributes.position ) {
+
+		targetGeometry.setAttribute( 'position', createAttributeClone( attributes.position ) );
+
+	}
+
+	if ( includeNormal && ! targetAttributes.normal && attributes.normal ) {
+
+		targetGeometry.setAttribute( 'normal', createAttributeClone( attributes.normal ) );
+
+	}
+
+	if ( includeTangent && ! targetAttributes.tangent && attributes.tangent ) {
+
+		targetGeometry.setAttribute( 'tangent', createAttributeClone( attributes.tangent ) );
+
+	}
+
+	// ensure the attributes are consistent
+	validateAttributes( geometry.index, targetGeometry.index );
+	validateAttributes( attributes.position, targetAttributes.position );
+
+	if ( includeNormal ) {
+
+		validateAttributes( attributes.normal, targetAttributes.normal );
+
+	}
+
+	if ( includeTangent ) {
+
+		validateAttributes( attributes.tangent, targetAttributes.tangent );
+
+	}
+
+	// generate transformed vertex attribute data
+	const position = attributes.position;
+	const normal = includeNormal ? attributes.normal : null;
+	const tangent = includeTangent ? attributes.tangent : null;
+	const morphPosition = geometry.morphAttributes.position;
+	const morphNormal = geometry.morphAttributes.normal;
+	const morphTangent = geometry.morphAttributes.tangent;
+	const morphTargetsRelative = geometry.morphTargetsRelative;
+	const morphInfluences = mesh.morphTargetInfluences;
+	const normalMatrix = new Matrix3();
+	normalMatrix.getNormalMatrix( mesh.matrixWorld );
+
+	// copy the index
+	if ( geometry.index ) {
+
+		targetGeometry.index.array.set( geometry.index.array );
+
+	}
+
+	// copy and apply other attributes
+	for ( let i = 0, l = attributes.position.count; i < l; i ++ ) {
+
+		_positionVector.fromBufferAttribute( position, i );
+		if ( normal ) {
+
+			_normalVector.fromBufferAttribute( normal, i );
+
+		}
+
+		if ( tangent ) {
+
+			_tangentVector4.fromBufferAttribute( tangent, i );
+			_tangentVector.fromBufferAttribute( tangent, i );
+
+		}
+
+		// apply morph target transform
+		if ( morphInfluences ) {
+
+			if ( morphPosition ) {
+
+				applyMorphTarget( morphPosition, morphInfluences, morphTargetsRelative, i, _positionVector );
+
+			}
+
+			if ( morphNormal ) {
+
+				applyMorphTarget( morphNormal, morphInfluences, morphTargetsRelative, i, _normalVector );
+
+			}
+
+			if ( morphTangent ) {
+
+				applyMorphTarget( morphTangent, morphInfluences, morphTargetsRelative, i, _tangentVector );
+
+			}
+
+		}
+
+		// apply bone transform
+		if ( mesh.isSkinnedMesh ) {
+
+			mesh.applyBoneTransform( i, _positionVector );
+			if ( normal ) {
+
+				boneNormalTransform( mesh, i, _normalVector );
+
+			}
+
+			if ( tangent ) {
+
+				boneNormalTransform( mesh, i, _tangentVector );
+
+			}
+
+		}
+
+		// update the vectors of the attributes
+		if ( applyWorldTransforms ) {
+
+			_positionVector.applyMatrix4( mesh.matrixWorld );
+
+		}
+
+		targetAttributes.position.setXYZ( i, _positionVector.x, _positionVector.y, _positionVector.z );
+
+		if ( normal ) {
+
+			if ( applyWorldTransforms ) {
+
+				_normalVector.applyNormalMatrix( normalMatrix );
+
+			}
+
+			targetAttributes.normal.setXYZ( i, _normalVector.x, _normalVector.y, _normalVector.z );
+
+		}
+
+		if ( tangent ) {
+
+			if ( applyWorldTransforms ) {
+
+				_tangentVector.transformDirection( mesh.matrixWorld );
+
+			}
+
+			targetAttributes.tangent.setXYZW( i, _tangentVector.x, _tangentVector.y, _tangentVector.z, _tangentVector4.w );
+
+		}
+
+	}
+
+	// copy other attributes over
+	for ( const i in options.attributes ) {
+
+		const key = options.attributes[ i ];
+		if ( key === 'position' || key === 'tangent' || key === 'normal' || ! ( key in attributes ) ) {
+
+			continue;
+
+		}
+
+		if ( ! targetAttributes[ key ] ) {
+
+			targetGeometry.setAttribute( key, createAttributeClone( attributes[ key ] ) );
+
+		}
+
+		validateAttributes( attributes[ key ], targetAttributes[ key ] );
+		copyAttributeContents( attributes[ key ], targetAttributes[ key ] );
+
+	}
+
+	if ( mesh.matrixWorld.determinant() < 0 ) {
+
+		invertGeometry( targetGeometry );
+
+	}
+
+	return targetGeometry;
+
+}