#include <Opcode.h>

Inheritance diagram for Opcode::HybridPlanesCollider:

Public Member Functions
	HybridPlanesCollider ()

virtual	~HybridPlanesCollider ()

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

Public Member Functions inherited from Opcode::PlanesCollider
	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 Attributes
Container	mTouchedBoxes

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

Additional Inherited Members
Protected Member Functions inherited from Opcode::PlanesCollider
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)

Detailed Description

Definition at line 110 of file Opcode.h.

Constructor & Destructor Documentation

HybridPlanesCollider::HybridPlanesCollider ( )

Constructor.

Definition at line 514 of file OPC_PlanesCollider.cpp.

515 {

516 }

HybridPlanesCollider::~HybridPlanesCollider ( )

virtual

Destructor.

Definition at line 523 of file OPC_PlanesCollider.cpp.

524 {

525 }

Member Function Documentation

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

Definition at line 527 of file OPC_PlanesCollider.cpp.

References Opcode::PlanesCollider::_CollideNoPrimitiveTest(), Opcode::Collider::GetContactStatus(), Opcode::HybridModel::GetIndices(), Opcode::HybridModel::GetLeafTriangles(), Container::GetNbEntries(), Opcode::LeafTriangles::GetNbTriangles(), Opcode::MeshInterface::GetNbTriangles(), Opcode::BaseModel::GetTree(), Opcode::LeafTriangles::GetTriangleIndex(), Opcode::BaseModel::HasLeafNodes(), Opcode::BaseModel::HasSingleNode(), i, Opcode::Collider::InitQuery(), Opcode::BaseModel::IsQuantized(), Opcode::VolumeCollider::mCenterCoeff, Opcode::AABBQuantizedTree::mCenterCoeff, Opcode::AABBQuantizedNoLeafTree::mCenterCoeff, Opcode::Collider::mCurrentModel, Opcode::VolumeCollider::mExtentsCoeff, Opcode::AABBQuantizedTree::mExtentsCoeff, Opcode::AABBQuantizedNoLeafTree::mExtentsCoeff, Opcode::Collider::mFlags, Opcode::Collider::mIMesh, Opcode::PlanesCollider::mNbPlanes, Opcode::VolumeCollider::mTouchedPrimitives, Opcode::OPC_CONTACT, Opcode::OPC_NO_PRIMITIVE_TESTS, PLANES_PRIM, Container::Reset(), Opcode::Collider::Setup(), and Opcode::VolumeCache::TouchedPrimitives.

 {
     // We don't want primitive tests here!
     mFlags |= OPC_NO_PRIMITIVE_TESTS;
 
     // Checkings
     if(!Setup(&model))  return false;
 
     // Init collision query
     if(InitQuery(cache, planes, nb_planes, worldm)) return true;
 
     // Special case for 1-leaf trees
     if(mCurrentModel && mCurrentModel->HasSingleNode())
     {
         // Here we're supposed to perform a normal query, except our tree has a single node, i.e. just a few triangles
         udword Nb = mIMesh->GetNbTriangles();
 
         // Loop through all triangles
         udword clip_mask = (1<<mNbPlanes)-1;
         for(udword i=0;i<Nb;i++)
         {
             PLANES_PRIM(i, OPC_CONTACT)
         }
         return true;
     }
 
     // Override destination array since we're only going to get leaf boxes here
     mTouchedBoxes.Reset();
     mTouchedPrimitives = &mTouchedBoxes;
 
     udword PlaneMask = (1<<nb_planes)-1;
 
     // Now, do the actual query against leaf boxes
     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 - we don't want primitive tests here!
             _CollideNoPrimitiveTest(Tree->GetNodes(), PlaneMask);
         }
         else
         {
             const AABBNoLeafTree* Tree = (const AABBNoLeafTree*)model.GetTree();
 
             // Perform collision query - we don't want primitive tests here!
             _CollideNoPrimitiveTest(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 - we don't want primitive tests here!
             _CollideNoPrimitiveTest(Tree->GetNodes(), PlaneMask);
         }
         else
         {
             const AABBCollisionTree* Tree = (const AABBCollisionTree*)model.GetTree();
 
             // Perform collision query - we don't want primitive tests here!
             _CollideNoPrimitiveTest(Tree->GetNodes(), PlaneMask);
         }
     }
 
     // We only have a list of boxes so far
     if(GetContactStatus())
     {
         // Reset contact status, since it currently only reflects collisions with leaf boxes
         Collider::InitQuery();
 
         // Change dest container so that we can use built-in overlap tests and get collided primitives
         cache.TouchedPrimitives.Reset();
         mTouchedPrimitives = &cache.TouchedPrimitives;
 
         // Read touched leaf boxes
         udword Nb = mTouchedBoxes.GetNbEntries();
         const udword* Touched = mTouchedBoxes.GetEntries();
 
         const LeafTriangles* LT = model.GetLeafTriangles();
         const udword* Indices = model.GetIndices();
 
         // Loop through touched leaves
         udword clip_mask = (1<<mNbPlanes)-1;
         while(Nb--)
         {
             const LeafTriangles& CurrentLeaf = LT[*Touched++];
 
             // Each leaf box has a set of triangles
             udword NbTris = CurrentLeaf.GetNbTriangles();
             if(Indices)
             {
                 const udword* T = &Indices[CurrentLeaf.GetTriangleIndex()];
 
                 // Loop through triangles and test each of them
                 while(NbTris--)
                 {
                     udword TriangleIndex = *T++;
                     PLANES_PRIM(TriangleIndex, OPC_CONTACT)
                 }
             }
             else
             {
                 udword BaseIndex = CurrentLeaf.GetTriangleIndex();
 
                 // Loop through triangles and test each of them
                 while(NbTris--)
                 {
                     udword TriangleIndex = BaseIndex++;
                     PLANES_PRIM(TriangleIndex, OPC_CONTACT)
                 }
             }
         }
     }
 
     return true;
 }

Member Data Documentation

Container Opcode::HybridPlanesCollider::mTouchedBoxes

protected

Definition at line 119 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 Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation