OPC_MeshInterface.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_MESHINTERFACE_H__
#define __OPC_MESHINTERFACE_H__
 
        struct VertexPointers
        {
                const Point*    Vertex[3];
 
                bool BackfaceCulling(const Point& source)
                {
                        const Point& p0 = *Vertex[0];
                        const Point& p1 = *Vertex[1];
                        const Point& p2 = *Vertex[2];
 
                        // Compute normal direction
                        Point Normal = (p2 - p1)^(p0 - p1);
 
                        // Backface culling
                        return (Normal | (source - p0)) >= 0.0f;
                }
        };
 
#ifdef OPC_USE_CALLBACKS
 
        typedef void    (*RequestCallback)      (udword triangle_index, VertexPointers& triangle, void* user_data);
#endif
 
        class OPCODE_API MeshInterface
        {
                public:
                // Constructor / Destructor
                                                                                        MeshInterface();
                                                                                        ~MeshInterface();
                // Common settings
                inline_                 udword                          GetNbTriangles()        const   { return mNbTris;       }
                inline_                 udword                          GetNbVertices()         const   { return mNbVerts;      }
                inline_                 void                            SetNbTriangles(udword nb)       { mNbTris = nb;         }
                inline_                 void                            SetNbVertices(udword nb)        { mNbVerts = nb;        }
 
#ifdef OPC_USE_CALLBACKS
                // Callback settings
 
 
                                                bool                            SetCallback(RequestCallback callback, void* user_data);
                inline_                 void*                           GetUserData()           const   { return mUserData;             }
                inline_                 RequestCallback         GetCallback()           const   { return mObjCallback;  }
#else
                // Pointers settings
 
 
                                                bool                            SetPointers(const IndexedTriangle* tris, const Point* verts);
                inline_ const   IndexedTriangle*        GetTris()                       const   { return mTris;                 }
                inline_ const   Point*                          GetVerts()                      const   { return mVerts;                }
 
        #ifdef OPC_USE_STRIDE
                // Strides settings
 
 
                                                bool                            SetStrides(udword tri_stride=sizeof(IndexedTriangle), udword vertex_stride=sizeof(Point));
                inline_                 udword                          GetTriStride()          const   { return mTriStride;    }
                inline_                 udword                          GetVertexStride()       const   { return mVertexStride; }
        #endif
#endif
 
 
                inline_                 void                            GetTriangle(VertexPointers& vp, udword index)   const
                                                                                        {
#ifdef OPC_USE_CALLBACKS
                                                                                                (mObjCallback)(index, vp, mUserData);
#else
        #ifdef OPC_USE_STRIDE
                                                                                                const IndexedTriangle* T = (const IndexedTriangle*)(((ubyte*)mTris) + index * mTriStride);
 
                                                                                                if (Single){
                                                                                                        vp.Vertex[0] = (const Point*)(((ubyte*)mVerts) + T->mVRef[0] * mVertexStride);
                                                                                                        vp.Vertex[1] = (const Point*)(((ubyte*)mVerts) + T->mVRef[1] * mVertexStride);
                                                                                                        vp.Vertex[2] = (const Point*)(((ubyte*)mVerts) + T->mVRef[2] * mVertexStride);
                                                                                                }
                                                                                                else{
                                                                                                        for (int i = 0; i < 3; i++){
                                                                                                                const double* v = (const double*)(((ubyte*)mVerts) + T->mVRef[i] * mVertexStride);
 
                                                                                                                VertexCache[i].x = (float)v[0];
                                                                                                                VertexCache[i].y = (float)v[1];
                                                                                                                VertexCache[i].z = (float)v[2];
                                                                                                                vp.Vertex[i] = &VertexCache[i];
                                                                                                        }
                                                                                                }
        #else
                                                                                                const IndexedTriangle* T = &mTris[index];
                                                                                                vp.Vertex[0] = &mVerts[T->mVRef[0]];
                                                                                                vp.Vertex[1] = &mVerts[T->mVRef[1]];
                                                                                                vp.Vertex[2] = &mVerts[T->mVRef[2]];
        #endif
#endif
                                                                                        }
 
 
                bool                            RemapClient(udword nb_indices, const udword* permutation)       const;
 
 
                                                bool                            IsValid()               const;
 
 
                                                udword                          CheckTopology() const;
                private:
 
                                                udword                          mNbTris;                        
                                                udword                          mNbVerts;                       
#ifdef OPC_USE_CALLBACKS
                // User callback
                                                void*                           mUserData;                      
                                                RequestCallback         mObjCallback;           
#else
                // User pointers
                                const   IndexedTriangle*        mTris;                          
                                const   Point*                          mVerts;                         
        #ifdef OPC_USE_STRIDE
                                                udword                          mTriStride;                     
                                                udword                          mVertexStride;          
        #endif
                public:
                                                bool Single;                                                    
                private:
                                                static Point VertexCache[3];
#endif
        };
 
#endif //__OPC_MESHINTERFACE_H__