basic/geometry/vrml_reader/VrmlInline.cpp

Go to the documentation of this file.

#pragma warning ( disable : 4786 )

#include <assert.h>
#include <geometry/igs/IGS_Group.h>
#include <stdio.h>
#include "utility.h"
#include <vector>
#include "VrmlBboxCenter.h"
#include "VrmlBboxSize.h"
#include "VrmlInline.h"

char VrmlInline::m_RootPath[ 256 ]  ="";

//=============================================================================
// VrmlInline
//
// Description: Constructor
//=============================================================================
VrmlInline::VrmlInline()
:
        m_BboxCenter( NULL ),
        m_BboxSize( NULL )
{
}

//=============================================================================
// ~VrmlInline
//
// Description: Destructor
//=============================================================================
VrmlInline::~VrmlInline()
{
        if( m_BboxCenter != NULL )
        {
                m_BboxCenter->Release();
        }
        if( m_BboxSize != NULL )
        {
                m_BboxSize->Release();
        }
        int i;
        int size = this->m_Subnodes.size();
        for( i = 0; i < size; i++ )
        {
                m_Subnodes[ i ]->Release();
        }
}

//=============================================================================
// Parse
//
// Description: Parses the node from the character buffer
//=============================================================================
void VrmlInline::Parse( char*& buffer )
{
        EatWhite( buffer );
        while( *buffer != '}' )
        {
                Keyword keyword = VrmlNode::GetKeyword( buffer );

                EatWhite( buffer );
                if( IsNodeType( keyword ) )
                {
                        buffer ++;
                }

                //IAN IMPROVE: change this to a case statement
                switch( keyword )
                {
                case VRML_BboxCenter:
                        {
                                assert( m_BboxCenter == NULL );
                                m_BboxCenter = new VrmlBboxCenter;
                                m_BboxCenter->Parse( buffer );
                                m_BboxCenter->AddRef();
                                break;
                        }
                case VRML_BboxSize:
                        {
                                assert( m_BboxSize == NULL );
                                m_BboxSize = new VrmlBboxSize;
                                m_BboxSize->Parse( buffer );
                                m_BboxSize->AddRef();
                                break;
                        }
                case VRML_Url:
                        {
                                std::vector< std::string > strings;
                                        
                                EatWhite( buffer );
                                assert( buffer[ 0 ] == '[' );
                                while( buffer[ 0 ] != ']' )
                                {
                                        char theString[ 256 ] = "";
                                        char* stringPointer = theString;

                                        //advance past any '[' or ',' characters 
                                        buffer++;
                                        EatWhite( buffer );

                                        //read in a string
                                        
                                        //advance past opening '"'
                                        assert( buffer[ 0 ] = '"' );
                                        buffer++;
                                        while( buffer[ 0 ] != '"' )
                                        {
                                                stringPointer[ 0 ] = buffer[ 0 ];
                                                buffer++;
                                                stringPointer++;
                                        }

                                        //advance past closing '"'
                                        assert( buffer[ 0 ] == '"' );
                                        buffer++;

                                        //add string to the array of strings
                                        strings.push_back( theString );
                                        EatWhite( buffer );
                                }

                                //advance past the trailing ']'
                                EatWhite( buffer );
                                buffer++;
                                
                                int i;
                                int size = strings.size();
                                for( i = 0; i < size; i++ )
                                {
                                        std::string theString = strings[ i ];
                                        bool success = ParseFile( theString.c_str() );
                                        if( success )
                                        {
                                                break;
                                        }
                                }
                                break;
                        }
                default:
                        {
                                assert( false );
                                printf( "VrmlInline::Parse - unknown node type\n" );
                        }
                }
                EatWhite( buffer );
        }

        buffer++;
}


//=============================================================================
// ParseFile
//
// Description: opens and parses a seperate file
//=============================================================================
bool VrmlInline::ParseFile( const char* filename )
{
        std::string myString = filename;
        int where = myString.find( "file:" );
        if( where != -1 )
        {
                myString.erase( where, 5 );
        }

        //check if the filename begins with "file:"

        //open the file
    char fname[ 256 ] = "";
    strcat( fname, m_RootPath );
    strcat( fname, myString.c_str() );
        FILE* file = fopen( fname, "rb" );
        assert( file != NULL );
        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 ];
        char* originalBuffer = buffer;
        fread( buffer, 1, size, file );
        fclose( file );

        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();
                        this->m_Subnodes.push_back( node );
                }
                EatWhite( buffer );
        }

        //clear the buffer
        delete[] originalBuffer;
        originalBuffer = NULL;
        return true;                                            //IAN IMPROVE: return false if the file could not be opened
}

//=============================================================================
// Render
//
// Description: Renders the object to the stack
//=============================================================================
void VrmlInline::Render( VrmlStack& stack ) const
{
        if( m_BboxCenter != NULL )
        {
                m_BboxCenter->Render( stack );
        }
        if( m_BboxSize != NULL )
        {
                m_BboxSize->Render( stack );
        }

        int i;
        int size = this->m_Subnodes.size();
        for( i = 0; i < size; i++ )
        {
                VrmlNode* subnode = this->m_Subnodes[ i ];
                if( subnode != NULL )
                {
                        subnode->Render( stack );
                }
                else
                {
                        assert( false );
                }
        }
}

//=============================================================================
// RenderOpenGl
//
// Description: Renders the object to OpenGL
//=============================================================================
void VrmlInline::RenderOpenGl( VrmlStack& stack ) const
{
        if( m_BboxCenter != NULL )
        {
                m_BboxCenter->RenderOpenGl( stack );
        }
        if( m_BboxSize != NULL )
        {
                m_BboxSize->RenderOpenGl( stack );
        }

        int i;
        int size = this->m_Subnodes.size();
        for( i = 0; i < size; i++ )
        {
                VrmlNode* subnode = this->m_Subnodes[ i ];
                if( subnode != NULL )
                {
                        subnode->RenderOpenGl( stack );
                }
                else
                {
                        assert( false );
                }
        }
}

//=============================================================================
// RenderToIGS
//
// Description: Renders the object to the stack
//=============================================================================
IGS_Object* VrmlInline::RenderToIGS( VrmlStack& stack ) const
{
        IGS_Group* group;
        group = new IGS_Group;

        if( m_BboxCenter != NULL )
        {
                m_BboxCenter->RenderToIGS( stack );
        }
        if( m_BboxSize != NULL )
        {
                m_BboxSize->RenderToIGS( stack );
        }

        int i;
        int size = this->m_Subnodes.size();
        for( i = 0; i < size; i++ )
        {
                VrmlNode* subnode = this->m_Subnodes[ i ];
                if( subnode != NULL )
                {
                        IGS_Object* object = subnode->RenderToIGS( stack );
                        if( object != NULL )
                        {
                                group->AddObject( object );
                        }
                        else
                        {
                        }
                }
                else
                {
                        assert( false );
                }
        }
        return group;
}

//=============================================================================
// SetRootPath
//
// Description: sets the path for loading files
//=============================================================================
void VrmlInline::SetRootPath( const char* path )
{
    strcpy( m_RootPath, path );
}

---