Opcode::OBBCollider Class Reference

#include <Opcode.h>

Inheritance diagram for Opcode::OBBCollider:

Public Member Functions
	OBBCollider ()
virtual	~OBBCollider ()
bool	Collide (OBBCache &cache, const OBB &box, const Model &model, const Matrix4x4 *worldb=null, const Matrix4x4 *worldm=null)
inline_ void	SetFullBoxBoxTest (bool flag)
	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)
void	_Collide (const AABBNoLeafNode *node)
void	_Collide (const AABBQuantizedNode *node)
void	_Collide (const AABBQuantizedNoLeafNode *node)
void	_CollideNoPrimitiveTest (const AABBCollisionNode *node)
void	_CollideNoPrimitiveTest (const AABBNoLeafNode *node)
void	_CollideNoPrimitiveTest (const AABBQuantizedNode *node)
void	_CollideNoPrimitiveTest (const AABBQuantizedNoLeafNode *node)
inline_ bool	OBBContainsBox (const Point &bc, const Point &be)
inline_ bool	BoxBoxOverlap (const Point &extents, const Point &center)
inline_ bool	TriBoxOverlap ()
bool	InitQuery (OBBCache &cache, const OBB &box, const Matrix4x4 *worldb=null, 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
Matrix3x3	mAR
	Absolute rotation matrix. More...
Matrix3x3	mRModelToBox
	Rotation from model space to obb space. More...
Matrix3x3	mRBoxToModel
	Rotation from obb space to model space. More...
Point	mTModelToBox
	Translation from model space to obb space. More...
Point	mTBoxToModel
	Translation from obb space to model space. More...
Point	mBoxExtents
Point	mB0
Point	mB1
float	mBBx1
float	mBBy1
float	mBBz1
float	mBB_1
float	mBB_2
float	mBB_3
float	mBB_4
float	mBB_5
float	mBB_6
float	mBB_7
float	mBB_8
float	mBB_9
Point	mLeafVerts [3]
	Triangle vertices. More...
bool	mFullBoxBoxTest
	Perform full BV-BV tests (true) or SAT-lite tests (false) More...
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 39 of file Opcode.h.

Constructor & Destructor Documentation

OBBCollider::OBBCollider

(

)

Constructor.

Definition at line 63 of file OPC_OBBCollider.cpp.

                         : mFullBoxBoxTest(true)
{
}

OBBCollider::~OBBCollider ( )

virtual

Destructor.

Definition at line 72 of file OPC_OBBCollider.cpp.

{
}

Member Function Documentation

void OBBCollider::_Collide ( const AABBCollisionNode *  node)

protected

Recursive collision query for normal AABB trees.

Parameters

node	[in] current collision node

Definition at line 412 of file OPC_OBBCollider.cpp.

{
    // Perform OBB-AABB overlap test
    if(!BoxBoxOverlap(node->mAABB.mExtents, node->mAABB.mCenter))   return;

    TEST_BOX_IN_OBB(node->mAABB.mCenter, node->mAABB.mExtents)

    if(node->IsLeaf())
    {
        OBB_PRIM(node->GetPrimitive(), OPC_CONTACT)
    }
    else
    {
        _Collide(node->GetPos());

        if(ContactFound()) return;

        _Collide(node->GetNeg());
    }
}

void OBBCollider::_Collide ( const AABBNoLeafNode *  node)

protected

Recursive collision query for no-leaf AABB trees.

Parameters

node	[in] current collision node

Definition at line 530 of file OPC_OBBCollider.cpp.

{
    // Perform OBB-AABB overlap test
    if(!BoxBoxOverlap(node->mAABB.mExtents, node->mAABB.mCenter))   return;

    TEST_BOX_IN_OBB(node->mAABB.mCenter, node->mAABB.mExtents)

    if(node->HasPosLeaf())  { OBB_PRIM(node->GetPosPrimitive(), OPC_CONTACT) }
    else                    _Collide(node->GetPos());

    if(ContactFound()) return;

    if(node->HasNegLeaf())  { OBB_PRIM(node->GetNegPrimitive(), OPC_CONTACT) }
    else                    _Collide(node->GetNeg());
}

void OBBCollider::_Collide ( const AABBQuantizedNode *  node)

protected

Recursive collision query for quantized AABB trees.

Parameters

node	[in] current collision node

Definition at line 466 of file OPC_OBBCollider.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);

    // Perform OBB-AABB overlap test
    if(!BoxBoxOverlap(Extents, Center)) return;

    TEST_BOX_IN_OBB(Center, Extents)

    if(node->IsLeaf())
    {
        OBB_PRIM(node->GetPrimitive(), OPC_CONTACT)
    }
    else
    {
        _Collide(node->GetPos());

        if(ContactFound()) return;

        _Collide(node->GetNeg());
    }
}

