basic/geometry/vrml_reader/VrmlMaterial.cpp

Go to the documentation of this file.

#pragma warning ( disable : 4786 )

#include <assert.h>
#include <math/vector4.h>
#include "../IGS/IGS_Material.h"
#ifndef NOGL
#include "opengl/glos.h"
#include <gl/gl.h>
#endif
#include <stdio.h>
#include "utility.h"
#include "VrmlMaterial.h"
#include "VrmlStack.h"

//=============================================================================
// Constructor
//
// Description: Constructor
//=============================================================================
VrmlMaterial::VrmlMaterial()
{
}

//=============================================================================
// Parse
//
// Description: Parses the node from the file
//=============================================================================
void VrmlMaterial::Parse( char*& buffer )
{
        EatWhite( buffer );
        while( buffer[ 0 ] != '}' )
        {
                Keyword keyword = VrmlNode::GetKeyword( buffer );
                EatWhite( buffer );
                if( buffer[ 0 ] == '[' )
                {
                        buffer++;
                        EatWhite( buffer );
                }

                switch( keyword )
                {
                case VRML_AmbientColor:
                        {
                                //read in 3 floating point numbers
                                int result;
                                result = sscanf( buffer, "%f%f%f", &m_Ambient[ 0 ], &m_Ambient[ 1 ], &m_Ambient[ 2 ] );
                                assert( result == 3 );
                                m_Ambient[ 3 ] = 1.0f;

                                //advance to the end of the line
                                while( buffer[ 0 ] != '\n' )
                                {
                                        buffer++;
                                }
                                break;
                        }
                case VRML_AmbientIntensity:
                        {
                                //advance to the end of the line
                                while( buffer[ 0 ] != '\n' )
                                {
                                        buffer++;
                                }
                                break;
                        }
                case VRML_DiffuseColor:
                        {
                                //read in 3 floating point numbers
                                int result;
                                result = sscanf( buffer, "%f%f%f", &m_Diffuse[ 0 ], &m_Diffuse[ 1 ], &m_Diffuse[ 2 ] );
                                assert( result == 3 );
                                m_Diffuse[ 3 ] = 1.0f;

                                //advance to the end of the line
                                while( buffer[ 0 ] != '\n' )
                                {
                                        buffer++;
                                }
                                break;
                        }
                case VRML_EmissiveColor:
                        {
                                //read in 3 floating point numbers
                                int result;
                                result = sscanf( buffer, "%f%f%f", &m_Emissive[ 0 ], &m_Emissive[ 1 ], &m_Emissive[ 2 ] );
                                assert( result == 3 );
                                m_Emissive[ 3 ] = 1.0f;

                                //advance over 3 fields
                                EatWhite( buffer );
                EatNotWhite( buffer );
                                EatWhite( buffer );
                EatNotWhite( buffer );
                                EatWhite( buffer );
                EatNotWhite( buffer );
                                break;
                        }
                case VRML_SpecularColor:
                        {
                                //read in 3 floating point numbers
                                int result;
                                result = sscanf( buffer, "%f%f%f", &m_Specular[ 0 ], &m_Specular[ 1 ], &m_Specular[ 2 ] );
                                assert( result == 3 );
                                m_Specular[ 3 ] = 1.0f;

                                //advance to the end of the line
                                while( buffer[ 0 ] != '\n' )
                                {
                                        buffer++;
                                }
                                break;
                        }
                case VRML_Shininess:
                        {
                                //read in 1 floating point numbers
                                int result;
                                result = sscanf( buffer, "%f", &m_Shininess );
                                assert( result == 1 );

                                //advance to the end of the line
                                while( buffer[ 0 ] != '\n' )
                                {
                                        buffer++;
                                }
                                break;
                        }
                case VRML_Transparency:
                        {
                                //advance to the end of the line
                                while( buffer[ 0 ] != '\n' )
                                {
                                        buffer++;
                                }
                                break;
                        }
                default:
                        {
                                //advance to the end of the line
                                while( buffer[ 0 ] != '\n' )
                                {
                                        buffer++;
                                }
                                assert( false );
                                break;
                        }
                }
                EatWhite( buffer );
                if( buffer[ 0 ] == ',' )
                {
                        buffer++;
                }
                EatWhite( buffer );
                if( buffer[ 0 ] == ']' )
                {
                        buffer++;
                }
                EatWhite( buffer );
        }
        buffer++;
}

//=============================================================================
// Render
//
// Description: renders the object to the stack
//=============================================================================
void VrmlMaterial::Render( VrmlStack& stack ) const
{
        stack.m_Ambient = IGS_Color( m_Ambient[ 0 ], m_Ambient[ 1 ], m_Ambient[ 2 ] );
        stack.m_Diffuse = IGS_Color( m_Diffuse[ 0 ], m_Diffuse[ 1 ], m_Diffuse[ 2 ] );
        stack.m_Specular = IGS_Color( m_Specular[ 0 ], m_Specular[ 1 ], m_Specular[ 2 ] );
        stack.m_Emissive = IGS_Color( m_Emissive[ 0 ], m_Emissive[ 1 ], m_Emissive[ 2 ] );
        stack.m_Shininess = m_Shininess;
}

//=============================================================================
// RenderOpenGl
//
// Description: Renders the object to OpenGl
//=============================================================================
void VrmlMaterial::RenderOpenGl( VrmlStack& stack ) const
{
#ifndef NOGL
        ::glMaterialfv( GL_FRONT_AND_BACK, GL_AMBIENT, this->m_Ambient );
        ::glMaterialfv( GL_FRONT_AND_BACK, GL_DIFFUSE, this->m_Diffuse );
        ::glMaterialfv( GL_FRONT_AND_BACK, GL_SPECULAR, this->m_Specular );
        ::glMaterialfv( GL_FRONT_AND_BACK, GL_EMISSION, this->m_Emissive );
#endif
        //assert( false );
}

//=============================================================================
// RenderToIGS
//
// Description: Renders the object to the IGS subsystem
//=============================================================================
IGS_Object* VrmlMaterial::RenderToIGS( VrmlStack& stack ) const
{
        IGS_Material* returnMe = new IGS_Material;
        return returnMe;
}

---