basic/geometry/VRML_20_Reader.cpp

Go to the documentation of this file.

#include <additional\streams\mystreams.h>
#include <assert.h>
#include "debug/debug.h"
#include <stdio.h>
#include "geometry/IGS/IGS_Object.h"
#include <geometry/vrml_reader/keyword.h>
#include <geometry/vrml_reader/utility.h>
#include <geometry/vrml_reader/VrmlStack.h>
#ifdef WIN32
    #include <direct.h>
#endif
#include <fstream>
#include "geometry\VRML_20_Reader.h"
#include <geometry/vrml_reader/vrmlinline.h>

//char VRML_20_Reader::rootpath[ 256 ] = "";
VRML_20_Reader::VRML_20_Reader()
{
        rootpath[0] = '\0';
}

VRML_20_Reader::~VRML_20_Reader()
{
  //## begin VRML_20_Reader::~VRML_20_Reader%.body preserve=yes
  //## end VRML_20_Reader::~VRML_20_Reader%.body
}

void VRML_20_Reader::SetRootPath( const char* path )
{
    strcpy( rootpath, path );
}

void GetPath( const char* file, char* path )
{
    const char* p1 = file ;
    while( strchr( p1, '/' ) != NULL )
    {
        p1 = strchr( p1, '/' );
        p1++;
    }

    const char* p2 = file ;
    while( strchr( p2, '\\' ) != NULL )
    {
        p2 = strchr( p2, '\\' );
        p2++;
    }

    const char* position;
    if( p1 > p2 )
    {
        position = p1;
    }
    else
    {
        position = p2;
    }

    int number = position - file;
    strncpy( path, file, number );
}

//## Other Operations (implementation)
bool VRML_20_Reader::Read ()
{
    char path[ 256 ] = "";
    GetPath( filename.c_str(), path );
    char wholePath[ 256 ] = "";
    strcat( wholePath, rootpath );
    strcat( wholePath, path );
    VrmlInline::SetRootPath( wholePath );

        //open the file
    char filen[ 256 ] = "";
    strcat( filen, rootpath );
    strcat( filen, filename.c_str() );
        FILE* file = fopen( filen, "rb" );
        IJG_Assert( file != NULL );
        if (file == NULL)
                return false;

        long start = ftell( file );
        int success = fseek( file, 0, SEEK_END );
        long end = ftell( file );
        rewind( file );
        assert( success == 0 );
        int size = end - start;
        char* buffer = new char[ size + 1 ];
        memset( buffer, 0x00, size + 1 );
        char* originalBuffer = buffer;
        fread( buffer, 1, size, file );
        success = fclose( file );
        assert( success == 0 );

        char* endOfBuffer = buffer + size;

        //now the VRML file is loaded into a buffer
        VrmlStack stack;

	::RemoveAllCommentsFromBuffer( buffer, size );
        while( buffer < endOfBuffer )
        {
                Keyword keyword = VrmlNode::GetKeyword( buffer );

                //we must process define keywords differently
                EatWhite( buffer );
                if( keyword != VRML_Define )
                {
                        //parse the node
                        EatWhite( buffer );
                        buffer++;
                }

                VrmlNode* node = VrmlNode::ParseNode( keyword, buffer );
                if( node != NULL )
                {
                        node->AddRef();
                        m_Nodes.push_back( node );

                        IGS_Object* object = node->RenderToIGS( stack );
                        if( object != NULL )
                        {
                                //IAN IMPROVE: this should be calling a member function in the parent
                                m_Objects.push_back( object );
                        }
                }
                else
                {
                        assert( node != NULL );
                }
                EatWhite( buffer );
        }

        int i;
        size = m_Nodes.size();
        for( i = 0; i < size; i++ )
        {
                VrmlNode* node = m_Nodes[ i ];
        }
        delete[] originalBuffer;
        originalBuffer = NULL;

        //return to the original directory
//      int returnValue = ::chdir( directory );
//      assert( returnValue == 0 );

        size = m_Nodes.size();
        for( i = 0; i < size; i++ )
        {
                VrmlNode* node = m_Nodes[ i ];
                node->Release();
        }
        m_Nodes.clear();
        VrmlNode::CleanupGlobals();
        return true;                                    //IAN IMPROVE: is true the right thing to return all the time?
}

// Additional Declarations
  //## begin VRML_20_Reader%37CC77810341.declarations preserve=yes
  //## end VRML_20_Reader%37CC77810341.declarations

//## begin module%37CC77810341.epilog preserve=yes
//## end module%37CC77810341.epilog

---