basic/geometry/IGS/IGS_Circle.cpp

Go to the documentation of this file.

#pragma warning ( disable : 4786 )

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


std::map< double, IGS_Circle::VertexList > IGS_Circle::g_VertexLists;

//=============================================================================
// Constructor
//
// Description: Constructor
//=============================================================================
IGS_Circle::IGS_Circle()
:
        Circle( 0.1 ),
    m_VertexList( NULL ),
    m_RenderFilled( false )
{
}

//=============================================================================
// Constructor
//
// Description: Constructor
//=============================================================================
IGS_Circle::IGS_Circle( const double radius )
:
    Circle( radius ),
    m_VertexList( NULL )
{
}


//=============================================================================
// Prepare
//
// Description: Called before rendering occurs
//=============================================================================
void IGS_Circle::Prepare( const IGS_Controller& controller )
{
        if( this->PreparationComplete() )
        {
                return;
        }

        //check if this circle radius is mapped already
        std::map< double, VertexList >::iterator it = g_VertexLists.find( m_Radius );
        if( it != g_VertexLists.end() )
        {
                IGS_Object::Prepare( controller );
                this->m_VertexList = &( *it ).second;
                return;
        }
        //this radius is not mapped, so lets create it!

        VertexList vertexList;

        //set up the circle polygon
        int i;
        const int steps = 33 - 1;
        for( i = 0; i < steps; i++ )
        {
                double theta = M_PI * 2 * i / steps;
                double x = ::sin( theta ) * m_Radius;
                double y = ::cos( theta ) * m_Radius;
                vertexList.vertices[ i ][ 0 ] = x;
                vertexList.vertices[ i ][ 1 ] = y;
                vertexList.vertices[ i ][ 2 ] = 0;
        }

        double theta = M_PI * 2 * 0 / steps;
        double x = ::sin( theta ) * m_Radius;
        double y = ::cos( theta ) * m_Radius;
        vertexList.vertices[ 32 ][ 0 ] = x;
        vertexList.vertices[ 32 ][ 1 ] = y;
        vertexList.vertices[ 32 ][ 2 ] = 0;
        g_VertexLists.insert( std::map< double, VertexList >::value_type( m_Radius, vertexList ) );

        //call this function recursively, to grab the vertex list properly
        this->Prepare( controller );
}

//=============================================================================
// Radius
//
// Description: returns the circle's radius
//=============================================================================
double IGS_Circle::Radius() const
{
        return this->m_Radius;
}

//=============================================================================
// Render
//
// Description: renders the mesh to an openGl context
//=============================================================================
void IGS_Circle::Render( const IGS_Controller& controller ) const
{   
    ::CheckGlErrorCode();
    glPushMatrix();
    ::CheckGlErrorCode();
    glTranslatef( m_Center[ 0 ], m_Center[ 1 ], 0.0 );
    ::CheckGlErrorCode();

        //check if this circle radius is mapped already
        if( m_VertexList == NULL )
        {
        IJG_Assert( m_VertexList != NULL );
                return;
        }
    if( m_RenderFilled )
    {
        ::glBegin( GL_TRIANGLE_FAN );
    }
    else
    {
        ::glBegin( GL_LINE_STRIP );
    }
        int i;
        for( i = 0; i < 33; i++ )
        {
                ::glVertex3dv( m_VertexList->vertices[ i ] );
        }

        ::glEnd();

    ::CheckGlErrorCode();
    glPopMatrix();
}

//=============================================================================
// SetCenter
//
// Description: Sets the center of the circle
//=============================================================================
void IGS_Circle::SetCenter( const Vector2& center )
{
    Circle::SetCenter( center );
}

//=============================================================================
// SetRenderFilled
//
// Description: set whether or not the circle should be filled in when rendered 
//              or not
//=============================================================================
void IGS_Circle::SetRenderFilled( const bool filled )
{
    m_RenderFilled = true;
}

---