#include <Opcode.h>

Inheritance diagram for Opcode::PlanesCollider:

Public Member Functions
	PlanesCollider ()

virtual	~PlanesCollider ()

bool	Collide (PlanesCache &cache, const Plane planes, udword nb_planes, const Model &model, const Matrix4x4 worldm=null)

inline_ bool	Collide (PlanesCache &cache, const OBB &box, const Model &model, const Matrix4x4 worldb=null, const Matrix4x4 worldm=null)

	override (Collider) const char *ValidateSettings()

Public Member Functions inherited from Opcode::VolumeCollider
	VolumeCollider ()

virtual	~VolumeCollider ()=0

inline_ udword	GetNbTouchedPrimitives () const

inline_ const udword *	GetTouchedPrimitives () const

inline_ udword	GetNbVolumeBVTests () const

inline_ udword	GetNbVolumePrimTests () const

	override (Collider) const char *ValidateSettings()

Public Member Functions inherited from Opcode::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 *node, udword clip_mask)

void	_Collide (const AABBNoLeafNode *node, udword clip_mask)

void	_Collide (const AABBQuantizedNode *node, udword clip_mask)

void	_Collide (const AABBQuantizedNoLeafNode *node, udword clip_mask)

void	_CollideNoPrimitiveTest (const AABBCollisionNode *node, udword clip_mask)

void	_CollideNoPrimitiveTest (const AABBNoLeafNode *node, udword clip_mask)

void	_CollideNoPrimitiveTest (const AABBQuantizedNode *node, udword clip_mask)

void	_CollideNoPrimitiveTest (const AABBQuantizedNoLeafNode *node, udword clip_mask)

inline_ bool	PlanesAABBOverlap (const Point &center, const Point &extents, udword &out_clip_mask, udword in_clip_mask)

inline_ bool	PlanesTriOverlap (udword in_clip_mask)

bool	InitQuery (PlanesCache &cache, const Plane planes, udword nb_planes, const Matrix4x4 worldm=null)

Protected Member Functions inherited from Opcode::VolumeCollider
void	_Dump (const AABBCollisionNode *node)

void	_Dump (const AABBNoLeafNode *node)

void	_Dump (const AABBQuantizedNode *node)

void	_Dump (const AABBQuantizedNoLeafNode *node)

	override (Collider) inline_ void InitQuery()

inline_ BOOL	IsCacheValid (VolumeCache &cache)

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

virtual inline_ void	InitQuery ()

Protected Attributes
udword	mNbPlanes

Plane *	mPlanes

VertexPointers	mVP

Protected Attributes inherited from Opcode::VolumeCollider
Container *	mTouchedPrimitives
	List of touched primitives. More...

Point	mCenterCoeff

Point	mExtentsCoeff

udword	mNbVolumeBVTests
	Number of Volume-BV tests. More...

udword	mNbVolumePrimTests
	Number of Volume-Primitive tests. More...

Protected Attributes inherited from Opcode::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

Definition at line 31 of file Opcode.h.

Constructor & Destructor Documentation

PlanesCollider::PlanesCollider ( )

Constructor.

Definition at line 59 of file OPC_PlanesCollider.cpp.

                                :
     mNbPlanes   (0),
     mPlanes     (null)
 {
 }

PlanesCollider::~PlanesCollider ( )

virtual

Destructor.

Definition at line 70 of file OPC_PlanesCollider.cpp.

 {
     DELETEARRAY(mPlanes);
 }

Member Function Documentation

void PlanesCollider::_Collide	(	const AABBCollisionNode *	node,
		udword	clip_mask
	)

protected

Recursive collision query for normal AABB trees.

Parameters

node	[in] current collision node

Definition at line 277 of file OPC_PlanesCollider.cpp.

 {
     // Test the box against the planes. If the box is completely culled, so are its children, hence we exit.
     udword OutClipMask;
     if(!PlanesAABBOverlap(node->mAABB.mCenter, node->mAABB.mExtents, OutClipMask, clip_mask))   return;
 
     TEST_CLIP_MASK
 
     // Else the box straddles one or several planes, so we need to recurse down the tree.
     if(node->IsLeaf())
     {
         PLANES_PRIM(node->GetPrimitive(), OPC_CONTACT)
     }
     else
     {
         _Collide(node->GetPos(), OutClipMask);
 
         if(ContactFound()) return;
 
         _Collide(node->GetNeg(), OutClipMask);
     }
 }

