basic/geometry/vrml_reader/VrmlNode.cpp

Go to the documentation of this file.

#pragma warning ( disable : 4786 )

#include <assert.h>
#include <map>
#include <stdio.h>
#include <string.h>
#include "utility.h"
#include "VrmlAppearance.h"
#include "VrmlBboxCenter.h"
#include "VrmlBboxSize.h"
#include "VrmlChildren.h"
#include "VrmlCoordinate3.h"
#include "VrmlGroup.h"
#include "VrmlIndexedFaceSet.h"
#include "VrmlInline.h"
#include "VrmlMaterial.h"
#include "VrmlNode.h"
#include "VrmlOneWordNode.h"
#include "VrmlRotation.h"
#include "VrmlScale.h"
#include "VrmlSeparator.h"
#include "VrmlShape.h"
#include "VrmlTransform.h"
#include "VrmlTranslation.h"
#include "VrmlWorldInfo.h"


std::map< std::string, VrmlNode* > VrmlNode::g_DataBase ;

//=============================================================================
// CleanVrmlNodes
//
// Description: Constructor
//=============================================================================
static void CleanVrmlNodes()
{
        //delete the contents of the global define nodes
        std::map< std::string, VrmlNode* >::iterator it;
        for( it = VrmlNode::g_DataBase.begin(); it != VrmlNode::g_DataBase.end(); it++ )
        {
                VrmlNode* deleteMe = ( *it ).second;
        }

        VrmlNode::g_DataBase.clear();
}

//=============================================================================
// VrmlNode
//
// Description: Constructor
//=============================================================================
VrmlNode::VrmlNode()
:
        m_RefCount( 0 )
{
        static bool firstTime = true;
        if( firstTime )
        {
                int result = ::atexit( CleanVrmlNodes );
                assert( result == 0 );
                firstTime = false;
        }

#ifdef _DEBUG
        vrmlType[ 0 ] = 0x00;
        strcpy( vrmlType, "==NO NAME==" );
#endif
}

//=============================================================================
// VrmlNode
//
// Description: Constructor
//=============================================================================
VrmlNode::~VrmlNode()
{
        //do nothing
        assert( m_RefCount == 0 );
}

//=============================================================================
// AddRef
//
// Description: keeps track of the reference count
//=============================================================================
void VrmlNode::AddRef()
{
        m_RefCount++;
}

//=============================================================================
// CleanupGlobals
//
// Description: deletes all the global 
//=============================================================================
void VrmlNode::CleanupGlobals()
{
        //look up the node in the database
        std::map< std::string, VrmlNode* >::iterator it = g_DataBase.begin();

        for( ; it != g_DataBase.end(); it++ )
        {
                VrmlNode* node = ( *it ).second;
                node->Release();
        }
        g_DataBase.clear();
}

