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__