TAPsRead3dsMaxASC.cpp

Go to the documentation of this file.

/******************************************************************************
TAPsRead3dsMaxASC.cpp

Create an OpenGLModel from a 3dsMax .ASC format file.

SUKITTI PUNAK   (11/11/2004)
UPDATE          (08/28/2005)
******************************************************************************/
#include "TAPsRead3dsMaxASC.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.

//-----------------------------------------------------------------------------
// DEBUG ENABLE
#ifdef TAPs_DEBUG_MODE
    #define DEBUG_MESSAGE_TAPs_READ_3DSMAX_ASC_HPP
#endif

BEGIN_NAMESPACE_TAPs
//=============================================================================
template <typename T>   FILE * Read3dsMaxASC<T>::fileIn = NULL;
template <typename T>   int Read3dsMaxASC<T>::faceNo = 0;
template <typename T>   int Read3dsMaxASC<T>::vertexNo = 0;
//=============================================================================
//-----------------------------------------------------------------------------
// Read the model from the input file
template <typename T>
bool Read3dsMaxASC<T>::readFile( 
        const char *fileName, OpenGL::PolygonalModel<T> * const prModel )
{
    // Open the input file
    fileIn = fopen( fileName, "r" );
    if ( !fileIn ) {
        #ifdef DEBUG_MESSAGE_TAPs_READ_3DSMAX_ASC_HPP
        std::perror( fileName );
        #endif
        return false;
    }
    //----------------------------------------------------------------
    // Initialization
    faceNo   = 0;
    vertexNo = 0;
    //----------------------------------------------------------------
    // Read in each line, check what its contents are, 
    // and pass it out to the relevant decoder function
    const char * const ALC = "Ambient light color";
    const char * const NO  = "Named object: ";
    const char * const VL  = "Vertex list";
    const char * const FL  = "Face list";
    const char * const TM  = "Tri-mesh";
    const char * const V   = "Vertex ";
    const char * const F   = "Face ";
    
    char line[256];
    while ( !feof( fileIn ) ) {
        fgets( line, 256, fileIn );
        if ( !strncmp( line, ALC, strlen( ALC ) ) )
            ProcessAmbientLight( line, prModel );
        else if ( !strncmp( line, NO, strlen( NO ) ) )
            ProcessNamedObject( line, prModel );
        else if ( !strncmp( line, VL, strlen( VL ) ) )
            ;
        else if ( !strncmp( line, FL, strlen( FL ) ) )
            ;
        else if ( !strncmp( line, TM, strlen( TM ) ) )
            ProcessTriMesh( line, prModel );
        else if ( !strncmp( line, V, strlen( V ) ) )
            ProcessVertex( line, prModel );
        else if ( !strncmp( line, F, strlen( F ) ) )
            ProcessFace( line, prModel );
    }
    fclose( fileIn );   // close the input file
    prModel->GetMaterial()->ApplyMaterial();
    return true;
}
//-----------------------------------------------------------------------------
// Read the model from the input file
template <typename T>
bool Read3dsMaxASC<T>::readFile( 
        const char *fileName, OpenGL::XPolygonalModel<T> * const prModel )
{
    // Open the input file
    fileIn = fopen( fileName, "r" );
    if ( !fileIn ) {
        #ifdef DEBUG_MESSAGE_TAPs_READ_3DSMAX_ASC_HPP
        std::perror( fileName );
        #endif
        return false;
    }
    //----------------------------------------------------------------
    // Initialization
    faceNo   = 0;
    vertexNo = 0;
    //----------------------------------------------------------------
    // Read in each line, check what its contents are, 
    // and pass it out to the relevant decoder function
    const char * const ALC = "Ambient light color";
    const char * const NO  = "Named object: ";
    const char * const VL  = "Vertex list";
    const char * const FL  = "Face list";
    const char * const TM  = "Tri-mesh";
    const char * const V   = "Vertex ";
    const char * const F   = "Face ";
    
    char line[256];
    while ( !feof( fileIn ) ) {
        fgets( line, 256, fileIn );
        if ( !strncmp( line, ALC, strlen( ALC ) ) )
            ProcessAmbientLight( line, prModel );
        else if ( !strncmp( line, NO, strlen( NO ) ) )
            ProcessNamedObject( line, prModel );
        else if ( !strncmp( line, VL, strlen( VL ) ) )
            ;
        else if ( !strncmp( line, FL, strlen( FL ) ) )
            ;
        else if ( !strncmp( line, TM, strlen( TM ) ) )
            ProcessTriMesh( line, prModel );
        else if ( !strncmp( line, V, strlen( V ) ) )
            ProcessVertex( line, prModel );
        else if ( !strncmp( line, F, strlen( F ) ) )
            ProcessFace( line, prModel );
        else    // skip, we don't know what it is!
            ;
    }
    fclose( fileIn );   // close the input file
    prModel->GetMaterial()->ApplyMaterial();
    return true;
}
//-----------------------------------------------------------------------------
// Read the model from the input file
template <typename T>
bool Read3dsMaxASC<T>::readFile( 
        const char *fileName, OpenGL::HalfEdgeModel<T> * const prModel )
{
    //----------------------------------------------------------------
    // Open the input file
    fileIn = fopen( fileName, "r" );
    if ( !fileIn ) {
        #ifdef DEBUG_MESSAGE_TAPs_READ_3DSMAX_ASC_HPP
        std::perror( fileName );
        #endif
        return false;
    }
    //----------------------------------------------------------------
    // Initialization
    faceNo   = 0;
    vertexNo = 0;
    //----------------------------------------------------------------
    // Read in each line, check what its contents are, 
    // and pass it out to the relevant decoder function
    const char * const ALC = "Ambient light color";
    const char * const NO  = "Named object: ";
    const char * const VL  = "Vertex list";
    const char * const FL  = "Face list";
    const char * const TM  = "Tri-mesh";
    const char * const V   = "Vertex ";
    const char * const F   = "Face ";

    char line[256];
    while ( !feof( fileIn ) ) {
        fgets( line, 256, fileIn );
        if ( !strncmp( line, ALC, strlen( ALC ) ) )
            ProcessAmbientLight( line, prModel );
        else if ( !strncmp( line, NO, strlen( NO ) ) )
            ProcessNamedObject( line, prModel );
        else if ( !strncmp( line, VL, strlen( VL ) ) )
            ;
        else if ( !strncmp( line, FL, strlen( FL ) ) )
            ;
        else if ( !strncmp( line, TM, strlen( TM ) ) )
            ProcessTriMesh( line, prModel );
        else if ( !strncmp( line, V, strlen( V ) ) )
            ProcessVertex( line, prModel );
        else if ( !strncmp( line, F, strlen( F ) ) )
            ProcessFace( line, prModel );
        else    // skip, we don't know what it is!
            ;
    }
    fclose( fileIn );   // close the input file
    //----------------------------------------------------------------
    HelpCreateHalfEdgeModel<T>::CreateHalfEdgeModel( prModel );
    //----------------------------------------------------------------
    prModel->GetMaterial()->ApplyMaterial();
    return true;
}
//-----------------------------------------------------------------------------
//=============================================================================
//-----------------------------------------------------------------------------
// Convert the ambient light line
template <typename T>
void Read3dsMaxASC<T>::ProcessAmbientLight( char *line, OpenGL::PolygonalModel<T> * const prModel )
{
    //Example
    //Ambient light color: Red=0.0000 Green=0.0000 Blue=0.0000
    float r, g, b;
    sscanf( line, "Ambient light color: Red=%f Green=%f Blue=%f", &r, &g, &b );
    prModel->material.SetAmbient( r, g, b, 1.0 );
}
//-----------------------------------------------------------------------------
// Convert the ambient light line
template <typename T>
void Read3dsMaxASC<T>::ProcessAmbientLight( char *line, OpenGL::XPolygonalModel<T> * const prModel )
{
    //Example
    //Ambient light color: Red=0.0000 Green=0.0000 Blue=0.0000
    float r, g, b;
    sscanf( line, "Ambient light color: Red=%f Green=%f Blue=%f", &r, &g, &b );
    prModel->material.SetAmbient( r, g, b, 1.0 );
}
//-----------------------------------------------------------------------------
// Convert the ambient light line
template <typename T>
void Read3dsMaxASC<T>::ProcessAmbientLight( char *line, OpenGL::HalfEdgeModel<T> * const prModel )
{
    //Example
    //Ambient light color: Red=0.0000 Green=0.0000 Blue=0.0000
    float r, g, b;
    sscanf( line, "Ambient light color: Red=%f Green=%f Blue=%f", &r, &g, &b );
    prModel->material.SetAmbient( r, g, b, 1.0 );
}
//-----------------------------------------------------------------------------
//=============================================================================
//-----------------------------------------------------------------------------
// Convert the named object line
template <typename T>
void Read3dsMaxASC<T>::ProcessNamedObject( char *line, OpenGL::PolygonalModel<T> * const prModel )
{
    //Example
    //Named object: "Box01"
    char acTmpName[256];
    char *pcTmpName;
    sscanf( line, "Named object: %s", acTmpName );

    // set up the object_c->m_pcObjectName
    pcTmpName = new char[ strlen( acTmpName ) + 1 ];    // allocate memory for the temp object name
    assert( pcTmpName != 0 );           // terminate if not allocated
    strcpy( pcTmpName, acTmpName );     // copy the string to the temp object name
    prModel->SetName( pcTmpName );  // set the object name to the temp object name
}
//-----------------------------------------------------------------------------
// Convert the named object line
template <typename T>
void Read3dsMaxASC<T>::ProcessNamedObject( char *line, OpenGL::XPolygonalModel<T> * const prModel )
{
    //Example
    //Named object: "Box01"
    char acTmpName[256];
    char *pcTmpName;
    sscanf( line, "Named object: %s", acTmpName );

    // set up the object_c->m_pcObjectName
    pcTmpName = new char[ strlen( acTmpName ) + 1 ];    // allocate memory for the temp object name
    assert( pcTmpName != 0 );           // terminate if not allocated
    strcpy( pcTmpName, acTmpName );     // copy the string to the temp object name
    prModel->SetName( pcTmpName );  // set the object name to the temp object name
}
//-----------------------------------------------------------------------------
// Convert the named object line
template <typename T>
void Read3dsMaxASC<T>::ProcessNamedObject( char *line, OpenGL::HalfEdgeModel<T> * const prModel )
{
    //Example
    //Named object: "Box01"
    char acTmpName[256];
    char *pcTmpName;
    sscanf( line, "Named object: %s", acTmpName );

    // set up the object_c->m_pcObjectName
    pcTmpName = new char[ strlen( acTmpName ) + 1 ];    // allocate memory for the temp object name
    assert( pcTmpName != 0 );           // terminate if not allocated
    strcpy( pcTmpName, acTmpName );     // copy the string to the temp object name
    prModel->SetName( pcTmpName );  // set the object name to the temp object name
    delete [] pcTmpName;
}
//-----------------------------------------------------------------------------
//=============================================================================
//-----------------------------------------------------------------------------
// Convert the tri-mesh line
template <typename T>
void Read3dsMaxASC<T>::ProcessTriMesh( char *line, OpenGL::PolygonalModel<T> * const prModel )
{
    // Example
    // Tri-mesh, Vertices: 8     Faces: 12
    int nv, nf;
    sscanf( line, "Tri-mesh, Vertices: %d     Faces: %d", &nv, &nf );
    prModel->SetNoVertices( nv );
    prModel->SetNoFaces( nf );

    // Allocate memory for the vertex and face data
    prModel->NewVertexListByNoVertices();
    prModel->NewFaceListByNoFaces();
}
//-----------------------------------------------------------------------------
// Convert the tri-mesh line
template <typename T>
void Read3dsMaxASC<T>::ProcessTriMesh( char *line, OpenGL::XPolygonalModel<T> * const prModel )
{
    // Example
    // Tri-mesh, Vertices: 8     Faces: 12
    int nv, nf;
    sscanf( line, "Tri-mesh, Vertices: %d     Faces: %d", &nv, &nf );
    prModel->SetNoVertices( nv );
    prModel->SetNoFaces( nf );

    // Allocate memory for the vertex and face data
    prModel->NewVertexListByNoVertices();
    prModel->NewFaceListByNoFaces();
}
//-----------------------------------------------------------------------------
// Convert the tri-mesh line
template <typename T>
void Read3dsMaxASC<T>::ProcessTriMesh( char *line, OpenGL::HalfEdgeModel<T> * const prModel )
{
    // Example
    // Tri-mesh, Vertices: 8     Faces: 12
    int nv, nf;
    sscanf( line, "Tri-mesh, Vertices: %d     Faces: %d", &nv, &nf );
    prModel->SetNoVertices( nv );
    prModel->SetNoFaces( nf );

    // Allocate memory for vertices
    HelpCreateHalfEdgeModel<T>::vertexList = new HEVertex<T>*[ nv ];
    HelpCreateHalfEdgeModel<T>::vertexRingList = new DS::HashTableBySTLVector<int>( nv );
    HelpCreateHalfEdgeModel<T>::halfEdgeRingList = new DS::HashTableBySTLVector< HEHalfEdge<T> * >( nv );
}
//-----------------------------------------------------------------------------
//=============================================================================
//-----------------------------------------------------------------------------
// Convert a vertex line
template <typename T>
void Read3dsMaxASC<T>::ProcessVertex( char *line, OpenGL::PolygonalModel<T> * const prModel )
{
    //Example
    //Vertex 0:  X:-2705.7974     Y:745.8893     Z:0.0000
    float fx, fy, fz;
    // fx, fy, and fz have to be float,
    // otherwise sscanf will not work.
    sscanf( line, "Vertex %*d:  X:%f     Y:%f     Z:%f", 
            &fx, 
            &fy,
            &fz
    );

    prModel->GetVertexList()[vertexNo  ][0] = fx;
    prModel->GetVertexList()[vertexNo  ][1] = fy;
    prModel->GetVertexList()[vertexNo++][2] = fz;
}
//-----------------------------------------------------------------------------
// Convert a vertex line
template <typename T>
void Read3dsMaxASC<T>::ProcessVertex( char *line, OpenGL::XPolygonalModel<T> * const prModel )
{
    //Example
    //Vertex 0:  X:-2705.7974     Y:745.8893     Z:0.0000
    float fx, fy, fz;
    // fx, fy, and fz have to be float,
    // otherwise sscanf will not work.
    sscanf( line, "Vertex %*d:  X:%f     Y:%f     Z:%f", 
            &fx, 
            &fy,
            &fz
    );
    prModel->GetVertexList()[vertexNo  ][0] = fx;
    prModel->GetVertexList()[vertexNo  ][1] = fy;
    prModel->GetVertexList()[vertexNo++][2] = fz;
}
//-----------------------------------------------------------------------------
// Convert a vertex line
template <typename T>
void Read3dsMaxASC<T>::ProcessVertex( char *line, OpenGL::HalfEdgeModel<T> * const prModel )
{
    //Example
    //Vertex 0:  X:-2705.7974     Y:745.8893     Z:0.0000
    float fx, fy, fz;
    // fx, fy, and fz have to be float,
    // otherwise sscanf will not work.
    sscanf( line, "Vertex %*d:  X:%f     Y:%f     Z:%f", 
            &fx, 
            &fy,
            &fz
    );
    // Put created vertex in vertexList for look up later
    HelpCreateHalfEdgeModel<T>::vertexList[vertexNo] = new HEVertex<T>( 
        fx, fy, fz, 
        0, 0, 0 
    #ifdef  TAPs_USE_DATA_POOL
        , prModel->GetArrayOfVertexPositions().GetAddressOfDataNumber( vertexNo )
        , prModel->GetArrayOfVertexNormals().GetAddressOfDataNumber( vertexNo )
    #endif//TAPs_USE_DATA_POOL
    );
    // Put created vertex in vertexList of the model
    prModel->GetVertexList()->Append( HelpCreateHalfEdgeModel<T>::vertexList[vertexNo] );
    ++vertexNo; // next vertex#
    //std::cout << "Vertex: " << vertexNo << "\n";
}
//-----------------------------------------------------------------------------
//=============================================================================
//-----------------------------------------------------------------------------
// Convert a face line
template <typename T>
void Read3dsMaxASC<T>::ProcessFace( char *line, OpenGL::PolygonalModel<T> * const prModel )
{
    //Example
    //Face 0:    A:0 B:2 C:3 AB:1 BC:1 CA:0
    prModel->GetFaceList()[faceNo].SetNoVertices( 3 );
    int e0, e1, e2;
    sscanf( line, "Face %*d:    A:%d B:%d C:%d", &e0, &e1, &e2 );
    prModel->GetFaceList()[faceNo  ].SetVertexNo( 0, e0 );
    prModel->GetFaceList()[faceNo  ].SetVertexNo( 1, e1 );
    prModel->GetFaceList()[faceNo++].SetVertexNo( 2, e2 );
}
//-----------------------------------------------------------------------------
// Convert a face line
template <typename T>
void Read3dsMaxASC<T>::ProcessFace( char *line, OpenGL::XPolygonalModel<T> * const prModel )
{
    //Example
    //Face 0:    A:0 B:2 C:3 AB:1 BC:1 CA:0
    prModel->GetFaceList()[faceNo].SetNoVertices( 3 );
    int e0, e1, e2;
    sscanf( line, "Face %*d:    A:%d B:%d C:%d", &e0, &e1, &e2 );
    prModel->GetFaceList()[faceNo  ].SetVertexNo( 0, e0 );
    prModel->GetFaceList()[faceNo  ].SetVertexNo( 1, e1 );
    prModel->GetFaceList()[faceNo++].SetVertexNo( 2, e2 );
}
//-----------------------------------------------------------------------------
// Convert a face line
template <typename T>
void Read3dsMaxASC<T>::ProcessFace( char *line, OpenGL::HalfEdgeModel<T> * const prModel )
{
    //Example
    //Face 0:    A:0 B:2 C:3 AB:1 BC:1 CA:0
    //----------------------------------------------------------------
    HEFace<T> *heFace = new HEFace<T>();
    prModel->GetFaceList()->Append( heFace );
    int v0, v1, v2;
    sscanf( line, "Face %*d:    A:%d B:%d C:%d", &v0, &v1, &v2 );
    //----------------------------------------------------------------
    // Create and Set all three half-edges
    HEHalfEdge<T> *heHalfEdge0 = HelpCreateHalfEdgeModel<T>::CreateHalfEdgeFrom( 
        HelpCreateHalfEdgeModel<T>::vertexList[v0], 
        HelpCreateHalfEdgeModel<T>::vertexList[v1], 
        heFace );
    HEHalfEdge<T> *heHalfEdge1 = HelpCreateHalfEdgeModel<T>::CreateHalfEdgeFrom( 
        HelpCreateHalfEdgeModel<T>::vertexList[v1], 
        HelpCreateHalfEdgeModel<T>::vertexList[v2], 
        heFace, heHalfEdge0 );                  // w/ prev ptr
    HEHalfEdge<T> *heHalfEdge2 = HelpCreateHalfEdgeModel<T>::CreateHalfEdgeFrom( 
        HelpCreateHalfEdgeModel<T>::vertexList[v2], 
        HelpCreateHalfEdgeModel<T>::vertexList[v0], 
        heFace, heHalfEdge1, heHalfEdge0 );     // w/ prev and next ptrs
    //----------------------------------------------------------------
    // Set incident half-edge of this face
    heFace->IncidentHalfEdge( heHalfEdge0 );
    //----------------------------------------------------------------
    // (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
}
//-----------------------------------------------------------------------------
//=============================================================================
END_NAMESPACE_TAPs
//-----------------------------------------------------------------------------
//345678901234567890123456789012345678901234567890123456789012345678901234567890
//--+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8