void PlanesCollider::_Collide	(	const AABBNoLeafNode *	node,
		udword	clip_mask
	)

protected

Recursive collision query for no-leaf AABB trees.

Parameters

node	[in] current collision node

Definition at line 403 of file OPC_PlanesCollider.cpp.

 {
     // Test the box against the planes. If the box is completely culled, so are its children, hence we exit.
     udword OutClipMask;
     if(!PlanesAABBOverlap(node->mAABB.mCenter, node->mAABB.mExtents, OutClipMask, clip_mask))   return;
 
     TEST_CLIP_MASK
 
     // Else the box straddles one or several planes, so we need to recurse down the tree.
     if(node->HasPosLeaf())  { PLANES_PRIM(node->GetPosPrimitive(), OPC_CONTACT) }
     else                    _Collide(node->GetPos(), OutClipMask);
 
     if(ContactFound()) return;
 
     if(node->HasNegLeaf())  { PLANES_PRIM(node->GetNegPrimitive(), OPC_CONTACT) }
     else                    _Collide(node->GetNeg(), OutClipMask);
 }

void PlanesCollider::_Collide	(	const AABBQuantizedNode *	node,
		udword	clip_mask
	)

protected

Recursive collision query for quantized AABB trees.

Parameters

node	[in] current collision node

Definition at line 335 of file OPC_PlanesCollider.cpp.

 {
     // Dequantize box
     const QuantizedAABB& Box = node->mAABB;
     const Point Center(float(Box.mCenter[0]) * mCenterCoeff.x, float(Box.mCenter[1]) * mCenterCoeff.y, float(Box.mCenter[2]) * mCenterCoeff.z);
     const Point Extents(float(Box.mExtents[0]) * mExtentsCoeff.x, float(Box.mExtents[1]) * mExtentsCoeff.y, float(Box.mExtents[2]) * mExtentsCoeff.z);
 
     // Test the box against the planes. If the box is completely culled, so are its children, hence we exit.
     udword OutClipMask;
     if(!PlanesAABBOverlap(Center, Extents, OutClipMask, clip_mask)) return;
 
     TEST_CLIP_MASK
 
     // Else the box straddles one or several planes, so we need to recurse down the tree.
     if(node->IsLeaf())
     {
         PLANES_PRIM(node->GetPrimitive(), OPC_CONTACT)
     }
     else
     {
         _Collide(node->GetPos(), OutClipMask);
 
         if(ContactFound()) return;
 
         _Collide(node->GetNeg(), OutClipMask);
     }
 }

void PlanesCollider::_Collide	(	const AABBQuantizedNoLeafNode *	node,
		udword	clip_mask
	)

protected

Recursive collision query for quantized no-leaf AABB trees.

Parameters

node	[in] current collision node

Definition at line 451 of file OPC_PlanesCollider.cpp.

 {
     // Dequantize box
     const QuantizedAABB& Box = node->mAABB;
     const Point Center(float(Box.mCenter[0]) * mCenterCoeff.x, float(Box.mCenter[1]) * mCenterCoeff.y, float(Box.mCenter[2]) * mCenterCoeff.z);
     const Point Extents(float(Box.mExtents[0]) * mExtentsCoeff.x, float(Box.mExtents[1]) * mExtentsCoeff.y, float(Box.mExtents[2]) * mExtentsCoeff.z);
 
     // Test the box against the planes. If the box is completely culled, so are its children, hence we exit.
     udword OutClipMask;
     if(!PlanesAABBOverlap(Center, Extents, OutClipMask, clip_mask)) return;
 
     TEST_CLIP_MASK
 
     // Else the box straddles one or several planes, so we need to recurse down the tree.
     if(node->HasPosLeaf())  { PLANES_PRIM(node->GetPosPrimitive(), OPC_CONTACT) }
     else                    _Collide(node->GetPos(), OutClipMask);
 
     if(ContactFound()) return;
 
     if(node->HasNegLeaf())  { PLANES_PRIM(node->GetNegPrimitive(), OPC_CONTACT) }
     else                    _Collide(node->GetNeg(), OutClipMask);
 }