void OBBCollider::_Collide ( const AABBQuantizedNoLeafNode *  node)

protected

Recursive collision query for quantized no-leaf AABB trees.

Parameters

node	[in] current collision node

Definition at line 574 of file OPC_OBBCollider.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);

    // Perform OBB-AABB overlap test
    if(!BoxBoxOverlap(Extents, Center)) return;

    TEST_BOX_IN_OBB(Center, Extents)

    if(node->HasPosLeaf())  { OBB_PRIM(node->GetPosPrimitive(), OPC_CONTACT) }
    else                    _Collide(node->GetPos());

    if(ContactFound()) return;

    if(node->HasNegLeaf())  { OBB_PRIM(node->GetNegPrimitive(), OPC_CONTACT) }
    else                    _Collide(node->GetNeg());
}

void OBBCollider::_CollideNoPrimitiveTest ( const AABBCollisionNode *  node)

protected

Recursive collision query for normal AABB trees, without primitive tests.

Parameters

node	[in] current collision node

Definition at line 439 of file OPC_OBBCollider.cpp.

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

{
    // Perform OBB-AABB overlap test
    if(!BoxBoxOverlap(node->mAABB.mExtents, node->mAABB.mCenter))   return;

    TEST_BOX_IN_OBB(node->mAABB.mCenter, node->mAABB.mExtents)

    if(node->IsLeaf())
    {
        SET_CONTACT(node->GetPrimitive(), OPC_CONTACT)
    }
    else
    {
        _CollideNoPrimitiveTest(node->GetPos());

        if(ContactFound()) return;

        _CollideNoPrimitiveTest(node->GetNeg());
    }
}

void OBBCollider::_CollideNoPrimitiveTest ( const AABBNoLeafNode *  node)

protected

Recursive collision query for no-leaf AABB trees, without primitive tests.

Parameters

node	[in] current collision node

Definition at line 552 of file OPC_OBBCollider.cpp.

{
    // Perform OBB-AABB overlap test
    if(!BoxBoxOverlap(node->mAABB.mExtents, node->mAABB.mCenter))   return;

    TEST_BOX_IN_OBB(node->mAABB.mCenter, node->mAABB.mExtents)

    if(node->HasPosLeaf())  { SET_CONTACT(node->GetPosPrimitive(), OPC_CONTACT) }
    else                    _CollideNoPrimitiveTest(node->GetPos());

    if(ContactFound()) return;

    if(node->HasNegLeaf())  { SET_CONTACT(node->GetNegPrimitive(), OPC_CONTACT) }
    else                    _CollideNoPrimitiveTest(node->GetNeg());
}

void OBBCollider::_CollideNoPrimitiveTest ( const AABBQuantizedNode *  node)

protected

Recursive collision query for quantized AABB trees, without primitive tests.

Parameters

node	[in] current collision node

Definition at line 498 of file OPC_OBBCollider.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);

    // Perform OBB-AABB overlap test
    if(!BoxBoxOverlap(Extents, Center)) return;

    TEST_BOX_IN_OBB(Center, Extents)

    if(node->IsLeaf())
    {
        SET_CONTACT(node->GetPrimitive(), OPC_CONTACT)
    }
    else
    {
        _CollideNoPrimitiveTest(node->GetPos());

        if(ContactFound()) return;

        _CollideNoPrimitiveTest(node->GetNeg());
    }
}

void OBBCollider::_CollideNoPrimitiveTest ( const AABBQuantizedNoLeafNode *  node)

protected

Recursive collision query for quantized no-leaf AABB trees, without primitive tests.

Parameters

node	[in] current collision node

Definition at line 601 of file OPC_OBBCollider.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);

    // Perform OBB-AABB overlap test
    if(!BoxBoxOverlap(Extents, Center)) return;

    TEST_BOX_IN_OBB(Center, Extents)

    if(node->HasPosLeaf())  { SET_CONTACT(node->GetPosPrimitive(), OPC_CONTACT) }
    else                    _CollideNoPrimitiveTest(node->GetPos());

    if(ContactFound()) return;

    if(node->HasNegLeaf())  { SET_CONTACT(node->GetNegPrimitive(), OPC_CONTACT) }
    else                    _CollideNoPrimitiveTest(node->GetNeg());
}

