ReadObj< T > Class Template Reference

#include <TAPsReadObj.hpp>

List of all members.

Static Public Member Functions
static bool	ReadFile (const char *fileName, OpenGL::HalfEdgeModel< T > *const prModel)
static bool	ReadFile (const char *fileName, OpenGL::XPolygonalModel< T > *const prModel)
static bool	ReadFile (const char *fileName, OpenGL::PolygonalModel< T > *const prModel)
Static Private Member Functions
static void	ProcessLineFace_f (char *line, OpenGL::MeshModel< T > *const prModel)
static void	ProcessLineGroupName_g (char *line, OpenGL::MeshModel< T > *const prModel)
static void	ProcessLineMaterialLibrary_mtllib (char *line, OpenGL::MeshModel< T > *const prModel)
static void	ProcessLineObjectName_o (char *line, OpenGL::MeshModel< T > *const prModel)
static void	ProcessLineUseMaterialName_usemtl (char *line, OpenGL::MeshModel< T > *const prModel)
static void	ProcessLineVertexNormal_vn (char *line, OpenGL::MeshModel< T > *const prModel)
static void	ProcessLineVertexPosition_v (char *line, OpenGL::MeshModel< T > *const prModel)
static void	ProcessLineVertexTextureCoordinates_vt (char *line, OpenGL::MeshModel< T > *const prModel)
static bool	ReadDataFile (const char *fileName, OpenGL::MeshModel< T > *const prModel)
static void	SetModelProperties (OpenGL::MeshModel< T > *const prModel)
static void	SetupModel (OpenGL::HalfEdgeModel< T > *const prModel)
static void	SetupModel (OpenGL::XPolygonalModel< T > *const prModel)
static void	SetupModel (OpenGL::PolygonalModel< T > *const prModel)
Static Private Attributes
static int	faceNo = 0
static FILE *	fileIn = NULL
static MeshData< T >	meshData
static int	vertexNormalNo = 0
static int	vertexPositionNo = 0
static int	vertexTextureCoordNo = 0
Friends
class	ReadModels< T >

---

Detailed Description

template<typename T>
class ReadObj< T >

Definition at line 52 of file TAPsReadObj.hpp.

---

Member Function Documentation

template<typename T>

void ReadObj< T >::ProcessLineFace_f	(	char *	line,
		OpenGL::MeshModel< T > *const	prModel
	)			[inline, static, private]

Face (f) assigns a face.

A group composed of an index of vertex position, coordinates, and normal represent one vertex of the face.

There is no space between indices and slashes

Support format:

( v v ... )

( v/vt v/vt ... )

( v v ... )