void PlanesCollider::_CollideNoPrimitiveTest	(	const AABBCollisionNode *	node,
		udword	clip_mask
	)

protected

Recursive collision query for normal AABB trees.

Parameters

node	[in] current collision node

Definition at line 306 of file OPC_PlanesCollider.cpp.

Referenced by Opcode::HybridPlanesCollider::Collide().

 {
     // Test the box against the planes. If the box is completely culled, so are its children, hence we exit.
     udword OutClipMask;
     if(!PlanesAABBOverlap(node->mAABB.mCenter, node->mAABB.mExtents, OutClipMask, clip_mask))   return;
 
     TEST_CLIP_MASK
 
     // Else the box straddles one or several planes, so we need to recurse down the tree.
     if(node->IsLeaf())
     {
         SET_CONTACT(node->GetPrimitive(), OPC_CONTACT)
     }
     else
     {
         _CollideNoPrimitiveTest(node->GetPos(), OutClipMask);
 
         if(ContactFound()) return;
 
         _CollideNoPrimitiveTest(node->GetNeg(), OutClipMask);
     }
 }

void PlanesCollider::_CollideNoPrimitiveTest	(	const AABBNoLeafNode *	node,
		udword	clip_mask
	)

protected

Recursive collision query for no-leaf AABB trees.

Parameters

node	[in] current collision node

Definition at line 427 of file OPC_PlanesCollider.cpp.

 {
     // Test the box against the planes. If the box is completely culled, so are its children, hence we exit.
     udword OutClipMask;
     if(!PlanesAABBOverlap(node->mAABB.mCenter, node->mAABB.mExtents, OutClipMask, clip_mask))   return;
 
     TEST_CLIP_MASK
 
     // Else the box straddles one or several planes, so we need to recurse down the tree.
     if(node->HasPosLeaf())  { SET_CONTACT(node->GetPosPrimitive(), OPC_CONTACT) }
     else                    _CollideNoPrimitiveTest(node->GetPos(), OutClipMask);
 
     if(ContactFound()) return;
 
     if(node->HasNegLeaf())  { SET_CONTACT(node->GetNegPrimitive(), OPC_CONTACT) }
     else                    _CollideNoPrimitiveTest(node->GetNeg(), OutClipMask);
 }

void PlanesCollider::_CollideNoPrimitiveTest	(	const AABBQuantizedNode *	node,
		udword	clip_mask
	)

protected

Recursive collision query for quantized AABB trees.

Parameters

node	[in] current collision node

Definition at line 369 of file OPC_PlanesCollider.cpp.

 {
     // Dequantize box
     const QuantizedAABB& Box = node->mAABB;
     const Point Center(float(Box.mCenter[0]) * mCenterCoeff.x, float(Box.mCenter[1]) * mCenterCoeff.y, float(Box.mCenter[2]) * mCenterCoeff.z);
     const Point Extents(float(Box.mExtents[0]) * mExtentsCoeff.x, float(Box.mExtents[1]) * mExtentsCoeff.y, float(Box.mExtents[2]) * mExtentsCoeff.z);
 
     // Test the box against the planes. If the box is completely culled, so are its children, hence we exit.
     udword OutClipMask;
     if(!PlanesAABBOverlap(Center, Extents, OutClipMask, clip_mask)) return;
 
     TEST_CLIP_MASK
 
     // Else the box straddles one or several planes, so we need to recurse down the tree.
     if(node->IsLeaf())
     {
         SET_CONTACT(node->GetPrimitive(), OPC_CONTACT)
     }
     else
     {
         _CollideNoPrimitiveTest(node->GetPos(), OutClipMask);
 
         if(ContactFound()) return;
 
         _CollideNoPrimitiveTest(node->GetNeg(), OutClipMask);
     }
 }

void PlanesCollider::_CollideNoPrimitiveTest	(	const AABBQuantizedNoLeafNode *	node,
		udword	clip_mask
	)

protected

Recursive collision query for quantized no-leaf AABB trees.

Parameters

node	[in] current collision node

