basic/geometry/vrml_reader/VrmlIndexedFaceSet.cpp

Go to the documentation of this file.

#include <assert.h>
#ifndef NOGL
#include "opengl/glos.h"
#include <gl/gl.h>
#endif
#include <geometry/igs/IGS_Mesh.h>
#include <geometry/igs/IGS_MeshTri.h>
#include <math/Vector4.h>
#include <stdio.h>
#include <string.h>
#include "utility.h"
#include "VrmlCoordinate3.h"
#include "VrmlIndexedFaceSet.h"
#include "VrmlStack.h"

//=============================================================================
// constructor
//
// Description: constructor
//=============================================================================
VrmlIndexedFaceSet::VrmlIndexedFaceSet()
:
        m_Coords( NULL ),
        m_TexCoord( NULL ),
        m_NormalsComputed( false )
{
}

//=============================================================================
// Destructor
//
// Description: delete all the nodes
//=============================================================================
VrmlIndexedFaceSet::~VrmlIndexedFaceSet()
{
        if( m_Coords != NULL )
        {
                m_Coords->Release();
                m_Coords = NULL;
        }

        if( m_TexCoord != NULL )
        {
                m_TexCoord->Release();
                m_TexCoord = NULL;
        }
}

//=============================================================================
// ComputeNormals
//
// Description: computes the normals for this indexed face set if they weren't 
//                              already specified in the file
//=============================================================================
void VrmlIndexedFaceSet::ComputeNormals( VrmlStack& stack ) const
{
        int index = 0;
        int size = this->indexes.size();
        this->m_Normals.resize( size );
        while( index < size )
        {
                //compute the normals for this polygon
                int i0 = this->indexes[ index + 0 ];
                int i1 = this->indexes[ index + 1 ];
                int i2 = this->indexes[ index + 2 ];

                Vector4 v0 = stack.vrmlCoordinate3->GetCoordinate( i0 );
                Vector4 v1 = stack.vrmlCoordinate3->GetCoordinate( i1 );
                Vector4 v2 = stack.vrmlCoordinate3->GetCoordinate( i2 );

                Vector4 n = ( v1 - v0 ).Cross( v2 - v0 );
                n.Normalize();

                for( index; this->indexes[ index ] != -1; index++ )
                {
                        this->m_Normals[ index ] = n;
                }
                index++;
        }
        this->m_NormalsComputed = true;
}

//=============================================================================
// GetNormal
//
// Description: returns the normal that corresponds to a given vertex in a 
//                              specific face
//=============================================================================
Vector4 VrmlIndexedFaceSet::GetNormal( const int index, VrmlStack& stack ) const
{
        if( !m_NormalsComputed )
        {
                ComputeNormals( stack );
        }

        return this->m_Normals[ index ];
}

//=============================================================================
// GetKeyword
//
// Description: gets the keyword that is valid for an IndexedFaceSet
//=============================================================================
Keyword VrmlIndexedFaceSet::GetKeyword( char*& buffer )
{
        char keyword[ 80 ] = "";
        VrmlNode::GetKeywordString( buffer, keyword );  

        //compare the keyword with the string values of various keywords
        if( strcmp( keyword, VrmlKeywordCcw ) == 0 )
        {
                return VRML_Ccw;
        }
        if( strcmp( keyword, VrmlKeywordCoordIndex ) == 0 )
        {
                return VRML_CoordIndex;
        }
        if( strcmp( keyword, VrmlKeywordMaterialIndex ) == 0 )
        {
                return VRML_MaterialIndex;
        }
        if( strcmp( keyword, VrmlKeywordNormalIndex ) == 0 )
        {
                return VRML_NormalIndex;
        }
        if( strcmp( keyword, VrmlKeywordTextureCoordIndex ) == 0 )
        {
                return VRML_TextureCoordIndex;
        }

        assert( false );
        return VRML_Invalid;
}

//=============================================================================
// Parse
//
// Description: renders this node to the screen (OpenGL)
//=============================================================================
void VrmlIndexedFaceSet::Parse( char*& buffer )
{
        EatWhite( buffer );
        while( *buffer != '}' )
        {
                EatWhite( buffer );
                Keyword keyword = VrmlNode::GetKeyword( buffer );
                this->ParseSubnode( keyword, buffer );
                EatWhite( buffer );
        }

        //advance past the trailing '}'
        EatWhite( buffer );
        buffer++;
}

//=============================================================================
// ParseNodeColor
//
// Description: extracts all the color data
//=============================================================================
void VrmlIndexedFaceSet::ParseNodeColor( char*& buffer )
{
        EatWhite( buffer );
        buffer = strchr( buffer, '}' );
        buffer++;
}

//=============================================================================
// ParseNodeCoord
//
// Description: extracts all the coord data
//=============================================================================
void VrmlIndexedFaceSet::ParseNodeCoord( char*& buffer )
{
        Keyword keyword = VrmlNode::GetKeyword( buffer );
        EatWhite( buffer );
        if( ( keyword != VRML_Define ) && ( keyword != VRML_Use ) )
        {
                buffer++;
        }
        VrmlNode* node = VrmlNode::ParseNode( keyword, buffer );                //IMPROVE: what does it do with the node?
        assert( m_Coords == NULL );
        this->m_Coords = node;
        this->m_Coords->AddRef();
}