( v//vn v//vn ... )

( v/vt/vn v/vt/vn ... )

Example (a tri face): f v_1/vt_1/vn_1 v_2/vt_2/vn_2 v_3/vt_3/vn_3

Definition at line 438 of file TAPsReadObj.cpp.

{
/*
    // DEBUG
    char debugLine[256];
    strcpy( debugLine, line );
//*/

    // Examples
    // f 111/49/111 110/129/110 109/102/109 108/30/108      (a quad)
    // f 15//15 16//16 8//8         (a triangle without vt)
    //---------------------------------------------------------------
    std::vector< int > idxV, idxVT, idxVN;
    //---------------------------------------------------------------
    char *delimSpaces = "\t \n";    // tab, space, new line
    char *token = NULL;
    char *vertexGroup = NULL;
    char *firstSlash  = NULL;
    char *secondSlash = NULL;
    int tokenLen = 0;
    int len = 0;
    char *end;
    int numberOfVertices = 0;
    //---------------------------------------------------------------
    token = strtok( line, delimSpaces );    // token is now 'f'
    token = strtok( '\0', delimSpaces );    // vertex properties (v/vt/vn)
    while ( token ) {
        tokenLen = static_cast<int>( strlen( token ) );
        //if ( tokenLen <= 0 )  return;
        //-------------------------------------------------
        // Check format:
        //   ( v       v       ... )
        //   ( v/vt    v/vt    ... )
        //   ( v//vn   v//vn   ... )
        //   ( v/vt/vn v/vt/vn ... )
        firstSlash = strchr( token, '/' );
        //---------------------------------------
        // Format: v v ...
        if ( firstSlash == NULL ) {
            idxVT.push_back( -1 );
            idxVN.push_back( -1 );
            idxV.push_back( static_cast<int>( strtol( token, &end, 10 ) ) - 1 );
        }
        //---------------------------------------
        // Format: v/vt v/vt ...
        else {
            secondSlash = strrchr( token, '/' );
            if ( secondSlash == firstSlash ) {
                idxVN.push_back( -1 );
                int i = 0;
                int n = 0;
                char vStr[16];
                //-----------------
                // v
                for ( ; n < firstSlash - token; ++i, ++n ) {
                    vStr[n] = token[i];
                }
                vStr[n] = '\0';     // null terminated
                idxV.push_back( static_cast<int>( strtol( vStr, &end, 10 ) ) - 1 );
                //-----------------
                // vt
                for ( ++i, n = 0; n < token + tokenLen - firstSlash; ++i, ++n ) {
                    vStr[n] = token[i];
                }
                vStr[n] = '\0';     // null terminated
                idxVT.push_back( static_cast<int>( strtol( vStr, &end, 10 ) ) - 1 );
            }
        //---------------------------------------
        // Format: v//vn v//vn ...
            else {
                len = secondSlash - firstSlash;
                if ( len == 1 ) {
                    idxVT.push_back( -1 );
                    int i = 0;
                    int n = 0;
                    char vStr[16];
                    //-----------------
                    // v
                    for ( ; n < firstSlash - token; ++i, ++n ) {
                        vStr[n] = token[i];
                    }
                    vStr[n] = '\0';     // null terminated
                    idxV.push_back( static_cast<int>( strtol( vStr, &end, 10 ) ) - 1 );
                    //-----------------
                    // vn
                    for ( i+=2, n = 0; n < token + tokenLen - secondSlash; ++i, ++n ) {
                        vStr[n] = token[i];
                    }
                    vStr[n] = '\0';     // null terminated
                    idxVN.push_back( static_cast<int>( strtol( vStr, &end, 10 ) ) - 1 );
                }
        //---------------------------------------
        // Format: v/vt/vn v/vt/vn ...
                else {
                    int i = 0;
                    int n = 0;
                    char vStr[16];
                    //-----------------
                    // v
                    for ( ; n < firstSlash - token; ++i, ++n ) {
                        vStr[n] = token[i];
                    }
                    vStr[n] = '\0';     // null terminated
                    idxV.push_back( static_cast<int>( strtol( vStr, &end, 10 ) ) - 1 );
                    //-----------------
                    // vt
                    for ( ++i, n = 0; n < secondSlash - firstSlash - 1; ++i, ++n ) {
                        vStr[n] = token[i];
                    }
                    vStr[n] = '\0';     // null terminated
                    idxVT.push_back( static_cast<int>( strtol( vStr, &end, 10 ) ) - 1 );
                    //-----------------
                    // vn
                    for ( ++i, n = 0; n < token + tokenLen - secondSlash; ++i, ++n ) {
                        vStr[n] = token[i];
                    }
                    vStr[n] = '\0';     // null terminated
                    idxVN.push_back( static_cast<int>( strtol( vStr, &end, 10 ) ) - 1 );
                }
            }
        }
        //-------------------------------------------------
        ++numberOfVertices;
        token = strtok( '\0', delimSpaces );    // vertex properties (v/vt/vn)
        //token = strtok( line, delimSpaces );  // vertex properties (v/vt/vn)
    }
    //---------------------------------------------------------------
    Face<T> * face = new Face<T>();
    //-----------------------------------------------------
    // Vertices of Face
/*
#ifdef DEBUG_MESSAGE_TAPS_READ_OBJ_HPP
    std::cout << "Face: Number of vertices: " << numberOfVertices << "\n";
#endif
//*/

/*
#ifdef DEBUG_MESSAGE_TAPS_READ_OBJ_HPP
    char buf[32];
    std::string str = "f";
    for ( int i = 0; i < numberOfVertices; ++i ) {
        itoa( idxV[i] + 1, buf, 10 );
        str = str + " " + buf;
        if ( idxVT[0] != -1 ) {
            itoa( idxVT[i] + 1, buf, 10 );
            str = str + "/" + buf;
            if ( idxVN[0] != -1 ) {
                itoa( idxVN[i] + 1, buf, 10 );
                str = str + "/" + buf;
            }
        }
        else {
            if ( idxVN[0] != -1 ) {
                itoa( idxVN[i] + 1, buf, 10 );
                str = str + "//" + buf;
            }
        }
    }
    if ( strncmp( debugLine, str.c_str(), strlen( str.c_str() ) ) != 0 ) {
        std::cout << "Different!\n";
        std::cout << debugLine;
        std::cout << str << "\n";
        std::cout << "Ori Len: " << static_cast<int>( strlen( debugLine ) ) << "\n";
        std::cout << "Str Len: " << static_cast<int>( strlen( str.c_str() ) ) << "\n";
        std::cout << "\n";
    }
#endif
//*/

    face->SetNoVertices( numberOfVertices );
    for ( int i = 0; i < numberOfVertices; ++i )
        face->SetVertexNo( i, idxV[i] );
    //-----------------------------------------------------
    // Normals of Vertices of Face
    if ( idxVN[ 0 ] != -1 ) {
        for ( int i = 0; i < numberOfVertices; ++i )
            meshData.VertexList[ face->GetVertexNo( i ) ]->SetNormal( meshData.NormalList[ idxVN[i] ] );
    }
    //-----------------------------------------------------
    // Texture Coordinates of Vertices of Face
    if ( idxVT[ 0 ] != -1 ) {
        face->SetNoTexCoords( numberOfVertices );
        T s, t;
        for ( int i = 0; i < numberOfVertices; ++i ) {
            meshData.TextureCoor2DList[idxVT[i]].GetXY( s, t );
            face->SetTexCoordNo( i, s, t );
        }
    }
    //-----------------------------------------------------
    meshData.FaceList.push_back( face );
    //---------------------------------------------------------------
/*
#ifdef DEBUG_MESSAGE_TAPS_READ_OBJ_HPP
    std::cout << "Face# " << faceNo << ":\t" << *face << "\n";
#endif
//*/
    ++faceNo;
}

template<typename T>

void ReadObj< T >::ProcessLineGroupName_g	(	char *	line,
		OpenGL::MeshModel< T > *const	prModel
	)			[inline, static, private]

Group name (g) assigns a name to the elements that follow it.

Multiple group names are allowed.

If there are multiple groups, the elemetns that follows belong to all groups.

Example: g group_name1 group_name2 ...

Definition at line 346 of file TAPsReadObj.cpp.

{
    // ???
}

template<typename T>

void ReadObj< T >::ProcessLineMaterialLibrary_mtllib	(	char *	line,
		OpenGL::MeshModel< T > *const	prModel
	)			[inline, static, private]

Material library (mtllib) specifies the material library file to be searched for a material name.

Multiple filenames can be used with the material library statement.

Example: mtllib mat_lib_file1 mat_lib_file2 ...

Definition at line 354 of file TAPsReadObj.cpp.

{
    // ???
}

template<typename T>

void ReadObj< T >::ProcessLineObjectName_o	(	char *	line,
		OpenGL::MeshModel< T > *const	prModel
	)			[inline, static, private]

Object name (o) assigns a name to an entire object in a single file.

Example: o object_name

Definition at line 338 of file TAPsReadObj.cpp.

{
    // ???
}

template<typename T>

void ReadObj< T >::ProcessLineUseMaterialName_usemtl	(	char *	line,
		OpenGL::MeshModel< T > *const	prModel
	)			[inline, static, private]

Use material name (usemtl) specifies the material name for the elements that follow it.

If a material name is not specified, a default material or default model color is used.

Example: usemtl material_name

Definition at line 362 of file TAPsReadObj.cpp.

{
    // ???
}

template<typename T>

void ReadObj< T >::ProcessLineVertexNormal_vn	(	char *	line,
		OpenGL::MeshModel< T > *const	prModel
	)			[inline, static, private]

Vertex Normal (vn) assigns normal of a vertex.

Example: vn i j k

Definition at line 416 of file TAPsReadObj.cpp.

{
    // Example
    // vn 0.855148 0.250195 -0.454009
    float i, j, k;
    char acNode[4];
    sscanf( line, "%s %f %f %f", acNode, &i, &j, &k );
    meshData.NormalList.push_back( Vector3<T>( i, j, k ) );
    //---------------------------------------------------------------
/*
#ifdef DEBUG_MESSAGE_TAPS_READ_OBJ_HPP
    std::cout << "Normal# " << vertexNormalNo << ":\t" << i << "\t" << j << "\t" << k << "\n";
#endif
//*/
    ++vertexNormalNo;
}

template<typename T>

void ReadObj< T >::ProcessLineVertexPosition_v	(	char *	line,
		OpenGL::MeshModel< T > *const	prModel
	)			[inline, static, private]

Vertex Position (v) assigns a position of the vertex.

Currently support only x, y, and z components and ignore w component.

Example: v x y z w

Definition at line 372 of file TAPsReadObj.cpp.

{
    // Example
    // v 0.279370 157.247177 -5.951185
    float x, y, z;
    char acNode[4];
    sscanf( line, "%s %f %f %f", acNode, &x, &y, &z );
    meshData.VertexList.push_back( new Vertex<T>( x, y, z ) );
    //---------------------------------------------------------------
/*
#ifdef DEBUG_MESSAGE_TAPS_READ_OBJ_HPP
    std::cout << "Position# " << vertexPositionNo << ":\t" << x << "\t" << y << "\t" << z << "\n";
#endif
//*/
    ++vertexPositionNo;
}

template<typename T>

void ReadObj< T >::ProcessLineVertexTextureCoordinates_vt	(	char *	line,
		OpenGL::MeshModel< T > *const	prModel
	)			[inline, static, private]

Vertex Texture Coordinates (vt) assigns texture coordinates of a vertex.

Currently support only s and t and ignore p and q components.

Example: vt s t p q

Definition at line 394 of file TAPsReadObj.cpp.

{
    // Example
    // vt 0.2 0.5
    float s, t;
    char acNode[4];
    sscanf( line, "%vt %f %f", acNode, &s, &t );
    meshData.TextureCoor2DList.push_back( Vector2<T>( s, t ) );
    //---------------------------------------------------------------
/*
#ifdef DEBUG_MESSAGE_TAPS_READ_OBJ_HPP
    std::cout << "TextureCoord# " << vertexTextureCoordNo << ":\t" << s << "\t" << t << "\n";
#endif
//*/
    ++vertexTextureCoordNo;
}

template<typename T>

bool ReadObj< T >::ReadDataFile	(	const char *	fileName,
		OpenGL::MeshModel< T > *const	prModel
	)			[inline, static, private]

Set Model Properties

E.g. its numbers of vertices and faces.

Definition at line 77 of file TAPsReadObj.cpp.

{
    //---------------------------------------------------------------
    // Open the input file

    std::cout << "Open the input file: " << fileName << std::endl;

    fileIn = fopen( fileName, "r" );
    if ( !fileIn ) {
        #ifdef DEBUG_MESSAGE_TAPS_READ_OBJ_HPP
        std::perror( fileName );
        #endif
        return false;
    }
    //---------------------------------------------------------------
#ifdef DEBUG_MESSAGE_TAPS_READ_OBJ_HPP
    std::cout << "START READING " << fileName << "\n";
#endif
    //---------------------------------------------------------------
    // Initialization
    faceNo                  = 0;
    vertexPositionNo        = 0;
    vertexTextureCoordNo    = 0;
    vertexNormalNo          = 0;
    meshData.ClearAll();
    //---------------------------------------------------------------
    // Read in each line, check what its contents are, 
    // and pass it out to the relevant decoder function
    char line[256];
    fgets( line, 256, fileIn );
    do {
        #ifdef DEBUG_MESSAGE_TAPS_READ_OBJ_HPP
        //std::cout << "I/P Line: " << line;
        #endif
        //-------------------------------------------------
        // Vertex Normal
        if      ( !strncmp( line, "vn", strlen( "vn" ) ) )
            ProcessLineVertexNormal_vn( line, prModel );
        //-------------------------------------------------
        // Vertex Texture Coordinates
        else if ( !strncmp( line, "vt", strlen( "vt" ) ) )
            ProcessLineVertexTextureCoordinates_vt( line, prModel );
        //-------------------------------------------------
        // Vertex Position
        else if ( !strncmp( line, "v", strlen( "v" ) ) )
            ProcessLineVertexPosition_v( line, prModel );
        //-------------------------------------------------
        // Face
        else if ( !strncmp( line, "f", strlen( "f" ) ) )
            ProcessLineFace_f( line, prModel );
        //-------------------------------------------------
        // Group Name
        else if ( !strncmp( line, "g", strlen( "g" ) ) )
            ProcessLineGroupName_g( line, prModel );
        //-------------------------------------------------
        // Use Material Name
        else if ( !strncmp( line, "usemtl", strlen( "usemtl" ) ) )
            ProcessLineUseMaterialName_usemtl( line, prModel );
        //-------------------------------------------------
        // Use Material Name
        else if ( !strncmp( line, "mtllib", strlen( "mtllib" ) ) )
            ProcessLineMaterialLibrary_mtllib( line, prModel );
        //-------------------------------------------------
        // Object Name
        else if ( !strncmp( line, "o", strlen( "o" ) ) )
            ProcessLineObjectName_o( line, prModel );
        //-------------------------------------------------
        fgets( line, 256, fileIn );
    } while ( !feof( fileIn ) );
    //---------------------------------------------------------------
    fclose( fileIn );   // close the input file
#ifdef DEBUG_MESSAGE_TAPS_READ_OBJ_HPP
    std::cout << "END READING " << fileName << "\n";
#endif
    return true;
}

template<typename T>

bool ReadObj< T >::ReadFile	(	const char *	fileName,
		OpenGL::HalfEdgeModel< T > *const	prModel
	)			[inline, static]

Definition at line 61 of file TAPsReadObj.cpp.

{
    if ( !ReadDataFile( fileName, prModel ) )   return false;
    //---------------------------------------------------------------
    SetupModel( prModel );
    prModel->GetMaterial()->ApplyMaterial();
    //---------------------------------------------------------------
    meshData.ClearAll();
    return true;
}

template<typename T>

bool ReadObj< T >::ReadFile	(	const char *	fileName,
		OpenGL::XPolygonalModel< T > *const	prModel
	)			[inline, static]

Definition at line 47 of file TAPsReadObj.cpp.

{
    if ( !ReadDataFile( fileName, prModel ) )   return false;
    //---------------------------------------------------------------
    SetupModel( prModel );
    prModel->GetMaterial()->ApplyMaterial();
    //---------------------------------------------------------------
    meshData.ClearAll();
    return true;
}

template<typename T>

bool ReadObj< T >::ReadFile	(	const char *	fileName,
		OpenGL::PolygonalModel< T > *const	prModel
	)			[inline, static]

Definition at line 33 of file TAPsReadObj.cpp.

{
    if ( !ReadDataFile( fileName, prModel ) )   return false;
    //---------------------------------------------------------------
    SetupModel( prModel );
    prModel->GetMaterial()->ApplyMaterial();
    //---------------------------------------------------------------
    meshData.ClearAll();
    return true;
}

template<typename T>

void ReadObj< T >::SetModelProperties

(

OpenGL::MeshModel< T > *const

prModel

)

[inline, static, private]

Definition at line 157 of file TAPsReadObj.cpp.

{
    prModel->SetNumVertices( static_cast<int>( meshData.VertexList.size() ) );
    prModel->SetNumFaces( static_cast<int>( meshData.FaceList.size() ) );

#ifdef DEBUG_MESSAGE_TAPS_READ_OBJ_HPP
    std::cout << "Number of Vertices: " << prModel->GetNumVertices() << "\n";
    std::cout << "Number of Faces:    " << prModel->GetNumFaces() << "\n";
#endif
}

template<typename T>

void ReadObj< T >::SetupModel

(

OpenGL::HalfEdgeModel< T > *const

prModel

)

[inline, static, private]

Definition at line 228 of file TAPsReadObj.cpp.

{
    SetModelProperties( prModel );
    //---------------------------------------------------------------
    int iNumVertices = prModel->GetNumVertices();
    // Allocate memory for vertices
    HelpCreateHalfEdgeModel<T>::vertexList = 
        new HEVertex<T>*[ iNumVertices ];
    HelpCreateHalfEdgeModel<T>::vertexRingList = 
        new DS::HashTableBySTLVector<int>( iNumVertices );
    HelpCreateHalfEdgeModel<T>::halfEdgeRingList = 
        new DS::HashTableBySTLVector< HEHalfEdge<T> * >( iNumVertices );
    //---------------------------------------------------------------
    // For Each Vertex
    for ( int i = 0; i < iNumVertices; ++i ) {
        // Put created vertex in vertexList for look up later
        HelpCreateHalfEdgeModel<T>::vertexList[ i ] = 
            new HEVertex<T>( 
                meshData.VertexList[ i ]->GetPosition(), 
                meshData.VertexList[ i ]->GetNormal()
            #ifdef  TAPs_USE_DATA_POOL
                , prModel->GetArrayOfVertexPositions().GetAddressOfDataNumber( i )
                , prModel->GetArrayOfVertexNormals().GetAddressOfDataNumber( i )
            #endif//TAPs_USE_DATA_POOL
            );
        // Put created vertex in vertexList of the model
        prModel->GetVertexList()->Append( 
            HelpCreateHalfEdgeModel<T>::vertexList[ i ] );
    }
    //---------------------------------------------------------------
    // For Each Face
    for ( int i = 0; i < prModel->GetNumFaces(); ++i ) {
        //-------------------------------------------------
        HEFace<T> * heFace = new HEFace<T>();
        prModel->GetFaceList()->Append( heFace );
        std::vector< HEHalfEdge<T> * > heHalfEdge;
        int v = 0;
            //-----------------------------------
            // (CCW) Record v0 to v1, v1 to v2, ... in vertexRingList
            // put v1 in bucket v0
            HelpCreateHalfEdgeModel<T>::vertexRingList->Insert( 
                meshData.FaceList[i]->GetVertexNo( 1 ), 
                meshData.FaceList[i]->GetVertexNo( 0 ) );
            //-----------------------------------
            // Create and Set half-edge
            heHalfEdge.push_back( HelpCreateHalfEdgeModel<T>::CreateHalfEdgeFrom( 
                HelpCreateHalfEdgeModel<T>::vertexList[ meshData.FaceList[i]->GetVertexNo( 0 ) ], 
                HelpCreateHalfEdgeModel<T>::vertexList[ meshData.FaceList[i]->GetVertexNo( 1 ) ], 
                heFace ) );
            //-----------------------------------
            // Record half-edges in halfEdgeRingList
            HelpCreateHalfEdgeModel<T>::halfEdgeRingList->Insert( 
                heHalfEdge[0], meshData.FaceList[i]->GetVertexNo( 0 ) );    // put in bucket v0
            //-----------------------------------
            // Set incident half-edge of this face
            heFace->IncidentHalfEdge( heHalfEdge[ 0 ] );
            //-----------------------------------
        for ( v = 1; v < meshData.FaceList[i]->GetNumVertices() - 1; ++v ) {
            //-----------------------------------
            // put v+1 in bucket v
            HelpCreateHalfEdgeModel<T>::vertexRingList->Insert( 
                meshData.FaceList[i]->GetVertexNo( v+1 ), 
                meshData.FaceList[i]->GetVertexNo( v ) );
            //-----------------------------------
            // Create and Set half-edge
            heHalfEdge.push_back( HelpCreateHalfEdgeModel<T>::CreateHalfEdgeFrom( 
                HelpCreateHalfEdgeModel<T>::vertexList[ meshData.FaceList[i]->GetVertexNo( v ) ], 
                HelpCreateHalfEdgeModel<T>::vertexList[ meshData.FaceList[i]->GetVertexNo( v+1 ) ], 
                heFace, heHalfEdge[ v-1 ] ) );                  // w/ prev ptr
            //-----------------------------------
            // Record half-edges in halfEdgeRingList
            HelpCreateHalfEdgeModel<T>::halfEdgeRingList->Insert( 
                heHalfEdge[v], meshData.FaceList[i]->GetVertexNo( v ) );    // put in bucket v
        }
            //-----------------------------------
            // put v0 in bucket v
            HelpCreateHalfEdgeModel<T>::vertexRingList->Insert( 
                meshData.FaceList[i]->GetVertexNo( 0 ), 
                meshData.FaceList[i]->GetVertexNo( v ) );
            //-----------------------------------
            // Create and Set half-edge
            heHalfEdge.push_back( HelpCreateHalfEdgeModel<T>::CreateHalfEdgeFrom( 
                HelpCreateHalfEdgeModel<T>::vertexList[ meshData.FaceList[i]->GetVertexNo( v ) ], 
                HelpCreateHalfEdgeModel<T>::vertexList[ meshData.FaceList[i]->GetVertexNo( 0 ) ], 
                heFace, heHalfEdge[ v-1 ], heHalfEdge[ 0 ] ) ); // w/ prev and next ptrs
            //-----------------------------------
            // Record half-edges in halfEdgeRingList
            HelpCreateHalfEdgeModel<T>::halfEdgeRingList->Insert( 
                heHalfEdge[v], meshData.FaceList[i]->GetVertexNo( v ) );    // put in bucket v0
            //-----------------------------------
            // (CCW) Record v0 to v1, v1 to v2, and v2 to v0 in vertexRingList
//          HelpCreateHalfEdgeModel<T>::vertexRingList->Insert( v1, v0 );   // put v1 in bucket v0
//          HelpCreateHalfEdgeModel<T>::vertexRingList->Insert( v2, v1 );   // put v2 in bucket v1
//          HelpCreateHalfEdgeModel<T>::vertexRingList->Insert( v0, v2 );   // put v0 in bucket v2
            //-----------------------------------
            // Record half-edges in halfEdgeRingList
//          HelpCreateHalfEdgeModel<T>::halfEdgeRingList->Insert( heHalfEdge0, v0 );    // put in bucket v0
//          HelpCreateHalfEdgeModel<T>::halfEdgeRingList->Insert( heHalfEdge1, v1 );    // put in bucket v1
//          HelpCreateHalfEdgeModel<T>::halfEdgeRingList->Insert( heHalfEdge2, v2 );    // put in bucket v2
    }
    //---------------------------------------------------------------
    //---------------------------------------------------------------
    HelpCreateHalfEdgeModel<T>::CreateHalfEdgeModel( prModel );
    //*/
}

template<typename T>

void ReadObj< T >::SetupModel

(

OpenGL::XPolygonalModel< T > *const

prModel

)

[inline, static, private]

Definition at line 200 of file TAPsReadObj.cpp.

{
    SetModelProperties( prModel );
    prModel->NewVertexListByNoVertices();
    prModel->NewFaceListByNoFaces();
    for ( int i = 0; i < prModel->GetNumVertices(); ++i ) {
        prModel->GetVertexList()[i].SetPosition( meshData.VertexList[i]->GetPosition() );
        prModel->GetVertexList()[i].SetNormal( meshData.VertexList[i]->GetNormal() );
    }
    for ( int i = 0; i < prModel->GetNumFaces(); ++i ) {
        prModel->GetFaceList()[i] = *meshData.FaceList[i];
    }
/*
#ifdef DEBUG_MESSAGE_TAPS_READ_OBJ_HPP
    std::cout << "Number of Vertices: " << prModel->GetNumVertices() << "\n";
    for ( int i = 0; i < prModel->GetNumVertices(); ++i ) {
        std::cout << "Vertex# " << prModel->GetVertexList()[i] << "\n";
    }
    std::cout << "Number of Faces:    " << prModel->GetNumFaces() << "\n";
    for ( int i = 0; i < prModel->GetNumFaces(); ++i ) {
        std::cout << "Vertex# " << prModel->GetFaceList()[i] << "\n";
    }
#endif
//*/
}

template<typename T>

void ReadObj< T >::SetupModel

(

OpenGL::PolygonalModel< T > *const

prModel

)

[inline, static, private]

Definition at line 172 of file TAPsReadObj.cpp.

{
    SetModelProperties( prModel );
    prModel->NewVertexListByNoVertices();
    prModel->NewFaceListByNoFaces();
    for ( int i = 0; i < prModel->GetNumVertices(); ++i ) {
        prModel->GetVertexList()[i].SetPosition( meshData.VertexList[i]->GetPosition() );
        prModel->GetVertexList()[i].SetNormal( meshData.VertexList[i]->GetNormal() );
    }
    for ( int i = 0; i < prModel->GetNumFaces(); ++i ) {
        prModel->GetFaceList()[i] = *meshData.FaceList[i];
    }
/*
#ifdef DEBUG_MESSAGE_TAPS_READ_OBJ_HPP
    std::cout << "Number of Vertices: " << prModel->GetNumVertices() << "\n";
    for ( int i = 0; i < prModel->GetNumVertices(); ++i ) {
        std::cout << "Vertex# " << prModel->GetVertexList()[i] << "\n";
    }
    std::cout << "Number of Faces:    " << prModel->GetNumFaces() << "\n";
    for ( int i = 0; i < prModel->GetNumFaces(); ++i ) {
        std::cout << "Vertex# " << prModel->GetFaceList()[i] << "\n";
    }
#endif
//*/
}

---

Friends And Related Function Documentation

template<typename T>

friend class ReadModels< T > [friend]

Definition at line 53 of file TAPsReadObj.hpp.

---

Member Data Documentation

template<typename T>

int ReadObj< T >::faceNo = 0 [inline, static, private]

Definition at line 193 of file TAPsReadObj.hpp.

template<typename T>

BEGIN_NAMESPACE_TAPs FILE * ReadObj< T >::fileIn = NULL [inline, static, private]

Definition at line 192 of file TAPsReadObj.hpp.

template<typename T>

MeshData< T > ReadObj< T >::meshData [inline, static, private]

Definition at line 197 of file TAPsReadObj.hpp.

template<typename T>

int ReadObj< T >::vertexNormalNo = 0 [inline, static, private]

Definition at line 196 of file TAPsReadObj.hpp.

template<typename T>

int ReadObj< T >::vertexPositionNo = 0 [inline, static, private]

Definition at line 194 of file TAPsReadObj.hpp.

template<typename T>

int ReadObj< T >::vertexTextureCoordNo = 0 [inline, static, private]

Definition at line 195 of file TAPsReadObj.hpp.

---

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

• G:/spunak_xp/Works/TAPs/Include/TAPs/OpenGLModelFromFile/TAPsReadObj.hpp
• G:/spunak_xp/Works/TAPs/Include/TAPs/OpenGLModelFromFile/TAPsReadObj.cpp