inline_ bool Opcode::OBBCollider::BoxBoxOverlap ( const Point &  extents, const Point &  center  )

protected

bool OBBCollider::Collide	(	OBBCache &	cache,
		const OBB &	box,
		const Model &	model,
		const Matrix4x4 *	worldb = null,
		const Matrix4x4 *	worldm = null
	)

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

• with GetContactStatus()
• with GetNbTouchedPrimitives()
• with GetTouchedPrimitives()

Parameters

cache	[in/out] a box cache
box	[in] collision OBB in local space
model	[in] Opcode model to collide with
worldb	[in] OBB's world matrix, or null
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 105 of file OPC_OBBCollider.cpp.

{
    // Checkings
    if(!Setup(&model))  return false;

    // Init collision query
    if(InitQuery(cache, box, worldb, worldm))   return true;

    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());
            else                        _Collide(Tree->GetNodes());
        }
        else
        {
            const AABBNoLeafTree* Tree = (const AABBNoLeafTree*)model.GetTree();

            // Perform collision query
            if(SkipPrimitiveTests())    _CollideNoPrimitiveTest(Tree->GetNodes());
            else                        _Collide(Tree->GetNodes());
        }
    }
    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());
            else                        _Collide(Tree->GetNodes());
        }
        else
        {
            const AABBCollisionTree* Tree = (const AABBCollisionTree*)model.GetTree();

            // Perform collision query
            if(SkipPrimitiveTests())    _CollideNoPrimitiveTest(Tree->GetNodes());
            else                        _Collide(Tree->GetNodes());
        }
    }

    return true;
}

bool OBBCollider::InitQuery ( OBBCache &  cache, const OBB &  box, const Matrix4x4 *  worldb = null, const Matrix4x4 *  worldm = null  )

protected

Initializes a collision query :

• reset stats & contact status
• setup matrices
• check temporal coherence

Parameters

cache	[in/out] a box cache
box	[in] obb in local space
worldb	[in] obb's world matrix, or null
worldm	[in] model's world matrix, or null

Returns

TRUE if we can return immediately

Warning

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

Definition at line 178 of file OPC_OBBCollider.cpp.