//=============================================================================
// GetKeyword
//
// Description: gets the node keyword that corresponds
//=============================================================================
Keyword VrmlNode::GetKeyword( char*& buffer )
{
        char keyword[ 80 ] = "";
        VrmlNode::GetKeywordString( buffer, keyword );  
        //compare the keyword with the string values of various keywords
        if( strcmp( keyword, VrmlKeywordAmbientColor ) == 0 )
        {
                return VRML_AmbientColor;
        }
        if( strcmp( keyword, VrmlKeywordAmbientIntensity ) == 0 )
        {
                return VRML_AmbientIntensity;
        }
        if( strcmp( keyword, VrmlKeywordAppearanceLower ) == 0 )
        {
                return VRML_AppearanceLower;
        }
        if( strcmp( keyword, VrmlKeywordAppearanceUpper ) == 0 )
        {
                return VRML_AppearanceUpper;
        }
        if( strcmp( keyword, VrmlKeywordBboxCenter ) == 0 )
        {
                return VRML_BboxCenter;
        }
        if( strcmp( keyword, VrmlKeywordBboxSize ) == 0 )
        {
                return VRML_BboxSize;
        }
        if( strcmp( keyword, VrmlKeywordCcw ) == 0 )
        {
                return VRML_Ccw;
        }
        if( strcmp( keyword, VrmlKeywordChildren ) == 0 )
        {
                return VRML_Children;
        }
        if( strcmp( keyword, VrmlKeywordColor ) == 0 )
        {
                return VRML_Color;
        }
        if( strcmp( keyword, VrmlKeywordColorPerVertex  ) == 0 )
        {
                return VRML_ColorPerVertex;
        }
        if( strcmp( keyword, VrmlKeywordCollision  ) == 0 )
        {
                return VRML_Collision;
        }
        if( strcmp( keyword, VrmlKeywordConvex ) == 0 )
        {
                return VRML_Convex;
        }
        if( strcmp( keyword, "Coordinate" ) == 0 )
        {
                return VRML_Coordinate3;
        }
        if( strcmp( keyword, VrmlKeywordCoord ) == 0 )
        {
                return VRML_Coord;
        }
        if( strcmp( keyword, VrmlKeywordCoordIndex ) == 0 )
        {
                return VRML_CoordIndex;
        }
        if( strcmp( keyword, "Coordinate3" ) == 0 )
        {
                return VRML_Coordinate3;
        }
        if( strcmp( keyword, VrmlKeywordCreaseAngle ) == 0 )
        {
                return VRML_CreaseAngle;
        }
        if( strcmp( keyword, VrmlKeywordCylinder ) == 0 )
        {
                return VRML_Cylinder;
        }
        if( strcmp( keyword, VrmlKeywordDefine ) == 0 )
        {
                return VRML_Define;
        }
        if( strcmp( keyword, VrmlKeywordDiffuseColor ) == 0 )
        {
                return VRML_DiffuseColor;
        }
        if( strcmp( keyword, VrmlKeywordDirectionalLight ) == 0 )
        {
        return VRML_DirectionalLight;
        }
    if( strcmp( keyword, "DrawStyle" ) == 0 )
        {
                return VRML_DrawStyle;
        }
        if( strcmp( keyword, VrmlKeywordEmissiveColor ) == 0 )
        {
                return VRML_EmissiveColor;
        }
        if( strcmp( keyword, VrmlKeywordGeometry ) == 0 )
        {
                return VRML_Geometry;
        }
        if( strcmp( keyword, VrmlKeywordGroup ) == 0 )
        {
                return VRML_Group;
        }
        if( strcmp( keyword, VrmlKeywordInline ) == 0 )
        {
                return VRML_Inline;
        }
        if( strcmp( keyword, "IndexedFaceSet" ) == 0 )
        {
                return VRML_IndexedFaceSet;
        }
        if( strcmp( keyword, "IndexedLineSet" ) == 0 )
        {
                return VRML_IndexedLineSet;
        }
        if( strcmp( keyword, VrmlKeywordInfo ) == 0 )
        {
                return VRML_Info;
        }
        if( strcmp( keyword, VrmlKeywordMaterialBinding ) == 0 )
        {
                return VRML_MaterialBinding;
        }
        if( strcmp( keyword, VrmlKeywordMaterialLower ) == 0 )
        {
                return VRML_MaterialLower;
        }
        if( strcmp( keyword, VrmlKeywordMaterialUpper ) == 0 )
        {
                return VRML_MaterialUpper;
        }
        if( strcmp( keyword, VrmlKeywordMaterialIndex ) == 0 )
        {
                return VRML_MaterialIndex;
        }
        if( strcmp( keyword, VrmlKeywordMatrixTransform ) == 0 )
        {
                return VRML_MatrixTransform;
        }
        if( strcmp( keyword, VrmlKeywordNavigationInfo ) == 0 )
        {
                return VRML_NavigationInfo;
        }
        if( strcmp( keyword, VrmlKeywordNormal ) == 0 )
        {
                return VRML_Normal;
        }
        if( strcmp( keyword, VrmlKeywordNormalBinding ) == 0 )
        {
                return VRML_NormalBinding;
        }
        if( strcmp( keyword, VrmlKeywordNormalIndex ) == 0 )
        {
                return VRML_NormalIndex;
        }
        if( strcmp( keyword, VrmlKeywordNormalPerVertex ) == 0 )
        {
                return VRML_NormalPerVertex;
        }
        if( strcmp( keyword, "PointSet" ) == 0 )
        {
                return VRML_PointSet;
        }
        if( strcmp( keyword, VrmlKeywordRenderCulling ) == 0 )
        {
                return VRML_RenderCulling;
        }
        if( strcmp( keyword, VrmlKeywordRotation ) == 0 )
        {
                return VRML_Rotation;
        }
        if( strcmp( keyword, VrmlKeywordRotationUpper ) == 0 )
        {
                return VRML_Rotation;           //IAN IMPROVE: is this backwards compatible?
        }
        if( strcmp( keyword, VrmlKeywordScale ) == 0 )
        {
                return VRML_Scale;
        }
        if( strcmp( keyword, VrmlKeywordScaleFactor ) == 0 )
        {
                return VRML_Scale;                      //IAN IMPROVE: is this backwards compatible?
        }
        if( strcmp( keyword, VrmlKeywordScaleUpper ) == 0 )
        {
                return VRML_Scale;              //IAN IMPROVE: is this backwards compatible?
        }
        if( strcmp( keyword, VrmlKeywordScaleOrientation ) == 0 )
        {
                return VRML_ScaleOrientation;
        }
        if( strcmp( keyword, VrmlKeywordSeparator ) == 0 )
        {
                return VRML_Separator;
        }
        if( strcmp( keyword, VrmlKeywordShape ) == 0 )
        {
                return VRML_Shape;
        }
        if( strcmp( keyword, "ShapeHints" ) == 0 )
        {
                return VRML_ShapeHints;
        }
        if( strcmp( keyword, VrmlKeywordShininess ) == 0 )
        {
                return VRML_Shininess;
        }
        if( strcmp( keyword, VrmlKeywordSpecularColor ) == 0 )
        {
                return VRML_SpecularColor;
        }
        if( strcmp( keyword, VrmlKeywordSphere ) == 0 )
        {
                return VRML_Sphere;
        }
        if( strcmp( keyword, VrmlKeywordSolid ) == 0 )
        {
                return VRML_Solid;
        }
        if( strcmp( keyword, VrmlKeywordTexCoord ) == 0 )
        {
                return VRML_TexCoord;
        }
        if( strcmp( keyword, VrmlKeywordTexCoordIndex ) == 0 )
        {
                return VRML_TexCoordIndex;
        }
        if( strcmp( keyword, VrmlKeywordTextureCoordinate ) == 0 )
        {
                return VRML_TextureCoordinate;
        }
        if( strcmp( keyword, VrmlKeywordTexture ) == 0 )
        {
                return VRML_Texture;
        }
        if( strcmp( keyword, VrmlKeywordTextureCoordIndex ) == 0 )
        {
                return VRML_TextureCoordIndex;
        }
        if( strcmp( keyword, VrmlKeywordTimeSensor ) == 0 )
        {
                return VRML_TimeSensor;
        }
        if( strcmp( keyword, VrmlKeywordTransform ) == 0 )
        {
                return VRML_Transform;
        }
        if( strcmp( keyword, VrmlKeywordTranslation ) == 0 )
        {
                return VRML_Translation;
        }
        if( strcmp( keyword, VrmlKeywordTranslationUpper ) == 0 )
        {
                return VRML_Translation;                //IAN: is this backwards compatible?
        }
        if( strcmp( keyword, VrmlKeywordTransparency ) == 0 )
        {
                return VRML_Transparency;
        }
        if( strcmp( keyword, VrmlKeywordUse ) == 0 )
        {
                return VRML_Use;
        }
        if( strcmp( keyword, VrmlKeywordUrl ) == 0 )
        {
                return VRML_Url;
        }
        if( strcmp( keyword, VrmlKeywordVector ) == 0 )
        {
                return VRML_Vector;
        }
        if( strcmp( keyword, VrmlKeywordViewpoint ) == 0 )
        {
                return VRML_Viewpoint;
        }
        if( strcmp( keyword, VrmlKeywordWorldInfo ) == 0 )
        {
                return VRML_WorldInfo;
        }
        printf( "VrmlNode::GetKeyword - Discovered invalid keyword : %s\n", keyword );
        IJG_Assert( false );            
        return VRML_Invalid;
}

