TAPsFace.cpp

Go to the documentation of this file.

/******************************************************************************
TAPsFace.cpp

Face class is a class for 3D Face.
It contains a set of pointers to its vertices in CCW order.
Example:
          2-------1
           \       \
            \       \
             \       0
              \     /
               \   /
                \ /
                 3

SUKITTI PUNAK   (10/18/2004)
UPDATE          (04/04/2005)
******************************************************************************/
#include "TAPsFace.hpp"
// Using Inclusion Model (i.e. definitions are included in declarations)
//                       (this name.cpp is included in name.hpp)
// Each friend is defined directly inside its declaration.

BEGIN_NAMESPACE_TAPs
//=============================================================================
// Constructors and Destructor
//-----------------------------------------------------------------------------
template <typename T>
Face<T>::Face ( Vector3<T> normal ) 
    : m_iVertexList( NULL ), m_iNoVertices( 0 ),
      m_v3N( normal ), m_pt2DTexCoords( NULL ), m_iNo2DTexCoords( 0 )
{}
//-----------------------------------------------------------------------------
template <typename T>
Face<T>::Face ( int * vList, int n, Vector3<T> normal ) 
    : m_iNoVertices( n ), m_v3N( normal ),
      m_pt2DTexCoords( NULL ), m_iNo2DTexCoords( 0 )
{
    m_iVertexList = new int[n];
    if ( m_iVertexList == NULL )
    {
        std::cerr << "[MEMORY ALLOC ERR] In Class Face: Cannot create a vertex list!" 
                  << std::endl;
        exit(1);
    }
    for (int i = 0; i < n; ++i )
    {
        m_iVertexList[i] = vList[i];
    }

    #ifdef  TAPs_ENABLE_FACE_VERTEX_COLOR
        m_iVertexColorList = new int[n];
        if ( m_iVertexColorList == NULL )
        {
            std::cerr << "[MEMORY ALLOC ERR] In Class Face: Cannot create a vertex color list!" 
                    << std::endl;
            exit(1);
        }
    #endif//TAPs_ENABLE_FACE_VERTEX_COLOR

    #ifdef  TAPs_ENABLE_FACE_VERTEX_TEXTURE_COORDINATES
        m_iVertexTextureList = new int[n];
        if ( m_iVertexTextureList == NULL )
        {
            std::cerr << "[MEMORY ALLOC ERR] In Class Face: Cannot create a vertex texture coordinate list!" 
                    << std::endl;
            exit(1);
        }
    #endif//TAPs_ENABLE_FACE_VERTEX_TEXTURE_COORDINATES
}
//-----------------------------------------------------------------------------
template <typename T>
Face<T>::Face ( Face<T> const &f ) 
    : m_iNoVertices( f.m_iNoVertices ),
      m_v3N( normal ), 
      m_iNo2DTexCoords( f.m_iNo2DTexCoords )
{
    //----------------------------------------------------------------
    // Copy Vertex List (Loop)
    m_iVertexList = new int[m_iNoVertices];
    if ( m_iVertexList == NULL )
    {
        std::cerr << "[MEMORY ALLOC ERR] In Class Face: Cannot create a vertex list!" 
                  << std::endl;
        exit(1);
    }
    for (int i = 0; i < m_iNoVertices; ++i )
    {
        m_iVertexList[i] = f.m_iVertexList[i];
    }
    //----------------------------------------------------------------
    #ifdef  TAPs_ENABLE_FACE_VERTEX_COLOR
        // Copy Vertex Color list (Loop)
        m_iVertexColorList = new int[m_iNoVertices];
        if ( m_iVertexColorList == NULL )
        {
            std::cerr << "[MEMORY ALLOC ERR] In Class Face: Cannot create a vertex color list!" 
                    << std::endl;
            exit(1);
        }
        for (int i = 0; i < m_iNoVertices; ++i )
        {
            m_iVertexColorList[i] = f.m_iVertexColorList[i];
        }
    #endif//TAPs_ENABLE_FACE_VERTEX_COLOR
    //----------------------------------------------------------------
    #ifdef  TAPs_ENABLE_FACE_VERTEX_TEXTURE_COORDINATES
        // Copy Vertex Texture Coordinate list (Loop)
        m_iVertexTextureList = new int[m_iNoVertices];
        if ( m_iVertexTextureList == NULL )
        {
            std::cerr << "[MEMORY ALLOC ERR] In Class Face: Cannot create a vertex texture coordinate list!" 
                    << std::endl;
            exit(1);
        }
        for (int i = 0; i < m_iNoVertices; ++i )
        {
            m_iVertexTextureList[i] = f.m_iVertexTextureList[i];
        }
    #endif//TAPs_ENABLE_FACE_VERTEX_TEXTURE_COORDINATES
    //----------------------------------------------------------------
    // Copy Texture Coordinates
    m_pt2DTexCoords = new T[2*m_iNo2DTexCoords];
    if ( m_pt2DTexCoords == NULL )
    {
        std::cerr << "[MEMORY ALLOC ERR] In Class Face: Cannot create a texture coordinates!" 
                  << std::endl;
        exit(1);
    }
    for (int i = 0; i < 2*m_iNo2DTexCoords; ++i )
    {
        m_pt2DTexCoords[i] = f.m_pt2DTexCoords[i];
    }
}
//-----------------------------------------------------------------------------
template <typename T>
Face<T>::~Face ()
{
    // delete texture coordinates
    if ( m_pt2DTexCoords ) {
        delete [] m_pt2DTexCoords;
        m_pt2DTexCoords = NULL;
    }
    // delete vertex list
    if ( m_iVertexList ) {
        delete [] m_iVertexList;
        m_iVertexList = NULL;
    }

    #ifdef  TAPs_ENABLE_FACE_VERTEX_COLOR
        // delete vertex color list
        if ( m_iVertexColorList ) {
            delete [] m_iVertexColorList;
            m_iVertexColorList = NULL;
        }
    #endif//TAPs_ENABLE_FACE_VERTEX_COLOR

    #ifdef  TAPs_ENABLE_FACE_VERTEX_TEXTURE_COORDINATES
        // delete vertex texture coordinate list
        if ( m_iVertexTextureList ) {
            delete [] m_iVertexTextureList;
            m_iVertexTextureList = NULL;
        }
    #endif//TAPs_ENABLE_FACE_VERTEX_TEXTURE_COORDINATES
}
//-----------------------------------------------------------------------------
//=============================================================================
// Member Access for Vertex List
//-----------------------------------------------------------------------------
template <typename T>
inline int Face<T>::GetNoVertices () const
{   return m_iNoVertices;   }
//-----------------------------------------------------------------------------
template <typename T>
inline void Face<T>::SetNoVertices ( int n )
{   
    if ( m_iVertexList )    delete [] m_iVertexList;
    m_iVertexList = new int[n];
    m_iNoVertices = n;

    #ifdef  TAPs_ENABLE_FACE_VERTEX_COLOR
        if ( m_iVertexColorList )   delete [] m_iVertexColorList;
        m_iVertexColorList = new int[n];
    #endif//TAPs_ENABLE_FACE_VERTEX_COLOR

    #ifdef  TAPs_ENABLE_FACE_VERTEX_TEXTURE_COORDINATES
        if ( m_iVertexTextureList ) delete [] m_iVertexTextureList;
        m_iVertexTextureList = new int[n];
    #endif//TAPs_ENABLE_FACE_VERTEX_TEXTURE_COORDINATES
}
//-----------------------------------------------------------------------------
template <typename T>
inline int Face<T>::GetVertexNo ( int i ) const
{   
    assert( 0 <= i && i < m_iNoVertices );
    return m_iVertexList[i];
}
//-----------------------------------------------------------------------------
template <typename T>
inline void Face<T>::SetVertexNo ( int i, int vNo )
{   
    assert( 0 <= i && i < m_iNoVertices );
    m_iVertexList[i] = vNo;
}