//=============================================================================
// ParseNodeCoordIndex
//
// Description: extracts all the coordIndex data
//=============================================================================
void VrmlIndexedFaceSet::ParseNodeCoordIndex( char*& buffer )
{
        EatWhite( buffer );
        assert( *buffer == '[' );
        buffer++;
        EatWhite( buffer );

        while( true )
        {
                int value = 0;
                int number = sscanf( buffer, "%d", &value );
                if( number == 1 )
                {
                        indexes.push_back( value );
                }

                int position = strcspn( buffer, ",]" );         //IMPROVE: reuse these characters
                buffer += position;
                if( *buffer == ']' )
                {
                        break;
                }
                assert( *buffer == ',' );
                buffer++;
        }

        //advance past the trailing ']'
        buffer++;
}

//=============================================================================
// ParseNodeIgnore
//
// Description: parses a subnode but ignores all the data - BAD BAD BAD
//                              IAN IMPROVE: this shoule not even exist
//=============================================================================
void VrmlIndexedFaceSet::ParseNodeIgnore( char*& buffer )
{
        EatWhite( buffer );
        assert( *buffer == '[' );
        buffer = strchr( buffer, ']' );
        buffer++;
}

//=============================================================================
// ParseNodeMaterialIndex
//
// Description: parses a material index
//=============================================================================
void VrmlIndexedFaceSet::ParseNodeMaterialIndex( char*& buffer )
{
        EatWhite( buffer );
        assert( *buffer == '[' );
        buffer++;
        EatWhite( buffer );

        while( true )
        {
                int value = 0;
                int number = sscanf( buffer, "%d", &value );
                if( number == 1 )
                {
                        //indexes.push_back( value );
                }

                int position = strcspn( buffer, ",]" );         //IMPROVE: reuse these characters
                buffer += position;
                if( *buffer == ']' )
                {
                        break;
                }
                assert( *buffer == ',' );
                buffer++;
        }

        //advance past the trailing ']'
        buffer++;

}

//=============================================================================
// ParseNodeNormalIndex
//
// Description: parses a normal index
//=============================================================================
void VrmlIndexedFaceSet::ParseNodeNormalIndex( char*& buffer )
{
        EatWhite( buffer );
        assert( *buffer == '[' );
        buffer++;
        EatWhite( buffer );

        while( true )
        {
                int value = 0;
                int number = sscanf( buffer, "%d", &value );
                if( number == 1 )
                {
                        //indexes.push_back( value );
                }

                int position = strcspn( buffer, ",]" );         //IMPROVE: reuse these characters
                buffer += position;
                if( *buffer == ']' )
                {
                        break;
                }
                assert( *buffer == ',' );
                buffer++;
        }
        //advance past the trailing ']'
        buffer++;
}

//=============================================================================
// ParseNodeTexCoord
//
// Description: 
//=============================================================================
void VrmlIndexedFaceSet::ParseNodeTexCoord( char*& buffer )
{
        EatWhite( buffer );
        Keyword keyword = VrmlNode::GetKeyword( buffer );
        EatWhite( buffer );
        if( ( keyword != VRML_Define ) && ( keyword != VRML_Use ) )
        {
                buffer++;
        }
        VrmlNode* node = VrmlNode::ParseNode( keyword, buffer );                //IMPROVE: what does it do with the node?
        this->m_TexCoord = node;
        this->m_TexCoord->AddRef();
}

//=============================================================================
// Parse
//
// Description: parses all the subnodes for this node type
//=============================================================================
void VrmlIndexedFaceSet::ParseSubnode( Keyword keyword, char*& buffer )
{
        switch( keyword )
        {
        case VRML_Ccw:
        case VRML_ColorPerVertex:
        case VRML_Convex:
        case VRML_CreaseAngle:
        case VRML_Solid:
    case VRML_NormalPerVertex:
                {
                        //read until the end of the line
                        while( buffer[ 0 ] != '\n' )
                        {
                                buffer++;
                        }
                        break;
                }
        case VRML_Coord:
                 {
                         this->ParseNodeCoord( buffer );
                         break;
                 }
    case VRML_Color:
        case VRML_Normal:
                 {
                         ParseNodeColor( buffer );
                         break;
                 }
        case VRML_CoordIndex:
                 {
                         this->ParseNodeCoordIndex( buffer );
                         break;
                 }
        case VRML_NormalIndex:
                {
                        this->ParseNodeNormalIndex( buffer );
                        break;
                }
        case VRML_MaterialIndex:
                {
                        this->ParseNodeMaterialIndex( buffer );
                        break;
                }
        case VRML_TexCoord:
                {
                        this->ParseNodeTexCoord( buffer );
                        break;
                }
        case VRML_TextureCoordIndex:
        case VRML_TexCoordIndex:
    case VRML_Vector:
                {
                        this->ParseNodeIgnore( buffer );
                        break;
                }
        default:
                {
                        printf( "WARNING: VrmlIndexedFaceSet::ParseSubnode - Don't know how to parse this keyword\n" );
                        IJG_Assert( false );
                        break;
                }
        }
}