//=============================================================================
// GetKeywordString
//
// Description: gets a string that should represent a keyword
//=============================================================================
void VrmlNode::GetKeywordString( char*& buffer, char* keyword )
{
        EatWhite( buffer );

        //find the end of the first keyword
        int position = strcspn( buffer, " \t\n\r{" );           //IMPROVE: reuse these characters

        strncpy( keyword, buffer, position );
        buffer += position;
}

//=============================================================================
// Parse
//
// Description: Parses the buffer - this is the default behavior
//=============================================================================
void VrmlNode::Parse( char*& buffer )
{
        //depth is 1 because we're past the first '{' already
        int depth = 0;
//      if( *buffer != '{' )
//      {
//              buffer = strpbrk( buffer, "{}" );
//      }
        assert( *buffer = '{' );
        buffer++;
        depth++;
        while( depth != 0 )
        {
                buffer = strpbrk( buffer, "{}" );
                if( *buffer == '{' )
                {
                        depth++;
                }
                if( *buffer == '}' )
                {
                        depth--;
                }
                buffer++;
        }
}

//=============================================================================
// ParseDefNode
//
// Description: Parses a define node - saves an existing node in the database
//=============================================================================
VrmlNode* VrmlNode::ParseDefNode( char*& buffer )
{
        //read the next word - it's the name of the object
        char keywordString[ 80 ] = "";
        VrmlNode::GetKeywordString( buffer, keywordString );

        //the real keyword is here
        Keyword keyword = VrmlNode::GetKeyword( buffer );
        EatWhite( buffer );
        buffer++;
        VrmlNode* node = VrmlNode::ParseNode( keyword, buffer );
        node->AddRef();

        g_DataBase.insert( std::map< std::string, VrmlNode* >::value_type( keywordString, node ) );

        return node;
}

