#include <OPC_TreeCollider.h>

Inheritance diagram for AABBTreeCollider:

Public Member Functions
	AABBTreeCollider ()

virtual	~AABBTreeCollider ()

bool	Collide (BVTCache &cache, const Matrix4x4 world0=null, const Matrix4x4 world1=null)

bool	Collide (const AABBCollisionTree tree0, const AABBCollisionTree tree1, const Matrix4x4 world0=null, const Matrix4x4 world1=null, Pair *cache=null)

bool	Collide (const AABBNoLeafTree tree0, const AABBNoLeafTree tree1, const Matrix4x4 world0=null, const Matrix4x4 world1=null, Pair *cache=null)

bool	Collide (const AABBQuantizedTree tree0, const AABBQuantizedTree tree1, const Matrix4x4 world0=null, const Matrix4x4 world1=null, Pair *cache=null)

bool	Collide (const AABBQuantizedNoLeafTree tree0, const AABBQuantizedNoLeafTree tree1, const Matrix4x4 world0=null, const Matrix4x4 world1=null, Pair *cache=null)

inline_ void	SetFullBoxBoxTest (bool flag)

void	SetFullPrimBoxTest (bool flag)

inline_ udword	GetNbBVBVTests () const

inline_ udword	GetNbPrimPrimTests () const

inline_ udword	GetNbBVPrimTests () const

inline_ udword	GetNbPairs () const

inline_ const Pair *	GetPairs () const

	override (Collider) const char *ValidateSettings()

Public Member Functions inherited from Collider
	Collider ()

virtual	~Collider ()

inline_ BOOL	GetContactStatus () const

inline_ BOOL	FirstContactEnabled () const

inline_ BOOL	TemporalCoherenceEnabled () const

inline_ BOOL	ContactFound () const

inline_ BOOL	TemporalHit () const

inline_ BOOL	SkipPrimitiveTests () const

inline_ void	SetFirstContact (bool flag)

inline_ void	SetTemporalCoherence (bool flag)

inline_ void	SetPrimitiveTests (bool flag)

virtual const char *	ValidateSettings ()=0

Protected Member Functions
void	_Collide (const AABBCollisionNode b0, const AABBCollisionNode b1)

void	_Collide (const AABBQuantizedNode b0, const AABBQuantizedNode b1, const Point &a, const Point &Pa, const Point &b, const Point &Pb)

void	_CollideTriBox (const AABBNoLeafNode *b)

void	_CollideBoxTri (const AABBNoLeafNode *b)

void	_Collide (const AABBNoLeafNode a, const AABBNoLeafNode b)

void	_CollideTriBox (const AABBQuantizedNoLeafNode *b)

void	_CollideBoxTri (const AABBQuantizedNoLeafNode *b)

void	_Collide (const AABBQuantizedNoLeafNode a, const AABBQuantizedNoLeafNode b)

void	PrimTest (udword id0, udword id1)

inline_ void	PrimTestTriIndex (udword id1)

inline_ void	PrimTestIndexTri (udword id0)

inline_ bool	BoxBoxOverlap (const Point &ea, const Point &ca, const Point &eb, const Point &cb)

inline_ bool	TriBoxOverlap (const Point &center, const Point &extents)

inline_ bool	TriTriOverlap (const Point &V0, const Point &V1, const Point &V2, const Point &U0, const Point &U1, const Point &U2)

void	InitQuery (const Matrix4x4 world0=null, const Matrix4x4 world1=null)

bool	CheckTemporalCoherence (Pair *cache)

inline_ bool	Setup (const MeshInterface mi0, const MeshInterface mi1)

Protected Member Functions inherited from Collider
inline_ BOOL	Setup (const BaseModel *model)

virtual inline_ void	InitQuery ()

Protected Attributes
Container	mPairs
	Pairs of colliding primitives. More...

const MeshInterface *	mIMesh0
	User-defined mesh interface for object0. More...