#ifdef  TAPs_ENABLE_FACE_VERTEX_COLOR
    template <typename T>
    inline int  Face<T>::GetVertexColorNo( int i ) const
    {
        assert( 0 <= i && i < m_iNoVertices );
        return m_iVertexColorList[i];
    }

    template <typename T>
    inline void Face<T>::SetVertexColorNo( int i, int vNo )
    {
        assert( 0 <= i && i < m_iNoVertices );
        m_iVertexColorList[i] = vNo;
    }
#endif//TAPs_ENABLE_FACE_VERTEX_COLOR

#ifdef  TAPs_ENABLE_FACE_VERTEX_TEXTURE_COORDINATES
    template <typename T>
    inline int  Face<T>::GetVertexTextureNo( int i ) const
    {
        assert( 0 <= i && i < m_iNoVertices );
        return m_iVertexTextureList[i];
    }

    template <typename T>
    inline void Face<T>::SetVertexTextureNo( int i, int vNo )
    {
        assert( 0 <= i && i < m_iNoVertices );
        m_iVertexTextureList[i] = vNo;
    }
#endif//TAPs_ENABLE_FACE_VERTEX_TEXTURE_COORDINATES

//-----------------------------------------------------------------------------
//=============================================================================
// Member Access for Texture Coordinates
//-----------------------------------------------------------------------------
template <typename T>
inline int Face<T>::GetNoTexCoords () const
{   return m_iNo2DTexCoords;    }
//-----------------------------------------------------------------------------
template <typename T>
inline void Face<T>::SetNoTexCoords ( int n )
{   
    if ( m_pt2DTexCoords )  delete [] m_pt2DTexCoords;
    m_pt2DTexCoords = new T[2*n];
    m_iNo2DTexCoords = n;
}
//-----------------------------------------------------------------------------
template <typename T>
inline T Face<T>::GetTexCoordNoS ( int i ) const
{   
    assert( 0 <= i && i < m_iNo2DTexCoords );
    return m_pt2DTexCoords[i*2];
}
//-----------------------------------------------------------------------------
template <typename T>
inline T Face<T>::GetTexCoordNoT ( int i ) const
{   
    assert( 0 <= i && i < m_iNo2DTexCoords );
    return m_pt2DTexCoords[i*2 + 1];
}
//-----------------------------------------------------------------------------
template <typename T>
inline void Face<T>::GetTexCoordNoS ( int i, T &s ) const
{   
    assert( 0 <= i && i < m_iNo2DTexCoords );
    s = m_pt2DTexCoords[i*2];
}
//-----------------------------------------------------------------------------
template <typename T>
inline void Face<T>::GetTexCoordNoT ( int i, T &t ) const
{   
    assert( 0 <= i && i < m_iNo2DTexCoords );
    t = m_pt2DTexCoords[i*2 + 1];
}
//-----------------------------------------------------------------------------
template <typename T>
inline void Face<T>::SetTexCoordNoS ( int i, T s )
{   
    assert( 0 <= i && i < m_iNo2DTexCoords );
    m_pt2DTexCoords[i*2] = s;
}
//-----------------------------------------------------------------------------
template <typename T>
inline void Face<T>::SetTexCoordNoT ( int i, T t )
{   
    assert( 0 <= i && i < m_iNo2DTexCoords );
    m_pt2DTexCoords[i*2 + 1] = t;
}
//-----------------------------------------------------------------------------
template <typename T>
inline void Face<T>::GetTexCoordNo ( int i, T &s, T &t ) const
{   
    assert( 0 <= i && i < m_iNo2DTexCoords );
    s = m_pt2DTexCoords[i*2    ];
    t = m_pt2DTexCoords[i*2 + 1];
}
//-----------------------------------------------------------------------------
template <typename T>
inline void Face<T>::SetTexCoordNo ( int i, T s, T t )
{   
    assert( 0 <= i && i < m_iNo2DTexCoords );
    m_pt2DTexCoords[i*2    ] = s;
    m_pt2DTexCoords[i*2 + 1] = t;
}
//-----------------------------------------------------------------------------
template <typename T>
inline T Face<T>::GetTexCoordHalfNo ( int i ) const
{   
    assert( 0 <= i && i < m_iNo2DTexCoords*2 );
    return m_pt2DTexCoords[i];
}
//-----------------------------------------------------------------------------
template <typename T>
inline void Face<T>::GetTexCoordHalfNo ( int i, T &v ) const
{   
    assert( 0 <= i && i < m_iNo2DTexCoords*2 );
    v = m_pt2DTexCoords[i];
}
//-----------------------------------------------------------------------------
template <typename T>
inline void Face<T>::SetTexCoordHalfNo ( int i, T v )
{   
    assert( 0 <= i && i < m_iNo2DTexCoords*2 );
    m_pt2DTexCoords[i] = v;
}
//-----------------------------------------------------------------------------
//=============================================================================
// Assignment Operator
//-----------------------------------------------------------------------------
template <typename T>
inline Face<T> & Face<T>::operator= ( Face<T> const &f )
{   
    int *vertexList  = m_iVertexList;       // vertex list
    T   *texCoords   = m_pt2DTexCoords;     // texture coordinate list
    //----------------------------------------------------------------
    // Set vertex List (Loop)
    m_iVertexList = new int[f.m_iNoVertices];
    if ( m_iVertexList == NULL )
    {
        std::cerr << "[MEMORY ALLOC ERR] In Class Face: Cannot create a vertex list!" 
                  << std::endl;
        m_iVertexList = vertexList;
        exit(1);
    }
    for (int i = 0; i < f.m_iNoVertices; ++i )
    {
        m_iVertexList[i] = f.m_iVertexList[i];
    }
    //----------------------------------------------------------------
    // Set texture coordinates
    m_pt2DTexCoords = new T[2*f.m_iNo2DTexCoords];
    if ( m_pt2DTexCoords == NULL )
    {
        std::cerr << "[MEMORY ALLOC ERR] In Class Face: Cannot create a texture coordinates!" 
                  << std::endl;
        m_pt2DTexCoords = texCoords;
        exit(1);
    }
    for (int i = 0; i < 2*f.m_iNo2DTexCoords; ++i )
    {
        m_pt2DTexCoords[i] = f.m_pt2DTexCoords[i];
    }
    m_iNoVertices    = f.m_iNoVertices;     // number of vertices
    m_v3N            = f.m_v3N;             // normal vector
    m_iNo2DTexCoords = f.m_iNo2DTexCoords;  // number of texture coordinates
    return *this;
}
//-----------------------------------------------------------------------------
//=============================================================================
END_NAMESPACE_TAPs
//345678901234567890123456789012345678901234567890123456789012345678901234567890
//--+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8