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;
}