OPC_TreeCollider.h

Go to the documentation of this file.

/*
 *      OPCODE - Optimized Collision Detection
 *      Copyright (C) 2001 Pierre Terdiman
 *      Homepage: http://www.codercorner.com/Opcode.htm
 */
 
 
 
// Include Guard
#ifndef __OPC_TREECOLLIDER_H__
#define __OPC_TREECOLLIDER_H__
 
#include"../config.h"
        struct OPCODE_API BVTCache : Pair
        {
                inline_                         BVTCache()
                                                        {
                                                                ResetCache();
                                                                ResetCountDown();
                                                        }
 
                                        void    ResetCache()
                                                        {
                                                                Model0                  = null;
                                                                Model1                  = null;
                                                                id0                             = 0;
                                                                id1                             = 1;
#ifdef __MESHMERIZER_H__                // Collision hulls only supported within ICE !
                                                                HullTest                = true;
                                                                SepVector.pid   = 0;
                                                                SepVector.qid   = 0;
                                                                SepVector.SV    = Point(1.0f, 0.0f, 0.0f);
#endif // __MESHMERIZER_H__
                                                        }
 
                inline_         void    ResetCountDown()
                                                        {
#ifdef __MESHMERIZER_H__                // Collision hulls only supported within ICE !
                                                                CountDown               = 50;
#endif // __MESHMERIZER_H__
                                                        }
 
                const Model*            Model0; 
                const Model*            Model1; 
 
#ifdef __MESHMERIZER_H__        // Collision hulls only supported within ICE !
                SVCache                         SepVector;
                udword                          CountDown;
                bool                            HullTest;
#endif // __MESHMERIZER_H__
        };
 
        class OPCODE_API AABBTreeCollider : public Collider
        {
                public:
                // Constructor / Destructor
                AABBTreeCollider();
                virtual                                                         ~AABBTreeCollider();
 
                inline void setCollisionPairInserter(hrp::CollisionPairInserterBase* collisionPairInserter) {
                    this->collisionPairInserter = collisionPairInserter;
                }
 
                
                // Generic collision query
 
 
                                                        bool                    Collide(BVTCache& cache, const Matrix4x4* world0=null, const Matrix4x4* world1=null);
 
                // Collision queries
                                                        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);
                // Settings
 
 
                inline_                         void                    SetFullBoxBoxTest(bool flag)                    { mFullBoxBoxTest               = flag;                                 }
 
 
                inline_                         void                    SetFullPrimBoxTest(bool flag)                   { mFullPrimBoxTest              = flag;                                 }
 
                // Stats
 
 
                inline_                         udword                  GetNbBVBVTests()                                const   { return mNbBVBVTests;                                                  }
 
 
                inline_                         udword                  GetNbPrimPrimTests()                    const   { return mNbPrimPrimTests;                                              }
 
 
                inline_                         udword                  GetNbBVPrimTests()                              const   { return mNbBVPrimTests;                                                }
 
                // Data access
 
 
                inline_                         udword                  GetNbPairs()                                    const   { return mPairs.GetNbEntries()>>1;                              }
 
 
                inline_                         const Pair*             GetPairs()                                              const   { return (const Pair*)mPairs.GetEntries();              }
 
 
                override(Collider)      HRP_COLLISION_EXPORT const char*                ValidateSettings();
 
                protected:
                // Colliding pairs
                                                        Container               mPairs;                         
                // User mesh interfaces
                                        const   MeshInterface*  mIMesh0;                        
                                        const   MeshInterface*  mIMesh1;                        
                // Stats
                                                        udword                  mNbBVBVTests;           
                                                        udword                  mNbPrimPrimTests;       
                                                        udword                  mNbBVPrimTests;         
                // Precomputed data
                                                        Matrix3x3               mAR;                            
                                                        Matrix3x3               mR0to1;                         
                                                        Matrix3x3               mR1to0;                         
                                                        Point                   mT0to1;                         
                                                        Point                   mT1to0;                         
                // Dequantization coeffs
                                                        Point                   mCenterCoeff0;
                                                        Point                   mExtentsCoeff0;
                                                        Point                   mCenterCoeff1;
                                                        Point                   mExtentsCoeff1;
                // Modified!!
            // For normal vector detection
                                                        udword          mId0;
                                                        udword          mId1;
                                                        const AABBCollisionNode*   mNowNode0;
                                                        const AABBCollisionNode*   mNowNode1;
                // Leaf description
                                                        Point                   mLeafVerts[3];          
                                                        udword                  mLeafIndex;                     
                // Settings
                                                        bool                    mFullBoxBoxTest;        
                                                        bool                    mFullPrimBoxTest;       
                                                        hrp::CollisionPairInserterBase* collisionPairInserter;
                // Internal methods
 
                        // Standard AABB trees
                                                        void                    _Collide(const AABBCollisionNode* b0, const AABBCollisionNode* b1);
                        // Quantized AABB trees
                                                        void                    _Collide(const AABBQuantizedNode* b0, const AABBQuantizedNode* b1, const Point& a, const Point& Pa, const Point& b, const Point& Pb);
                        // No-leaf AABB trees
                                                        void                    _CollideTriBox(const AABBNoLeafNode* b);
                                                        void                    _CollideBoxTri(const AABBNoLeafNode* b);
                                                        void                    _Collide(const AABBNoLeafNode* a, const AABBNoLeafNode* b);
                        // Quantized no-leaf AABB trees
                                                        void                    _CollideTriBox(const AABBQuantizedNoLeafNode* b);
                                                        void                    _CollideBoxTri(const AABBQuantizedNoLeafNode* b);
                                                        void                    _Collide(const AABBQuantizedNoLeafNode* a, const AABBQuantizedNoLeafNode* b);
                        // Overlap tests
                                                        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);
                                                BOOL                    TriTriOverlap(const Point& V0, const Point& V1, const Point& V2, const Point& U0, const Point& U1, const Point& U2);
                        // Init methods
                        HRP_COLLISION_EXPORT    void    InitQuery(const Matrix4x4* world0=null, const Matrix4x4* world1=null);
                                                        bool                    CheckTemporalCoherence(Pair* cache);
 
                inline_                         BOOL                    Setup(const MeshInterface* mi0, const MeshInterface* mi1)
                                                                                        {
                                                                                                mIMesh0 = mi0;
                                                                                                mIMesh1 = mi1;
 
                                                                                                if(!mIMesh0 || !mIMesh1)        return FALSE;
 
                                                                                                return TRUE;
                                                                                        }
        };
 
#endif // __OPC_TREECOLLIDER_H__