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__

    struct OPCODE_API BVTCache : Pair
    {
        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__
                            }

        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();
        // 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;                 }


        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)  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;
        // Leaf description
                            Point           mLeafVerts[3];      
                            udword          mLeafIndex;         
        // Settings
                            bool            mFullBoxBoxTest;    
                            bool            mFullPrimBoxTest;   
        // 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);
            inline_         bool            TriTriOverlap(const Point& V0, const Point& V1, const Point& V2, const Point& U0, const Point& U1, const Point& U2);
            // Init methods
                            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__