//=============================================================================
// Render
//
// Description: renders this node to the screen (OpenGL)
//=============================================================================
void VrmlIndexedFaceSet::Render( VrmlStack& stack ) const
{
        if( this->m_Coords != NULL )
        {
                this->m_Coords->Render( stack );
        }
}

//=============================================================================
// RenderOpenGl
//
// Description: renders this object to an openGl Context
//=============================================================================
void VrmlIndexedFaceSet::RenderOpenGl( VrmlStack& stack ) const
{
#ifndef NOGL
        this->Render( stack );

        //IAN IMPROVE: this matrix pushing stuff has not been tested

        ::glPushMatrix();
        double matrixValues[ 16 ];
        stack.m_Matrix.GetValuesOpenGl( matrixValues );
        ::glMultMatrixd( reinterpret_cast< double* >( matrixValues ) );


        int i = 0;
        int size = indexes.size();
        while( i < size )
        {
                //for every polygon do..
                glBegin( GL_POLYGON );

                int index = indexes[ i ];
                while( index != -1 )
                {
                        //get the normal associated with this vertex
                        Vector4 n = this->GetNormal( i, stack );
                        ::glNormal3f( n[ 0 ], n[ 1 ], n[ 2 ] );

                        //for every vertex do...
                        Vector4 v = stack.vrmlCoordinate3->GetCoordinate( index );
                        ::glVertex3f( v[ 0 ], v[ 1 ], v[ 2 ] );
                        i++;
                        index = indexes[ i ];
                }
                i++;
                glEnd();
        }

        ::glPopMatrix();
        GLenum errorcode = ::glGetError();
        assert( errorcode == GL_NO_ERROR );


/*      ::glBegin( GL_POLYGON );                //IAN IMPROVE: is polygons appropriate

        //compute normal to this face for flat shading
        int i0 = indexes[ 0 ];
        int i1 = indexes[ 1 ];
        int i2 = indexes[ 2 ];
        Vector4 p0 = stack.vrmlCoordinate3->GetCoordinate( i0 );
        Vector4 p1 = stack.vrmlCoordinate3->GetCoordinate( i1 );
        Vector4 p2 = stack.vrmlCoordinate3->GetCoordinate( i2 );
        Vector4 n = ( p1 - p0 ).Cross( p2 - p0 );
        ::glNormal3f( n[ 0 ], n[ 1 ], n[ 2 ] );
        int i;
        for( i = 0; i < this->indexes.size(); i++ )
        {
                int index = indexes[ i ];
                if( index == -1 )
                {
                        glEnd();
                        glBegin( GL_POLYGON );
                        int i0 = indexes[ i + 1 ];
                        int i1 = indexes[ i + 2 ];
                        int i2 = indexes[ i + 3 ];
                        Vector4 p0 = stack.vrmlCoordinate3->GetCoordinate( i0 );
                        Vector4 p1 = stack.vrmlCoordinate3->GetCoordinate( i1 );
                        Vector4 p2 = stack.vrmlCoordinate3->GetCoordinate( i2 );
                        Vector4 n = ( p1 - p0 ).Cross( p2 - p0 );
                        ::glNormal3f( n[ 0 ], n[ 1 ], n[ 2 ] );

                }
                else
                {
                        Vector4 vector = stack.vrmlCoordinate3->GetCoordinate( index );
                        ::glVertex3f( vector[ 0 ], vector[ 1 ], vector[ 2 ] );
                }
        }
        ::glEnd();
        ::glPopMatrix();
*/
#endif
}

//=============================================================================
// RenderToIGS
//
// Description: creates an IGS object for the mesh
//=============================================================================
IGS_Object* VrmlIndexedFaceSet::RenderToIGS( VrmlStack& stack ) const
{
        this->Render( stack );

        //need to build an IGS mesh out of this data
        IGS_Mesh* mesh = new IGS_Mesh;
        MeshFacet facet;

        int maxIndex = -1;

        int i;
        for( i = 0; i < this->indexes.size(); i++ )
        {
                int index = indexes[ i ];
                if( index == -1 )
                {
                        mesh->AddFacet( facet );
                        facet.Clear();
                }
                else
                {
                        facet.AddVertexIndex( index );
                        if( index > maxIndex )
                        {
                                maxIndex = index;
                        }
                }
        }

        for( i = 0; i < maxIndex + 1; i++ )
        {
                assert( stack.vrmlCoordinate3 != NULL );
                Vector4 vector = stack.vrmlCoordinate3->GetCoordinate( i );
                assert( vector.Magnitude() < 1000.0 );
                vector = stack.m_Matrix * vector;
                assert( vector.Magnitude() < 1000.0 );
                mesh->AddVertexCoordinates( vector );
        }

        //convert the mesh to a triangulated mesh before we return it
        IGS_MeshTri* triangulatedMesh = new IGS_MeshTri( *mesh );
        delete mesh;
        mesh = NULL;
        return triangulatedMesh;
}

---