OPC_PlanesCollider.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_PLANESCOLLIDER_H__
#define __OPC_PLANESCOLLIDER_H__
 
        struct OPCODE_API PlanesCache : VolumeCache
        {
                                        PlanesCache()
                                        {
                                        }
        };
 
        class OPCODE_API PlanesCollider : public VolumeCollider
        {
                public:
                // Constructor / Destructor
                                                                                        PlanesCollider();
                virtual                                                         ~PlanesCollider();
 
                inline void setCollisionPairInserter(hrp::CollisionPairInserterBase* collisionPairInserter) {
                    this->collisionPairInserter = collisionPairInserter;
                }
 
                                                        bool                    Collide(PlanesCache& cache, const Plane* planes, udword nb_planes, const Model& model, const Matrix4x4* worldm=null);
 
                // Mutant box-with-planes collision queries
                inline_                         bool                    Collide(PlanesCache& cache, const OBB& box, const Model& model, const Matrix4x4* worldb=null, const Matrix4x4* worldm=null)
                                                                                        {
                                                                                                Plane PL[6];
 
                                                                                                if(worldb)
                                                                                                {
                                                                                                        // Create a new OBB in world space
                                                                                                        OBB WorldBox;
                                                                                                        box.Rotate(*worldb, WorldBox);
                                                                                                        // Compute planes from the sides of the box
                                                                                                        WorldBox.ComputePlanes(PL);
                                                                                                }
                                                                                                else
                                                                                                {
                                                                                                        // Compute planes from the sides of the box
                                                                                                        box.ComputePlanes(PL);
                                                                                                }
 
                                                                                                // Collide with box planes
                                                                                                return Collide(cache, PL, 6, model, worldm);
                                                                                        }
                // Settings
 
 
                override(Collider)      const char*             ValidateSettings();
 
                protected:
                                                        hrp::CollisionPairInserterBase* collisionPairInserter;
                // Planes in model space
                                                        udword                  mNbPlanes;
                                                        Plane*                  mPlanes;
                // Leaf description
                                                        VertexPointers  mVP;
                // Internal methods
                                                        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);
                        // Overlap tests
                inline_                         BOOL                    PlanesAABBOverlap(const Point& center, const Point& extents, udword& out_clip_mask, udword in_clip_mask);
                inline_                         BOOL                    PlanesTriOverlap(udword in_clip_mask);
                        // Init methods
                                                        BOOL                    InitQuery(PlanesCache& cache, const Plane* planes, udword nb_planes, const Matrix4x4* worldm=null);
        };
 
        class OPCODE_API HybridPlanesCollider : public PlanesCollider
        {
                public:
                // Constructor / Destructor
                                                                                        HybridPlanesCollider();
                virtual                                                         ~HybridPlanesCollider();
 
                                                        bool                    Collide(PlanesCache& cache, const Plane* planes, udword nb_planes, const HybridModel& model, const Matrix4x4* worldm=null);
                protected:
                                                        Container               mTouchedBoxes;
        };
 
#endif // __OPC_PLANESCOLLIDER_H__