32#define GL_SILENCE_DEPRECATION 1
61using namespace std::placeholders;
69#include <glsl_kicad_frag.h>
70#include <glsl_kicad_vert.h>
74static const int glAttributes[] = { WX_GL_RGBA, WX_GL_DOUBLEBUFFER, WX_GL_DEPTH_SIZE, 8, 0 };
76wxGLContext* OPENGL_GAL::m_glMainContext =
nullptr;
77int OPENGL_GAL::m_instanceCounter = 0;
78GLuint OPENGL_GAL::g_fontTexture = 0;
79bool OPENGL_GAL::m_isBitmapFontLoaded =
false;
116GL_BITMAP_CACHE::~GL_BITMAP_CACHE()
119 glDeleteTextures( 1, &bitmap.second.id );
125#ifndef DISABLE_BITMAP_CACHE
131 if( glIsTexture( it->second.id ) )
133 return it->second.id;
138 glDeleteTextures( 1, &it->second.id );
166 return std::numeric_limits< GLuint >::max();
168 const wxImage& imgData = *imgPtr;
170 bmp.
w = imgData.GetSize().x;
171 bmp.
h = imgData.GetSize().y;
176 int extra_w = bmp.
w % 4;
179 extra_w = 4 - extra_w;
185 glGenTextures( 1, &textureID );
194 bmp.
size = ( bmp.
w + extra_w ) * bmp.
h * 4;
195 auto buf = std::make_unique<uint8_t[]>( bmp.
size );
197 for(
int y = 0; y < bmp.
h; y++ )
199 for(
int x = 0; x < bmp.
w; x++ )
201 uint8_t* p = buf.get() + ( ( bmp.
w + extra_w ) * y + x ) * 4;
203 p[0] = imgData.GetRed( x, y );
204 p[1] = imgData.GetGreen( x, y );
205 p[2] = imgData.GetBlue( x, y );
207 if( imgData.HasAlpha() )
208 p[3] = imgData.GetAlpha( x, y );
209 else if( imgData.HasMask() && p[0] == imgData.GetMaskRed()
210 && p[1] == imgData.GetMaskGreen() && p[2] == imgData.GetMaskBlue() )
211 p[3] = wxALPHA_TRANSPARENT;
213 p[3] = wxALPHA_OPAQUE;
217 glBindTexture( GL_TEXTURE_2D, textureID );
218 glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA8, bmp.
w + extra_w, bmp.
h, 0, GL_RGBA, GL_UNSIGNED_BYTE,
221 glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST );
222 glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST );
226#ifndef DISABLE_BITMAP_CACHE
238 glDeleteTextures( 1, &cachedBitmap.
id );
250 wxEvtHandler* aMouseListener, wxEvtHandler* aPaintListener,
251 const wxString& aName ) :
252 GAL( aDisplayOptions ),
255 m_mouseListener( aMouseListener ),
256 m_paintListener( aPaintListener ),
257 m_currentManager( nullptr ),
258 m_cachedManager( nullptr ),
259 m_nonCachedManager( nullptr ),
260 m_overlayManager( nullptr ),
261 m_tempManager( nullptr ),
263 m_overlayBuffer( 0 ),
265 m_isContextLocked( false ),
266 m_lockClientCookie( 0 )
319#if wxCHECK_VERSION( 3, 1, 0 ) || defined( USE_OSX_MAGNIFY_EVENT )
322#if defined _WIN32 || defined _WIN64
326 SetSize( aParent->GetClientSize() );
337 gluTessProperty(
m_tesselator, GLU_TESS_WINDING_RULE, GLU_TESS_WINDING_POSITIVE );
398 wxString retVal = wxEmptyString;
400 wxFrame* testFrame =
new wxFrame(
nullptr, wxID_ANY, wxT(
"" ), wxDefaultPosition,
401 wxSize( 1, 1 ), wxFRAME_TOOL_WINDOW | wxNO_BORDER );
415 catch( std::runtime_error& err )
418 retVal = wxString( err.what() );
482#ifdef KICAD_GAL_PROFILE
483 PROF_TIMER totalRealTime(
"OPENGL_GAL::beginDrawing()",
true );
486 wxASSERT_MSG(
m_isContextLocked,
"GAL_DRAWING_CONTEXT RAII object should have locked context. "
487 "Calling GAL::beginDrawing() directly is not allowed." );
489 wxASSERT_MSG(
IsVisible(),
"GAL::beginDrawing() must not be entered when GAL is not visible. "
490 "Other drawing routines will expect everything to be initialized "
491 "which will not be the case." );
497 glMatrixMode( GL_PROJECTION );
514 catch(
const std::runtime_error& )
516 wxLogVerbose(
"Could not create a framebuffer for overlays.\n" );
526 glDisable( GL_TEXTURE_2D );
528 glShadeModel( GL_FLAT );
531 glEnable( GL_DEPTH_TEST );
532 glDepthFunc( GL_LESS );
535 glEnable( GL_BLEND );
536 glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
538 glMatrixMode( GL_MODELVIEW );
542 GLdouble matrixData[16] = { 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1 };
552 glLoadMatrixd( matrixData );
571 const GLint FONT_TEXTURE_UNIT = 2;
576 glActiveTexture( GL_TEXTURE0 + FONT_TEXTURE_UNIT );
581 glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
582 glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
583 checkGlError(
"loading bitmap font", __FILE__, __LINE__ );
585 glActiveTexture( GL_TEXTURE0 );
591 glActiveTexture( GL_TEXTURE0 + FONT_TEXTURE_UNIT );
593 glActiveTexture( GL_TEXTURE0 );
608 checkGlError(
"setting bitmap font sampler as shader parameter", __FILE__, __LINE__ );
621 renderingOffset.
x *= screenPixelSize.
x;
622 renderingOffset.
y *= screenPixelSize.
y;
628 glActiveTexture( GL_TEXTURE0 );
633#ifdef KICAD_GAL_PROFILE
634 totalRealTime.
Stop();
635 wxLogTrace(
traceGalProfile, wxT(
"OPENGL_GAL::beginDrawing(): %.1f ms" ),
636 totalRealTime.
msecs() );
647 PROF_TIMER cntEndNoncached(
"gl-end-noncached");
656 cntEndNoncached.
Start();
658 cntEndNoncached.
Stop();
660 cntEndCached.
Start();
664 cntEndOverlay.
Start();
670 cntEndOverlay.
Stop();
672 cntComposite.
Start();
674 glColor4d( 1.0, 1.0, 1.0, 1.0 );
711 wxASSERT_MSG(
m_isContextLocked,
"Context not locked. A GAL_CONTEXT_LOCKER RAII object must "
712 "be stacked rather than making separate lock/unlock calls." );
714 wxASSERT_MSG(
m_lockClientCookie == aClientCookie,
"Context was locked by a different client. "
715 "Should not be possible with RAII objects." );
725 wxASSERT_MSG(
m_isContextLocked,
"GAL_UPDATE_CONTEXT RAII object should have locked context. "
726 "Calling this from anywhere else is not allowed." );
728 wxASSERT_MSG(
IsVisible(),
"GAL::beginUpdate() must not be entered when GAL is not visible. "
729 "Other update routines will expect everything to be initialized "
730 "which will not be the case." );
766 VECTOR2D startEndVector = aEndPoint - aStartPoint;
769 float startx = aStartPoint.
x;
770 float starty = aStartPoint.
y;
771 float endx = aStartPoint.
x + lineLength;
772 float endy = aStartPoint.
y + lineLength;
777 if( startx == endx || starty == endy )
779 drawCircle( aStartPoint, aWidth / 2, aReserve );
894 double startAngle = aStartAngle.
AsRadians();
898 SWAP( startAngle, >, endAngle );
912 for( alpha = startAngle; ( alpha + alphaIncrement ) < endAngle; )
918 alpha += alphaIncrement;
924 const VECTOR2D endPoint( cos( endAngle ) * aRadius, sin( endAngle ) * aRadius );
937 VECTOR2D p( cos( startAngle ) * aRadius, sin( startAngle ) * aRadius );
940 for( alpha = startAngle + alphaIncrement; alpha <= endAngle; alpha += alphaIncrement )
942 VECTOR2D p_next( cos( alpha ) * aRadius, sin( alpha ) * aRadius );
949 if( alpha != endAngle )
951 VECTOR2D p_last( cos( endAngle ) * aRadius, sin( endAngle ) * aRadius );
962 double aWidth,
double aMaxError )
973 double startAngle = aStartAngle.
AsRadians();
977 SWAP( startAngle, >, endAngle );
982 double alphaIncrement = 2.0 * M_PI / segCount360;
987 int seg_count =
KiROUND( ( endAngle - startAngle ) / alphaIncrement );
989 if( seg_count % 2 != 0 )
994 alphaIncrement = ( endAngle - startAngle ) / seg_count;
1004 double width = aWidth / 2.0;
1005 VECTOR2D startPoint( cos( startAngle ) * aRadius, sin( startAngle ) * aRadius );
1006 VECTOR2D endPoint( cos( endAngle ) * aRadius, sin( endAngle ) * aRadius );
1011 VECTOR2D pOuter( cos( startAngle ) * ( aRadius + width ),
1012 sin( startAngle ) * ( aRadius + width ) );
1014 VECTOR2D pInner( cos( startAngle ) * ( aRadius - width ),
1015 sin( startAngle ) * ( aRadius - width ) );
1019 for( alpha = startAngle + alphaIncrement; alpha <= endAngle; alpha += alphaIncrement )
1021 VECTOR2D pNextOuter( cos( alpha ) * ( aRadius + width ),
1022 sin( alpha ) * ( aRadius + width ) );
1023 VECTOR2D pNextInner( cos( alpha ) * ( aRadius - width ),
1024 sin( alpha ) * ( aRadius - width ) );
1029 pOuter = pNextOuter;
1030 pInner = pNextInner;
1034 if( alpha != endAngle )
1036 VECTOR2D pLastOuter( cos( endAngle ) * ( aRadius + width ),
1037 sin( endAngle ) * ( aRadius + width ) );
1038 VECTOR2D pLastInner( cos( endAngle ) * ( aRadius - width ),
1039 sin( endAngle ) * ( aRadius - width ) );
1051 VECTOR2D p( cos( startAngle ) * aRadius, sin( startAngle ) * aRadius );
1056 for( alpha = startAngle + alphaIncrement; alpha <= endAngle; alpha += alphaIncrement )
1062 if( alpha != endAngle )
1069 for( alpha = startAngle + alphaIncrement; alpha <= endAngle; alpha += alphaIncrement )
1071 VECTOR2D p_next( cos( alpha ) * aRadius, sin( alpha ) * aRadius );
1078 if( alpha != endAngle )
1080 VECTOR2D p_last( cos( endAngle ) * aRadius, sin( endAngle ) * aRadius );
1092 VECTOR2D diagonalPointA( aEndPoint.
x, aStartPoint.
y );
1093 VECTOR2D diagonalPointB( aStartPoint.
x, aEndPoint.
y );
1117 std::deque<VECTOR2D> pointList;
1118 pointList.push_back( aStartPoint );
1119 pointList.push_back( diagonalPointA );
1120 pointList.push_back( aEndPoint );
1121 pointList.push_back( diagonalPointB );
1122 pointList.push_back( aStartPoint );
1133 return aPointList[idx];
1135 aPointList.size(), aWidth );
1149 return aLineChain.
CPoint( idx );
1151 numPoints, aWidth );
1160 return aPointList[idx];
1162 aPointList.size() );
1171 return aPointList[idx];
1173 aPointList.size() );
1182 return aPointList[idx];
1198 return aLineChain.
CPoint( idx );
1206 int lineQuadCount = 0;
1208 for(
const std::vector<VECTOR2D>& points : aPointList )
1209 lineQuadCount += points.size() - 1;
1213 for(
const std::vector<VECTOR2D>& points : aPointList )
1220 points.size(),
false );
1227 wxCHECK( aPointList.size() >= 2, );
1228 auto points = std::unique_ptr<GLdouble[]>(
new GLdouble[3 * aPointList.size()] );
1229 GLdouble* ptr = points.get();
1231 for(
const VECTOR2D& p : aPointList )
1244 wxCHECK( aListSize >= 2, );
1245 auto points = std::unique_ptr<GLdouble[]>(
new GLdouble[3 * aListSize] );
1246 GLdouble* target = points.get();
1249 for(
int i = 0; i < aListSize; ++i )
1262 bool aStrokeTriangulation )
1269 int totalTriangleCount = 0;
1284 for(
size_t i = 0; i < triPoly->GetTriangleCount(); i++ )
1287 triPoly->GetTriangle( i, a, b, c );
1299 const auto& poly = aPolySet.
Polygon( j );
1301 for(
const auto& lc : poly )
1310 aStrokeTriangulation =
true;
1314 if( aStrokeTriangulation )
1325 for(
size_t i = 0; i < triPoly->GetTriangleCount(); i++ )
1328 triPoly->GetTriangle( i, a, b, c );
1362 std::unique_ptr<GLdouble[]> points(
new GLdouble[3 * pointCount] );
1363 GLdouble* ptr = points.get();
1365 for(
int i = 0; i < pointCount; ++i )
1379 double aFilterValue )
1381 std::vector<VECTOR2D> output;
1382 std::vector<VECTOR2D> pointCtrl;
1384 pointCtrl.push_back( aStartPoint );
1385 pointCtrl.push_back( aControlPointA );
1386 pointCtrl.push_back( aControlPointB );
1387 pointCtrl.push_back( aEndPoint );
1390 converter.
GetPoly( output, aFilterValue );
1398 GLfloat alpha = std::clamp( alphaBlend, 0.0, 1.0 );
1408 glm::vec4 v0 = xform * glm::vec4( -w / 2, -h / 2, 0.0, 0.0 );
1409 glm::vec4
v1 = xform * glm::vec4( w / 2, h / 2, 0.0, 0.0 );
1410 glm::vec4 trans = xform[3];
1414 if( !glIsTexture( texture_id ) )
1417 glMatrixMode( GL_TEXTURE );
1419 glTranslated( 0.5, 0.5, 0.5 );
1421 glTranslated( -0.5, -0.5, -0.5 );
1423 glMatrixMode( GL_MODELVIEW );
1425 glTranslated( trans.x, trans.y, trans.z );
1427 glEnable( GL_TEXTURE_2D );
1428 glActiveTexture( GL_TEXTURE0 );
1429 glBindTexture( GL_TEXTURE_2D, texture_id );
1431 float texStartX = aBitmap.
IsMirrored() ? 1.0 : 0.0;
1432 float texEndX = aBitmap.
IsMirrored() ? 0.0 : 1.0;
1434 glBegin( GL_QUADS );
1435 glColor4f( 1.0, 1.0, 1.0, alpha );
1436 glTexCoord2f( texStartX, 0.0 );
1438 glColor4f( 1.0, 1.0, 1.0, alpha );
1439 glTexCoord2f( texEndX, 0.0 );
1441 glColor4f( 1.0, 1.0, 1.0, alpha );
1442 glTexCoord2f( texEndX, 1.0 );
1444 glColor4f( 1.0, 1.0, 1.0, alpha );
1445 glTexCoord2f( texStartX, 1.0 );
1449 glBindTexture( GL_TEXTURE_2D, 0 );
1451#ifdef DISABLE_BITMAP_CACHE
1452 glDeleteTextures( 1, &texture_id );
1457 glMatrixMode( GL_TEXTURE );
1459 glMatrixMode( GL_MODELVIEW );
1468 || aText.Contains( wxT(
"^{" ) )
1469 || aText.Contains( wxT(
"_{" ) )
1470 || aText.Contains( wxT(
"\n" ) ) )
1481 double overbarHeight = textSize.
y;
1524 overbarHeight = -textSize.
y / 2.0;
1528 int overbarLength = 0;
1529 int overbarDepth = -1;
1530 int braceNesting = 0;
1532 auto iterateString =
1533 [&]( std::function<void(
int aOverbarLength,
int aOverbarHeight )> overbarFn,
1534 std::function<int(
unsigned long aChar )> bitmapCharFn )
1538 wxASSERT_MSG( *chIt !=
'\n' && *chIt !=
'\r',
1539 "No support for multiline bitmap text yet" );
1541 if( *chIt ==
'~' && overbarDepth == -1 )
1545 if( ++lookahead != end && *lookahead ==
'{' )
1548 overbarDepth = braceNesting;
1553 else if( *chIt ==
'{' )
1557 else if( *chIt ==
'}' )
1559 if( braceNesting > 0 )
1562 if( braceNesting == overbarDepth )
1564 overbarFn( overbarLength, overbarHeight );
1572 if( overbarDepth != -1 )
1573 overbarLength += bitmapCharFn( *chIt );
1575 bitmapCharFn( *chIt );
1582 int overbarsCount = 0;
1585 [&overbarsCount](
int aOverbarLength,
int aOverbarHeight )
1589 [&charsCount](
unsigned long aChar ) ->
int
1605 [&](
int aOverbarLength,
int aOverbarHeight )
1609 [&](
unsigned long aChar ) ->
int
1617 if( overbarDepth != -1 && overbarLength > 0 )
1632 float minorLineWidth = std::fmax( 1.0f,
1634 float majorLineWidth = minorLineWidth * 2.0f;
1669 SWAP( gridStartX, >, gridEndX );
1670 SWAP( gridStartY, >, gridEndY );
1678 glDisable( GL_DEPTH_TEST );
1679 glDisable( GL_TEXTURE_2D );
1683 glEnable( GL_STENCIL_TEST );
1684 glStencilFunc( GL_ALWAYS, 1, 1 );
1685 glStencilOp( GL_KEEP, GL_KEEP, GL_INCR );
1686 glColor4d( 0.0, 0.0, 0.0, 0.0 );
1698 for(
int j = gridStartY; j <= gridEndY; j++ )
1704 for(
int i = gridStartX; i <= gridEndX; i++ )
1707 SetLineWidth( ( ( tickX && tickY ) ? majorLineWidth : minorLineWidth ) );
1721 for(
int j = gridStartY; j <= gridEndY; j++ )
1740 glStencilFunc( GL_NOTEQUAL, 0, 1 );
1746 for(
int i = gridStartX; i <= gridEndX; i++ )
1763 glDisable( GL_STENCIL_TEST );
1766 glEnable( GL_DEPTH_TEST );
1767 glEnable( GL_TEXTURE_2D );
1780 wxGLCanvas::SetSize( aWidth, aHeight );
1786 bool s = wxGLCanvas::Show( aShow );
1789 wxGLCanvas::Raise();
1807 glClearColor( 0, 0, 0, 1 );
1808 glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT );
1814 GLdouble matrixData[16] = { 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1 };
1816 matrixData[0] = aTransformation.
m_data[0][0];
1817 matrixData[1] = aTransformation.
m_data[1][0];
1818 matrixData[2] = aTransformation.
m_data[2][0];
1819 matrixData[4] = aTransformation.
m_data[0][1];
1820 matrixData[5] = aTransformation.
m_data[1][1];
1821 matrixData[6] = aTransformation.
m_data[2][1];
1822 matrixData[12] = aTransformation.
m_data[0][2];
1823 matrixData[13] = aTransformation.
m_data[1][2];
1824 matrixData[14] = aTransformation.
m_data[2][2];
1826 glMultMatrixd( matrixData );
1864 std::shared_ptr<VERTEX_ITEM> newItem = std::make_shared<VERTEX_ITEM>( *
m_cachedManager );
1866 m_groups.insert( std::make_pair( groupNumber, newItem ) );
2002 glBlendEquation( GL_MAX );
2004 glBlendEquation( GL_FUNC_ADD );
2042 const bool aReserve )
2060 * glm::vec4( aStartPoint.
x, aStartPoint.
y, 0.0, 0.0 );
2062 * glm::vec4( aEndPoint.
x, aEndPoint.
y, 0.0, 0.0 );
2146 double outerRadius = aRadius + (
m_lineWidth / 2 );
2192 GLdouble* point = aPoints;
2194 for(
int i = 0; i < aPointCount; ++i )
2212 return VECTOR2D( aPoints[idx * 3], aPoints[idx * 3 + 1] );
2222 wxCHECK( aPointCount > 0, );
2226 if( aPointCount == 1 )
2228 drawLineQuad( aPointGetter( 0 ), aPointGetter( 0 ), aReserve );
2237 for(
int i = 1; i < aPointCount; ++i )
2239 auto start = aPointGetter( i - 1 );
2240 auto end = aPointGetter( i );
2248 int aPointCount,
double aWidth,
bool aReserve )
2250 wxCHECK( aPointCount >= 2, );
2256 for(
int i = 1; i < aPointCount; ++i )
2258 auto start = aPointGetter( i - 1 );
2259 auto end = aPointGetter( i );
2261 VECTOR2D startEndVector = start - end;
2264 float startx = start.x;
2265 float starty = end.y;
2266 float endx = start.x + lineLength;
2267 float endy = end.y + lineLength;
2272 if( startx == endx || starty == endy )
2284 vertices += 6 + 6 + 3 + 3;
2290 for(
int i = 1; i < aPointCount; ++i )
2292 auto start = aPointGetter( i - 1 );
2293 auto end = aPointGetter( i );
2312 double spaceWidth = g->
advance * 0.74;
2330 const float XOFF = glyph->
minx;
2333 const float round_adjust = ( glyph->
maxy - glyph->
miny )
2336 const float YOFF = round_adjust + top_adjust;
2385 const float H = glyph->
maxy - glyph->
miny;
2415 float commonOffset = std::numeric_limits<float>::max();
2417 int overbarDepth = -1;
2418 int braceNesting = 0;
2422 if( *chIt ==
'~' && overbarDepth == -1 )
2426 if( ++lookahead != end && *lookahead ==
'{' )
2429 overbarDepth = braceNesting;
2434 else if( *chIt ==
'{' )
2438 else if( *chIt ==
'}' )
2440 if( braceNesting > 0 )
2443 if( braceNesting == overbarDepth )
2453 || *chIt ==
'-' || *chIt ==
'_' )
2455 glyph = defaultGlyph;
2462 textSize.
y = std::max<float>( textSize.
y, charHeight );
2464 textSize.
y -= commonOffset;
2466 return std::make_pair( textSize, commonOffset );
2495 VECTOR2D cursorCenter = ( cursorBegin + cursorEnd ) / 2;
2498 const COLOR4D color( cColor.
r * cColor.
a, cColor.
g * cColor.
a, cColor.
b * cColor.
a, 1.0 );
2500 glActiveTexture( GL_TEXTURE0 );
2501 glDisable( GL_TEXTURE_2D );
2505 glBegin( GL_LINES );
2506 glVertex2d( cursorCenter.
x, cursorBegin.
y );
2507 glVertex2d( cursorCenter.
x, cursorEnd.
y );
2509 glVertex2d( cursorBegin.
x, cursorCenter.
y );
2510 glVertex2d( cursorEnd.
x, cursorCenter.
y );
2517 wxASSERT_MSG(
m_groups.size() < std::numeric_limits<unsigned int>::max(),
2518 wxT(
"There are no free slots to store a group" ) );
2529 wxASSERT( IsShownOnScreen() );
2531 wxASSERT_MSG(
m_isContextLocked,
"This should only be called from within a locked context." );
2535#if wxCHECK_VERSION( 3, 0, 3 ) and !wxCHECK_VERSION( 3, 1, 0 )
2536 const int attr[] = { WX_GL_MAJOR_VERSION, 2, WX_GL_MINOR_VERSION, 1, 0 };
2538 if( !IsDisplaySupported( attr ) )
2539 throw std::runtime_error(
"OpenGL 2.1 or higher is required!" );
2544 throw std::runtime_error(
"Could not create the main OpenGL context" );
2547 throw std::runtime_error(
"Could not create a private OpenGL context" );
2550 throw std::runtime_error(
"Could not create the m_tesselator" );
2553 GLenum err = glewInit();
2555 if( GLEW_OK != err )
2556 throw std::runtime_error( (
const char*) glewGetErrorString( err ) );
2559 if( !GLEW_VERSION_2_1 )
2560 throw std::runtime_error(
"OpenGL 2.1 or higher is required!" );
2562#if defined( __LINUX__ )
2564 if( GLEW_ARB_debug_output )
2570 if( !GLEW_EXT_framebuffer_object )
2571 throw std::runtime_error(
"Framebuffer objects are not supported!" );
2574 if( !GLEW_ARB_vertex_buffer_object )
2575 throw std::runtime_error(
"Vertex buffer objects are not supported!" );
2580 BUILTIN_SHADERS::glsl_kicad_vert ) )
2582 throw std::runtime_error(
"Cannot compile vertex shader!" );
2587 BUILTIN_SHADERS::glsl_kicad_frag ) )
2589 throw std::runtime_error(
"Cannot compile fragment shader!" );
2593 throw std::runtime_error(
"Cannot link the shaders!" );
2597 glGetIntegerv( GL_MAX_TEXTURE_SIZE, &maxTextureSize );
2603 throw std::runtime_error(
"Requested texture size is not supported" );
2626 GLdouble* vertex =
static_cast<GLdouble*
>( aVertexPtr );
2630 assert( vboManager );
2631 vboManager->
Vertex( vertex[0], vertex[1], vertex[2] );
2636 GLdouble** dataOut,
void* aData )
2638 GLdouble* vertex =
new GLdouble[3];
2644 param->
intersectPoints.emplace_back( vertex, std::default_delete<GLdouble[]>() );
2646 memcpy( vertex, coords, 3 *
sizeof( GLdouble ) );
2683 return ( ceil( f / r ) - 0.5 ) * r;
2716 outlineGlyph.Triangulate(
2731 if( aGlyphs.empty() )
2734 bool allGlyphsAreStroke =
true;
2735 bool allGlyphsAreOutline =
true;
2737 for(
const std::unique_ptr<KIFONT::GLYPH>& glyph : aGlyphs )
2739 if( !glyph->IsStroke() )
2741 allGlyphsAreStroke =
false;
2746 for(
const std::unique_ptr<KIFONT::GLYPH>& glyph : aGlyphs )
2748 if( !glyph->IsOutline() )
2750 allGlyphsAreOutline =
false;
2755 if( allGlyphsAreStroke )
2758 int lineQuadCount = 0;
2760 for(
const std::unique_ptr<KIFONT::GLYPH>& glyph : aGlyphs )
2764 for(
const std::vector<VECTOR2D>& points : strokeGlyph )
2765 lineQuadCount += points.size() - 1;
2770 for(
const std::unique_ptr<KIFONT::GLYPH>& glyph : aGlyphs )
2774 for(
const std::vector<VECTOR2D>& points : strokeGlyph )
2781 points.size(),
false );
2787 else if( allGlyphsAreOutline )
2790 int triangleCount = 0;
2792 for(
const std::unique_ptr<KIFONT::GLYPH>& glyph : aGlyphs )
2798 if( outlineGlyph.TriangulatedPolyCount() == 0 )
2801 for(
unsigned int i = 0; i < outlineGlyph.TriangulatedPolyCount(); i++ )
2804 outlineGlyph.TriangulatedPolygon( i );
2815 for(
const std::unique_ptr<KIFONT::GLYPH>& glyph : aGlyphs )
2819 for(
unsigned int i = 0; i < outlineGlyph.TriangulatedPolyCount(); i++ )
2822 outlineGlyph.TriangulatedPolygon( i );
2839 for(
size_t i = 0; i < aGlyphs.size(); i++ )
2840 DrawGlyph( *aGlyphs[i], i, aGlyphs.size() );
static const ADVANCED_CFG & GetCfg()
Get the singleton instance's config, which is shared by all consumers.
Bezier curves to polygon converter.
void GetPoly(std::vector< VECTOR2I > &aOutput, int aMinSegLen=0, int aMaxSegCount=32)
Convert a Bezier curve to a polygon.
This class handle bitmap images in KiCad.
const wxImage * GetOriginalImageData() const
VECTOR2I GetSizePixels() const
EDA_ANGLE Rotation() const
static const wxCursor GetCursor(KICURSOR aCursorType)
void UnlockCtx(wxGLContext *aContext)
Allow other canvases to bind an OpenGL context.
void DestroyCtx(wxGLContext *aContext)
Destroy a managed OpenGL context.
void LockCtx(wxGLContext *aContext, wxGLCanvas *aCanvas)
Set a context as current and prevents other canvases from switching it.
static GL_CONTEXT_MANAGER & Get()
Return the GL_CONTEXT_MANAGER instance (singleton).
wxGLContext * CreateCtx(wxGLCanvas *aCanvas, const wxGLContext *aOther=nullptr)
Create a managed OpenGL context.
static int SetSwapInterval(int aVal)
Attempts to set the OpenGL swap interval.
wxGLCanvas wrapper for HiDPI/Retina support.
void SetScaleFactor(double aFactor)
Set the canvas scale factor, probably for a hi-DPI display.
virtual wxSize GetNativePixelSize() const
double GetScaleFactor() const
Get the current scale factor.
virtual bool IsStroke() const
virtual bool IsOutline() const
A color representation with 4 components: red, green, blue, alpha.
static const COLOR4D BLACK
OPENGL_ANTIALIASING_MODE gl_antialiasing_mode
Abstract interface for drawing on a 2D-surface.
bool IsTextMirrored() const
void SetGridColor(const COLOR4D &aGridColor)
Set the grid color.
virtual void SetLayerDepth(double aLayerDepth)
Set the depth of the layer (position on the z-axis)
bool IsCursorEnabled() const
Return information about cursor visibility.
MATRIX3x3D m_worldScreenMatrix
World transformation.
VECTOR2D GetVisibleGridSize() const
Return the visible grid size in x and y directions.
double m_layerDepth
The actual layer depth.
MATRIX3x3D m_screenWorldMatrix
Screen transformation.
bool m_axesEnabled
Should the axes be drawn.
float m_gridLineWidth
Line width of the grid.
VECTOR2I m_screenSize
Screen size in screen coordinates.
GR_TEXT_H_ALIGN_T GetHorizontalJustify() const
VECTOR2D m_depthRange
Range of the depth.
virtual void SetFillColor(const COLOR4D &aColor)
Set the fill color.
GRID_STYLE m_gridStyle
Grid display style.
COLOR4D m_axesColor
Color of the axes.
const MATRIX3x3D & GetScreenWorldMatrix() const
Get the screen <-> world transformation matrix.
float m_lineWidth
The line width.
void computeWorldScale()
Compute the scaling factor for the world->screen matrix.
virtual void SetLineWidth(float aLineWidth)
Set the line width.
VECTOR2D m_gridSize
The grid size.
COLOR4D getCursorColor() const
Get the actual cursor color to draw.
COLOR4D m_fillColor
The fill color.
double m_worldUnitLength
The unit length of the world coordinates [inch].
virtual bool updatedGalDisplayOptions(const GAL_DISPLAY_OPTIONS &aOptions)
Handle updating display options.
void SetAxesColor(const COLOR4D &aAxesColor)
Set the axes color.
virtual void SetStrokeColor(const COLOR4D &aColor)
Set the stroke color.
VECTOR2D m_cursorPosition
Current cursor position (world coordinates)
const VECTOR2I & GetGlyphSize() const
int m_gridTick
Every tick line gets the double width.
double m_worldScale
The scale factor world->screen.
virtual bool SetNativeCursorStyle(KICURSOR aCursor)
Set the cursor in the native panel.
VECTOR2D m_gridOrigin
The grid origin.
KICURSOR m_currentNativeCursor
Current cursor.
bool m_globalFlipY
Flag for Y axis flipping.
bool m_fullscreenCursor
Shape of the cursor (fullscreen or small cross)
bool m_isFillEnabled
Is filling of graphic objects enabled ?
virtual void ComputeWorldScreenMatrix()
Compute the world <-> screen transformation matrix.
COLOR4D m_gridColor
Color of the grid.
COLOR4D m_strokeColor
The color of the outlines.
bool m_isStrokeEnabled
Are the outlines stroked ?
GAL_DISPLAY_OPTIONS & m_options
bool m_gridVisibility
Should the grid be shown.
virtual void BitmapText(const wxString &aText, const VECTOR2I &aPosition, const EDA_ANGLE &aAngle)
Draw a text using a bitmap font.
float GetLineWidth() const
Get the line width.
bool m_globalFlipX
Flag for X axis flipping.
GR_TEXT_V_ALIGN_T GetVerticalJustify() const
VECTOR2D m_lookAtPoint
Point to be looked at in world space.
GLuint cacheBitmap(const BITMAP_BASE *aBitmap)
const size_t m_cacheMaxElements
GLuint RequestBitmap(const BITMAP_BASE *aBitmap)
std::list< GLuint > m_freedTextureIds
const size_t m_cacheMaxSize
std::map< const KIID, CACHED_BITMAP > m_bitmaps
std::list< KIID > m_cacheLru
VECTOR2D GetAntialiasRenderingOffset() const
virtual void Begin() override
Call this at the beginning of each frame.
static const unsigned int DIRECT_RENDERING
virtual unsigned int GetBuffer() const override
Return currently used buffer handle.
OPENGL_ANTIALIASING_MODE GetAntialiasingMode() const
void SetAntialiasingMode(OPENGL_ANTIALIASING_MODE aMode)
virtual void Present() override
Call this to present the output buffer to the screen.
virtual void Initialize() override
Perform primary initialization, necessary to use the object.
virtual void ClearBuffer(const COLOR4D &aColor) override
Clear the selected buffer (set by the SetBuffer() function).
virtual void Resize(unsigned int aWidth, unsigned int aHeight) override
Clear the state of COMPOSITOR, so it has to be reinitialized again with the new dimensions.
virtual void DrawBuffer(unsigned int aBufferHandle) override
Draw the selected buffer to the output buffer.
int GetAntialiasSupersamplingFactor() const
virtual void SetBuffer(unsigned int aBufferHandle) override
Set the selected buffer as the rendering target.
virtual unsigned int CreateBuffer() override
Prepare a new buffer that may be used as a rendering target.
OpenGL implementation of the Graphics Abstraction Layer.
void Transform(const MATRIX3x3D &aTransformation) override
Transform the context.
void drawPolygon(GLdouble *aPoints, int aPointCount)
Draw a filled polygon.
void ChangeGroupDepth(int aGroupNumber, int aDepth) override
Change the depth (Z-axis position) of the group.
void skipMouseEvent(wxMouseEvent &aEvent)
Skip the mouse event to the parent.
void drawSegment(const VECTOR2D &aStartPoint, const VECTOR2D &aEndPoint, double aWidth, bool aReserve=true)
Internal method for segment drawing.
unsigned int m_groupCounter
Counter used for generating keys for groups.
void EndDiffLayer() override
Ends rendering of a differential layer.
VERTEX_MANAGER * m_overlayManager
Container for storing overlaid VERTEX_ITEMs.
void Scale(const VECTOR2D &aScale) override
Scale the context.
bool m_isInitialized
Basic initialization flag, has to be done when the window is visible.
VERTEX_MANAGER * m_currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs).
void drawCircle(const VECTOR2D &aCenterPoint, double aRadius, bool aReserve=true)
Internal method for circle drawing.
std::deque< std::shared_ptr< GLdouble > > m_tessIntersects
void DrawCircle(const VECTOR2D &aCenterPoint, double aRadius) override
Draw a circle using world coordinates.
void LockContext(int aClientCookie) override
Use GAL_CONTEXT_LOCKER RAII object unless you know what you're doing.
unsigned int m_mainBuffer
Main rendering target.
std::unique_ptr< GL_BITMAP_CACHE > m_bitmapCache
std::pair< VECTOR2D, float > computeBitmapTextSize(const UTF8 &aText) const
Compute a size of text drawn using bitmap font with current text setting applied.
void SetTarget(RENDER_TARGET aTarget) override
Set the target for rendering.
void blitCursor()
Blit cursor into the current screen.
static wxString CheckFeatures(GAL_DISPLAY_OPTIONS &aOptions)
Checks OpenGL features.
void ClearTarget(RENDER_TARGET aTarget) override
Clear the target for rendering.
void drawBitmapOverbar(double aLength, double aHeight, bool aReserve=true)
Draw an overbar over the currently drawn text.
void EndGroup() override
End the group.
bool m_isBitmapFontInitialized
Is the shader set to use bitmap fonts?
void drawSegmentChain(const std::function< VECTOR2D(int)> &aPointGetter, int aPointCount, double aWidth, bool aReserve=true)
Generic way of drawing a chain of segments stored in different containers.
void BitmapText(const wxString &aText, const VECTOR2I &aPosition, const EDA_ANGLE &aAngle) override
Draw a text using a bitmap font.
bool updatedGalDisplayOptions(const GAL_DISPLAY_OPTIONS &aOptions) override
Handle updating display options.
unsigned int m_overlayBuffer
Auxiliary rendering target (for menus etc.)
void PostPaint(wxPaintEvent &aEvent)
Function PostPaint posts an event to m_paint_listener.
void DrawArc(const VECTOR2D &aCenterPoint, double aRadius, const EDA_ANGLE &aStartAngle, const EDA_ANGLE &aEndAngle) override
Draw an arc.
OPENGL_COMPOSITOR * m_compositor
Handles multiple rendering targets.
VERTEX_MANAGER * m_cachedManager
Container for storing cached VERTEX_ITEMs.
void Translate(const VECTOR2D &aTranslation) override
Translate the context.
void DrawPolyline(const std::deque< VECTOR2D > &aPointList) override
Draw a polyline.
void DrawCurve(const VECTOR2D &startPoint, const VECTOR2D &controlPointA, const VECTOR2D &controlPointB, const VECTOR2D &endPoint, double aFilterValue=0.0) override
Draw a cubic bezier spline.
void drawFilledSemiCircle(const VECTOR2D &aCenterPoint, double aRadius, double aAngle)
Draw a filled semicircle.
void onPaint(wxPaintEvent &aEvent)
This is the OnPaint event handler.
void DrawGroup(int aGroupNumber) override
Draw the stored group.
void Restore() override
Restore the context.
void DrawSegmentChain(const std::vector< VECTOR2D > &aPointList, double aWidth) override
Draw a chain of rounded segments.
void drawStrokedSemiCircle(const VECTOR2D &aCenterPoint, double aRadius, double aAngle, bool aReserve=true)
Draw a stroked semicircle.
unsigned int getNewGroupNumber()
Return a valid key that can be used as a new group number.
void Flush() override
Force all remaining objects to be drawn.
GLint ufm_antialiasingOffset
void DeleteGroup(int aGroupNumber) override
Delete the group from the memory.
bool IsVisible() const override
Return true if the GAL canvas is visible on the screen.
void DrawArcSegment(const VECTOR2D &aCenterPoint, double aRadius, const EDA_ANGLE &aStartAngle, const EDA_ANGLE &aEndAngle, double aWidth, double aMaxError) override
Draw an arc segment.
wxEvtHandler * m_mouseListener
int m_swapInterval
Used to store swap interval information.
void ClearCache() override
Delete all data created during caching of graphic items.
double getWorldPixelSize() const
void DrawSegment(const VECTOR2D &aStartPoint, const VECTOR2D &aEndPoint, double aWidth) override
Draw a rounded segment.
GROUPS_MAP m_groups
Stores information about VBO objects (groups)
void endUpdate() override
void ClearScreen() override
Clear the screen.
void ResizeScreen(int aWidth, int aHeight) override
Resizes the canvas.
void DrawPolygon(const std::deque< VECTOR2D > &aPointList) override
Draw a polygon.
void drawTriangulatedPolyset(const SHAPE_POLY_SET &aPoly, bool aStrokeTriangulation)
Draw a set of polygons with a cached triangulation.
void DrawCursor(const VECTOR2D &aCursorPosition) override
Draw the cursor.
void DrawRectangle(const VECTOR2D &aStartPoint, const VECTOR2D &aEndPoint) override
Draw a rectangle.
VERTEX_MANAGER * m_nonCachedManager
Container for storing non-cached VERTEX_ITEMs.
int drawBitmapChar(unsigned long aChar, bool aReserve=true)
Draw a single character using bitmap font.
GLUtesselator * m_tesselator
wxEvtHandler * m_paintListener
void StartDiffLayer() override
Begins rendering of a differential layer.
bool m_isContextLocked
Used for assertion checking.
void Save() override
Save the context.
wxCursor m_currentwxCursor
wxCursor showing the current native cursor
bool m_isFramebufferInitialized
Are the framebuffers initialized?
void ComputeWorldScreenMatrix() override
Compute the world <-> screen transformation matrix.
bool Show(bool aShow) override
Shows/hides the GAL canvas.
static GLuint g_fontTexture
Bitmap font texture handle (shared)
virtual bool HasTarget(RENDER_TARGET aTarget) override
Return true if the target exists.
void reserveLineQuads(const int aLineCount)
Reserves specified number of line quads.
void DrawLine(const VECTOR2D &aStartPoint, const VECTOR2D &aEndPoint) override
Draw a line.
void beginUpdate() override
double calcAngleStep(double aRadius) const
Compute the angle step when drawing arcs/circles approximated with lines.
virtual void DrawGlyph(const KIFONT::GLYPH &aGlyph, int aNth, int aTotal) override
Draw a polygon representing a font glyph.
bool m_isGrouping
Was a group started?
void BeginDrawing() override
Start/end drawing functions, draw calls can be only made in between the calls to BeginDrawing()/EndDr...
GLint ufm_screenPixelSize
void Rotate(double aAngle) override
Rotate the context.
int BeginGroup() override
Begin a group.
GLint ufm_pixelSizeMultiplier
OPENGL_GAL(GAL_DISPLAY_OPTIONS &aDisplayOptions, wxWindow *aParent, wxEvtHandler *aMouseListener=nullptr, wxEvtHandler *aPaintListener=nullptr, const wxString &aName=wxT("GLCanvas"))
VECTOR2D getScreenPixelSize() const
bool SetNativeCursorStyle(KICURSOR aCursor) override
Set the cursor in the native panel.
void DrawBitmap(const BITMAP_BASE &aBitmap, double alphaBlend=1.0) override
Draw a bitmap image.
void drawPolyline(const std::function< VECTOR2D(int)> &aPointGetter, int aPointCount, bool aReserve=true)
Generic way of drawing a polyline stored in different containers.
RENDER_TARGET GetTarget() const override
Get the currently used target for rendering.
void UnlockContext(int aClientCookie) override
void drawSemiCircle(const VECTOR2D &aCenterPoint, double aRadius, double aAngle)
Draw a semicircle.
void drawLineQuad(const VECTOR2D &aStartPoint, const VECTOR2D &aEndPoint, bool aReserve=true)
Draw a quad for the line.
VERTEX_MANAGER * m_tempManager
Container for storing temp (diff mode) VERTEX_ITEMs.
virtual void DrawGlyphs(const std::vector< std::unique_ptr< KIFONT::GLYPH > > &aGlyphs) override
Draw polygons representing font glyphs.
void onSetNativeCursor(wxSetCursorEvent &aEvent)
Give the correct cursor image when the native widget asks for it.
void EnableDepthTest(bool aEnabled=false) override
void EndDrawing() override
End the drawing, needs to be called for every new frame.
SHADER * m_shader
There is only one shader used for different objects.
void DrawPolylines(const std::vector< std::vector< VECTOR2D > > &aPointLists) override
Draw multiple polylines.
RENDER_TARGET m_currentTarget
Current rendering target.
wxGLContext * m_glPrivContext
Canvas-specific OpenGL context.
void ChangeGroupColor(int aGroupNumber, const COLOR4D &aNewColor) override
Change the color used to draw the group.
static bool m_isBitmapFontLoaded
Is the bitmap font texture loaded?
static wxGLContext * m_glMainContext
Parent OpenGL context.
unsigned int m_tempBuffer
Temporary rendering target (for diffing etc.)
void init()
Basic OpenGL initialization and feature checks.
static int m_instanceCounter
GL GAL instance counter.
Provide the access to the OpenGL shaders.
bool IsLinked() const
Return true if shaders are linked correctly.
void SetParameter(int aParameterNumber, float aValue) const
Set a parameter of the shader.
bool Link()
Link the shaders.
void Use()
Use the shader.
bool LoadShaderFromStrings(SHADER_TYPE aShaderType, Args &&... aArgs)
Add a shader and compile the shader sources.
int AddParameter(const std::string &aParameterName)
Add a parameter to the parameter queue.
void Deactivate()
Deactivate the shader and use the default OpenGL program.
Class to control vertex container and GPU with possibility of emulating old-style OpenGL 1....
void EndDrawing() const
Finish drawing operations.
bool Vertex(const VERTEX &aVertex)
Add a vertex with the given coordinates to the currently set item.
const glm::mat4 & GetTransformation() const
void Map()
Map vertex buffer.
void Clear() const
Remove all the stored vertices from the container.
void BeginDrawing() const
Prepare buffers and items to start drawing.
void ChangeItemColor(const VERTEX_ITEM &aItem, const COLOR4D &aColor) const
Change the color of all vertices owned by an item.
void Color(const COLOR4D &aColor)
Changes currently used color that will be applied to newly added vertices.
bool Reserve(unsigned int aSize)
Allocate space for vertices, so it will be used with subsequent Vertex() calls.
void FinishItem() const
Clean after adding an item.
void ChangeItemDepth(const VERTEX_ITEM &aItem, GLfloat aDepth) const
Change the depth of all vertices owned by an item.
void Rotate(GLfloat aAngle, GLfloat aX, GLfloat aY, GLfloat aZ)
Multiply the current matrix by a rotation matrix, so the newly vertices will be rotated by the given ...
void EnableDepthTest(bool aEnabled)
Enable/disable Z buffer depth test.
void PopMatrix()
Pop the current transformation matrix stack.
void Shader(GLfloat aShaderType, GLfloat aParam1=0.0f, GLfloat aParam2=0.0f, GLfloat aParam3=0.0f)
Change currently used shader and its parameters that will be applied to newly added vertices.
void PushMatrix()
Push the current transformation matrix stack.
void Scale(GLfloat aX, GLfloat aY, GLfloat aZ)
Multiply the current matrix by a scaling matrix, so the newly vertices will be scaled by the given fa...
void Unmap()
Unmap vertex buffer.
void SetShader(SHADER &aShader) const
Set a shader program that is going to be used during rendering.
void Translate(GLfloat aX, GLfloat aY, GLfloat aZ)
Multiply the current matrix by a translation matrix, so newly vertices will be translated by the give...
void DrawItem(const VERTEX_ITEM &aItem) const
Draw an item to the buffer.
VECTOR2< T > GetScale() const
Get the scale components of the matrix.
A small class to help profiling.
void Stop()
Save the time when this function was called, and set the counter stane to stop.
void Start()
Start or restart the counter.
double msecs(bool aSinceLast=false)
Represent a polyline containing arcs as well as line segments: A chain of connected line and/or arc s...
bool IsClosed() const override
int PointCount() const
Return the number of points (vertices) in this line chain.
const VECTOR2I & CPoint(int aIndex) const
Return a reference to a given point in the line chain.
int SegmentCount() const
Return the number of segments in this line chain.
size_t GetTriangleCount() const
void GetTriangle(int index, VECTOR2I &a, VECTOR2I &b, VECTOR2I &c) const
Represent a set of closed polygons.
bool IsTriangulationUpToDate() const
POLYGON & Polygon(int aIndex)
const TRIANGULATED_POLYGON * TriangulatedPolygon(int aIndex) const
unsigned int TriangulatedPolyCount() const
Return the number of outlines in the set.
int OutlineCount() const
Return the number of vertices in a given outline/hole.
const SHAPE_LINE_CHAIN & COutline(int aIndex) const
uni_iter is a non-mutating iterator that walks through unicode code points in the UTF8 encoded string...
An 8 bit string that is assuredly encoded in UTF8, and supplies special conversion support to and fro...
uni_iter uend() const
Return a uni_iter initialized to the end of "this" UTF8 byte sequence.
uni_iter ubegin() const
Returns a uni_iter initialized to the start of "this" UTF8 byte sequence.
T EuclideanNorm() const
Compute the Euclidean norm of the vector, which is defined as sqrt(x ** 2 + y ** 2).
#define SWAP(varA, condition, varB)
Swap the variables if a condition is met.
static constexpr EDA_ANGLE & FULL_CIRCLE
a few functions useful in geometry calculations.
int GetArcToSegmentCount(int aRadius, int aErrorMax, const EDA_ANGLE &aArcAngle)
const wxChar *const traceGalProfile
Flag to enable debug output of GAL performance profiling.
This file contains miscellaneous commonly used macros and functions.
FONT_IMAGE_TYPE font_image
const FONT_GLYPH_TYPE * LookupGlyph(unsigned int aCodepoint)
FONT_INFO_TYPE font_information
The Cairo implementation of the graphics abstraction layer.
@ SMALL_CROSS
Use small cross instead of dots for the grid.
@ DOTS
Use dots for the grid.
@ SHADER_TYPE_VERTEX
Vertex shader.
@ SHADER_TYPE_FRAGMENT
Fragment shader.
RENDER_TARGET
RENDER_TARGET: Possible rendering targets.
@ TARGET_NONCACHED
Auxiliary rendering target (noncached)
@ TARGET_TEMP
Temporary target for drawing in separate layer.
@ TARGET_CACHED
Main rendering target (cached)
@ TARGET_OVERLAY
Items that may change while the view stays the same (noncached)
EDA_ANGLE abs(const EDA_ANGLE &aAngle)
static void InitTesselatorCallbacks(GLUtesselator *aTesselator)
void CALLBACK CombineCallback(GLdouble coords[3], GLdouble *vertex_data[4], GLfloat weight[4], GLdouble **dataOut, void *aData)
void CALLBACK VertexCallback(GLvoid *aVertexPtr, void *aData)
void CALLBACK EdgeCallback(GLboolean aEdgeFlag)
void CALLBACK ErrorCallback(GLenum aErrorCode)
double round_to_half_pixel(double f, double r)
static const int glAttributes[]
#define SEG_PER_CIRCLE_COUNT
#define CALLBACK
The default number of points for circle approximation.
void Refresh()
Update the board display after modifying it by a python script (note: it is automatically called by a...
unsigned char pixels[1024 *1024 *3]
unsigned int smooth_pixels
VERTEX_MANAGER * vboManager
Manager used for storing new vertices.
std::deque< std::shared_ptr< GLdouble > > & intersectPoints
Intersect points, that have to be freed after tessellation.
VECTOR2I v2(1, 0)
Test suite for KiCad math code.
wxLogTrace helper definitions.
#define KI_TRACE(aWhat,...)
constexpr ret_type KiROUND(fp_type v)
Round a floating point number to an integer using "round halfway cases away from zero".
void enableGlDebug(bool aEnable)
Enable or disable OpenGL driver messages output.
int checkGlError(const std::string &aInfo, const char *aFile, int aLine, bool aThrow)
Check if a recent OpenGL operation has failed.
VECTOR2< double > VECTOR2D
VECTOR2I ToVECTOR2I(const wxSize &aSize)