//=============================================================================
// Parsenode
//
// Description: Parses the buffer - this is the default behavior
//=============================================================================
VrmlNode* VrmlNode::ParseNode( Keyword keyword, char*& buffer )
{
        VrmlNode* node = NULL;
        switch( keyword )
        {
        case VRML_AppearanceUpper:
                {
                        node = new VrmlAppearance;
                        node->SetType( VrmlKeywordAppearanceUpper );
                        break;
                }
        case VRML_BboxCenter:
                {
                        node = new VrmlBboxCenter;
                        node->SetType( VrmlKeywordBboxCenter );
                        break;
                }
        case VRML_BboxSize:
                {
                        node = new VrmlBboxSize;
                        node->SetType( VrmlKeywordBboxSize );
                        break;
                }
        case VRML_Children:
                {
                        node = new VrmlChildren;
                        node->SetType( VrmlKeywordChildren );
                        break;
                }
        case VRML_Coordinate3:
                {
                        node = new VrmlCoordinate3;
                        node->SetType( "Coordinate3" );
                        break;
                }
        case VRML_Cylinder: 
                {
                        node = new VrmlNode;
                        node->SetType( VrmlKeywordCylinder );
                        break;
                }
        case VRML_Define:
                {
                        node = VrmlNode::ParseDefNode( buffer );
                        return node;
                        break;
                }
        case VRML_DrawStyle:
                {
                        node = new VrmlNode;
                        node->SetType( VrmlKeywordDrawStyle );
                        break;
                }
        case VRML_DirectionalLight:
                {
                        node = new VrmlNode;
                        node->SetType( VrmlKeywordDirectionalLight );
                        break;
                }
    case VRML_Group:
                {
                        node = new VrmlGroup;
                        node->SetType( "Group" );
                        break;
                }
        case VRML_Info:
                {
                        node = new VrmlNode;
                        node->SetType( VrmlKeywordInfo );
                        break;
                }
        case VRML_IndexedFaceSet:
                {
                        node = new VrmlIndexedFaceSet;
                        node->SetType( "IndexedFaceSet" );
                        break;
                }
        case VRML_IndexedLineSet:
                {
                        node = new VrmlNode;
                        node->SetType( VrmlKeywordIndexedLineSet );
                        break;
                }
        case VRML_Inline:
                {
                        node = new VrmlInline;
                        node->SetType( VrmlKeywordInline );
                        break;
                }
        case VRML_MaterialUpper:
                {
                        node = new VrmlMaterial;
                        node->SetType( VrmlKeywordMaterialUpper );
                        break;
                }
        case VRML_MaterialBinding:
                {
                        node = new VrmlNode;
                        node->SetType( VrmlKeywordMaterialBinding );
                        break;
                }
        case VRML_MatrixTransform:
                {
                        node = new VrmlNode;
                        node->SetType( VrmlKeywordMatrixTransform );
                        break;
                }
        case VRML_NavigationInfo:
                {
                        node = new VrmlNode;
                        node->SetType( VrmlKeywordNavigationInfo );
                        break;
                }
        case VRML_NormalBinding:
                {
                        node = new VrmlNode;
                        node->SetType( VrmlKeywordNormalBinding );
                        break;
                }
        case VRML_PointSet:
                {
                        node = new VrmlNode;
                        node->SetType( VrmlKeywordPointSet );
                        break;
                }
        case VRML_RenderCulling:
                {
                        node = new VrmlOneWordNode;
                        node->SetType( ::VrmlKeywordRenderCulling );
                        break;
                }
        case VRML_Rotation:
                {
                        node = new VrmlRotation;
                        node->SetType( VrmlKeywordRotation );
                        break;
                }
        case VRML_Scale:
                {
                        node = new VrmlScale;
                        node->SetType( VrmlKeywordScale );
                        break;
                }
        case VRML_Separator:
                {
                        node = new VrmlSeparator;
                        node->SetType( "Separator" );
                        break;
                }
        case VRML_Shape:
                {
                        node = new VrmlShape;
                        node->SetType( VrmlKeywordShape );
                        break;
                }
        case VRML_ShapeHints: 
                {
                        node = new VrmlNode;
                        node->SetType( "ShapeHints" );
                        break;
                }
        case VRML_Sphere: 
                {
                        node = new VrmlNode;
                        node->SetType( VrmlKeywordSphere );
                        break;
                }
        case VRML_TextureCoordinate:
                {
                        node = new VrmlNode;
                        node->SetType( VrmlKeywordTextureCoordinate );
                        break;
                }
        case VRML_TimeSensor:
                {
                        node = new VrmlNode;
                        node->SetType( VrmlKeywordTimeSensor );
                        break;
                }
        case VRML_Transform:
                {
                        node = new VrmlTransform;
                        node->SetType( VrmlKeywordTransform );
                        break;
                }
        case VRML_Translation:
                {
                        node = new VrmlTranslation;
                        node->SetType( VrmlKeywordTranslation );
                        break;
                }
        case VRML_Use:
                {
                        node = VrmlNode::ParseUseNode( buffer );
                        return node;
                        break;
                }
        case VRML_Viewpoint:
                {
                        //this type of node is harmless - just ignore it
                        node = new VrmlNode;
                        node->SetType( VrmlKeywordViewpoint );
                        break;
                }
        case VRML_WorldInfo:
                {
                        //this type of node is harmless - just ignore it
                        node = new VrmlWorldInfo;
                        node->SetType( "WorldInfo" );
                        break;
                }
        case VRML_Invalid:
                {
                        printf( "VrmlNode::ParseNode - parsed invalid node\n" );
                        assert( false );
                        break;
                }
        default:
                {
                        assert( false );
                        node = new VrmlNode;
                        node->SetType( "MISC" );
                        break;
                }
        }
        if (node == NULL)
                return NULL;
        node->Parse( buffer );
        return node;
}

