void ocpnDC::DrawPolygon( int n, wxPoint points[], wxCoord xoffset, wxCoord yoffset )
{
if( dc )
dc->DrawPolygon( n, points, xoffset, yoffset );
#ifdef ocpnUSE_GL
else {
glPushAttrib( GL_ENABLE_BIT | GL_COLOR_BUFFER_BIT | GL_LINE_BIT | GL_HINT_BIT | GL_POLYGON_BIT ); //Save state
SetGLAttrs( true );
if( ConfigureBrush() ) {
glBegin( GL_POLYGON );
for( int i = 0; i < n; i++ )
glVertex2i( points[i].x + xoffset, points[i].y + yoffset );
glEnd();
}
if( ConfigurePen() ) {
glBegin( GL_LINE_LOOP );
for( int i = 0; i < n; i++ )
glVertex2i( points[i].x + xoffset, points[i].y + yoffset );
glEnd();
}
glPopAttrib();
}
#endif
}
void ocpnDC::DrawEllipse( wxCoord x, wxCoord y, wxCoord width, wxCoord height )
{
if( dc ) dc->DrawEllipse( x, y, width, height );
else {
double r1 = width / 2, r2 = height / 2;
double cx = x + r1, cy = y + r2;
glPushAttrib( GL_COLOR_BUFFER_BIT | GL_LINE_BIT | GL_HINT_BIT ); //Save state
// Enable anti-aliased lines, at best quality
glEnable( GL_LINE_SMOOTH );
glEnable( GL_BLEND );
glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
glHint( GL_LINE_SMOOTH_HINT, GL_NICEST );
if( ConfigureBrush() ) {
glBegin( GL_TRIANGLE_FAN );
glVertex2d( cx, cy );
for( double a = 0; a <= 2 * M_PI; a += 2 * M_PI / 20 )
glVertex2d( cx + r1 * sin( a ), cy + r2 * cos( a ) );
glEnd();
}
if( ConfigurePen() ) {
glBegin( GL_LINE_STRIP );
for( double a = 0; a <= 2 * M_PI; a += 2 * M_PI / 200 )
glVertex2d( cx + r1 * sin( a ), cy + r2 * cos( a ) );
glEnd();
}
glPopAttrib(); // restore state
}
}
void ocpnDC::DrawRectangle( wxCoord x, wxCoord y, wxCoord w, wxCoord h )
{
if( dc )
dc->DrawRectangle( x, y, w, h );
#ifdef ocpnUSE_GL
else {
if( ConfigureBrush() ) {
glBegin( GL_QUADS );
glVertex2i( x, y );
glVertex2i( x + w, y );
glVertex2i( x + w, y + h );
glVertex2i( x, y + h );
glEnd();
}
if( ConfigurePen() ) {
glBegin( GL_LINE_LOOP );
glVertex2i( x, y );
glVertex2i( x + w, y );
glVertex2i( x + w, y + h );
glVertex2i( x, y + h );
glEnd();
}
}
#endif
}
void ocpnDC::DrawEllipse( wxCoord x, wxCoord y, wxCoord width, wxCoord height )
{
if( dc )
dc->DrawEllipse( x, y, width, height );
#ifdef ocpnUSE_GL
else {
float r1 = width / 2, r2 = height / 2;
float cx = x + r1, cy = y + r2;
// Enable anti-aliased lines, at best quality
glEnable( GL_BLEND );
/* formula for variable step count to produce smooth ellipse */
float steps = floorf(wxMax(sqrtf(sqrtf((float)(width*width + height*height))), 1) * M_PI);
if( ConfigureBrush() ) {
glBegin( GL_TRIANGLE_FAN );
glVertex2f( cx, cy );
for( float a = 0; a <= 2 * M_PI + M_PI/steps; a += 2 * M_PI / steps )
glVertex2f( cx + r1 * sinf( a ), cy + r2 * cosf( a ) );
glEnd();
}
if( ConfigurePen() ) {
glBegin( GL_LINE_LOOP );
for( float a = 0; a < 2 * M_PI - M_PI/steps; a += 2 * M_PI / steps )
glVertex2f( cx + r1 * sinf( a ), cy + r2 * cosf( a ) );
glEnd();
}
glDisable( GL_BLEND );
}
#endif
}
void ocpnDC::DrawRoundedRectangle( wxCoord x, wxCoord y, wxCoord w, wxCoord h, wxCoord r )
{
if( dc )
dc->DrawRoundedRectangle( x, y, w, h, r );
#ifdef ocpnUSE_GL
else {
r++;
int steps = ceil(sqrt((float)r));
wxCoord x1 = x + r, x2 = x + w - r;
wxCoord y1 = y + r, y2 = y + h - r;
if( ConfigureBrush() ) {
glBegin( GL_TRIANGLE_FAN );
drawrrhelper( x2, y1, r, 0, steps );
drawrrhelper( x1, y1, r, 1, steps );
drawrrhelper( x1, y2, r, 2, steps );
drawrrhelper( x2, y2, r, 3, steps );
glEnd();
}
if( ConfigurePen() ) {
glBegin( GL_LINE_LOOP );
drawrrhelper( x2, y1, r, 0, steps );
drawrrhelper( x1, y1, r, 1, steps );
drawrrhelper( x1, y2, r, 2, steps );
drawrrhelper( x2, y2, r, 3, steps );
glEnd();
}
}
#endif
}
void ocpnDC::DrawPolygon( int n, wxPoint points[], wxCoord xoffset, wxCoord yoffset, float scale )
{
if( dc )
dc->DrawPolygon( n, points, xoffset, yoffset );
#ifdef ocpnUSE_GL
else {
#ifdef __WXQT__
SetGLAttrs( false ); // Some QT platforms (Android) have trouble with GL_BLEND / GL_LINE_SMOOTH
#else
SetGLAttrs( true );
#endif
if( ConfigureBrush() ) {
glBegin( GL_POLYGON );
for( int i = 0; i < n; i++ )
glVertex2f( (points[i].x * scale) + xoffset, (points[i].y * scale) + yoffset );
glEnd();
}
if( ConfigurePen() ) {
glBegin( GL_LINE_LOOP );
for( int i = 0; i < n; i++ )
glVertex2f( (points[i].x * scale) + xoffset, (points[i].y * scale) + yoffset );
glEnd();
}
SetGLAttrs( false );
}
#endif
}
void ODDC::DrawPolygonsTessellated( int n, int npoints[], wxPoint points[], wxCoord xoffset, wxCoord yoffset )
{
if( dc ) {
int prev = 0;
for( int i = 0; i < n; i++ ) {
dc->DrawPolygon( npoints[i], &points[i + prev], xoffset, yoffset );
prev += npoints[i];
}
}
#ifdef ocpnUSE_GL
else {
GLUtesselator *tobj = gluNewTess();
gluTessCallback( tobj, GLU_TESS_VERTEX, (_GLUfuncptr) &ODDCvertexCallback );
gluTessCallback( tobj, GLU_TESS_BEGIN, (_GLUfuncptr) &ODDCbeginCallback );
gluTessCallback( tobj, GLU_TESS_END, (_GLUfuncptr) &ODDCendCallback );
gluTessCallback( tobj, GLU_TESS_COMBINE, (_GLUfuncptr) &ODDCcombineCallback );
gluTessCallback( tobj, GLU_TESS_ERROR, (_GLUfuncptr) &ODDCerrorCallback );
gluTessNormal( tobj, 0, 0, 1);
gluTessProperty(tobj, GLU_TESS_WINDING_RULE, GLU_TESS_WINDING_ODD);
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
gluTessProperty(tobj, GLU_TESS_BOUNDARY_ONLY, GL_FALSE);
if(glIsEnabled(GL_TEXTURE_2D)) g_bTexture2D = true;
else g_bTexture2D = false;
ConfigurePen();
if( ConfigureBrush() ) {
gluTessBeginPolygon(tobj, NULL);
int prev = 0;
for( int j = 0; j < n; j++ ) {
gluTessBeginContour(tobj);
for( int i = 0; i < npoints[j]; i++ ) {
GLvertex* vertex = new GLvertex();
gTesselatorVertices.Add( vertex );
vertex->info.x = (GLdouble) points[i + prev].x;
vertex->info.y = (GLdouble) points[i + prev].y;
vertex->info.z = (GLdouble) 0.0;
vertex->info.r = (GLdouble) 0.0;
vertex->info.g = (GLdouble) 0.0;
vertex->info.b = (GLdouble) 0.0;
vertex->info.a = (GLdouble) 0.0;
gluTessVertex( tobj, (GLdouble*)vertex, (GLdouble*)vertex );
}
gluTessEndContour( tobj );
prev += npoints[j];
}
gluTessEndPolygon(tobj);
}
gluDeleteTess(tobj);
for (unsigned int i = 0; i<gTesselatorVertices.Count(); i++)
delete (GLvertex*)gTesselatorVertices.Item(i);
gTesselatorVertices.Clear();
}
#endif
}
void ODDC::DrawPolygon( int n, wxPoint points[], wxCoord xoffset, wxCoord yoffset, float scale )
{
if( dc )
dc->DrawPolygon( n, points, xoffset, yoffset );
#ifdef ocpnUSE_GL
else {
SetGLAttrs( true );
if( ConfigureBrush() ) {
glBegin( GL_POLYGON );
for( int i = 0; i < n; i++ )
glVertex2f( (points[i].x * scale) + xoffset, (points[i].y * scale) + yoffset );
glEnd();
}
if( ConfigurePen() ) {
glBegin( GL_LINE_LOOP );
for( int i = 0; i < n; i++ )
glVertex2f( (points[i].x * scale) + xoffset, (points[i].y * scale) + yoffset );
glEnd();
}
SetGLAttrs( false );
}
#endif
}
void ocpnDC::DrawPolygonTessellated( int n, wxPoint points[], wxCoord xoffset, wxCoord yoffset )
{
if( dc )
dc->DrawPolygon( n, points, xoffset, yoffset );
#ifdef ocpnUSE_GL
else {
# ifndef ocpnUSE_GLES // tessalator in glues is broken
if( n < 5 )
# endif
{
DrawPolygon( n, points, xoffset, yoffset );
return;
}
glPushAttrib( GL_ENABLE_BIT | GL_COLOR_BUFFER_BIT | GL_LINE_BIT | GL_HINT_BIT | GL_POLYGON_BIT ); //Save state
SetGLAttrs( false );
static GLUtesselator *tobj = NULL;
if( ! tobj ) tobj = gluNewTess();
gluTessCallback( tobj, GLU_TESS_VERTEX, (_GLUfuncptr) &ocpnDCvertexCallback );
gluTessCallback( tobj, GLU_TESS_BEGIN, (_GLUfuncptr) &ocpnDCbeginCallback );
gluTessCallback( tobj, GLU_TESS_END, (_GLUfuncptr) &ocpnDCendCallback );
gluTessCallback( tobj, GLU_TESS_COMBINE, (_GLUfuncptr) &ocpnDCcombineCallback );
gluTessCallback( tobj, GLU_TESS_ERROR, (_GLUfuncptr) &ocpnDCerrorCallback );
gluTessNormal( tobj, 0, 0, 1);
gluTessProperty( tobj, GLU_TESS_WINDING_RULE, GLU_TESS_WINDING_NONZERO );
if( ConfigureBrush() ) {
gluTessBeginPolygon( tobj, NULL );
gluTessBeginContour( tobj );
for( int i = 0; i < n; i++ ) {
GLvertex* vertex = new GLvertex();
gTesselatorVertices.Add( vertex );
vertex->info.x = (GLdouble) points[i].x;
vertex->info.y = (GLdouble) points[i].y;
vertex->info.z = (GLdouble) 0.0;
vertex->info.r = (GLdouble) 0.0;
vertex->info.g = (GLdouble) 0.0;
vertex->info.b = (GLdouble) 0.0;
gluTessVertex( tobj, (GLdouble*)vertex, (GLdouble*)vertex );
}
gluTessEndContour( tobj );
gluTessEndPolygon( tobj );
}
glPopAttrib();
for( unsigned int i=0; i<gTesselatorVertices.Count(); i++ )
delete (GLvertex*)gTesselatorVertices.Item(i);
gTesselatorVertices.Clear();
}
#endif
}
void ocpnDC::DrawRoundedRectangle( wxCoord x, wxCoord y, wxCoord w, wxCoord h, wxCoord r )
{
if( dc ) dc->DrawRoundedRectangle( x, y, w, h, r );
else {
wxCoord x0 = x, x1 = x + r, x2 = x + w - r, x3 = x + h;
wxCoord y0 = y, y1 = y + r, y2 = y + h - r, y3 = y + h;
if( ConfigureBrush() ) {
glBegin( GL_QUADS );
glVertex2i( x0, y1 );
glVertex2i( x1, y1 );
glVertex2i( x1, y2 );
glVertex2i( x0, y2 );
glVertex2i( x1, y0 );
glVertex2i( x2, y0 );
glVertex2i( x2, y3 );
glVertex2i( x0, y3 );
glVertex2i( x2, y1 );
glVertex2i( x3, y1 );
glVertex2i( x3, y2 );
glVertex2i( x2, y2 );
glEnd();
glBegin( GL_TRIANGLE_FAN );
glVertex2i( x1, y2 );
drawrrhelper( x1, y2, r, -M_PI, -M_PI / 2 );
glEnd();
glBegin( GL_TRIANGLE_FAN );
glVertex2i( x2, y2 );
drawrrhelper( x2, y2, r, -M_PI / 2, 0 );
glEnd();
glBegin( GL_TRIANGLE_FAN );
glVertex2i( x2, y1 );
drawrrhelper( x2, y1, r, 0, M_PI / 2 );
glEnd();
glBegin( GL_TRIANGLE_FAN );
glVertex2i( x1, y1 );
drawrrhelper( x1, y1, r, M_PI / 2, M_PI );
glEnd();
}
if( ConfigurePen() ) {
glBegin( GL_LINE_LOOP );
drawrrhelper( x1, y2, r, -M_PI, -M_PI / 2 );
drawrrhelper( x2, y2, r, -M_PI / 2, 0 );
drawrrhelper( x2, y1, r, 0, M_PI / 2 );
drawrrhelper( x1, y1, r, M_PI / 2, M_PI );
glEnd();
}
}
}
//------------------------------------------------------hitwh wht
void ocpnDC::DrawEllipse( wxCoord x, wxCoord y, wxCoord width, wxCoord height )
{
if( dc )
dc->DrawEllipse( x, y, width, height );
#ifdef ocpnUSE_GL
else {
float r1 = width / 2, r2 = height / 2;
float cx = x + r1, cy = y + r2;
glPushAttrib( GL_COLOR_BUFFER_BIT | GL_LINE_BIT | GL_HINT_BIT ); //Save state
// Enable anti-aliased lines, at best quality
glEnable( GL_LINE_SMOOTH );
glEnable( GL_BLEND );
glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
glHint( GL_LINE_SMOOTH_HINT, GL_NICEST );
/* formula for variable step count to produce smooth ellipse */
float steps = floorf(wxMax(sqrtf(sqrtf((float)(width*width + height*height))), 1) * M_PI);
if( ConfigureBrush() ) {
glBegin( GL_TRIANGLE_FAN );
glVertex2f( cx, cy );
for( float a = 0; a <= 2 * M_PI + M_PI/steps; a += 2 * M_PI / steps )
glVertex2f( cx + r1 * sinf( a ), cy + r2 * cosf( a ) );
glEnd();
}
if( ConfigurePen() ) {
glBegin( GL_LINE_LOOP );
for( float a = 0; a < 2 * M_PI - M_PI/steps; a += 2 * M_PI / steps )
glVertex2f( cx + r1 * sinf( a ), cy + r2 * cosf( a ) );
glEnd();
}
glPopAttrib(); // restore state
}
#endif
}