const MeshInterface *	mIMesh1
	User-defined mesh interface for object1. More...

udword	mNbBVBVTests
	Number of BV-BV tests. More...

udword	mNbPrimPrimTests
	Number of Primitive-Primitive tests. More...

udword	mNbBVPrimTests
	Number of BV-Primitive tests. More...

Matrix3x3	mAR
	Absolute rotation matrix. More...

Matrix3x3	mR0to1
	Rotation from object0 to object1. More...

Matrix3x3	mR1to0
	Rotation from object1 to object0. More...

Point	mT0to1
	Translation from object0 to object1. More...

Point	mT1to0
	Translation from object1 to object0. More...

Point	mCenterCoeff0

Point	mExtentsCoeff0

Point	mCenterCoeff1

Point	mExtentsCoeff1

Point	mLeafVerts [3]
	Triangle vertices. More...

udword	mLeafIndex
	Triangle index. More...

bool	mFullBoxBoxTest
	Perform full BV-BV tests (true) or SAT-lite tests (false) More...

bool	mFullPrimBoxTest
	Perform full Primitive-BV tests (true) or SAT-lite tests (false) More...

Protected Attributes inherited from Collider
udword	mFlags
	Bit flags. More...

const BaseModel *	mCurrentModel
	Current model for collision query (owner of touched faces) More...

const MeshInterface *	mIMesh
	User-defined mesh interface. More...

Detailed Description

Contains an AABB tree collider. This class performs a collision test between two AABB trees.

Author: Pierre Terdiman

Version: 1.3

Date: March, 20, 2001

Definition at line 69 of file OPC_TreeCollider.h.

Constructor & Destructor Documentation

AABBTreeCollider::AABBTreeCollider ( )

virtual AABBTreeCollider::~AABBTreeCollider ( )

virtual

Member Function Documentation

void AABBTreeCollider::_Collide	(	const AABBCollisionNode *	b0,
		const AABBCollisionNode *	b1
	)

protected

void AABBTreeCollider::_Collide	(	const AABBQuantizedNode *	b0,
		const AABBQuantizedNode *	b1,
		const Point &	a,
		const Point &	Pa,
		const Point &	b,
		const Point &	Pb
	)

protected

void AABBTreeCollider::_Collide	(	const AABBNoLeafNode *	a,
		const AABBNoLeafNode *	b
	)

protected

void AABBTreeCollider::_Collide	(	const AABBQuantizedNoLeafNode *	a,
		const AABBQuantizedNoLeafNode *	b
	)

protected

void AABBTreeCollider::_CollideBoxTri ( const AABBNoLeafNode * b)

protected

void AABBTreeCollider::_CollideBoxTri ( const AABBQuantizedNoLeafNode * b)

protected

void AABBTreeCollider::_CollideTriBox ( const AABBNoLeafNode * b)

protected

void AABBTreeCollider::_CollideTriBox ( const AABBQuantizedNoLeafNode * b)

protected

inline_ bool AABBTreeCollider::BoxBoxOverlap	(	const Point &	ea,
		const Point &	ca,
		const Point &	eb,
		const Point &	cb
	)

protected

OBB-OBB overlap test using the separating axis theorem.

