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);
                                                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
                                                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:

#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
#endif
                        udword              mNbTris;            
                        udword              mNbVerts;           
    };

#endif //__OPC_MESHINTERFACE_H__