Engine/lib/opcode/OPC_MeshInterface.h

   1 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
   2 /*
   3  *      OPCODE - Optimized Collision Detection
   4  *      Copyright (C) 2001 Pierre Terdiman
   5  *      Homepage: http://www.codercorner.com/Opcode.htm
   6  */
   7 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
   8
   9 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  10 /**
  11  *      Contains a mesh interface.
  12  *      \file           OPC_MeshInterface.h
  13  *      \author         Pierre Terdiman
  14  *      \date           November, 27, 2002
  15  */
  16 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  17
  18 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  19 // Include Guard
  20 #ifndef __OPC_MESHINTERFACE_H__
  21 #define __OPC_MESHINTERFACE_H__
  22
  23         struct VertexPointers
  24         {
  25                 const Point*    Vertex[3];
  26       udword         MatIdx;
  27
  28       VertexPointers() { MatIdx=-1; }
  29
  30                 bool BackfaceCulling(const Point& source)
  31                 {
  32                         const Point& p0 = *Vertex[0];
  33                         const Point& p1 = *Vertex[1];
  34                         const Point& p2 = *Vertex[2];
  35
  36                         // Compute normal direction
  37                         Point Normal = (p2 - p1)^(p0 - p1);
  38
  39                         // Backface culling
  40                         return (Normal | (source - p0)) >= 0.0f;
  41                 }
  42         };
  43
  44 #ifdef OPC_USE_CALLBACKS
  45         ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  46         /**
  47          *      User-callback, called by OPCODE to request vertices from the app.
  48          *      \param          triangle_index  [in] face index for which the system is requesting the vertices
  49          *      \param          triangle                [out] triangle's vertices (must be provided by the user)
  50          *      \param          user_data               [in] user-defined data from SetCallback()
  51          */
  52         ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  53         typedef void    (*RequestCallback)      (udword triangle_index, VertexPointers& triangle, void* user_data);
  54 #endif
  55
  56         class OPCODE_API MeshInterface
  57         {
  58                 public:
  59                 // Constructor / Destructor
  60                                                                                         MeshInterface();
  61                                                                                         ~MeshInterface();
  62                 // Common settings
  63                 inline_                 udword                          GetNbTriangles()        const   { return mNbTris;       }
  64                 inline_                 udword                          GetNbVertices()         const   { return mNbVerts;      }
  65                 inline_                 void                            SetNbTriangles(udword nb)       { mNbTris = nb;         }
  66                 inline_                 void                            SetNbVertices(udword nb)        { mNbVerts = nb;        }
  67
  68 #ifdef OPC_USE_CALLBACKS
  69                 // Callback settings
  70
  71                 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  72                 /**
  73                  *      Callback control: setups object callback. Must provide triangle-vertices for a given triangle index.
  74                  *      \param          callback        [in] user-defined callback
  75                  *      \param          user_data       [in] user-defined data
  76                  *      \return         true if success
  77                  */
  78                 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  79                                                 bool                            SetCallback(RequestCallback callback, void* user_data);
  80                 inline_                 void*                           GetUserData()           const   { return mUserData;             }
  81                 inline_                 RequestCallback         GetCallback()           const   { return mObjCallback;  }
  82 #else
  83                 // Pointers settings
  84
  85                 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  86                 /**
  87                  *      Pointers control: setups object pointers. Must provide access to faces and vertices for a given object.
  88                  *      \param          tris    [in] pointer to triangles
  89                  *      \param          verts   [in] pointer to vertices
  90                  *      \return         true if success
  91                  */
  92                 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  93                                                 bool                            SetPointers(const IndexedTriangle* tris, const Point* verts);
  94                 inline_ const   IndexedTriangle*        GetTris()                       const   { return mTris;                 }
  95                 inline_ const   Point*                          GetVerts()                      const   { return mVerts;                }
  96
  97         #ifdef OPC_USE_STRIDE
  98                 // Strides settings
  99
 100                 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 101                 /**
 102                  *      Strides control
 103                  *      \param          tri_stride              [in] size of a triangle in bytes. The first sizeof(IndexedTriangle) bytes are used to get vertex indices.
 104                  *      \param          vertex_stride   [in] size of a vertex in bytes. The first sizeof(Point) bytes are used to get vertex position.
 105                  *      \return         true if success
 106                  */
 107                 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 108                                                 bool                            SetStrides(udword tri_stride=sizeof(IndexedTriangle), udword vertex_stride=sizeof(Point));
 109                 inline_                 udword                          GetTriStride()          const   { return mTriStride;    }
 110                 inline_                 udword                          GetVertexStride()       const   { return mVertexStride; }
 111         #endif
 112 #endif
 113
 114                 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 115                 /**
 116                  *      Fetches a triangle given a triangle index.
 117                  *      \param          vp              [out] required triangle's vertex pointers
 118                  *      \param          index   [in] triangle index
 119                  */
 120                 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 121                 inline_                 void                            GetTriangle(VertexPointers& vp, udword index)   const
 122                                                                                         {
 123 #ifdef OPC_USE_CALLBACKS
 124                                                                                                 (mObjCallback)(index, vp, mUserData);
 125 #else
 126         #ifdef OPC_USE_STRIDE
 127                                                                                                 const IndexedTriangle* T = (const IndexedTriangle*)(((ubyte*)mTris) + index * mTriStride);
 128                                                                                                 vp.Vertex[0] = (const Point*)(((ubyte*)mVerts) + T->mVRef[0] * mVertexStride);
 129                                                                                                 vp.Vertex[1] = (const Point*)(((ubyte*)mVerts) + T->mVRef[1] * mVertexStride);
 130                                                                                                 vp.Vertex[2] = (const Point*)(((ubyte*)mVerts) + T->mVRef[2] * mVertexStride);
 131
 132                                     vp.MatIdx = T->mMatIdx;
 133         #else
 134                                                                                                 const IndexedTriangle* T = &mTris[index];
 135                                                                                                 vp.Vertex[0] = &mVerts[T->mVRef[0]];
 136                                                                                                 vp.Vertex[1] = &mVerts[T->mVRef[1]];
 137                                                                                                 vp.Vertex[2] = &mVerts[T->mVRef[2]];
 138
 139                                     vp.MatIdx = T->mMatIdx;
 140         #endif
 141 #endif
 142                                                                                         }
 143
 144                 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 145                 /**
 146                  *      Remaps client's mesh according to a permutation.
 147                  *      \param          nb_indices      [in] number of indices in the permutation (will be checked against number of triangles)
 148                  *      \param          permutation     [in] list of triangle indices
 149                  *      \return         true if success
 150                  */
 151                 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 152                                                 bool                            RemapClient(udword nb_indices, const udword* permutation)       const;
 153
 154                 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 155                 /**
 156                  *      Checks the mesh interface is valid, i.e. things have been setup correctly.
 157                  *      \return         true if valid
 158                  */
 159                 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 160                                                 bool                            IsValid()               const;
 161
 162                 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 163                 /**
 164                  *      Checks the mesh itself is valid.
 165                  *      Currently we only look for degenerate faces.
 166                  *      \return         number of degenerate faces
 167                  */
 168                 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 169                                                 udword                          CheckTopology() const;
 170                 private:
 171
 172                                                 udword                          mNbTris;                        //!< Number of triangles in the input model
 173                                                 udword                          mNbVerts;                       //!< Number of vertices in the input model
 174 #ifdef OPC_USE_CALLBACKS
 175                 // User callback
 176                                                 void*                           mUserData;                      //!< User-defined data sent to callback
 177                                                 RequestCallback         mObjCallback;           //!< Object callback
 178 #else
 179                 // User pointers
 180                                 const   IndexedTriangle*        mTris;                          //!< Array of indexed triangles
 181                                 const   Point*                          mVerts;                         //!< Array of vertices
 182         #ifdef OPC_USE_STRIDE
 183                                                 udword                          mTriStride;                     //!< Possible triangle stride in bytes [Opcode 1.3]
 184                                                 udword                          mVertexStride;          //!< Possible vertex stride in bytes [Opcode 1.3]
 185         #endif
 186 #endif
 187         };
 188
 189 #endif //__OPC_MESHINTERFACE_H__