Definition at line 480 of file OPC_PlanesCollider.cpp.

 {
     // Dequantize box
     const QuantizedAABB& Box = node->mAABB;
     const Point Center(float(Box.mCenter[0]) * mCenterCoeff.x, float(Box.mCenter[1]) * mCenterCoeff.y, float(Box.mCenter[2]) * mCenterCoeff.z);
     const Point Extents(float(Box.mExtents[0]) * mExtentsCoeff.x, float(Box.mExtents[1]) * mExtentsCoeff.y, float(Box.mExtents[2]) * mExtentsCoeff.z);
 
     // Test the box against the planes. If the box is completely culled, so are its children, hence we exit.
     udword OutClipMask;
     if(!PlanesAABBOverlap(Center, Extents, OutClipMask, clip_mask)) return;
 
     TEST_CLIP_MASK
 
     // Else the box straddles one or several planes, so we need to recurse down the tree.
     if(node->HasPosLeaf())  { SET_CONTACT(node->GetPosPrimitive(), OPC_CONTACT) }
     else                    _CollideNoPrimitiveTest(node->GetPos(), OutClipMask);
 
     if(ContactFound()) return;
 
     if(node->HasNegLeaf())  { SET_CONTACT(node->GetNegPrimitive(), OPC_CONTACT) }
     else                    _CollideNoPrimitiveTest(node->GetNeg(), OutClipMask);
 }

bool PlanesCollider::Collide	(	PlanesCache &	cache,
		const Plane *	planes,
		udword	nb_planes,
		const Model &	model,
		const Matrix4x4 *	worldm = `null`
	)

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

Parameters

cache	[in/out] a planes cache
planes	[in] list of planes in world space
nb_planes	[in] number of planes
model	[in] Opcode model to collide with
worldm	[in] model's world matrix, or null

Returns: true if success

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

Definition at line 104 of file OPC_PlanesCollider.cpp.

 {
     // Checkings
     if(!Setup(&model))  return false;
 
     // Init collision query
     if(InitQuery(cache, planes, nb_planes, worldm)) return true;
 
     udword PlaneMask = (1<<nb_planes)-1;
 
     if(!model.HasLeafNodes())
     {
         if(model.IsQuantized())
         {
             const AABBQuantizedNoLeafTree* Tree = (const AABBQuantizedNoLeafTree*)model.GetTree();
 
             // Setup dequantization coeffs
             mCenterCoeff    = Tree->mCenterCoeff;
             mExtentsCoeff   = Tree->mExtentsCoeff;
 
             // Perform collision query
             if(SkipPrimitiveTests())    _CollideNoPrimitiveTest(Tree->GetNodes(), PlaneMask);
             else                        _Collide(Tree->GetNodes(), PlaneMask);
         }
         else
         {
             const AABBNoLeafTree* Tree = (const AABBNoLeafTree*)model.GetTree();
 
             // Perform collision query
             if(SkipPrimitiveTests())    _CollideNoPrimitiveTest(Tree->GetNodes(), PlaneMask);
             else                        _Collide(Tree->GetNodes(), PlaneMask);
         }
     }
     else
     {
         if(model.IsQuantized())
         {
             const AABBQuantizedTree* Tree = (const AABBQuantizedTree*)model.GetTree();
 
             // Setup dequantization coeffs
             mCenterCoeff    = Tree->mCenterCoeff;
             mExtentsCoeff   = Tree->mExtentsCoeff;
 
             // Perform collision query
             if(SkipPrimitiveTests())    _CollideNoPrimitiveTest(Tree->GetNodes(), PlaneMask);
             else                        _Collide(Tree->GetNodes(), PlaneMask);
         }
         else
         {
             const AABBCollisionTree* Tree = (const AABBCollisionTree*)model.GetTree();
 
             // Perform collision query
             if(SkipPrimitiveTests())    _CollideNoPrimitiveTest(Tree->GetNodes(), PlaneMask);
             else                        _Collide(Tree->GetNodes(), PlaneMask);
         }
     }
     return true;
 }

inline_ bool Opcode::PlanesCollider::Collide	(	PlanesCache &	cache,
		const OBB &	box,
		const Model &	model,
		const Matrix4x4 *	worldb = `null`,
		const Matrix4x4 *	worldm = `null`
	)

inline

Definition at line 57 of file Opcode.h.

bool PlanesCollider::InitQuery	(	PlanesCache &	cache,
		const Plane *	planes,
		udword	nb_planes,
		const Matrix4x4 *	worldm = `null`
	)

