354 lines
6.7 KiB
JavaScript
354 lines
6.7 KiB
JavaScript
/**
|
|
* @author bhouston / http://exocortex.com
|
|
* @author WestLangley / http://github.com/WestLangley
|
|
*/
|
|
|
|
THREE.Box3 = function ( min, max ) {
|
|
|
|
this.min = ( min !== undefined ) ? min : new THREE.Vector3( Infinity, Infinity, Infinity );
|
|
this.max = ( max !== undefined ) ? max : new THREE.Vector3( - Infinity, - Infinity, - Infinity );
|
|
|
|
};
|
|
|
|
THREE.Box3.prototype = {
|
|
|
|
constructor: THREE.Box3,
|
|
|
|
set: function ( min, max ) {
|
|
|
|
this.min.copy( min );
|
|
this.max.copy( max );
|
|
|
|
return this;
|
|
|
|
},
|
|
|
|
setFromPoints: function ( points ) {
|
|
|
|
this.makeEmpty();
|
|
|
|
for ( var i = 0, il = points.length; i < il; i ++ ) {
|
|
|
|
this.expandByPoint( points[ i ] )
|
|
|
|
}
|
|
|
|
return this;
|
|
|
|
},
|
|
|
|
setFromCenterAndSize: function () {
|
|
|
|
var v1 = new THREE.Vector3();
|
|
|
|
return function ( center, size ) {
|
|
|
|
var halfSize = v1.copy( size ).multiplyScalar( 0.5 );
|
|
|
|
this.min.copy( center ).sub( halfSize );
|
|
this.max.copy( center ).add( halfSize );
|
|
|
|
return this;
|
|
|
|
};
|
|
|
|
}(),
|
|
|
|
setFromObject: function () {
|
|
|
|
// Computes the world-axis-aligned bounding box of an object (including its children),
|
|
// accounting for both the object's, and childrens', world transforms
|
|
|
|
var v1 = new THREE.Vector3();
|
|
|
|
return function ( object ) {
|
|
|
|
var scope = this;
|
|
|
|
object.updateMatrixWorld( true );
|
|
|
|
this.makeEmpty();
|
|
|
|
object.traverse( function ( node ) {
|
|
|
|
var geometry = node.geometry;
|
|
|
|
if ( geometry !== undefined ) {
|
|
|
|
if ( geometry instanceof THREE.Geometry ) {
|
|
|
|
var vertices = geometry.vertices;
|
|
|
|
for ( var i = 0, il = vertices.length; i < il; i ++ ) {
|
|
|
|
v1.copy( vertices[ i ] );
|
|
|
|
v1.applyMatrix4( node.matrixWorld );
|
|
|
|
scope.expandByPoint( v1 );
|
|
|
|
}
|
|
|
|
} else if ( geometry instanceof THREE.BufferGeometry && geometry.attributes[ 'position' ] !== undefined ) {
|
|
|
|
var positions = geometry.attributes[ 'position' ].array;
|
|
|
|
for ( var i = 0, il = positions.length; i < il; i += 3 ) {
|
|
|
|
v1.set( positions[ i ], positions[ i + 1 ], positions[ i + 2 ] );
|
|
|
|
v1.applyMatrix4( node.matrixWorld );
|
|
|
|
scope.expandByPoint( v1 );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} );
|
|
|
|
return this;
|
|
|
|
};
|
|
|
|
}(),
|
|
|
|
copy: function ( box ) {
|
|
|
|
this.min.copy( box.min );
|
|
this.max.copy( box.max );
|
|
|
|
return this;
|
|
|
|
},
|
|
|
|
makeEmpty: function () {
|
|
|
|
this.min.x = this.min.y = this.min.z = Infinity;
|
|
this.max.x = this.max.y = this.max.z = - Infinity;
|
|
|
|
return this;
|
|
|
|
},
|
|
|
|
empty: function () {
|
|
|
|
// this is a more robust check for empty than ( volume <= 0 ) because volume can get positive with two negative axes
|
|
|
|
return ( this.max.x < this.min.x ) || ( this.max.y < this.min.y ) || ( this.max.z < this.min.z );
|
|
|
|
},
|
|
|
|
center: function ( optionalTarget ) {
|
|
|
|
var result = optionalTarget || new THREE.Vector3();
|
|
return result.addVectors( this.min, this.max ).multiplyScalar( 0.5 );
|
|
|
|
},
|
|
|
|
size: function ( optionalTarget ) {
|
|
|
|
var result = optionalTarget || new THREE.Vector3();
|
|
return result.subVectors( this.max, this.min );
|
|
|
|
},
|
|
|
|
expandByPoint: function ( point ) {
|
|
|
|
this.min.min( point );
|
|
this.max.max( point );
|
|
|
|
return this;
|
|
|
|
},
|
|
|
|
expandByVector: function ( vector ) {
|
|
|
|
this.min.sub( vector );
|
|
this.max.add( vector );
|
|
|
|
return this;
|
|
|
|
},
|
|
|
|
expandByScalar: function ( scalar ) {
|
|
|
|
this.min.addScalar( - scalar );
|
|
this.max.addScalar( scalar );
|
|
|
|
return this;
|
|
|
|
},
|
|
|
|
containsPoint: function ( point ) {
|
|
|
|
if ( point.x < this.min.x || point.x > this.max.x ||
|
|
point.y < this.min.y || point.y > this.max.y ||
|
|
point.z < this.min.z || point.z > this.max.z ) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
},
|
|
|
|
containsBox: function ( box ) {
|
|
|
|
if ( ( this.min.x <= box.min.x ) && ( box.max.x <= this.max.x ) &&
|
|
( this.min.y <= box.min.y ) && ( box.max.y <= this.max.y ) &&
|
|
( this.min.z <= box.min.z ) && ( box.max.z <= this.max.z ) ) {
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
},
|
|
|
|
getParameter: function ( point, optionalTarget ) {
|
|
|
|
// This can potentially have a divide by zero if the box
|
|
// has a size dimension of 0.
|
|
|
|
var result = optionalTarget || new THREE.Vector3();
|
|
|
|
return result.set(
|
|
( point.x - this.min.x ) / ( this.max.x - this.min.x ),
|
|
( point.y - this.min.y ) / ( this.max.y - this.min.y ),
|
|
( point.z - this.min.z ) / ( this.max.z - this.min.z )
|
|
);
|
|
|
|
},
|
|
|
|
isIntersectionBox: function ( box ) {
|
|
|
|
// using 6 splitting planes to rule out intersections.
|
|
|
|
if ( box.max.x < this.min.x || box.min.x > this.max.x ||
|
|
box.max.y < this.min.y || box.min.y > this.max.y ||
|
|
box.max.z < this.min.z || box.min.z > this.max.z ) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
},
|
|
|
|
clampPoint: function ( point, optionalTarget ) {
|
|
|
|
var result = optionalTarget || new THREE.Vector3();
|
|
return result.copy( point ).clamp( this.min, this.max );
|
|
|
|
},
|
|
|
|
distanceToPoint: function () {
|
|
|
|
var v1 = new THREE.Vector3();
|
|
|
|
return function ( point ) {
|
|
|
|
var clampedPoint = v1.copy( point ).clamp( this.min, this.max );
|
|
return clampedPoint.sub( point ).length();
|
|
|
|
};
|
|
|
|
}(),
|
|
|
|
getBoundingSphere: function () {
|
|
|
|
var v1 = new THREE.Vector3();
|
|
|
|
return function ( optionalTarget ) {
|
|
|
|
var result = optionalTarget || new THREE.Sphere();
|
|
|
|
result.center = this.center();
|
|
result.radius = this.size( v1 ).length() * 0.5;
|
|
|
|
return result;
|
|
|
|
};
|
|
|
|
}(),
|
|
|
|
intersect: function ( box ) {
|
|
|
|
this.min.max( box.min );
|
|
this.max.min( box.max );
|
|
|
|
return this;
|
|
|
|
},
|
|
|
|
union: function ( box ) {
|
|
|
|
this.min.min( box.min );
|
|
this.max.max( box.max );
|
|
|
|
return this;
|
|
|
|
},
|
|
|
|
applyMatrix4: function () {
|
|
|
|
var points = [
|
|
new THREE.Vector3(),
|
|
new THREE.Vector3(),
|
|
new THREE.Vector3(),
|
|
new THREE.Vector3(),
|
|
new THREE.Vector3(),
|
|
new THREE.Vector3(),
|
|
new THREE.Vector3(),
|
|
new THREE.Vector3()
|
|
];
|
|
|
|
return function ( matrix ) {
|
|
|
|
// NOTE: I am using a binary pattern to specify all 2^3 combinations below
|
|
points[ 0 ].set( this.min.x, this.min.y, this.min.z ).applyMatrix4( matrix ); // 000
|
|
points[ 1 ].set( this.min.x, this.min.y, this.max.z ).applyMatrix4( matrix ); // 001
|
|
points[ 2 ].set( this.min.x, this.max.y, this.min.z ).applyMatrix4( matrix ); // 010
|
|
points[ 3 ].set( this.min.x, this.max.y, this.max.z ).applyMatrix4( matrix ); // 011
|
|
points[ 4 ].set( this.max.x, this.min.y, this.min.z ).applyMatrix4( matrix ); // 100
|
|
points[ 5 ].set( this.max.x, this.min.y, this.max.z ).applyMatrix4( matrix ); // 101
|
|
points[ 6 ].set( this.max.x, this.max.y, this.min.z ).applyMatrix4( matrix ); // 110
|
|
points[ 7 ].set( this.max.x, this.max.y, this.max.z ).applyMatrix4( matrix ); // 111
|
|
|
|
this.makeEmpty();
|
|
this.setFromPoints( points );
|
|
|
|
return this;
|
|
|
|
};
|
|
|
|
}(),
|
|
|
|
translate: function ( offset ) {
|
|
|
|
this.min.add( offset );
|
|
this.max.add( offset );
|
|
|
|
return this;
|
|
|
|
},
|
|
|
|
equals: function ( box ) {
|
|
|
|
return box.min.equals( this.min ) && box.max.equals( this.max );
|
|
|
|
},
|
|
|
|
clone: function () {
|
|
|
|
return new THREE.Box3().copy( this );
|
|
|
|
}
|
|
|
|
};
|