import { Line3, Mesh, Plane, Vector3 } from 'three'; import { ConvexGeometry } from '../geometries/ConvexGeometry.js'; /** * @fileoverview This class can be used to subdivide a convex Geometry object into pieces. * * Usage: * * Use the function prepareBreakableObject to prepare a Mesh object to be broken. * * Then, call the various functions to subdivide the object (subdivideByImpact, cutByPlane) * * Sub-objects that are product of subdivision don't need prepareBreakableObject to be called on them. * * Requisites for the object: * * - Mesh object must have a BufferGeometry (not Geometry) and a Material * * - Vertex normals must be planar (not smoothed) * * - The geometry must be convex (this is not checked in the library). You can create convex * geometries with ConvexGeometry. The BoxGeometry, SphereGeometry and other convex primitives * can also be used. * * Note: This lib adds member variables to object's userData member (see prepareBreakableObject function) * Use with caution and read the code when using with other libs. * * @param {double} minSizeForBreak Min size a debris can have to break. * @param {double} smallDelta Max distance to consider that a point belongs to a plane. * */ const _v1 = new Vector3(); class ConvexObjectBreaker { constructor( minSizeForBreak = 1.4, smallDelta = 0.0001 ) { this.minSizeForBreak = minSizeForBreak; this.smallDelta = smallDelta; this.tempLine1 = new Line3(); this.tempPlane1 = new Plane(); this.tempPlane2 = new Plane(); this.tempPlane_Cut = new Plane(); this.tempCM1 = new Vector3(); this.tempCM2 = new Vector3(); this.tempVector3 = new Vector3(); this.tempVector3_2 = new Vector3(); this.tempVector3_3 = new Vector3(); this.tempVector3_P0 = new Vector3(); this.tempVector3_P1 = new Vector3(); this.tempVector3_P2 = new Vector3(); this.tempVector3_N0 = new Vector3(); this.tempVector3_N1 = new Vector3(); this.tempVector3_AB = new Vector3(); this.tempVector3_CB = new Vector3(); this.tempResultObjects = { object1: null, object2: null }; this.segments = []; const n = 30 * 30; for ( let i = 0; i < n; i ++ ) this.segments[ i ] = false; } prepareBreakableObject( object, mass, velocity, angularVelocity, breakable ) { // object is a Object3d (normally a Mesh), must have a BufferGeometry, and it must be convex. // Its material property is propagated to its children (sub-pieces) // mass must be > 0 if ( ! object.geometry.isBufferGeometry ) { console.error( 'THREE.ConvexObjectBreaker.prepareBreakableObject(): Parameter object must have a BufferGeometry.' ); } const userData = object.userData; userData.mass = mass; userData.velocity = velocity.clone(); userData.angularVelocity = angularVelocity.clone(); userData.breakable = breakable; } /* * @param {int} maxRadialIterations Iterations for radial cuts. * @param {int} maxRandomIterations Max random iterations for not-radial cuts * * Returns the array of pieces */ subdivideByImpact( object, pointOfImpact, normal, maxRadialIterations, maxRandomIterations ) { const debris = []; const tempPlane1 = this.tempPlane1; const tempPlane2 = this.tempPlane2; this.tempVector3.addVectors( pointOfImpact, normal ); tempPlane1.setFromCoplanarPoints( pointOfImpact, object.position, this.tempVector3 ); const maxTotalIterations = maxRandomIterations + maxRadialIterations; const scope = this; function subdivideRadial( subObject, startAngle, endAngle, numIterations ) { if ( Math.random() < numIterations * 0.05 || numIterations > maxTotalIterations ) { debris.push( subObject ); return; } let angle = Math.PI; if ( numIterations === 0 ) { tempPlane2.normal.copy( tempPlane1.normal ); tempPlane2.constant = tempPlane1.constant; } else { if ( numIterations <= maxRadialIterations ) { angle = ( endAngle - startAngle ) * ( 0.2 + 0.6 * Math.random() ) + startAngle; // Rotate tempPlane2 at impact point around normal axis and the angle scope.tempVector3_2.copy( object.position ).sub( pointOfImpact ).applyAxisAngle( normal, angle ).add( pointOfImpact ); tempPlane2.setFromCoplanarPoints( pointOfImpact, scope.tempVector3, scope.tempVector3_2 ); } else { angle = ( ( 0.5 * ( numIterations & 1 ) ) + 0.2 * ( 2 - Math.random() ) ) * Math.PI; // Rotate tempPlane2 at object position around normal axis and the angle scope.tempVector3_2.copy( pointOfImpact ).sub( subObject.position ).applyAxisAngle( normal, angle ).add( subObject.position ); scope.tempVector3_3.copy( normal ).add( subObject.position ); tempPlane2.setFromCoplanarPoints( subObject.position, scope.tempVector3_3, scope.tempVector3_2 ); } } // Perform the cut scope.cutByPlane( subObject, tempPlane2, scope.tempResultObjects ); const obj1 = scope.tempResultObjects.object1; const obj2 = scope.tempResultObjects.object2; if ( obj1 ) { subdivideRadial( obj1, startAngle, angle, numIterations + 1 ); } if ( obj2 ) { subdivideRadial( obj2, angle, endAngle, numIterations + 1 ); } } subdivideRadial( object, 0, 2 * Math.PI, 0 ); return debris; } cutByPlane( object, plane, output ) { // Returns breakable objects in output.object1 and output.object2 members, the resulting 2 pieces of the cut. // object2 can be null if the plane doesn't cut the object. // object1 can be null only in case of internal error // Returned value is number of pieces, 0 for error. const geometry = object.geometry; const coords = geometry.attributes.position.array; const normals = geometry.attributes.normal.array; const numPoints = coords.length / 3; let numFaces = numPoints / 3; let indices = geometry.getIndex(); if ( indices ) { indices = indices.array; numFaces = indices.length / 3; } function getVertexIndex( faceIdx, vert ) { // vert = 0, 1 or 2. const idx = faceIdx * 3 + vert; return indices ? indices[ idx ] : idx; } const points1 = []; const points2 = []; const delta = this.smallDelta; // Reset segments mark const numPointPairs = numPoints * numPoints; for ( let i = 0; i < numPointPairs; i ++ ) this.segments[ i ] = false; const p0 = this.tempVector3_P0; const p1 = this.tempVector3_P1; const n0 = this.tempVector3_N0; const n1 = this.tempVector3_N1; // Iterate through the faces to mark edges shared by coplanar faces for ( let i = 0; i < numFaces - 1; i ++ ) { const a1 = getVertexIndex( i, 0 ); const b1 = getVertexIndex( i, 1 ); const c1 = getVertexIndex( i, 2 ); // Assuming all 3 vertices have the same normal n0.set( normals[ a1 ], normals[ a1 ] + 1, normals[ a1 ] + 2 ); for ( let j = i + 1; j < numFaces; j ++ ) { const a2 = getVertexIndex( j, 0 ); const b2 = getVertexIndex( j, 1 ); const c2 = getVertexIndex( j, 2 ); // Assuming all 3 vertices have the same normal n1.set( normals[ a2 ], normals[ a2 ] + 1, normals[ a2 ] + 2 ); const coplanar = 1 - n0.dot( n1 ) < delta; if ( coplanar ) { if ( a1 === a2 || a1 === b2 || a1 === c2 ) { if ( b1 === a2 || b1 === b2 || b1 === c2 ) { this.segments[ a1 * numPoints + b1 ] = true; this.segments[ b1 * numPoints + a1 ] = true; } else { this.segments[ c1 * numPoints + a1 ] = true; this.segments[ a1 * numPoints + c1 ] = true; } } else if ( b1 === a2 || b1 === b2 || b1 === c2 ) { this.segments[ c1 * numPoints + b1 ] = true; this.segments[ b1 * numPoints + c1 ] = true; } } } } // Transform the plane to object local space const localPlane = this.tempPlane_Cut; object.updateMatrix(); ConvexObjectBreaker.transformPlaneToLocalSpace( plane, object.matrix, localPlane ); // Iterate through the faces adding points to both pieces for ( let i = 0; i < numFaces; i ++ ) { const va = getVertexIndex( i, 0 ); const vb = getVertexIndex( i, 1 ); const vc = getVertexIndex( i, 2 ); for ( let segment = 0; segment < 3; segment ++ ) { const i0 = segment === 0 ? va : ( segment === 1 ? vb : vc ); const i1 = segment === 0 ? vb : ( segment === 1 ? vc : va ); const segmentState = this.segments[ i0 * numPoints + i1 ]; if ( segmentState ) continue; // The segment already has been processed in another face // Mark segment as processed (also inverted segment) this.segments[ i0 * numPoints + i1 ] = true; this.segments[ i1 * numPoints + i0 ] = true; p0.set( coords[ 3 * i0 ], coords[ 3 * i0 + 1 ], coords[ 3 * i0 + 2 ] ); p1.set( coords[ 3 * i1 ], coords[ 3 * i1 + 1 ], coords[ 3 * i1 + 2 ] ); // mark: 1 for negative side, 2 for positive side, 3 for coplanar point let mark0 = 0; let d = localPlane.distanceToPoint( p0 ); if ( d > delta ) { mark0 = 2; points2.push( p0.clone() ); } else if ( d < - delta ) { mark0 = 1; points1.push( p0.clone() ); } else { mark0 = 3; points1.push( p0.clone() ); points2.push( p0.clone() ); } // mark: 1 for negative side, 2 for positive side, 3 for coplanar point let mark1 = 0; d = localPlane.distanceToPoint( p1 ); if ( d > delta ) { mark1 = 2; points2.push( p1.clone() ); } else if ( d < - delta ) { mark1 = 1; points1.push( p1.clone() ); } else { mark1 = 3; points1.push( p1.clone() ); points2.push( p1.clone() ); } if ( ( mark0 === 1 && mark1 === 2 ) || ( mark0 === 2 && mark1 === 1 ) ) { // Intersection of segment with the plane this.tempLine1.start.copy( p0 ); this.tempLine1.end.copy( p1 ); let intersection = new Vector3(); intersection = localPlane.intersectLine( this.tempLine1, intersection ); if ( intersection === null ) { // Shouldn't happen console.error( 'Internal error: segment does not intersect plane.' ); output.segmentedObject1 = null; output.segmentedObject2 = null; return 0; } points1.push( intersection ); points2.push( intersection.clone() ); } } } // Calculate debris mass (very fast and imprecise): const newMass = object.userData.mass * 0.5; // Calculate debris Center of Mass (again fast and imprecise) this.tempCM1.set( 0, 0, 0 ); let radius1 = 0; const numPoints1 = points1.length; if ( numPoints1 > 0 ) { for ( let i = 0; i < numPoints1; i ++ ) this.tempCM1.add( points1[ i ] ); this.tempCM1.divideScalar( numPoints1 ); for ( let i = 0; i < numPoints1; i ++ ) { const p = points1[ i ]; p.sub( this.tempCM1 ); radius1 = Math.max( radius1, p.x, p.y, p.z ); } this.tempCM1.add( object.position ); } this.tempCM2.set( 0, 0, 0 ); let radius2 = 0; const numPoints2 = points2.length; if ( numPoints2 > 0 ) { for ( let i = 0; i < numPoints2; i ++ ) this.tempCM2.add( points2[ i ] ); this.tempCM2.divideScalar( numPoints2 ); for ( let i = 0; i < numPoints2; i ++ ) { const p = points2[ i ]; p.sub( this.tempCM2 ); radius2 = Math.max( radius2, p.x, p.y, p.z ); } this.tempCM2.add( object.position ); } let object1 = null; let object2 = null; let numObjects = 0; if ( numPoints1 > 4 ) { object1 = new Mesh( new ConvexGeometry( points1 ), object.material ); object1.position.copy( this.tempCM1 ); object1.quaternion.copy( object.quaternion ); this.prepareBreakableObject( object1, newMass, object.userData.velocity, object.userData.angularVelocity, 2 * radius1 > this.minSizeForBreak ); numObjects ++; } if ( numPoints2 > 4 ) { object2 = new Mesh( new ConvexGeometry( points2 ), object.material ); object2.position.copy( this.tempCM2 ); object2.quaternion.copy( object.quaternion ); this.prepareBreakableObject( object2, newMass, object.userData.velocity, object.userData.angularVelocity, 2 * radius2 > this.minSizeForBreak ); numObjects ++; } output.object1 = object1; output.object2 = object2; return numObjects; } static transformFreeVector( v, m ) { // input: // vector interpreted as a free vector // THREE.Matrix4 orthogonal matrix (matrix without scale) const x = v.x, y = v.y, z = v.z; const e = m.elements; v.x = e[ 0 ] * x + e[ 4 ] * y + e[ 8 ] * z; v.y = e[ 1 ] * x + e[ 5 ] * y + e[ 9 ] * z; v.z = e[ 2 ] * x + e[ 6 ] * y + e[ 10 ] * z; return v; } static transformFreeVectorInverse( v, m ) { // input: // vector interpreted as a free vector // THREE.Matrix4 orthogonal matrix (matrix without scale) const x = v.x, y = v.y, z = v.z; const e = m.elements; v.x = e[ 0 ] * x + e[ 1 ] * y + e[ 2 ] * z; v.y = e[ 4 ] * x + e[ 5 ] * y + e[ 6 ] * z; v.z = e[ 8 ] * x + e[ 9 ] * y + e[ 10 ] * z; return v; } static transformTiedVectorInverse( v, m ) { // input: // vector interpreted as a tied (ordinary) vector // THREE.Matrix4 orthogonal matrix (matrix without scale) const x = v.x, y = v.y, z = v.z; const e = m.elements; v.x = e[ 0 ] * x + e[ 1 ] * y + e[ 2 ] * z - e[ 12 ]; v.y = e[ 4 ] * x + e[ 5 ] * y + e[ 6 ] * z - e[ 13 ]; v.z = e[ 8 ] * x + e[ 9 ] * y + e[ 10 ] * z - e[ 14 ]; return v; } static transformPlaneToLocalSpace( plane, m, resultPlane ) { resultPlane.normal.copy( plane.normal ); resultPlane.constant = plane.constant; const referencePoint = ConvexObjectBreaker.transformTiedVectorInverse( plane.coplanarPoint( _v1 ), m ); ConvexObjectBreaker.transformFreeVectorInverse( resultPlane.normal, m ); // recalculate constant (like in setFromNormalAndCoplanarPoint) resultPlane.constant = - referencePoint.dot( resultPlane.normal ); } } export { ConvexObjectBreaker };