original code by Gomez / Gamasutra (similar to Gottschalk's one in RAPID)
optimized for AABB trees by computing the rotation matrix once (SOLID-fashion)
the fabs matrix is precomputed as well and epsilon-tweaked (RAPID-style, we found this almost mandatory)
Class III axes can be disabled... (SOLID & Intel fashion)
...or enabled to perform some profiling
CPU comparisons used when appropriate
lazy evaluation sometimes saves some work in case of early exits (unlike SOLID)

Parameters

ea	[in] extents from box A
ca	[in] center from box A
eb	[in] extents from box B
cb	[in] center from box B

Returns: true if boxes overlap

Definition at line 19 of file OPC_BoxBoxOverlap.h.

 {
     // Stats
     mNbBVBVTests++;
 
     float t,t2;
 
     // Class I : A's basis vectors
     float Tx = (mR1to0.m[0][0]*cb.x + mR1to0.m[1][0]*cb.y + mR1to0.m[2][0]*cb.z) + mT1to0.x - ca.x;
     t = ea.x + eb.x*mAR.m[0][0] + eb.y*mAR.m[1][0] + eb.z*mAR.m[2][0];
     if(GREATER(Tx, t))  return FALSE;
 
     float Ty = (mR1to0.m[0][1]*cb.x + mR1to0.m[1][1]*cb.y + mR1to0.m[2][1]*cb.z) + mT1to0.y - ca.y;
     t = ea.y + eb.x*mAR.m[0][1] + eb.y*mAR.m[1][1] + eb.z*mAR.m[2][1];
     if(GREATER(Ty, t))  return FALSE;
 
     float Tz = (mR1to0.m[0][2]*cb.x + mR1to0.m[1][2]*cb.y + mR1to0.m[2][2]*cb.z) + mT1to0.z - ca.z;
     t = ea.z + eb.x*mAR.m[0][2] + eb.y*mAR.m[1][2] + eb.z*mAR.m[2][2];
     if(GREATER(Tz, t))  return FALSE;
 
     // Class II : B's basis vectors
     t = Tx*mR1to0.m[0][0] + Ty*mR1to0.m[0][1] + Tz*mR1to0.m[0][2];  t2 = ea.x*mAR.m[0][0] + ea.y*mAR.m[0][1] + ea.z*mAR.m[0][2] + eb.x;
     if(GREATER(t, t2))  return FALSE;
 
     t = Tx*mR1to0.m[1][0] + Ty*mR1to0.m[1][1] + Tz*mR1to0.m[1][2];  t2 = ea.x*mAR.m[1][0] + ea.y*mAR.m[1][1] + ea.z*mAR.m[1][2] + eb.y;
     if(GREATER(t, t2))  return FALSE;
 
     t = Tx*mR1to0.m[2][0] + Ty*mR1to0.m[2][1] + Tz*mR1to0.m[2][2];  t2 = ea.x*mAR.m[2][0] + ea.y*mAR.m[2][1] + ea.z*mAR.m[2][2] + eb.z;
     if(GREATER(t, t2))  return FALSE;
 
     // Class III : 9 cross products
     // Cool trick: always perform the full test for first level, regardless of settings.
     // That way pathological cases (such as the pencils scene) are quickly rejected anyway !
     if(mFullBoxBoxTest || mNbBVBVTests==1)
     {
         t = Tz*mR1to0.m[0][1] - Ty*mR1to0.m[0][2];  t2 = ea.y*mAR.m[0][2] + ea.z*mAR.m[0][1] + eb.y*mAR.m[2][0] + eb.z*mAR.m[1][0]; if(GREATER(t, t2))  return FALSE;   // L = A0 x B0
         t = Tz*mR1to0.m[1][1] - Ty*mR1to0.m[1][2];  t2 = ea.y*mAR.m[1][2] + ea.z*mAR.m[1][1] + eb.x*mAR.m[2][0] + eb.z*mAR.m[0][0]; if(GREATER(t, t2))  return FALSE;   // L = A0 x B1
         t = Tz*mR1to0.m[2][1] - Ty*mR1to0.m[2][2];  t2 = ea.y*mAR.m[2][2] + ea.z*mAR.m[2][1] + eb.x*mAR.m[1][0] + eb.y*mAR.m[0][0]; if(GREATER(t, t2))  return FALSE;   // L = A0 x B2
         t = Tx*mR1to0.m[0][2] - Tz*mR1to0.m[0][0];  t2 = ea.x*mAR.m[0][2] + ea.z*mAR.m[0][0] + eb.y*mAR.m[2][1] + eb.z*mAR.m[1][1]; if(GREATER(t, t2))  return FALSE;   // L = A1 x B0
         t = Tx*mR1to0.m[1][2] - Tz*mR1to0.m[1][0];  t2 = ea.x*mAR.m[1][2] + ea.z*mAR.m[1][0] + eb.x*mAR.m[2][1] + eb.z*mAR.m[0][1]; if(GREATER(t, t2))  return FALSE;   // L = A1 x B1
         t = Tx*mR1to0.m[2][2] - Tz*mR1to0.m[2][0];  t2 = ea.x*mAR.m[2][2] + ea.z*mAR.m[2][0] + eb.x*mAR.m[1][1] + eb.y*mAR.m[0][1]; if(GREATER(t, t2))  return FALSE;   // L = A1 x B2
         t = Ty*mR1to0.m[0][0] - Tx*mR1to0.m[0][1];  t2 = ea.x*mAR.m[0][1] + ea.y*mAR.m[0][0] + eb.y*mAR.m[2][2] + eb.z*mAR.m[1][2]; if(GREATER(t, t2))  return FALSE;   // L = A2 x B0
         t = Ty*mR1to0.m[1][0] - Tx*mR1to0.m[1][1];  t2 = ea.x*mAR.m[1][1] + ea.y*mAR.m[1][0] + eb.x*mAR.m[2][2] + eb.z*mAR.m[0][2]; if(GREATER(t, t2))  return FALSE;   // L = A2 x B1
         t = Ty*mR1to0.m[2][0] - Tx*mR1to0.m[2][1];  t2 = ea.x*mAR.m[2][1] + ea.y*mAR.m[2][0] + eb.x*mAR.m[1][2] + eb.y*mAR.m[0][2]; if(GREATER(t, t2))  return FALSE;   // L = A2 x B2
     }
     return TRUE;
 }

bool AABBTreeCollider::CheckTemporalCoherence ( Pair * cache)

protected

bool AABBTreeCollider::Collide	(	BVTCache &	cache,
		const Matrix4x4 *	world0 = `null`,
		const Matrix4x4 *	world1 = `null`
	)

Generic collision query for generic OPCODE models. After the call, access the results with:

Parameters

cache	[in] collision cache for model pointers and a colliding pair of primitives
world0	[in] world matrix for first object, or null
world1	[in] world matrix for second object, or null

Returns: true if success

Warning: SCALE NOT SUPPORTED. The matrices must contain rotation & translation parts only.

bool AABBTreeCollider::Collide	(	const AABBCollisionTree *	tree0,
		const AABBCollisionTree *	tree1,
		const Matrix4x4 *	world0 = `null`,
		const Matrix4x4 *	world1 = `null`,
		Pair *	cache = `null`
	)

bool AABBTreeCollider::Collide	(	const AABBNoLeafTree *	tree0,
		const AABBNoLeafTree *	tree1,
		const Matrix4x4 *	world0 = `null`,
		const Matrix4x4 *	world1 = `null`,
		Pair *	cache = `null`
	)

bool AABBTreeCollider::Collide	(	const AABBQuantizedTree *	tree0,
		const AABBQuantizedTree *	tree1,
		const Matrix4x4 *	world0 = `null`,
		const Matrix4x4 *	world1 = `null`,
		Pair *	cache = `null`
	)

bool AABBTreeCollider::Collide	(	const AABBQuantizedNoLeafTree *	tree0,
		const AABBQuantizedNoLeafTree *	tree1,
		const Matrix4x4 *	world0 = `null`,
		const Matrix4x4 *	world1 = `null`,
		Pair *	cache = `null`
	)

inline_ udword AABBTreeCollider::GetNbBVBVTests ( ) const

inline

Stats: gets the number of BV-BV overlap tests after a collision query.

See Also: GetNbPrimPrimTests(); GetNbBVPrimTests()

Returns: the number of BV-BV tests performed during last query

Definition at line 128 of file OPC_TreeCollider.h.

128 { return mNbBVBVTests; }

inline_ udword AABBTreeCollider::GetNbBVPrimTests ( ) const

inline

Stats: gets the number of BV-Triangle overlap tests after a collision query.

See Also: GetNbBVBVTests(); GetNbPrimPrimTests()

Returns: the number of BV-Triangle tests performed during last query

Definition at line 148 of file OPC_TreeCollider.h.

148 { return mNbBVPrimTests; }

inline_ udword AABBTreeCollider::GetNbPairs ( ) const

inline

Gets the number of contacts after a collision query.

See Also: GetContactStatus(); GetPairs()

Returns: the number of contacts / colliding pairs.

Definition at line 160 of file OPC_TreeCollider.h.

160 { return mPairs.GetNbEntries()>>1; }

inline_ udword AABBTreeCollider::GetNbPrimPrimTests ( ) const

inline

Stats: gets the number of Triangle-Triangle overlap tests after a collision query.

See Also: GetNbBVBVTests(); GetNbBVPrimTests()

Returns: the number of Triangle-Triangle tests performed during last query

Definition at line 138 of file OPC_TreeCollider.h.

138 { return mNbPrimPrimTests; }

inline_ const Pair* AABBTreeCollider::GetPairs ( ) const

inline

Gets the pairs of colliding triangles after a collision query.

See Also: GetContactStatus(); GetNbPairs()

Returns: the list of colliding pairs (triangle indices)

Definition at line 170 of file OPC_TreeCollider.h.

170 { return (const Pair*)mPairs.GetEntries(); }

void AABBTreeCollider::InitQuery	(	const Matrix4x4 *	world0 = `null`,
		const Matrix4x4 *	world1 = `null`
	)

protected

AABBTreeCollider::override ( Collider ) const

Validates current settings. You should call this method after all the settings and callbacks have been defined for a collider.

Returns: null if everything is ok, else a string describing the problem

void AABBTreeCollider::PrimTest	(	udword	id0,
		udword	id1
	)

protected

inline_ void AABBTreeCollider::PrimTestIndexTri ( udword id0)

protected

inline_ void AABBTreeCollider::PrimTestTriIndex ( udword id1)

protected

inline_ void AABBTreeCollider::SetFullBoxBoxTest ( bool flag)

inline

Settings: selects between full box-box tests or "SAT-lite" tests (where Class III axes are discarded)

Parameters

flag	[in] true for full tests, false for coarse tests

See Also: SetFullPrimBoxTest(bool flag)

Definition at line 107 of file OPC_TreeCollider.h.

107 { mFullBoxBoxTest = flag; }

void AABBTreeCollider::SetFullPrimBoxTest ( bool flag)

inline

Settings: selects between full triangle-box tests or "SAT-lite" tests (where Class III axes are discarded)

Parameters

flag	[in] true for full tests, false for coarse tests

See Also: SetFullBoxBoxTest(bool flag)

Definition at line 116 of file OPC_TreeCollider.h.

116 { mFullPrimBoxTest = flag; }

inline_ bool AABBTreeCollider::Setup	(	const MeshInterface *	mi0,
		const MeshInterface *	mi1
	)

inlineprotected

Definition at line 233 of file OPC_TreeCollider.h.

References FALSE, and TRUE.

                                             {
                                                 mIMesh0 = mi0;
                                                 mIMesh1 = mi1;
 
                                                 if(!mIMesh0 || !mIMesh1)    return FALSE;
 
                                                 return TRUE;
                                             }

inline_ bool AABBTreeCollider::TriBoxOverlap	(	const Point &	center,
		const Point &	extents
	)

protected

Triangle-Box overlap test using the separating axis theorem. This is the code from Tomas M�ller, a bit optimized:

with some more lazy evaluation (faster path on PC)
with a tiny bit of assembly
with "SAT-lite" applied if needed
and perhaps with some more minor modifs...

Parameters

center	[in] box center
extents	[in] box extents

Returns: true if triangle & box overlap

Definition at line 118 of file OPC_TriBoxOverlap.h.

 {
     // Stats
     mNbBVPrimTests++;
 
     // use separating axis theorem to test overlap between triangle and box 
     // need to test for overlap in these directions: 
     // 1) the {x,y,z}-directions (actually, since we use the AABB of the triangle 
     //    we do not even need to test these) 
     // 2) normal of the triangle 
     // 3) crossproduct(edge from tri, {x,y,z}-directin) 
     //    this gives 3x3=9 more tests 
 
     // move everything so that the boxcenter is in (0,0,0) 
     Point v0, v1, v2;
     v0.x = mLeafVerts[0].x - center.x;
     v1.x = mLeafVerts[1].x - center.x;
     v2.x = mLeafVerts[2].x - center.x;
 
     // First, test overlap in the {x,y,z}-directions
 #ifdef OPC_USE_FCOMI
     // find min, max of the triangle in x-direction, and test for overlap in X
     if(FCMin3(v0.x, v1.x, v2.x)>extents.x)  return FALSE;
     if(FCMax3(v0.x, v1.x, v2.x)<-extents.x) return FALSE;
 
     // same for Y
     v0.y = mLeafVerts[0].y - center.y;
     v1.y = mLeafVerts[1].y - center.y;
     v2.y = mLeafVerts[2].y - center.y;
 
     if(FCMin3(v0.y, v1.y, v2.y)>extents.y)  return FALSE;
     if(FCMax3(v0.y, v1.y, v2.y)<-extents.y) return FALSE;
 
     // same for Z
     v0.z = mLeafVerts[0].z - center.z;
     v1.z = mLeafVerts[1].z - center.z;
     v2.z = mLeafVerts[2].z - center.z;
 
     if(FCMin3(v0.z, v1.z, v2.z)>extents.z)  return FALSE;
     if(FCMax3(v0.z, v1.z, v2.z)<-extents.z) return FALSE;
 #else
     float min,max;
     // Find min, max of the triangle in x-direction, and test for overlap in X
     FINDMINMAX(v0.x, v1.x, v2.x, min, max);
     if(min>extents.x || max<-extents.x) return FALSE;
 
     // Same for Y
     v0.y = mLeafVerts[0].y - center.y;
     v1.y = mLeafVerts[1].y - center.y;
     v2.y = mLeafVerts[2].y - center.y;
 
     FINDMINMAX(v0.y, v1.y, v2.y, min, max);
     if(min>extents.y || max<-extents.y) return FALSE;
 
     // Same for Z
     v0.z = mLeafVerts[0].z - center.z;
     v1.z = mLeafVerts[1].z - center.z;
     v2.z = mLeafVerts[2].z - center.z;
 
     FINDMINMAX(v0.z, v1.z, v2.z, min, max);
     if(min>extents.z || max<-extents.z) return FALSE;
 #endif
     // 2) Test if the box intersects the plane of the triangle
     // compute plane equation of triangle: normal*x+d=0
     // ### could be precomputed since we use the same leaf triangle several times
     const Point e0 = v1 - v0;
     const Point e1 = v2 - v1;
     const Point normal = e0 ^ e1;
     const float d = -normal|v0;
     if(!planeBoxOverlap(normal, d, extents)) return FALSE;
 
     // 3) "Class III" tests
     if(mFullPrimBoxTest)
     {
         IMPLEMENT_CLASS3_TESTS
     }
     return TRUE;
 }

inline_ bool AABBTreeCollider::TriTriOverlap	(	const Point &	V0,
		const Point &	V1,
		const Point &	V2,
		const Point &	U0,
		const Point &	U1,
		const Point &	U2
	)

protected

Triangle/triangle intersection test routine, by Tomas Moller, 1997. See article "A Fast Triangle-Triangle Intersection Test", Journal of Graphics Tools, 2(2), 1997

Updated June 1999: removed the divisions – a little faster now! Updated October 1999: added {} to CROSS and SUB macros

int NoDivTriTriIsect(float V0[3],float V1[3],float V2[3], float U0[3],float U1[3],float U2[3])

Parameters

V0	[in] triangle 0, vertex 0
V1	[in] triangle 0, vertex 1
V2	[in] triangle 0, vertex 2
U0	[in] triangle 1, vertex 0
U1	[in] triangle 1, vertex 1
U2	[in] triangle 1, vertex 2

Returns: true if triangles overlap

Definition at line 179 of file OPC_TriTriOverlap.h.

 {
     // Stats
     mNbPrimPrimTests++;
 
     // Compute plane equation of triangle(V0,V1,V2)
     Point E1 = V1 - V0;
     Point E2 = V2 - V0;
     const Point N1 = E1 ^ E2;
     const float d1 =-N1 | V0;
     // Plane equation 1: N1.X+d1=0
 
     // Put U0,U1,U2 into plane equation 1 to compute signed distances to the plane
     float du0 = (N1|U0) + d1;
     float du1 = (N1|U1) + d1;
     float du2 = (N1|U2) + d1;
 
     // Coplanarity robustness check
 #ifdef OPC_TRITRI_EPSILON_TEST
     if(fabsf(du0)<LOCAL_EPSILON) du0 = 0.0f;
     if(fabsf(du1)<LOCAL_EPSILON) du1 = 0.0f;
     if(fabsf(du2)<LOCAL_EPSILON) du2 = 0.0f;
 #endif
     const float du0du1 = du0 * du1;
     const float du0du2 = du0 * du2;
 
     if(du0du1>0.0f && du0du2>0.0f)  // same sign on all of them + not equal 0 ?
         return FALSE;               // no intersection occurs
 
     // Compute plane of triangle (U0,U1,U2)
     E1 = U1 - U0;
     E2 = U2 - U0;
     const Point N2 = E1 ^ E2;
     const float d2=-N2 | U0;
     // plane equation 2: N2.X+d2=0
 
     // put V0,V1,V2 into plane equation 2
     float dv0 = (N2|V0) + d2;
     float dv1 = (N2|V1) + d2;
     float dv2 = (N2|V2) + d2;
 
 #ifdef OPC_TRITRI_EPSILON_TEST
     if(fabsf(dv0)<LOCAL_EPSILON) dv0 = 0.0f;
     if(fabsf(dv1)<LOCAL_EPSILON) dv1 = 0.0f;
     if(fabsf(dv2)<LOCAL_EPSILON) dv2 = 0.0f;
 #endif
 
     const float dv0dv1 = dv0 * dv1;
     const float dv0dv2 = dv0 * dv2;
 
     if(dv0dv1>0.0f && dv0dv2>0.0f)  // same sign on all of them + not equal 0 ?
         return FALSE;               // no intersection occurs
 
     // Compute direction of intersection line
     const Point D = N1^N2;
 
     // Compute and index to the largest component of D
     float max=fabsf(D[0]);
     short index=0;
     float bb=fabsf(D[1]);
     float cc=fabsf(D[2]);
     if(bb>max) max=bb,index=1;
     if(cc>max) max=cc,index=2;
 
     // This is the simplified projection onto L
     const float vp0 = V0[index];
     const float vp1 = V1[index];
     const float vp2 = V2[index];
 
     const float up0 = U0[index];
     const float up1 = U1[index];
     const float up2 = U2[index];
 
     // Compute interval for triangle 1
     float a,b,c,x0,x1;
     NEWCOMPUTE_INTERVALS(vp0,vp1,vp2,dv0,dv1,dv2,dv0dv1,dv0dv2,a,b,c,x0,x1);
 
     // Compute interval for triangle 2
     float d,e,f,y0,y1;
     NEWCOMPUTE_INTERVALS(up0,up1,up2,du0,du1,du2,du0du1,du0du2,d,e,f,y0,y1);
 
     const float xx=x0*x1;
     const float yy=y0*y1;
     const float xxyy=xx*yy;
 
     float isect1[2], isect2[2];
 
     float tmp=a*xxyy;
     isect1[0]=tmp+b*x1*yy;
     isect1[1]=tmp+c*x0*yy;
 
     tmp=d*xxyy;
     isect2[0]=tmp+e*xx*y1;
     isect2[1]=tmp+f*xx*y0;
 
     SORT(isect1[0],isect1[1]);
     SORT(isect2[0],isect2[1]);
 
     if(isect1[1]<isect2[0] || isect2[1]<isect1[0]) return FALSE;
     return TRUE;
 }

Member Data Documentation

Matrix3x3 AABBTreeCollider::mAR

protected

Absolute rotation matrix.

Definition at line 191 of file OPC_TreeCollider.h.

Point AABBTreeCollider::mCenterCoeff0

protected

Definition at line 197 of file OPC_TreeCollider.h.

Point AABBTreeCollider::mCenterCoeff1

protected

Definition at line 199 of file OPC_TreeCollider.h.

Point AABBTreeCollider::mExtentsCoeff0

protected

Definition at line 198 of file OPC_TreeCollider.h.

Point AABBTreeCollider::mExtentsCoeff1

protected

Definition at line 200 of file OPC_TreeCollider.h.

bool AABBTreeCollider::mFullBoxBoxTest

protected

Perform full BV-BV tests (true) or SAT-lite tests (false)

Definition at line 205 of file OPC_TreeCollider.h.

bool AABBTreeCollider::mFullPrimBoxTest

protected

Perform full Primitive-BV tests (true) or SAT-lite tests (false)

Definition at line 206 of file OPC_TreeCollider.h.

const MeshInterface* AABBTreeCollider::mIMesh0

protected

User-defined mesh interface for object0.

Definition at line 184 of file OPC_TreeCollider.h.

const MeshInterface* AABBTreeCollider::mIMesh1

protected

User-defined mesh interface for object1.

Definition at line 185 of file OPC_TreeCollider.h.

udword AABBTreeCollider::mLeafIndex

protected

Triangle index.

Definition at line 203 of file OPC_TreeCollider.h.

Point AABBTreeCollider::mLeafVerts[3]

protected

Triangle vertices.

Definition at line 202 of file OPC_TreeCollider.h.

udword AABBTreeCollider::mNbBVBVTests

protected

Number of BV-BV tests.

Definition at line 187 of file OPC_TreeCollider.h.

udword AABBTreeCollider::mNbBVPrimTests

protected

Number of BV-Primitive tests.

Definition at line 189 of file OPC_TreeCollider.h.

udword AABBTreeCollider::mNbPrimPrimTests

protected

Number of Primitive-Primitive tests.

Definition at line 188 of file OPC_TreeCollider.h.

Container AABBTreeCollider::mPairs

protected

Pairs of colliding primitives.

Definition at line 182 of file OPC_TreeCollider.h.

Matrix3x3 AABBTreeCollider::mR0to1

protected

Rotation from object0 to object1.

Definition at line 192 of file OPC_TreeCollider.h.

Matrix3x3 AABBTreeCollider::mR1to0

protected

Rotation from object1 to object0.

Definition at line 193 of file OPC_TreeCollider.h.

Point AABBTreeCollider::mT0to1

protected

Translation from object0 to object1.

Definition at line 194 of file OPC_TreeCollider.h.

Point AABBTreeCollider::mT1to0

protected

Translation from object1 to object0.

Definition at line 195 of file OPC_TreeCollider.h.

The documentation for this class was generated from the following files:

src/cmd/collide2/OPC_TreeCollider.h
src/cmd/collide2/OPC_BoxBoxOverlap.h
src/cmd/collide2/OPC_TriBoxOverlap.h
src/cmd/collide2/OPC_TriTriOverlap.h

Public Member Functions

Protected Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation