OPC_RayCollider.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_RAYCOLLIDER_H__
#define __OPC_RAYCOLLIDER_H__

    class OPCODE_API CollisionFace
    {
        public:
        inline_             CollisionFace()         {}
        inline_             ~CollisionFace()        {}

                udword      mFaceID;                
                float       mDistance;              
                float       mU, mV;                 
    };

    class OPCODE_API CollisionFaces : private Container
    {
        public:
                                        CollisionFaces()                        {}
                                        ~CollisionFaces()                       {}

        inline_ udword                  GetNbFaces()                    const   { return GetNbEntries()>>2;                     }
        inline_ const CollisionFace*    GetFaces()                      const   { return (const CollisionFace*)GetEntries();    }

        inline_ void                    Reset()                                 { Container::Reset();                           }

        inline_ void                    AddFace(const CollisionFace& face)      { Add(face.mFaceID).Add(face.mDistance).Add(face.mU).Add(face.mV);  }
    };

#ifdef OPC_RAYHIT_CALLBACK

    typedef void    (*HitCallback)  (const CollisionFace& hit, void* user_data);
#endif

    class OPCODE_API RayCollider : public Collider
    {
        public:
        // Constructor / Destructor
                                            RayCollider();
        virtual                             ~RayCollider();


                            bool            Collide(const Ray& world_ray, const Model& model, const Matrix4x4* world=null, udword* cache=null);
        //
                            bool            Collide(const Ray& world_ray, const AABBTree* tree, Container& box_indices);
        // Settings

#ifndef OPC_RAYHIT_CALLBACK

        inline_             void            SetClosestHit(bool flag)                { mClosestHit   = flag;     }
#endif

        inline_             void            SetCulling(bool flag)                   { mCulling      = flag;     }


        inline_             void            SetMaxDist(float max_dist=MAX_FLOAT)    { mMaxDist      = max_dist; }

#ifdef OPC_RAYHIT_CALLBACK
        inline_             void            SetHitCallback(HitCallback cb)          { mHitCallback  = cb;           }
        inline_             void            SetUserData(void* user_data)            { mUserData     = user_data;    }
#else

        inline_             void            SetDestination(CollisionFaces* cf)      { mStabbedFaces = cf;       }
#endif
        // Stats

        inline_             udword          GetNbRayBVTests()               const   { return mNbRayBVTests;     }


        inline_             udword          GetNbRayPrimTests()             const   { return mNbRayPrimTests;   }

        // In-out test

        inline_             udword          GetNbIntersections()            const   { return mNbIntersections;  }


        override(Collider)  const char*     ValidateSettings();

        protected:
        // Ray in local space
                            Point           mOrigin;            
                            Point           mDir;               
                            Point           mFDir;              
                            Point           mData, mData2;
        // Stabbed faces
                            CollisionFace   mStabbedFace;       
#ifdef OPC_RAYHIT_CALLBACK
                            HitCallback     mHitCallback;       
                            void*           mUserData;          
#else
                            CollisionFaces* mStabbedFaces;      
#endif
        // Stats
                            udword          mNbRayBVTests;      
                            udword          mNbRayPrimTests;    
        // In-out test
                            udword          mNbIntersections;   
        // Dequantization coeffs
                            Point           mCenterCoeff;
                            Point           mExtentsCoeff;
        // Settings
                            float           mMaxDist;           
#ifndef OPC_RAYHIT_CALLBACK
                            bool            mClosestHit;        
#endif
                            bool            mCulling;           
        // Internal methods
                            void            _SegmentStab(const AABBCollisionNode* node);
                            void            _SegmentStab(const AABBNoLeafNode* node);
                            void            _SegmentStab(const AABBQuantizedNode* node);
                            void            _SegmentStab(const AABBQuantizedNoLeafNode* node);
                            void            _SegmentStab(const AABBTreeNode* node, Container& box_indices);
                            void            _RayStab(const AABBCollisionNode* node);
                            void            _RayStab(const AABBNoLeafNode* node);
                            void            _RayStab(const AABBQuantizedNode* node);
                            void            _RayStab(const AABBQuantizedNoLeafNode* node);
                            void            _RayStab(const AABBTreeNode* node, Container& box_indices);
            // Overlap tests
        inline_             bool            RayAABBOverlap(const Point& center, const Point& extents);
        inline_             bool            SegmentAABBOverlap(const Point& center, const Point& extents);
        inline_             bool            RayTriOverlap(const Point& vert0, const Point& vert1, const Point& vert2);
            // Init methods
                            bool            InitQuery(const Ray& world_ray, const Matrix4x4* world=null, udword* face_id=null);
    };

#endif // __OPC_RAYCOLLIDER_H__