{
    // 1) Call the base method
    VolumeCollider::InitQuery();

    // 2) Compute obb in world space
    mBoxExtents = box.mExtents;

    Matrix4x4 WorldB;

    if(worldb)
    {
        WorldB = Matrix4x4( box.mRot * Matrix3x3(*worldb) );
        WorldB.SetTrans(box.mCenter * *worldb);
    }
    else
    {
        WorldB = box.mRot;
        WorldB.SetTrans(box.mCenter);
    }

    // Setup matrices
    Matrix4x4 InvWorldB;
    InvertPRMatrix(InvWorldB, WorldB);

    if(worldm)
    {
        Matrix4x4 InvWorldM;
        InvertPRMatrix(InvWorldM, *worldm);

        Matrix4x4 WorldBtoM = WorldB * InvWorldM;
        Matrix4x4 WorldMtoB = *worldm * InvWorldB;

        mRModelToBox = WorldMtoB;       WorldMtoB.GetTrans(mTModelToBox);
        mRBoxToModel = WorldBtoM;       WorldBtoM.GetTrans(mTBoxToModel);
    }
    else
    {
        mRModelToBox = InvWorldB;   InvWorldB.GetTrans(mTModelToBox);
        mRBoxToModel = WorldB;      WorldB.GetTrans(mTBoxToModel);
    }

    // 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 box (and set contact status if needed)
            OBB_PRIM(udword(0), OPC_CONTACT)

            // Return immediately regardless of status
            return TRUE;
        }
    }

    // 5) 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 box (and set contact status if needed)
                OBB_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
        {
            // ### rewrite this
            OBB TestBox(mTBoxToModel, mBoxExtents, mRBoxToModel);

            // We're interested in all contacts =>test the new real box N(ew) against the previous fat box P(revious):
            if(IsCacheValid(cache) && TestBox.IsInside(cache.FatBox))
            {
                // - if N is included in P, return previous list
                // => we simply leave the list (mTouchedFaces) unchanged

                // Set contact status if needed
                if(mTouchedPrimitives->GetNbEntries())  mFlags |= OPC_TEMPORAL_CONTACT;

                // In any case we don't need to do a query
                return TRUE;
            }
            else
            {
                // - else do the query using a fat N

                // Reset cache since we'll about to perform a real query
                mTouchedPrimitives->Reset();

                // Make a fat box so that coherence will work for subsequent frames
                TestBox.mExtents *= cache.FatCoeff;
                mBoxExtents *= cache.FatCoeff;

                // Update cache with query data (signature for cached faces)
                cache.FatBox = TestBox;
            }
        }
    }
    else
    {
        // Here we don't use temporal coherence => do a normal query
        mTouchedPrimitives->Reset();
    }

    // Now we can precompute box-box data

    // Precompute absolute box-to-model rotation matrix
    for(udword i=0;i<3;i++)
    {
        for(udword j=0;j<3;j++)
        {
            // Epsilon value prevents floating-point inaccuracies (strategy borrowed from RAPID)
            mAR.m[i][j] = 1e-6f + fabsf(mRBoxToModel.m[i][j]);
        }
    }

    // Precompute bounds for box-in-box test
    mB0 = mBoxExtents - mTModelToBox;
    mB1 = - mBoxExtents - mTModelToBox;

    // Precompute box-box data - Courtesy of Erwin de Vries
    mBBx1 = mBoxExtents.x*mAR.m[0][0] + mBoxExtents.y*mAR.m[1][0] + mBoxExtents.z*mAR.m[2][0];
    mBBy1 = mBoxExtents.x*mAR.m[0][1] + mBoxExtents.y*mAR.m[1][1] + mBoxExtents.z*mAR.m[2][1];
    mBBz1 = mBoxExtents.x*mAR.m[0][2] + mBoxExtents.y*mAR.m[1][2] + mBoxExtents.z*mAR.m[2][2];

    mBB_1 = mBoxExtents.y*mAR.m[2][0] + mBoxExtents.z*mAR.m[1][0];
    mBB_2 = mBoxExtents.x*mAR.m[2][0] + mBoxExtents.z*mAR.m[0][0];
    mBB_3 = mBoxExtents.x*mAR.m[1][0] + mBoxExtents.y*mAR.m[0][0];
    mBB_4 = mBoxExtents.y*mAR.m[2][1] + mBoxExtents.z*mAR.m[1][1];
    mBB_5 = mBoxExtents.x*mAR.m[2][1] + mBoxExtents.z*mAR.m[0][1];
    mBB_6 = mBoxExtents.x*mAR.m[1][1] + mBoxExtents.y*mAR.m[0][1];
    mBB_7 = mBoxExtents.y*mAR.m[2][2] + mBoxExtents.z*mAR.m[1][2];
    mBB_8 = mBoxExtents.x*mAR.m[2][2] + mBoxExtents.z*mAR.m[0][2];
    mBB_9 = mBoxExtents.x*mAR.m[1][2] + mBoxExtents.y*mAR.m[0][2];

    return FALSE;
}

inline_ bool OBBCollider::OBBContainsBox ( const Point &  bc, const Point &  be  )

protected

Checks the OBB completely contains the box. In which case we can end the query sooner.

Parameters

bc	[in] box center
be	[in] box extents

Returns

true if the OBB contains the whole box

Definition at line 347 of file OPC_OBBCollider.cpp.

{
    // I assume if all 8 box vertices are inside the OBB, so does the whole box.
    // Sounds ok but maybe there's a better way?
/*
#define TEST_PT(a,b,c)                                                                                                              \
    p.x=a;  p.y=b;  p.z=c;      p+=bc;                                                                                              \
    f = p.x * mRModelToBox.m[0][0] + p.y * mRModelToBox.m[1][0] + p.z * mRModelToBox.m[2][0];   if(f>mB0.x || f<mB1.x) return FALSE;\
    f = p.x * mRModelToBox.m[0][1] + p.y * mRModelToBox.m[1][1] + p.z * mRModelToBox.m[2][1];   if(f>mB0.y || f<mB1.y) return FALSE;\
    f = p.x * mRModelToBox.m[0][2] + p.y * mRModelToBox.m[1][2] + p.z * mRModelToBox.m[2][2];   if(f>mB0.z || f<mB1.z) return FALSE;

    Point p;
    float f;

    TEST_PT(be.x, be.y, be.z)
    TEST_PT(-be.x, be.y, be.z)
    TEST_PT(be.x, -be.y, be.z)
    TEST_PT(-be.x, -be.y, be.z)
    TEST_PT(be.x, be.y, -be.z)
    TEST_PT(-be.x, be.y, -be.z)
    TEST_PT(be.x, -be.y, -be.z)
    TEST_PT(-be.x, -be.y, -be.z)

    return TRUE;
*/

    // Yes there is:
    // - compute model-box's AABB in OBB space
    // - test AABB-in-AABB
    float NCx = bc.x * mRModelToBox.m[0][0] + bc.y * mRModelToBox.m[1][0] + bc.z * mRModelToBox.m[2][0];
    float NEx = fabsf(mRModelToBox.m[0][0] * be.x) + fabsf(mRModelToBox.m[1][0] * be.y) + fabsf(mRModelToBox.m[2][0] * be.z);

    if(mB0.x < NCx+NEx) return FALSE;
    if(mB1.x > NCx-NEx) return FALSE;

    float NCy = bc.x * mRModelToBox.m[0][1] + bc.y * mRModelToBox.m[1][1] + bc.z * mRModelToBox.m[2][1];
    float NEy = fabsf(mRModelToBox.m[0][1] * be.x) + fabsf(mRModelToBox.m[1][1] * be.y) + fabsf(mRModelToBox.m[2][1] * be.z);

    if(mB0.y < NCy+NEy) return FALSE;
    if(mB1.y > NCy-NEy) return FALSE;

    float NCz = bc.x * mRModelToBox.m[0][2] + bc.y * mRModelToBox.m[1][2] + bc.z * mRModelToBox.m[2][2];
    float NEz = fabsf(mRModelToBox.m[0][2] * be.x) + fabsf(mRModelToBox.m[1][2] * be.y) + fabsf(mRModelToBox.m[2][2] * be.z);

    if(mB0.z < NCz+NEz) return FALSE;
    if(mB1.z > NCz-NEz) return FALSE;

    return TRUE;
}

