XPolygonalModel< T > Class Template Reference

#include <TAPsXPolygonalModel.hpp>

Inheritance diagram for XPolygonalModel< T >:

[legend]

Collaboration diagram for XPolygonalModel< T >:

[legend]

List of all members.

Public Member Functions
virtual void	ApplyAndResetTransform ()
virtual void	CalAndSetNormals ()
void	DetermineAndSortRings ()
Face< T > *const	GetFaceList () const
virtual T	GetMaxHalfLength () const
XVertex< T > *const	GetVertexList () const
virtual void	Initialize ()
void	NewFaceListByNoFaces ()
void	NewVertexListByNoVertices ()
void	SetFaceList (Face< T > *p)
void	SetVertexList (XVertex< T > *p)
	XPolygonalModel ()
virtual	~XPolygonalModel ()
Protected Member Functions
virtual void	CalAndSetFaceNormalsNotNormalized ()
virtual void	CalAndSetVertexNormals ()
virtual void	CalBoundingAABB ()
virtual void	CalBoundingEllipsoid ()
virtual void	CalBoundingSphere ()
virtual void	DetermineFaceRings ()
virtual void	NormalizeFaceNormals ()
Protected Attributes
Face< T > *	m_prFace
XVertex< T > *	m_prXVertex
std::vector< int > *	m_pviVertexRing1List
Friends
std::ostream &	operator<< (std::ostream &output, XPolygonalModel< T > const &o)

---

Detailed Description

template<typename T>
class XPolygonalModel< T >

Definition at line 34 of file TAPsXPolygonalModel.hpp.

---

Constructor & Destructor Documentation

template<typename T>

BEGIN_NAMESPACE_TAPs__OpenGL XPolygonalModel< T >::XPolygonalModel

(

)

[inline]

Definition at line 21 of file TAPsXPolygonalModel.cpp.

    : OpenGLMeshModel<T>(),
      m_prXVertex( NULL ), m_prFace( NULL ), m_pviVertexRing1List( NULL )
{
    #ifdef  TAPs_DEBUG_MODE
    std::cout << "XPolygonalModel<" << typeid(T).name() << "> Constructor\n";
    #endif//TAPs_ENABLE_DEBUG
}

template<typename T>

XPolygonalModel< T >::~XPolygonalModel

(

)

[inline, virtual]

Definition at line 32 of file TAPsXPolygonalModel.cpp.

{
    if ( m_prXVertex != NULL ) {
        delete [] m_prXVertex;
        m_prXVertex = NULL;
    }
    if ( m_prFace != NULL ) {
        delete [] m_prFace;
        m_prFace = NULL;
    }
    if ( m_pviVertexRing1List != NULL ) {
        delete [] m_pviVertexRing1List;
        m_pviVertexRing1List = NULL;
    }

    #ifdef  TAPs_DEBUG_MODE
    std::cout << "XPolygonalModel<" << typeid(T).name() << "> Destructor\n";
    #endif//TAPs_ENABLE_DEBUG
}

---

Member Function Documentation

template<typename T>

void XPolygonalModel< T >::ApplyAndResetTransform

(

)

[inline, virtual]

