diff options
Diffstat (limited to 'libs/ode-0.16.1/OPCODE/OPC_MeshInterface.h')
| -rw-r--r-- | libs/ode-0.16.1/OPCODE/OPC_MeshInterface.h | 280 |
1 files changed, 280 insertions, 0 deletions
diff --git a/libs/ode-0.16.1/OPCODE/OPC_MeshInterface.h b/libs/ode-0.16.1/OPCODE/OPC_MeshInterface.h new file mode 100644 index 0000000..c404948 --- /dev/null +++ b/libs/ode-0.16.1/OPCODE/OPC_MeshInterface.h @@ -0,0 +1,280 @@ +/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +/* + * OPCODE - Optimized Collision Detection + * Copyright (C) 2001 Pierre Terdiman + * Homepage: http://www.codercorner.com/Opcode.htm + */ +/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +/** + * Contains a mesh interface. + * \file OPC_MeshInterface.h + * \author Pierre Terdiman + * \date November, 27, 2002 + */ +/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +// 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; + } + }; + + struct VertexPointersEx + { + VertexPointers vp; + dTriIndex Index[3]; + }; + + typedef Point ConversionArea[3]; + +#ifdef OPC_USE_CALLBACKS + /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + /** + * User-callback, called by OPCODE to request vertices from the app. + * \param triangle_index [in] face index for which the system is requesting the vertices + * \param triangle [out] triangle's vertices (must be provided by the user) + * \param user_data [in] user-defined data from SetCallback() + */ + /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + typedef void (*RequestCallback) (udword triangle_index, VertexPointers& triangle, void* user_data); + + /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + /** + * User-callback, called by OPCODE to request vertex indices from the app. + * \param triangle_index [in] face index for which the system is requesting the vertices + * \param triangle [out] triangle's vertices with indices (must be provided by the user) + * \param user_data [in] user-defined data from SetExCallback() + */ + /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + typedef void (*RequestExCallback) (udword triangle_index, VertexPointersEx& 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 + + /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + /** + * Callback control: setups object callback. Must provide triangle-vertices for a given triangle index. + * \param callback [in] user-defined callback + * \param user_data [in] user-defined data + * \return true if success + */ + /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + bool SetCallback(RequestCallback callback, void* user_data); + inline_ void* GetUserData() const { return mUserData; } + inline_ RequestCallback GetCallback() const { return mObjCallback; } + + /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + /** + * Callback control: setups object callback. Must provide triangle-vertices for a given triangle index. + * \param callback [in] user-defined callback + * \param user_data [in] user-defined data + * \return true if success + */ + /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + bool SetExCallback(RequestExCallback callback, void* user_data); + inline_ void* GetExUserData() const { return mExUserData; } + inline_ RequestExCallback GetExCallback() const { return mObjExCallback; } +#else + // Pointers settings + + /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + /** + * Pointers control: setups object pointers. Must provide access to faces and vertices for a given object. + * \param tris [in] pointer to triangles + * \param verts [in] pointer to vertices + * \return true if success + */ + /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + 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 + + /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + /** + * Strides control + * \param tri_stride [in] size of a triangle in bytes. The first sizeof(IndexedTriangle) bytes are used to get vertex indices. + * \param vertex_stride [in] size of a vertex in bytes. The first sizeof(Point) bytes are used to get vertex position. + * \return true if success + */ + /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + bool SetStrides(udword tri_stride=sizeof(IndexedTriangle), udword vertex_stride=sizeof(Point)); + inline_ udword GetTriStride() const { return mTriStride; } + inline_ udword GetVertexStride() const { return mVertexStride; } + + /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + /** + * Single/Double control + * \param value [in] Indicates if mesh data is provided as array of \c single values. If \c false, data is expected to contain \c double elements. + */ + /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + inline_ void SetSingle(bool value) + { + mFetchTriangle = (value ? &MeshInterface::FetchTriangleFromSingles : &MeshInterface::FetchTriangleFromDoubles); + mFetchExTriangle = (value ? &MeshInterface::FetchExTriangleFromSingles : &MeshInterface::FetchExTriangleFromDoubles); + } + + #else + inline_ bool SetStrides(udword tri_stride=sizeof(IndexedTriangle), udword vertex_stride=sizeof(Point)) { return true; } + inline_ void SetSingle(bool value) {} + inline_ udword GetTriStride() const { return sizeof(IndexedTriangle); } + inline_ udword GetVertexStride() const { return sizeof(Point); } + #endif +#endif + + /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + /** + * Fetches a triangle given a triangle index. + * \param vp [out] required triangle's vertex pointers + * \param index [in] triangle index + * \param vc [in,out] storage required for data conversion (pass local variable with same scope as \a vp, as \a vp may point to this memory on return) + */ + /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + inline_ void GetTriangle(VertexPointers& vp, udword index, ConversionArea vc) const + { +#ifdef OPC_USE_CALLBACKS + (mObjCallback)(index, vp, mUserData); +#else + #ifdef OPC_USE_STRIDE + // Since there was conditional statement "if (Single)" which was unpredictable for compiler + // and required both branches to be always generated what made inlining a questionable + // benefit, I consider it better to introduce a forced call + // but get rig of branching and dead code injection. + ((*this).*mFetchTriangle)(vp, index, vc); + #else + const Point* Verts = GetVerts(); + const IndexedTriangle* T = &mTris[index]; + vp.Vertex[0] = &Verts[T->mVRef[0]]; + vp.Vertex[1] = &Verts[T->mVRef[1]]; + vp.Vertex[2] = &Verts[T->mVRef[2]]; + #endif +#endif + } + + inline_ bool GetExTriangle(VertexPointersEx& vpe, udword index, ConversionArea vc) const + { +#ifdef OPC_USE_CALLBACKS + if (mObjExCallback) { (mObjExCallback)(index, vpe, mUserData); return true; } + else { (mObjCallback)(index, vpe.vp, mUserData); return false; } +#else + #ifdef OPC_USE_STRIDE + // Since there was conditional statement "if (Single)" which was unpredictable for compiler + // and required both branches to be always generated what made inlining a questionable + // benefit, I consider it better to introduce a forced call + // but get rig of branching and dead code injection. + ((*this).*mFetchExTriangle)(vpe, index, vc); + return true; + #else + const Point* Verts = GetVerts(); + const IndexedTriangle* T = &mTris[index]; + dTriIndex VertIndex0 = T->mVRef[0]; + vpe.Index[0] = VertIndex0; + vpe.vp.Vertex[0] = &Verts[VertIndex0]; + dTriIndex VertIndex1 = T->mVRef[1]; + vpe.Index[1] = VertIndex1; + vpe.vp.Vertex[1] = &Verts[VertIndex1]; + dTriIndex VertIndex2 = T->mVRef[2]; + vpe.Index[2] = VertIndex2; + vpe.vp.Vertex[2] = &Verts[VertIndex2]; + return true; + #endif +#endif + } + + private: +#ifndef OPC_USE_CALLBACKS + #ifdef OPC_USE_STRIDE + void FetchTriangleFromSingles(VertexPointers& vp, udword index, ConversionArea vc) const; + void FetchTriangleFromDoubles(VertexPointers& vp, udword index, ConversionArea vc) const; + void FetchExTriangleFromSingles(VertexPointersEx& vpe, udword index, ConversionArea vc) const; + void FetchExTriangleFromDoubles(VertexPointersEx& vpe, udword index, ConversionArea vc) const; + #endif +#endif + + public: + /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + /** + * Remaps client's mesh according to a permutation. + * \param nb_indices [in] number of indices in the permutation (will be checked against number of triangles) + * \param permutation [in] list of triangle indices + * \return true if success + */ + /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + bool RemapClient(udword nb_indices, const dTriIndex* permutation) const; + + /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + /** + * Checks the mesh interface is valid, i.e. things have been setup correctly. + * \return true if valid + */ + /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + bool IsValid() const; + + /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + /** + * Checks the mesh itself is valid. + * Currently we only look for degenerate faces. + * \return number of degenerate faces + */ + /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + udword CheckTopology() const; + private: + + udword mNbTris; //!< Number of triangles in the input model + udword mNbVerts; //!< Number of vertices in the input model +#ifdef OPC_USE_CALLBACKS + // User callback + void* mUserData; //!< User-defined data sent to callback + RequestCallback mObjCallback; //!< Object callback + void* mExUserData; //!< User-defined data sent to ex-callback + RequestExCallback mObjExCallback; //!< Object ex-callback +#else + // User pointers + #ifdef OPC_USE_STRIDE + udword mTriStride; //!< Possible triangle stride in bytes [Opcode 1.3] + udword mVertexStride; //!< Possible vertex stride in bytes [Opcode 1.3] + typedef void (MeshInterface:: *TriangleFetchProc)(VertexPointers& vp, udword index, ConversionArea vc) const; + TriangleFetchProc mFetchTriangle; + typedef void (MeshInterface:: *ExTriangleFetchProc)(VertexPointersEx& vpe, udword index, ConversionArea vc) const; + ExTriangleFetchProc mFetchExTriangle; + #endif + const IndexedTriangle* mTris; //!< Array of indexed triangles + const Point* mVerts; //!< Array of vertices +#endif + }; + +#endif //__OPC_MESHINTERFACE_H__ |