Opcode::OBBCollider::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_ void Opcode::OBBCollider::SetFullBoxBoxTest ( bool  flag)

inline

Settings: select 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

Definition at line 72 of file Opcode.h.

inline_ bool Opcode::OBBCollider::TriBoxOverlap ( )

protected

Member Data Documentation

Matrix3x3 Opcode::OBBCollider::mAR

protected

Absolute rotation matrix.

Definition at line 86 of file Opcode.h.

Point Opcode::OBBCollider::mB0

protected

• mTModelToBox + mBoxExtents

Definition at line 93 of file Opcode.h.

Point Opcode::OBBCollider::mB1

protected

• mTModelToBox - mBoxExtents

Definition at line 94 of file Opcode.h.

float Opcode::OBBCollider::mBB_1

protected

Definition at line 100 of file Opcode.h.

float Opcode::OBBCollider::mBB_2

protected

Definition at line 101 of file Opcode.h.

float Opcode::OBBCollider::mBB_3

protected

Definition at line 102 of file Opcode.h.

float Opcode::OBBCollider::mBB_4

protected

Definition at line 103 of file Opcode.h.

float Opcode::OBBCollider::mBB_5

protected

Definition at line 104 of file Opcode.h.

float Opcode::OBBCollider::mBB_6

protected

Definition at line 105 of file Opcode.h.

float Opcode::OBBCollider::mBB_7

protected

Definition at line 106 of file Opcode.h.

float Opcode::OBBCollider::mBB_8

protected

Definition at line 107 of file Opcode.h.

float Opcode::OBBCollider::mBB_9

protected

Definition at line 108 of file Opcode.h.

float Opcode::OBBCollider::mBBx1

protected

Definition at line 96 of file Opcode.h.

float Opcode::OBBCollider::mBBy1

protected

Definition at line 97 of file Opcode.h.

float Opcode::OBBCollider::mBBz1

protected

Definition at line 98 of file Opcode.h.

Point Opcode::OBBCollider::mBoxExtents

protected

Definition at line 92 of file Opcode.h.

bool Opcode::OBBCollider::mFullBoxBoxTest

protected

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

Definition at line 113 of file Opcode.h.

Point Opcode::OBBCollider::mLeafVerts[3]

protected

Triangle vertices.

Definition at line 111 of file Opcode.h.

Matrix3x3 Opcode::OBBCollider::mRBoxToModel

protected

Rotation from obb space to model space.

Definition at line 88 of file Opcode.h.

Matrix3x3 Opcode::OBBCollider::mRModelToBox

protected

Rotation from model space to obb space.

Definition at line 87 of file Opcode.h.

Point Opcode::OBBCollider::mTBoxToModel

protected

Translation from obb space to model space.

Definition at line 90 of file Opcode.h.

Point Opcode::OBBCollider::mTModelToBox

protected

Translation from model space to obb space.

Definition at line 89 of file Opcode.h.

---

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

• src/cmd/collide2/OPC_OBBCollider.h
• src/cmd/collide2/OPC_OBBCollider.cpp