OPC_SphereCollider.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_SPHERECOLLIDER_H__
#define __OPC_SPHERECOLLIDER_H__

        struct OPCODE_API SphereCache : VolumeCache
        {
                                        SphereCache() : Center(0.0f,0.0f,0.0f), FatRadius2(0.0f), FatCoeff(1.1f)        {}
                                        ~SphereCache()                                                                                                                          {}

                // Cached faces signature
                Point           Center;         
                float           FatRadius2;     
                // User settings
                float           FatCoeff;       
        };

        class OPCODE_API SphereCollider : public VolumeCollider
        {
                public:
                // Constructor / Destructor
                                                                                        SphereCollider();
                virtual                                                         ~SphereCollider();



                                                        bool                    Collide(SphereCache& cache, const Sphere& sphere, const Model& model, const Matrix4x4* worlds=null, const Matrix4x4* worldm=null);

                // 
                                                        bool                    Collide(SphereCache& cache, const Sphere& sphere, const AABBTree* tree);
                protected:
                // Sphere in model space
                                                        Point                   mCenter;                        
                                                        float                   mRadius2;                       
                // Internal methods
                                                        void                    _Collide(const AABBCollisionNode* node);
                                                        void                    _Collide(const AABBNoLeafNode* node);
                                                        void                    _Collide(const AABBQuantizedNode* node);
                                                        void                    _Collide(const AABBQuantizedNoLeafNode* node);
                                                        void                    _Collide(const AABBTreeNode* node);
                                                        void                    _CollideNoPrimitiveTest(const AABBCollisionNode* node);
                                                        void                    _CollideNoPrimitiveTest(const AABBNoLeafNode* node);
                                                        void                    _CollideNoPrimitiveTest(const AABBQuantizedNode* node);
                                                        void                    _CollideNoPrimitiveTest(const AABBQuantizedNoLeafNode* node);
                        // Overlap tests
                inline_                         BOOL                    SphereContainsBox(const Point& bc, const Point& be);
                inline_                         BOOL                    SphereAABBOverlap(const Point& center, const Point& extents);
                                                        BOOL                    SphereTriOverlap(const Point& vert0, const Point& vert1, const Point& vert2);
                        // Init methods
                                                        BOOL                    InitQuery(SphereCache& cache, const Sphere& sphere, const Matrix4x4* worlds=null, const Matrix4x4* worldm=null);
        };

        class OPCODE_API HybridSphereCollider : public SphereCollider
        {
                public:
                // Constructor / Destructor
                                                                                        HybridSphereCollider();
                virtual                                                         ~HybridSphereCollider();

                                                        bool                    Collide(SphereCache& cache, const Sphere& sphere, const HybridModel& model, const Matrix4x4* worlds=null, const Matrix4x4* worldm=null);
                protected:
                                                        Container               mTouchedBoxes;
        };

#endif // __OPC_SPHERECOLLIDER_H__