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;


MeshInterface::MeshInterface() :
#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
    mNbTris         (0),
    mNbVerts        (0)
{
}


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");
    if(!callback) return(false);
    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);
    if(!tris || !verts) return(false);
        
    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;
}