basic/geometry/IGS/IGS_MeshTri.cpp

Go to the documentation of this file.

#ifndef NOGL
#include "opengl/glos.h"
#include <gl/gl.h>
#endif
#include "IGS_Mesh.h"
#include "IGS_MeshTri.h"
#include <stdio.h>


//=============================================================================
// Constructor
//
// Description: Default constructor
//=============================================================================
IGS_MeshTri::IGS_MeshTri()
{
        assert( false );
}

//=============================================================================
// Constructor
//
// Description: Copy Constructor
//=============================================================================
IGS_MeshTri::IGS_MeshTri( const IGS_MeshTri& right )
{
        assert( false );
}

//=============================================================================
// Constructor
//
// Description: copys from a regular IGS_Mesh
//=============================================================================
IGS_MeshTri::IGS_MeshTri( const IGS_Mesh& right )
:
        IGS_MeshBase( right )
{
        //copy the facetes of the IGS_Mesh one at a time
        int i;
        int size = right.facets.size();
        for( i = 0; i < right.facets.size(); i++ )
        {
                const MeshFacet& f = right.facets[ i ];
                this->AddFacet( f );
        }
}

//=============================================================================
// AddFacet
//
// Description: Adds a polyhedral facet to this mesh
//=============================================================================
void IGS_MeshTri::AddFacet( const MeshFacet& f )
{
        int i;
        int size = f.Size();

        int v0 = f.GetVertexNum( 0 );
        int v1 = f.GetVertexNum( 1 );
        for( i = 2; i < size; i++ )
        {
                int v2 = f.GetVertexNum( i );
                this->AddTriangle( v0, v1, v2 );
                v1 = v2;
        }
}

//=============================================================================
// AddTriangle
//
// Description: Adds a triangle to this object
//=============================================================================
void IGS_MeshTri::AddTriangle( const int v0, const int v1, const int v2 )
{
        Triangle addme;
        addme.v0 = v0;
        addme.v1 = v1;
        addme.v2 = v2;
        this->m_Triangles.push_back( addme );
}

//=============================================================================
// ComputeNormalForTriangle
//
// Description: if there has been normal assigned for this triangle, assign one
//=============================================================================
Vector4 IGS_MeshTri::ComputeNormalForTriangle( const int triangleNumber )
{
        const Triangle& t = this->m_Triangles[ triangleNumber ];

        const Vector4& v0 = this->GetVertex( t.v0 );
        const Vector4& v1 = this->GetVertex( t.v1 );
        const Vector4& v2 = this->GetVertex( t.v2 );

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

//=============================================================================
// GetNumTriangles
//
// Description: Returns the number of triangles used in this mesh
//=============================================================================
int IGS_MeshTri::GetNumTriangles() const
{
        return this->m_Triangles.size();
}

//=============================================================================
// GetTriangle
//
// Description: Allows access to the underlying triangles
//=============================================================================
const IGS_MeshTri::Triangle& IGS_MeshTri::GetTriangle( const int i ) const
{
        return this->m_Triangles[ i ];
}

//=============================================================================
// Prepare
//
// Description: Prepares the mesh for rendering by precomputing all the normals
//=============================================================================
void IGS_MeshTri::Prepare( const IGS_Controller& controller )
{
        if( IGS_Object::PreparationComplete() )
        {
                return;
        }
        IGS_Object::Prepare( controller );

        //compute normals for each triangle
        int size = this->m_Triangles.size();
        int i;
        for( i = 0; i < size; i++ )
        {
                Vector4 normal = this->ComputeNormalForTriangle( i );
                int normalNum = this->AddNormal( normal );
                Triangle& t = this->m_Triangles[ i ];
                t.n = normalNum;
        }
}

//=============================================================================
// Render
//
// Description: Actually renders the object to the screen
//=============================================================================
void IGS_MeshTri::Render( const IGS_Controller& controller ) const
{
#ifndef NOGL
        ::glBegin( GL_TRIANGLES );

        int i;
        int size = this->m_Triangles.size();
        for( i = 0; i < size; i++ )
        {
                const Triangle& t = m_Triangles[ i ];
                const Vector4& v0 = m_Vertexes[ t.v0 ];
                const Vector4& v1 = m_Vertexes[ t.v1 ];
                const Vector4& v2 = m_Vertexes[ t.v2 ];
                const Vector4& n = m_Normals[ t.n ];
                ::glNormal3d( n[ 0 ], n[ 1 ], n[ 2 ] );
                ::glVertex3d( v0[ 0 ], v0[ 1 ], v0[ 2 ] );
                ::glVertex3d( v1[ 0 ], v1[ 1 ], v1[ 2 ] );
                ::glVertex3d( v2[ 0 ], v2[ 1 ], v2[ 2 ] );
        }

        ::glEnd();
#endif
};

---