First apply the transformation matrix (from TAPsTransformationSupport.hpp (has a)) to the model, then reset the transformation matrix. (Apply means permanently change the positions of the model's vertices, etc.)

Reimplemented from Model< T >.

Reimplemented in VolPresPolygonalModel< T >.

Definition at line 308 of file TAPsXPolygonalModel.cpp.

{
    for ( int i = 0; i < m_iNoVertices; ++i ) {
        m_prXVertex[i].SetPosition( 
            (     GetTransform().ReturnMatrixTransform() 
                * Vector4<T>( m_prXVertex[i].GetPosition() )
            ).GetVector3()
        );
    }


    /*
    int i;
    //--------------------------------------------------------------------
    Vector3<T> Center = GetTransform().GetTranslation();
    if ( Center[0] != Math<T>::ZERO ) {
        for ( i = 0; i < m_iNoVertices; ++i )
            m_prXVertex[i][0] += Center[0];
        GetTransform().SetTranslation( 0, Math<T>::ZERO );
    }
    if ( Center[1] != Math<T>::ZERO ) {
        for ( i = 0; i < m_iNoVertices; ++i )
            m_prXVertex[i][1] += Center[1];
        GetTransform().SetTranslation( 1, Math<T>::ZERO );
    }
    if ( Center[2] != Math<T>::ZERO ) {
        for ( i = 0; i < m_iNoVertices; ++i )
            m_prXVertex[i][2] += Center[2];
        GetTransform().SetTranslation( 2, Math<T>::ZERO );
    }
    //--------------------------------------------------------------------
    Vector3<T> Rotation = GetTransform().GetRotationAngles();
    if ( Rotation[0] != Math<T>::ZERO ) {
        T deg = static_cast<T>( Rotation[0] * Math<T>::PI / 180.0 );
        T c = Math<T>::Cos( deg );
        T s = Math<T>::Sin( deg );
        T tmpX;
        for ( i = 0; i < m_iNoVertices; ++i ) {
            tmpX = m_prXVertex[i][1]*c - m_prXVertex[i][2]*s;
            m_prXVertex[i][2] = m_prXVertex[i][1]*s + m_prXVertex[i][2]*c;
            m_prXVertex[i][1] = tmpX;
        }
        GetTransform().SetRotationAxisAngle( 0, Math<T>::ZERO );
    }
    if ( Rotation[1] != Math<T>::ZERO ) {
        T deg = static_cast<T>( Rotation[1] * Math<T>::PI / 180.0 );
        T c = Math<T>::Cos( deg );
        T s = Math<T>::Sin( deg );
        T tmpX;
        for ( i = 0; i < m_iNoVertices; ++i ) {
            tmpX = m_prXVertex[i][0]*c + m_prXVertex[i][2]*s;
            m_prXVertex[i][2] = -(m_prXVertex[i][0]*s) + m_prXVertex[i][2]*c;
            m_prXVertex[i][0] = tmpX;
        }
        GetTransform().SetRotationAxisAngle( 1, Math<T>::ZERO );
    }
    if ( Rotation[2] != Math<T>::ZERO ) {
        T deg = static_cast<T>( Rotation[2] * Math<T>::PI / 180.0 );
        T c = Math<T>::Cos( deg );
        T s = Math<T>::Sin( deg );
        T tmpX;
        for ( i = 0; i < m_iNoVertices; ++i ) {
            tmpX = m_prXVertex[i][0]*c - m_prXVertex[i][1]*s;
            m_prXVertex[i][1] = m_prXVertex[i][0]*s + m_prXVertex[i][1]*c;
            m_prXVertex[i][0] = tmpX;
        }
        GetTransform().SetRotationAxisAngle( 2, Math<T>::ZERO );
    }
    //--------------------------------------------------------------------
    Vector3<T> Scale = GetTransform().GetScale();
    for ( int d = 0; d < 3; ++d ) {
        if ( Scale[d] != Math<T>::ONE ) {
            for ( i = 0; i < m_iNoVertices; ++i )
                m_prXVertex[i][d] *= Scale[d];
            GetTransform().SetScale( d, Math<T>::ONE );
        }
    }
    //--------------------------------------------------------------------
    //*/

    //--------------------------------------------------------------------
    // Set Transformation to Identity Matrix
    GetTransform().MakeIdentity();
    //--------------------------------------------------------------------
    // Recalculate Bounding Volume(s)
    CalBoundingAABB();
    CalBoundingEllipsoid();
    CalBoundingSphere();
}

template<typename T>

void XPolygonalModel< T >::CalAndSetFaceNormalsNotNormalized

(

)

[inline, protected, virtual]

Definition at line 117 of file TAPsXPolygonalModel.cpp.

{
    // Calculate and set the normal of each face
    for ( int i = 0; i < m_iNoFaces; ++i ) {
        m_prFace[i].SetNormal(
              (   m_prXVertex[ m_prFace[i].GetVertexNo( 1 ) ].GetPosition() 
                - m_prXVertex[ m_prFace[i].GetVertexNo( 0 ) ].GetPosition() )
            ^ (   m_prXVertex[ m_prFace[i].GetVertexNo( 2 ) ].GetPosition() 
                - m_prXVertex[ m_prFace[i].GetVertexNo( 1 ) ].GetPosition() )
        );
    }
}

template<typename T>

void XPolygonalModel< T >::CalAndSetNormals

(

)

[inline, virtual]

Definition at line 107 of file TAPsXPolygonalModel.cpp.

{
    CalAndSetFaceNormalsNotNormalized();
    DetermineFaceRings();
    CalAndSetVertexNormals();
    NormalizeFaceNormals();
}

template<typename T>

void XPolygonalModel< T >::CalAndSetVertexNormals

(

)

[inline, protected, virtual]

Definition at line 164 of file TAPsXPolygonalModel.cpp.

{
    for ( int v = 0; v < m_iNoVertices; ++v ) {
        Vector3<T> vNormal;
        for ( int f = 0; f < static_cast<int>( m_prXVertex[v].GetFaceRing().size() ); ++f ) {
            vNormal += m_prFace[ m_prXVertex[v].GetFaceRing()[f] ].GetNormal();
        }
        m_prXVertex[v].SetNormal( vNormal.Normalized() );
    }
}

template<typename T>

void XPolygonalModel< T >::CalBoundingAABB

(

)

[inline, protected, virtual]

Reimplemented from ColDetSupport< T >.

Definition at line 405 of file TAPsXPolygonalModel.cpp.

{
    m_paBoundingAABB[0][0] = m_paBoundingAABB[1][0] = m_prXVertex[0][0];
    m_paBoundingAABB[0][1] = m_paBoundingAABB[1][1] = m_prXVertex[0][1];
    m_paBoundingAABB[0][2] = m_paBoundingAABB[1][2] = m_prXVertex[0][2];
    for ( int i = 1; i < m_iNoVertices; ++i )
    {
        // Find lowest x, y, and z
        if ( m_paBoundingAABB[0][0] > m_prXVertex[i][0] )
             m_paBoundingAABB[0][0] = m_prXVertex[i][0];
        if ( m_paBoundingAABB[0][1] > m_prXVertex[i][1] )
             m_paBoundingAABB[0][1] = m_prXVertex[i][1];
        if ( m_paBoundingAABB[0][2] > m_prXVertex[i][2] )
             m_paBoundingAABB[0][2] = m_prXVertex[i][2];
        // Find highest x, y, and z
        if ( m_paBoundingAABB[1][0] < m_prXVertex[i][0] )
             m_paBoundingAABB[1][0] = m_prXVertex[i][0];
        if ( m_paBoundingAABB[1][1] < m_prXVertex[i][1] )
             m_paBoundingAABB[1][1] = m_prXVertex[i][1];
        if ( m_paBoundingAABB[1][2] < m_prXVertex[i][2] )
             m_paBoundingAABB[1][2] = m_prXVertex[i][2];
    }
    // Find the bounding volume center
    m_pBoundingCenter[0] = ( m_paBoundingAABB[0][0] + m_paBoundingAABB[1][0] ) / 2.0;
    m_pBoundingCenter[1] = ( m_paBoundingAABB[0][1] + m_paBoundingAABB[1][1] ) / 2.0;
    m_pBoundingCenter[2] = ( m_paBoundingAABB[0][2] + m_paBoundingAABB[1][2] ) / 2.0;
}

template<typename T>

void XPolygonalModel< T >::CalBoundingEllipsoid

(

)

[inline, protected, virtual]

Reimplemented from ColDetSupport< T >.

Definition at line 434 of file TAPsXPolygonalModel.cpp.

{
    /*
    m_pBoundingCenter[0] = ( m_paBoundingAABB[0][0] + m_paBoundingAABB[1][0] ) / 2.0;
    m_pBoundingCenter[1] = ( m_paBoundingAABB[0][1] + m_paBoundingAABB[1][1] ) / 2.0;
    m_pBoundingCenter[2] = ( m_paBoundingAABB[0][2] + m_paBoundingAABB[1][2] ) / 2.0;
    m_pBoundingEllipsoid[0] = fabs( (m_paBoundingAABB[0][0] - m_paBoundingAABB[1][0])/2.0 );
    m_pBoundingEllipsoid[1] = fabs( (m_paBoundingAABB[0][1] - m_paBoundingAABB[1][1])/2.0 );
    m_pBoundingEllipsoid[2] = fabs( (m_paBoundingAABB[0][2] - m_paBoundingAABB[1][2])/2.0 );
    //*/

    /*
    T xLength = m_paBoundingAABB[0][0] - m_paBoundingAABB[1][0];
    T yLength = m_paBoundingAABB[0][1] - m_paBoundingAABB[1][1];
    T zLength = m_paBoundingAABB[0][2] - m_paBoundingAABB[1][2];
    xLength *= xLength;
    yLength *= yLength;
    zLength *= zLength;
    m_pBoundingEllipsoid[0] = sqrt( yLength + zLength ) / 2.0;
    m_pBoundingEllipsoid[1] = sqrt( zLength + xLength ) / 2.0;
    m_pBoundingEllipsoid[2] = sqrt( xLength + yLength ) / 2.0;
    //*/

    T x = m_paBoundingAABB[1][0] - m_pBoundingCenter[0];
    x *= x;
    T y = m_paBoundingAABB[1][1] - m_pBoundingCenter[1];
    y *= y;
    T z = m_paBoundingAABB[1][2] - m_pBoundingCenter[2];
    z *= z;
    m_pBoundingEllipsoid[1] = sqrt( y + z );
    m_pBoundingEllipsoid[2] = sqrt( z + x );
    m_pBoundingEllipsoid[0] = sqrt( x + y );
}

template<typename T>

void XPolygonalModel< T >::CalBoundingSphere

(

)

[inline, protected, virtual]

Reimplemented from ColDetSupport< T >.

Definition at line 469 of file TAPsXPolygonalModel.cpp.

{
    /*
    T xLength = m_paBoundingAABB[0][0] - m_paBoundingAABB[1][0];
    T yLength = m_paBoundingAABB[0][1] - m_paBoundingAABB[1][1];
    T zLength = m_paBoundingAABB[0][2] - m_paBoundingAABB[1][2];
    xLength *= xLength;
    yLength *= yLength;
    zLength *= zLength;
    m_pBoundingSphere = sqrt( xLength + yLength + zLength ) / 2.0;
    //*/
    T squaredLength;
    m_pBoundingSphere = 0;
    for ( int i = 0; i < m_iNoVertices; ++i ) {
        squaredLength = (m_prXVertex[i].GetPosition() - m_pBoundingCenter).SquaredLength();
        if ( squaredLength > m_pBoundingSphere )
            m_pBoundingSphere = squaredLength;
    }
    m_pBoundingSphere = sqrt( m_pBoundingSphere );
}

template<typename T>

void XPolygonalModel< T >::DetermineAndSortRings

(

)

[inline]

Definition at line 177 of file TAPsXPolygonalModel.cpp.

{
    #ifdef  TAPs_DEBUG_MODE_DETAIL_1
    std::cout << "Xpolygonal Model: Determine and sort the first rings" << std::endl;
    #endif//TAPs_DEBUG_MODE_DETAIL_1
    //----------------------------------------------------------------
    /*  CCW
             2 --------- 1
            / \         / \
           /   \  f_2  /   \
          /     \     /     \
         /  f_3  \   /  f_1  \
        /         \ /         \
       3 --------- V --------- 0
        \         / \         /
         \  f_4  /   \  f_0  /
          \     /     \     /
           \   /  f_5  \   /
            \ /         \ /
             4 --------- 5
    */
    //----------------------------------------------------------------
    DetermineFaceRings ();
    //----------------------------------------------------------------
    // Local Variables
    int v, f, i, t1, n, k;
    int vertexAt[128];
    Face<T> * face;
    int lastVertexNo;
    //----------------------------------------------------------------
    // For each vertex v
    m_pviVertexRing1List = new std::vector<int>[m_iNoVertices];
    for ( v = 0; v < m_iNoVertices; ++v ) {
        //============================================================
        // Find the vertex number in each face ring of this vertex
        //------------------------------------------------------------
        int size = static_cast<int>( m_prXVertex[v].GetFaceRing().size() );
        if ( size <= 0 ) {
            continue;   // skip this vertex if it doesn't have a face ring
        }
        int current = 0;
        int noOfVertices;
        // For each face f in the ring of the vertex v
        // find the number of this v vertex in it
        for ( f = 0; f < size; ++f ) {
            face = &m_prFace[ m_prXVertex[v].GetFaceRing()[f] ];
            noOfVertices = face->GetNoVertices();
            // Get the number of this v vertex in the f face
            // keep the info in vertexAt[f]
            for ( i = 0; i < noOfVertices; ++i ) {
                if ( v == face->GetVertexNo(i) ) {
                    vertexAt[f] = i;
                    break;
                }
            }
        }
        //------------------------------------------------------------
        //============================================================
        // Arrange the face and vertex rings of this vertex
        //------------------------------------------------------------
        //------------------------------------------------------------
        // Face 0
        f = 0;
        face = &m_prFace[ m_prXVertex[v].GetFaceRing()[f] ];
        lastVertexNo = -1;
        // Use the fact that the vertices are listed CCW
        for ( i = vertexAt[f]+1; i < face->GetNoVertices(); ++i ) {
                m_pviVertexRing1List[v].push_back( face->GetVertexNo(i) );
        }
        for ( i = 0; i < vertexAt[f]; ++i ) {
                m_pviVertexRing1List[v].push_back( face->GetVertexNo(i) );
        }
        lastVertexNo  = ( vertexAt[f]-1 < 0 
                        ? face->GetVertexNo( face->GetNoVertices()-1 ) 
                        : face->GetVertexNo( vertexAt[f]-1 ) );
        //------------------------------------------------------------
        // Face 1 to size-1
        int iFaceNo;
        for ( f = 1; f < size; ++f ) {
            // Use the fact that only the next face contains 
            // the last inserted vertex to find the next face
            i = f;
            bool search = true;
            while ( i < size && search ) {
                iFaceNo = m_prXVertex[v].GetFaceRing()[i];  // Face#
                face = &m_prFace[ iFaceNo ];            // Face

                for ( n = 0; n < face->GetNoVertices(); ++n ) {
                    if ( lastVertexNo == face->GetVertexNo(n) ) {
                        search = false;

                        // Swap (sort) the face
                        if ( f != i ) {
                            t1 = m_prXVertex[v].GetFaceRing()[f];
                            m_prXVertex[v].GetFaceRing()[f] = m_prXVertex[v].GetFaceRing()[i];
                            m_prXVertex[v].GetFaceRing()[i] = t1;
                            t1 = vertexAt[f];
                            vertexAt[f] = vertexAt[i];
                            vertexAt[i] = t1;
                        }

                        // Use the fact that the vertices are listed CCW
                        for ( k = vertexAt[f]+1; k < face->GetNoVertices(); ++k ) {
                            if ( face->GetVertexNo(k) != v && face->GetVertexNo(k) != lastVertexNo ) {
                                m_pviVertexRing1List[v].push_back( face->GetVertexNo(k) );
                            }
                        }
                        for ( k = 0; k < vertexAt[f]; ++k ) {
                            if ( face->GetVertexNo(k) != v && face->GetVertexNo(k) != lastVertexNo ) {
                                m_pviVertexRing1List[v].push_back( face->GetVertexNo(k) );
                            }
                        }
                        lastVertexNo  = ( vertexAt[f]-1 < 0 
                                        ? face->GetVertexNo( face->GetNoVertices()-1 ) 
                                        : face->GetVertexNo( vertexAt[f]-1 ) );
                        break;
                    }
                }
                ++i;
            }
        }
        m_pviVertexRing1List[v].pop_back();
        //------------------------------------------------------------
    }
}

template<typename T>

void XPolygonalModel< T >::DetermineFaceRings

(

)

[inline, protected, virtual]

Definition at line 142 of file TAPsXPolygonalModel.cpp.

{
    bool notYetStored;
    // Insert the faces contain each vertex
    for ( int f = 0; f < m_iNoFaces; ++f ) {
        for ( int v = 0; v < m_prFace[f].GetNoVertices(); ++v ) {
            notYetStored = true;
            for ( int i = 0; i < static_cast<int>(m_prXVertex[m_prFace[f].GetVertexNo(v)].GetFaceRing().size()); ++i ) {
                if ( m_prXVertex[m_prFace[f].GetVertexNo(v)].GetFaceRing()[i] == f ) {
                    notYetStored = false;
                    break;
                }
            }
            if ( notYetStored ) {
                m_prXVertex[m_prFace[f].GetVertexNo(v)].GetFaceRing().push_back( f );
            }
        }
    }
}

template<typename T>

Face<T>* const XPolygonalModel< T >::GetFaceList

(

)

const [inline]

Definition at line 112 of file TAPsXPolygonalModel.hpp.

{ return m_prFace; }

template<typename T>

T XPolygonalModel< T >::GetMaxHalfLength

(

)

const [inline, virtual]

Implements Model< T >.

Definition at line 90 of file TAPsXPolygonalModel.cpp.

{
    T maxHalfSize = 0.0;
    for ( int i = 0; i < m_iNoVertices; ++i )
    {
        if ( fabs( m_prXVertex[i][0] ) > maxHalfSize )
            maxHalfSize = fabs( m_prXVertex[i][0] );
        if ( fabs( m_prXVertex[i][1] ) > maxHalfSize )
            maxHalfSize = fabs( m_prXVertex[i][1] );
        if ( fabs( m_prXVertex[i][2] ) > maxHalfSize )
            maxHalfSize = fabs( m_prXVertex[i][2] );
    }
    return maxHalfSize;
}

template<typename T>

XVertex<T>* const XPolygonalModel< T >::GetVertexList

(

)

const [inline]

Definition at line 111 of file TAPsXPolygonalModel.hpp.

{ return m_prXVertex; }

template<typename T>

void XPolygonalModel< T >::Initialize

(

)

[inline, virtual]

Implements Model< T >.

Reimplemented in ExtendedOpenGLPNTriangleVolPresModel< T >, ExtendedOpenGLVolPresPolygonalModel< T >, OpenGLPNTriangleModel< T >, OpenGLPNTriangleVolPresModel< T >, VolPresPolygonalModel< T >, and VolPresTriModel< T >.

Definition at line 54 of file TAPsXPolygonalModel.cpp.

{
    // Model Initialization
    DetermineAndSortRings();
    //DetermineFaceRings ();
    CalAndSetNormals();
    // DetermineAndSortRings();
    ApplyMaterial( Enum::FRONT );
    //DetermineEdgeList();
    CalBoundingAABB();
    CalBoundingEllipsoid();
    CalBoundingSphere();
}

template<typename T>

void XPolygonalModel< T >::NewFaceListByNoFaces

(

)

[inline]

Definition at line 80 of file TAPsXPolygonalModel.cpp.

{
    if ( m_prFace != NULL ) {
        delete [] m_prFace;
    }
    m_prFace = new Face<T>[m_iNoFaces];
}

template<typename T>

void XPolygonalModel< T >::NewVertexListByNoVertices

(

)

[inline]

Definition at line 70 of file TAPsXPolygonalModel.cpp.

{
    if ( m_prXVertex != NULL ) {
        delete [] m_prXVertex;
    }
    m_prXVertex = new XVertex<T>[m_iNoVertices];
}

template<typename T>

void XPolygonalModel< T >::NormalizeFaceNormals

(

)

[inline, protected, virtual]

Definition at line 132 of file TAPsXPolygonalModel.cpp.

{
    for ( int i = 0; i < m_iNoFaces; ++i ) {
        const_cast< Vector3<T> * >( &m_prFace[i].GetNormal() )->Normalized();
        //m_prFace[i].GetNormal().Normalized();
    }
}

template<typename T>

void XPolygonalModel< T >::SetFaceList

(

Face< T > *

p

)

[inline]

Definition at line 114 of file TAPsXPolygonalModel.hpp.

{ m_prFace = p; }

template<typename T>

void XPolygonalModel< T >::SetVertexList

(

XVertex< T > *

p

)

[inline]

Definition at line 113 of file TAPsXPolygonalModel.hpp.

{ m_prXVertex = p; }

---

Friends And Related Function Documentation

template<typename T>

std::ostream& operator<<	(	std::ostream &	output,
		XPolygonalModel< T > const &	o
	)			[friend]

Definition at line 37 of file TAPsXPolygonalModel.hpp.

    {
        output  << "\n======================\n"
                <<   "TAPs::XPolygonalModel<"
                << typeid(T).name() << "> Class:\n"
                <<   "======================\n";
        //----------------------------------------------------------------
        // Vertices Node
        output  << "\n\nVertices " << o.m_iNoVertices << "\n{";
        for ( int i = 0; i < o.m_iNoVertices; ++i ) {
            output << "\n  #" << i << "\t" << o.m_prXVertex[i];
        }
        output  << "\n}";
        //----------------------------------------------------------------
        // Neighbor vertex ring#1
        if ( o.m_pviVertexRing1List ) {
            std::vector<int>::const_iterator iterator;
            output  << "\n\nVertexRing1 " << o.m_iNoVertices << "\n{";
            for ( int i = 0; i < o.m_iNoVertices; ++i ) {
                output << "\n  #" << i;
                for (   iterator = o.m_pviVertexRing1List[i].begin(); 
                        iterator != o.m_pviVertexRing1List[i].end();
                        ++iterator )
                {
                    output << "\t" << *iterator;
                }
            }
            output  << "\n}";
        }
        //----------------------------------------------------------------
        // Faces Node
        output  << "\n\nFaces " << o.m_iNoFaces  << "\n{";
        for ( int i = 0; i < o.m_iNoFaces; ++i ) {
            output << "\n  #" << i << "\t" << o.m_prFace[i];
        }
        output  << "\n}";
        return output;
    }

---

Member Data Documentation

template<typename T>

Face<T>* XPolygonalModel< T >::m_prFace [protected]

Definition at line 123 of file TAPsXPolygonalModel.hpp.

template<typename T>

XVertex<T>* XPolygonalModel< T >::m_prXVertex [protected]

Definition at line 122 of file TAPsXPolygonalModel.hpp.

template<typename T>

std::vector<int>* XPolygonalModel< T >::m_pviVertexRing1List [protected]

Definition at line 124 of file TAPsXPolygonalModel.hpp.

---

The documentation for this class was generated from the following files:

• G:/spunak_xp/Works/TAPs/Include/TAPs/OpenGLModel/TAPsXPolygonalModel.hpp
• G:/spunak_xp/Works/TAPs/Include/TAPs/OpenGLModel/TAPsXPolygonalModel.cpp