OPC_MeshInterface.cpp

Go to the documentation of this file.

/*
 *      OPCODE - Optimized Collision Detection
 *      Copyright (C) 2001 Pierre Terdiman
 *      Homepage: http://www.codercorner.com/Opcode.htm
 */
 
 
 
 
 
 
 
// Precompiled Header
#include "Stdafx.h"
 
using namespace Opcode;
 
Point MeshInterface::VertexCache[3];
 
 
MeshInterface::MeshInterface() :
        mNbTris                 (0),
        mNbVerts                (0),
#ifdef OPC_USE_CALLBACKS
        mUserData               (null),
        mObjCallback    (null),
#else
        mTris                   (null),
        mVerts                  (null),
        #ifdef OPC_USE_STRIDE
        mTriStride              (sizeof(IndexedTriangle)),
        mVertexStride   (sizeof(Point)),
        #endif
#endif
 
        Single(true)
{
}
 
 
MeshInterface::~MeshInterface()
{
}
 
 
bool MeshInterface::IsValid() const
{
        if(!mNbTris || !mNbVerts)       return false;
#ifdef OPC_USE_CALLBACKS
        if(!mObjCallback)                       return false;
#else
        if(!mTris || !mVerts)           return false;
#endif
        return true;
}
 
 
udword MeshInterface::CheckTopology()   const
{
        // Check topology. If the model contains degenerate faces, collision report can be wrong in some cases.
        // e.g. it happens with the standard MAX teapot. So clean your meshes first... If you don't have a mesh cleaner
        // you can try this: www.codercorner.com/Consolidation.zip
 
        udword NbDegenerate = 0;
 
        VertexPointers VP;
 
        // Using callbacks, we don't have access to vertex indices. Nevertheless we still can check for
        // redundant vertex pointers, which cover all possibilities (callbacks/pointers/strides).
        for(udword i=0;i<mNbTris;i++)
        {
                GetTriangle(VP, i);
 
                if(             (VP.Vertex[0]==VP.Vertex[1])
                        ||      (VP.Vertex[1]==VP.Vertex[2])
                        ||      (VP.Vertex[2]==VP.Vertex[0]))   NbDegenerate++;
        }
 
        return NbDegenerate;
}
 
#ifdef OPC_USE_CALLBACKS
 
bool MeshInterface::SetCallback(RequestCallback callback, void* user_data)
{
        if(!callback)   return SetIceError("MeshInterface::SetCallback: callback pointer is null");
 
        mObjCallback    = callback;
        mUserData               = user_data;
        return true;
}
#else
 
bool MeshInterface::SetPointers(const IndexedTriangle* tris, const Point* verts)
{
        if(!tris || !verts)     return SetIceError("MeshInterface::SetPointers: pointer is null", null);
 
        mTris   = tris;
        mVerts  = verts;
        return true;
}
#ifdef OPC_USE_STRIDE
 
bool MeshInterface::SetStrides(udword tri_stride, udword vertex_stride)
{
        if(tri_stride<sizeof(IndexedTriangle))  return SetIceError("MeshInterface::SetStrides: invalid triangle stride", null);
        if(vertex_stride<sizeof(Point))                 return SetIceError("MeshInterface::SetStrides: invalid vertex stride", null);
 
        mTriStride              = tri_stride;
        mVertexStride   = vertex_stride;
        return true;
}
#endif
#endif
 
 
bool MeshInterface::RemapClient(udword nb_indices, const udword* permutation) const
{
        // Checkings
        if(!nb_indices || !permutation) return false;
        if(nb_indices!=mNbTris)                 return false;
 
#ifdef OPC_USE_CALLBACKS
        // We can't really do that using callbacks
        return false;
#else
        IndexedTriangle* Tmp = new IndexedTriangle[mNbTris];
        CHECKALLOC(Tmp);
 
        #ifdef OPC_USE_STRIDE
        udword Stride = mTriStride;
        #else
        udword Stride = sizeof(IndexedTriangle);
        #endif
 
        for(udword i=0;i<mNbTris;i++)
        {
                const IndexedTriangle* T = (const IndexedTriangle*)(((ubyte*)mTris) + i * Stride);
                Tmp[i] = *T;
        }
 
        for(udword i=0;i<mNbTris;i++)
        {
                IndexedTriangle* T = (IndexedTriangle*)(((ubyte*)mTris) + i * Stride);
                *T = Tmp[permutation[i]];
        }
 
        DELETEARRAY(Tmp);
#endif
        return true;
}