basic/geometry/IGS/IGS_Polygon.cpp

Go to the documentation of this file.

#include "IGS_Controller.h"
#include "IGS_Polygon.h"
#include "math/Matrix4x4.h"
#include "opengl/glos.h"
#include <gl/gl.h>

//=============================================================================
// AddEdge
//
// Description: adds an edge to the list of edges
//=============================================================================
/*int IGS_Polygon::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;
}
*/
//=============================================================================
// AddFacet
//
// Description: adds a vertex to the list of points
//=============================================================================
/*int IGS_Polygon::AddFacet( const MeshFacet& facet )
{
        this->facets.push_back( facet );
        return facets.size();
}
*/
//=============================================================================
// AddNormal
//
// Description: adds a vertex to the list of points
//=============================================================================
/*int IGS_Polygon::AddNormal( const Vector4& normal )
{
        this->normals.push_back( normal );
        return normals.size() - 1;
}
*/
//=============================================================================
// AddVertex
//
// Description: adds a vector with the vertex coordinates to the mesh
//=============================================================================
int IGS_Polygon::AddVertex( const Vector4& vector )
{
        this->vertexes.push_back( vector );
        return vertexes.size();
}

//=============================================================================
// ClearSilhouetteEdges
//
// Description: clears all the computed silhouette edges from the last frame
//=============================================================================
/*void IGS_Polygon::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_Polygon::ComputeNormalForFacet( const int facetNum ) const
{
        const MeshFacet& f = this->facets[ facetNum ];
        int size = this->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();
        assert( mag != 0 );
        normal.Normalize();
        return ( normal );
}
*/
//=============================================================================
// GetBoundingBox
//
// Description: returns the bounding XYZ coordinates of the mesh
//=============================================================================
/*void IGS_Polygon::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->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 ] );
        }
}
*/
//=============================================================================
// GetNormal
//
// Description: returns the normal at index i
//=============================================================================
/*const Vector4& IGS_Polygon::GetNormal( const int i ) const
{
#ifdef _DEBUG
        int size = this->normals.size();
        assert( i < size );
#endif
        return this->normals[ i ];
}
*/
//=============================================================================
// GetVertex
//
// Description: gets a constant reference to a particular vertex
//=============================================================================
/*const Vector4& IGS_Polygon::GetVertex( const int i ) const
{
#ifdef _DEBUG
        int size = this->vertexes.size();
        assert( i < size );
#endif
        return this->vertexes[ i ];
}
*/
//=============================================================================
// Prepare
//
// Description: adds flat shaded normals to the object if it needs them
//=============================================================================
void IGS_Polygon::Prepare( const IGS_Controller& controller )
{
        //do nothing
}

//=============================================================================
// Render
//
// Description: renders the mesh to an openGl context
//=============================================================================
void IGS_Polygon::Render( const IGS_Controller& controller ) const
{
        ::glBegin( GL_LINE_STRIP );
        {
                int i;
                for( i = 0; i < this->vertexes.size(); i++ )
                {
                        const Vector4& vector = vertexes[ i ];
                        ::glVertex3d( vector[ 0 ], vector[ 1 ], vector[ 2 ] );
                }
                const Vector4& vector = vertexes[ 0 ];
                ::glVertex3d( vector[ 0 ], vector[ 1 ], vector[ 2 ] );

        }
        ::glEnd();
}

//=============================================================================
// 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
{
#ifdef _DEBUG
        int size = this->normalNums.size();
        assert( i < size );
#endif
        return this->normalNums[ i ];
}
*/
//=============================================================================
// GetVertexNum
//
// Description: gets the index of the vertex for vertex i
//=============================================================================
/*int MeshFacet::GetVertexNum( const int i ) const
{
#ifdef _DEBUG
        int size = this->vertexNums.size();
        assert( i < size );
#endif
        return this->vertexNums[ i ];
}
*/
//=============================================================================
// MarkFrontFacing
//
// Description: marks all the edges associated with this mesh as being front 
//                              facing
//=============================================================================
/*void MeshFacet::MarkFrontFacing( const IGS_Polygon* 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_Polygon* 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();
}
*/

---