protected

Initializes a collision query :

reset stats & contact status
compute planes in model space
check temporal coherence

Parameters

cache	[in/out] a planes cache
planes	[in] list of planes
nb_planes	[in] number of planes
worldm	[in] model's world matrix, or null

Returns: TRUE if we can return immediately

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

Definition at line 178 of file OPC_PlanesCollider.cpp.

 {
     // 1) Call the base method
     VolumeCollider::InitQuery();
 
     // 2) Compute planes in model space
     if(nb_planes>mNbPlanes)
     {
         DELETEARRAY(mPlanes);
         mPlanes = new Plane[nb_planes];
     }
     mNbPlanes = nb_planes;
 
     if(worldm)
     {
         Matrix4x4 InvWorldM;
         InvertPRMatrix(InvWorldM, *worldm);
 
 //      for(udword i=0;i<nb_planes;i++) mPlanes[i] = planes[i] * InvWorldM;
         for(udword i=0;i<nb_planes;i++) TransformPlane(mPlanes[i], planes[i], InvWorldM);
     }
     else CopyMemory(mPlanes, planes, nb_planes*sizeof(Plane));
 
     // 3) Setup destination pointer
     mTouchedPrimitives = &cache.TouchedPrimitives;
 
     // 4) Special case: 1-triangle meshes [Opcode 1.3]
     if(mCurrentModel && mCurrentModel->HasSingleNode())
     {
         if(!SkipPrimitiveTests())
         {
             // We simply perform the BV-Prim overlap test each time. We assume single triangle has index 0.
             mTouchedPrimitives->Reset();
 
             // Perform overlap test between the unique triangle and the planes (and set contact status if needed)
             udword clip_mask = (1<<mNbPlanes)-1;
             PLANES_PRIM(udword(0), OPC_CONTACT)
 
             // Return immediately regardless of status
             return TRUE;
         }
     }
 
     // 4) Check temporal coherence:
     if(TemporalCoherenceEnabled())
     {
         // Here we use temporal coherence
         // => check results from previous frame before performing the collision query
         if(FirstContactEnabled())
         {
             // We're only interested in the first contact found => test the unique previously touched face
             if(mTouchedPrimitives->GetNbEntries())
             {
                 // Get index of previously touched face = the first entry in the array
                 udword PreviouslyTouchedFace = mTouchedPrimitives->GetEntry(0);
 
                 // Then reset the array:
                 // - if the overlap test below is successful, the index we'll get added back anyway
                 // - if it isn't, then the array should be reset anyway for the normal query
                 mTouchedPrimitives->Reset();
 
                 // Perform overlap test between the cached triangle and the planes (and set contact status if needed)
                 udword clip_mask = (1<<mNbPlanes)-1;
                 PLANES_PRIM(PreviouslyTouchedFace, OPC_TEMPORAL_CONTACT)
 
                 // Return immediately if possible
                 if(GetContactStatus())  return TRUE;
             }
             // else no face has been touched during previous query
             // => we'll have to perform a normal query
         }
         else mTouchedPrimitives->Reset();
     }
     else
     {
         // Here we don't use temporal coherence => do a normal query
         mTouchedPrimitives->Reset();
     }
 
     return FALSE;
 }

Opcode::PlanesCollider::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

inline_ bool Opcode::PlanesCollider::PlanesAABBOverlap	(	const Point &	center,
		const Point &	extents,
		udword &	out_clip_mask,
		udword	in_clip_mask
	)

protected

inline_ bool Opcode::PlanesCollider::PlanesTriOverlap ( udword in_clip_mask)

protected

Member Data Documentation

udword Opcode::PlanesCollider::mNbPlanes

protected

Definition at line 90 of file Opcode.h.

Referenced by Opcode::HybridPlanesCollider::Collide().

Plane* Opcode::PlanesCollider::mPlanes

protected

Definition at line 91 of file Opcode.h.

VertexPointers Opcode::PlanesCollider::mVP

protected

Definition at line 93 of file Opcode.h.

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

src/cmd/collide2/OPC_PlanesCollider.h
src/cmd/collide2/OPC_PlanesCollider.cpp

Public Member Functions

Protected Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation