basic/geometry/IGS/IGS_Mesh.cpp

Go to the documentation of this file.

#include "IGS_Controller.h"
#include "IGS_Mesh.h"
#include "math/Matrix4x4.h"
#ifndef NOGL
#include "opengl/glos.h"
#include <gl/gl.h>
#endif
#include <stdio.h>
//=============================================================================
// Constructor
//
// Description: Constructor
//=============================================================================
IGS_Mesh::IGS_Mesh()
{
}

//=============================================================================
// AddEdge
//
// Description: adds an edge to the list of edges
//=============================================================================
int IGS_Mesh::AddEdge( const int v0, const int v1 )
{
        int vertex0 = min( v0, v1 );
        int vertex1 = max( v0, v1 );
        MeshEdge m;
        m.v0 = vertex0;
        m.v1 = vertex1;

        //check if the edge already exists - linear search = slow!
        int i;
        int esize = this->edges.size();
        for( i = 0; i < esize; i++ )
        {
                MeshEdge& inarray = edges[ i ];
                if( inarray == m )
                {
                        return i;
                }
        }

        //we couldn't find the edge
        this->edges.push_back( m );
        return this->edges.size() - 1;
}

//=============================================================================
// AddVertex
//
// Description: adds a vertex to the list of points
//=============================================================================
int IGS_Mesh::AddFacet( const MeshFacet& facet )
{
        this->facets.push_back( facet );
        return facets.size();
}

//=============================================================================
// ClearSilhouetteEdges
//
// Description: clears all the computed silhouette edges from the last frame
//=============================================================================
void IGS_Mesh::ClearSilhouetteEdges() const
{
        int i;
        int esize = this->edges.size();
        for( i = 0; i < esize; i++ )
        {
                const MeshEdge& e = this->edges[ i ];
                e.ClearSilhouetteInfo();
        }
}

//=============================================================================
// ComputeNormalsForFacet
//
// Description: computes the facet normal( flat shading ) for a facet
//=============================================================================
Vector4 IGS_Mesh::ComputeNormalForFacet( const int facetNum ) const
{
        const MeshFacet& f = this->facets[ facetNum ];
        int size = this->m_Vertexes.size();

        int i0 = f.GetVertexNum( 0 );
        int i1 = f.GetVertexNum( 1 );
        int i2 = f.GetVertexNum( 2 );

        const Vector4& v0 = this->GetVertex( i0 );
        const Vector4& v1 = this->GetVertex( i1 );
        const Vector4& v2 = this->GetVertex( i2 );

        Vector4 normal = ( v1 - v0 ).Cross( v2 - v0 );
        double mag = normal.Magnitude();
        if( mag == 0 )
        {
                printf( "IGS_Mesh::ComputeNormalForFacet - found degenerate triangle\n" );
        }
        else
        {
                normal.Normalize();
        }
        return ( normal );
}

//=============================================================================
// GetBoundingBox
//
// Description: returns the bounding XYZ coordinates of the mesh
//=============================================================================
void IGS_Mesh::GetBoundingBox( double& xmin, double& xmax, double& ymin, double& ymax, double& zmin, double& zmax ) const
{
        //setup the initial min/max
        const Vector4& v0 = this->GetVertex( 0 );
        xmin = xmax = v0[ 0 ];
        ymin = ymax = v0[ 1 ];
        zmin = zmax = v0[ 2 ];

        int i;
        int vsize = this->m_Vertexes.size();
        for( i = 0; i < vsize; i++ )
        {
                const Vector4& v = this->GetVertex( i );
                xmin = min( xmin, v[ 0 ] );
                ymin = min( ymin, v[ 1 ] );
                zmin = min( zmin, v[ 2 ] );

                xmax = max( xmax, v[ 0 ] );
                ymax = max( ymax, v[ 1 ] );
                zmax = max( zmax, v[ 2 ] );
        }
}

//=============================================================================
// Prepare
//
// Description: adds flat shaded normals to the object if it needs them
//=============================================================================
void IGS_Mesh::Prepare( const IGS_Controller& controller )
{
        if( IGS_Object::PreparationComplete() )
        {
                return;
        }
        IGS_Object::Prepare( controller );

        //compute normals for each facet
        int size = this->facets.size();
        int i;
        for( i = 0; i < size; i++ )
        {
                Vector4 normal = this->ComputeNormalForFacet( i );
                int normalNum = this->AddNormal( normal );
                MeshFacet& f = this->facets[ i ];
                f.ClearNormals();

                int j;
                int fsize = f.Size();
                for( j = 0; j < fsize; j++ )
                {
                        f.AddNormalIndex( normalNum );
                }
        }

        //add edges for each facet
        for( i = 0; i < size; i++ )
        {
                MeshFacet& f = this->facets[ i ];
                int fsize = f.Size();
                int j;
                int v0 = f.GetVertexNum( 0 );
                for( j = 1; j < fsize; j++ )
                {
                        int v1 = f.GetVertexNum( j );
                        int edgenum = this->AddEdge( v0, v1 );
                        f.AddEdgeIndex( edgenum );
                        v0 = v1;
                }

                //don't foget the first/last wrapping
                int v1 = f.GetVertexNum( 0 );
                int edgenum = this->AddEdge( v0, v1 );
                f.AddEdgeIndex( edgenum );
        }
}

//=============================================================================
// Render
//
// Description: renders the mesh to an openGl context
//=============================================================================
void IGS_Mesh::Render( const IGS_Controller& controller ) const
{
#ifndef NOGL
        bool renderNormals = controller.SettingRenderNormals();
        bool renderSilhouettes = controller.SettingRenderSilhouettes();

        //clear all the silhouette info
        if( renderSilhouettes )
        {
                this->ClearSilhouetteEdges();
        }

        //get the cameraDriection 
        Vector4 cameraDirection;
        cameraDirection = controller.GetCameraDirection();
        //need to transform camera direction by the inverse of the modelview matrix
        double modelview[ 16 ];
        glGetDoublev(  GL_MODELVIEW_MATRIX , modelview );
        Matrix4x4 modelviewMatrix;
        modelviewMatrix.SetValues( modelview );
        modelviewMatrix = modelviewMatrix.Transpose();
        Matrix4x4 iModelviewMatrix = modelviewMatrix;
        iModelviewMatrix = iModelviewMatrix.Transpose();
        iModelviewMatrix( 3, 0 ) = 0;
        iModelviewMatrix( 3, 1 ) = 0;
        iModelviewMatrix( 3, 2 ) = 0;
        cameraDirection = iModelviewMatrix * cameraDirection;

        GLenum errorcode;

        //render all the polygons
        int i;
        int fsize = facets.size();
        for( i = 0; i < this->facets.size(); i++ )
        {
                const MeshFacet& f = facets[ i ];

                if( renderSilhouettes == true )
                {
                        //get the flat normal for this polygon
                        int normalNum = f.GetNormalNum( 0 );
                        const Vector4& normal = this->GetNormal( normalNum );

                        //transform the current normal by the modelview matrix

                        //compute the dot product of the camera direction and this normal
                        double dot = normal.Dot( cameraDirection );
                        if( dot > 0 ) 
                        {
                                f.MarkFrontFacing( this );
                        }
                        else
                        {
                                f.MarkBackFacing( this );
                        }
                }

                ::glBegin( GL_POLYGON );
                int j;
                int vsize = f.Size();
                for( j = 0; j < vsize; j++ )
                {
                        if( renderNormals == true )
                        {
                                //submit the normal
                                int normalNum = f.GetNormalNum( j );
                                const Vector4& normal = this->m_Normals[ normalNum ];
                                ::glNormal3d( normal[ 0 ], normal[ 1 ], normal[ 2 ] );
                        }

                        if( controller.SettingRenderNormalsAsColors() == true )
                        {
                                //rendering normals as colors
                                int normalNum = f.GetNormalNum( j );
                                Vector4 normal = this->m_Normals[ normalNum ];
                                if( controller.SettingNormalsRelativeToCamera() == true )
                                {
                                        normal = iModelviewMatrix * normal;
//                                      normal -= cameraDirection;
                                }

                                double n0 = normal[ 0 ];
                                double n1 = normal[ 1 ];
                                double n2 = normal[ 2 ];
                                n0 = ( n0 + 1.0 ) / 2.0;
                                n1 = ( n1 + 1.0 ) / 2.0;
                                n2 = ( n2 + 1.0 ) / 2.0;

                                ::glColor3d( n0, n1, n2 );
                        }
                        if( controller.GetRenderStyle() == G_PHOTOREALISTIC )
                        {
                                //IMPROVE: need a better way to specify colors
                                ::glColor3d( 0.5, 0.5, 0.5 );
                        }
                        else if( controller.GetRenderStyle() == G_COLOR )
                        {
                                ::glColor3d( 1.0, 0.0, 0.0 );
                        }

                        //submit the vertex
                        int vertexNum = f.GetVertexNum( j );
                        const Vector4& vertex = this->GetVertex( vertexNum );
                        ::glVertex3f( vertex[ 0 ], vertex[ 1 ], vertex[ 2 ] );
                }

                ::glEnd();
                errorcode = ::glGetError();
                assert( errorcode == GL_NO_ERROR );

        }

        if( renderSilhouettes )
        {
                //render all the edges
                float silhouetteEdgeWidth = controller.GetSilhouetteEdgeWidth();
                ::glDepthFunc( GL_LEQUAL );
                ::glLineWidth( silhouetteEdgeWidth );
                ::glEnable( GL_POINT_SMOOTH );
                ::glEnable( GL_LINE_SMOOTH );
                ::glPointSize( silhouetteEdgeWidth );
                ::glDisable( GL_LIGHTING );
                ::glColor3i( 0, 0, 0 );
                errorcode = ::glGetError();
                assert( errorcode == GL_NO_ERROR );

                ::glBegin( GL_LINES );
                int esize = this->edges.size();
                for( i = 0; i < esize; i++ )
                {
                        const MeshEdge& e = this->edges[ i ];
                        //draw all the edges marked as silhouette edges
                        if( e.IsSilhouette() )
                        {
                                int vertex0i = e.v0;
                                int vertex1i = e.v1;
                                Vector4 v0 = this->GetVertex( vertex0i );
                                Vector4 v1 = this->GetVertex( vertex1i );
                                ::glVertex3f( v0[ 0 ], v0[ 1 ], v0[ 2 ] );
                                ::glVertex3f( v1[ 0 ], v1[ 1 ], v1[ 2 ] );
                        }
                }
                ::glEnd();
                errorcode = ::glGetError();
                assert( errorcode == GL_NO_ERROR );

                //render dots where all the edges end 
                ::glBegin( GL_POINTS );
                esize = this->edges.size();
                for( i = 0; i < esize; i++ )
                {
                        const MeshEdge& e = this->edges[ i ];
                        //draw all the edges marked as silhouette edges
                        if( e.IsSilhouette() )
                        {
                                int vertex0i = e.v0;
                                int vertex1i = e.v1;
                                Vector4 v0 = this->GetVertex( vertex0i );
                                Vector4 v1 = this->GetVertex( vertex1i );
                                ::glVertex3f( v0[ 0 ], v0[ 1 ], v0[ 2 ] );
                                ::glVertex3f( v1[ 0 ], v1[ 1 ], v1[ 2 ] );
                        }
                }
                ::glEnd();
                errorcode = ::glGetError();
                assert( errorcode == GL_NO_ERROR );
        }
#endif
}

//=============================================================================
// constructor
//
// Description: constructor
//=============================================================================
MeshEdge::MeshEdge():
        mRenderedForward( false ),
        mRenderedReverse( false ),
        mTimesRendered( 0 )
{
}

//=============================================================================
// operator==
//
// Description: comparison on two mesh edges
//=============================================================================
bool MeshEdge::operator==( const MeshEdge& right ) const
{
        if( v0 != right.v0 )
        {
                return false;
        }
        if( v1 != right.v1 )
        {
                return false;
        }
        return true;
}

//=============================================================================
// ClearSilhouetteInfo
//
// Description: removes all cached silhouete info
//=============================================================================
void MeshEdge::ClearSilhouetteInfo() const
{
        this->mTimesRendered = 0;
        this->mRenderedForward = false;
        this->mRenderedReverse = false;
}

//=============================================================================
// IsSilhouette
//
// Description: determines if an edge has been flagged as a silhouette or not
//=============================================================================
bool MeshEdge::IsSilhouette() const
{
        if( ( this->mRenderedForward == true ) && ( this->mRenderedReverse == true ) )
        {
                return true;
        }
        if( this->mTimesRendered != 2 )
        {
//              assert( this->mTimesRendered == 2 );
                return true;
        }
        return false;
}

//=============================================================================
// MarkFrontFacing
//
// Description: marks an edge as front facing
//=============================================================================
void MeshEdge::MarkFrontFacing() const
{
        this->mTimesRendered++;
        this->mRenderedForward = true;
}

//=============================================================================
// MarkBackFacing
//
// Description: marks an edge as back facing
//=============================================================================
void MeshEdge::MarkBackFacing() const
{
        this->mTimesRendered++;
        this->mRenderedReverse = true ;
}


//=============================================================================
// AddEdgeIndex
//
// Description: adds an edge index to this facet of a mesh
//=============================================================================
void MeshFacet::AddEdgeIndex( const int index )
{
        //check to see if this edge already exists
        int i;
        int esize = this->edgeNums.size();
        for( i = 0; i < esize; i++ )
        {
                int inarray = this->edgeNums[ i ];
                if( index == inarray )
                {
                        return;
                }
        }

        this->edgeNums.push_back( index );       
}

//=============================================================================
// AddNormalIndex
//
// Description: adds a normal index to a facet
//=============================================================================
void MeshFacet::AddNormalIndex( const int index )
{
        this->normalNums.push_back( index );
}

//=============================================================================
// AddVertexIndex
//
// Description: adds a vertex index to a facet
//=============================================================================
void MeshFacet::AddVertexIndex( const int index )
{
        this->vertexNums.push_back( index );
}

//=============================================================================
// Clear
//
// Description: clears all the data out of the facet
//=============================================================================
void MeshFacet::Clear()
{
        this->vertexNums.clear();
}

//=============================================================================
// ClearNormals
//
// Description: clears all the data about the normals
//=============================================================================
void MeshFacet::ClearNormals()
{
        this->normalNums.clear();
        this->normalNums.reserve( this->Size() );
}

//=============================================================================
// GetNormalNum
//
// Description: gets the index of thr normal for vertex i
//=============================================================================
int MeshFacet::GetNormalNum( const int i ) const
{
        return this->normalNums[ i ];
}

//=============================================================================
// GetVertexNum
//
// Description: gets the index of the vertex for vertex i
//=============================================================================
int MeshFacet::GetVertexNum( const int i ) const
{
        return this->vertexNums[ i ];
}

//=============================================================================
// MarkFrontFacing
//
// Description: marks all the edges associated with this mesh as being front 
//                              facing
//=============================================================================
void MeshFacet::MarkFrontFacing( const IGS_Mesh* parent ) const 
{
        int i;
        int esize = this->edgeNums.size();
        int vsize = this->vertexNums.size();
        for( i = 0; i < esize; i++ )
        {
                int index = this->edgeNums[ i ];
                parent->edges[ index ].MarkFrontFacing();
        }
}

//=============================================================================
// MarkBackFacing
//
// Description: marks all the edges associated with this mesh as being front 
//                              facing
//=============================================================================
void MeshFacet::MarkBackFacing( const IGS_Mesh* parent ) const
{
        int i;
        int esize = this->edgeNums.size();
        int vsize = this->vertexNums.size();
        for( i = 0; i < esize; i++ )
        {
                int index = this->edgeNums[ i ];
                parent->edges[ index ].MarkBackFacing();
        }
}


//=============================================================================
// Size
//
// Description: determines how many verteces are int this facet
//=============================================================================
int MeshFacet::Size() const
{
        return this->vertexNums.size();
}

---