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__