//=============================================================================
// ParseUseNode
//
// Description: Parses a using node - looks up an existing node in the database
//=============================================================================
VrmlNode* VrmlNode::ParseUseNode( char*& buffer )
{
        //get the name of the define to find
        char keywordString[ 80 ] = "";
        VrmlNode::GetKeywordString( buffer, keywordString );

        //look up the node in the database
        std::map< std::string, VrmlNode* >::iterator it = g_DataBase.find( keywordString );

        if( it != g_DataBase.end() )
        {
                return ( *it ).second;
        }
        assert( false );
        return NULL;
}

//=============================================================================
// Release
//
// Description: Releases a reference to this object
//=============================================================================
void VrmlNode::Release()
{
        assert( m_RefCount > 0 );
        m_RefCount--;
        if( m_RefCount == 0 )
        {
                delete this;
        }
}

//=============================================================================
// Render
//
// Description: renders this node to the screen (OpenGL)
//=============================================================================
void VrmlNode::Render( VrmlStack& stack ) const
{
#ifdef _DEBUG
        printf( "WARNING: do not know how to render node %s\n", this->vrmlType );
#endif
}

//=============================================================================
// RenderOpenGl
//
// Description: renders this node to the screen (OpenGL)
//=============================================================================
void VrmlNode::RenderOpenGl( VrmlStack& stack ) const
{
        this->Render( stack );
}

//=============================================================================
// RenderToIGS
//
// Description: renders this VRML object to the faster to process 
//                              IanGraphicsSystem
//=============================================================================
IGS_Object* VrmlNode::RenderToIGS( VrmlStack& stack ) const
{
        this->Render( stack );
        return NULL;
}

//=============================================================================
// SetType
//
// Description: Sets the string for the type - debug mode only
//=============================================================================
void VrmlNode::SetType( const char* string )
{
#ifdef _DEBUG
        strcpy( this->vrmlType, string );
#endif
}

---