KiCad PCB EDA Suite
opengl_gal.h
Go to the documentation of this file.
1 /*
2  * This program source code file is part of KICAD, a free EDA CAD application.
3  *
4  * Copyright (C) 2012 Torsten Hueter, torstenhtr <at> gmx.de
5  * Copyright (C) 2012 Kicad Developers, see change_log.txt for contributors.
6  * Copyright (C) 2013-2017 CERN
7  * @author Maciej Suminski <maciej.suminski@cern.ch>
8  *
9  * Graphics Abstraction Layer (GAL) for OpenGL
10  *
11  * This program is free software; you can redistribute it and/or
12  * modify it under the terms of the GNU General Public License
13  * as published by the Free Software Foundation; either version 2
14  * of the License, or (at your option) any later version.
15  *
16  * This program is distributed in the hope that it will be useful,
17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19  * GNU General Public License for more details.
20  *
21  * You should have received a copy of the GNU General Public License
22  * along with this program; if not, you may find one here:
23  * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
24  * or you may search the http://www.gnu.org website for the version 2 license,
25  * or you may write to the Free Software Foundation, Inc.,
26  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
27  */
28 
29 #ifndef OPENGLGAL_H_
30 #define OPENGLGAL_H_
31 
32 // GAL imports
35 #include <gal/opengl/shader.h>
37 #include <gal/opengl/vertex_item.h>
41 #include <gal/hidpi_gl_canvas.h>
42 
43 #include <unordered_map>
44 #include <boost/smart_ptr/shared_array.hpp>
45 #include <memory>
46 
47 #ifndef CALLBACK
48 #define CALLBACK
49 #endif
50 
51 struct bitmap_glyph;
52 
53 namespace KIGFX
54 {
55 class SHADER;
56 class GL_BITMAP_CACHE;
57 
65 class OPENGL_GAL : public GAL, public HIDPI_GL_CANVAS
66 {
67 public:
83  OPENGL_GAL( GAL_DISPLAY_OPTIONS& aDisplayOptions, wxWindow* aParent,
84  wxEvtHandler* aMouseListener = nullptr, wxEvtHandler* aPaintListener = nullptr,
85  const wxString& aName = wxT( "GLCanvas" ) );
86 
87  virtual ~OPENGL_GAL();
88 
90  virtual bool IsInitialized() const override
91  {
92  // is*Initialized flags, but it is enough for OpenGL to show up
93  return IsShownOnScreen() && !GetClientRect().IsEmpty();
94  }
95 
97  bool IsVisible() const override
98  {
99  return IsShownOnScreen() && !GetClientRect().IsEmpty();
100  }
101 
102  // ---------------
103  // Drawing methods
104  // ---------------
105 
107  virtual void DrawLine( const VECTOR2D& aStartPoint, const VECTOR2D& aEndPoint ) override;
108 
110  virtual void DrawSegment( const VECTOR2D& aStartPoint, const VECTOR2D& aEndPoint,
111  double aWidth ) override;
112 
114  virtual void DrawCircle( const VECTOR2D& aCenterPoint, double aRadius ) override;
115 
117  virtual void DrawArc( const VECTOR2D& aCenterPoint, double aRadius,
118  double aStartAngle, double aEndAngle ) override;
119 
121  virtual void DrawArcSegment( const VECTOR2D& aCenterPoint, double aRadius,
122  double aStartAngle, double aEndAngle, double aWidth ) override;
123 
125  virtual void DrawRectangle( const VECTOR2D& aStartPoint, const VECTOR2D& aEndPoint ) override;
126 
128  virtual void DrawPolyline( const std::deque<VECTOR2D>& aPointList ) override;
129  virtual void DrawPolyline( const VECTOR2D aPointList[], int aListSize ) override;
130  virtual void DrawPolyline( const SHAPE_LINE_CHAIN& aLineChain ) override;
131 
133  virtual void DrawPolygon( const std::deque<VECTOR2D>& aPointList ) override;
134  virtual void DrawPolygon( const VECTOR2D aPointList[], int aListSize ) override;
135  virtual void DrawPolygon( const SHAPE_POLY_SET& aPolySet ) override;
136 
138  virtual void DrawCurve( const VECTOR2D& startPoint, const VECTOR2D& controlPointA,
139  const VECTOR2D& controlPointB, const VECTOR2D& endPoint ) override;
140 
142  virtual void DrawBitmap( const BITMAP_BASE& aBitmap ) override;
143 
145  virtual void BitmapText( const wxString& aText, const VECTOR2D& aPosition,
146  double aRotationAngle ) override;
147 
149  virtual void DrawGrid() override;
150 
151  // --------------
152  // Screen methods
153  // --------------
154 
156  virtual void ResizeScreen( int aWidth, int aHeight ) override;
157 
159  virtual bool Show( bool aShow ) override;
160 
162  virtual void Flush() override;
163 
165  virtual void ClearScreen( ) override;
166 
167  // --------------
168  // Transformation
169  // --------------
170 
172  virtual void Transform( const MATRIX3x3D& aTransformation ) override;
173 
175  virtual void Rotate( double aAngle ) override;
176 
178  virtual void Translate( const VECTOR2D& aTranslation ) override;
179 
181  virtual void Scale( const VECTOR2D& aScale ) override;
182 
184  virtual void Save() override;
185 
187  virtual void Restore() override;
188 
189  // --------------------------------------------
190  // Group methods
191  // ---------------------------------------------
192 
194  virtual int BeginGroup() override;
195 
197  virtual void EndGroup() override;
198 
200  virtual void DrawGroup( int aGroupNumber ) override;
201 
203  virtual void ChangeGroupColor( int aGroupNumber, const COLOR4D& aNewColor ) override;
204 
206  virtual void ChangeGroupDepth( int aGroupNumber, int aDepth ) override;
207 
209  virtual void DeleteGroup( int aGroupNumber ) override;
210 
212  virtual void ClearCache() override;
213 
214  // --------------------------------------------------------
215  // Handling the world <-> screen transformation
216  // --------------------------------------------------------
217 
219  virtual void SaveScreen() override;
220 
222  virtual void RestoreScreen() override;
223 
225  virtual void SetTarget( RENDER_TARGET aTarget ) override;
226 
228  virtual RENDER_TARGET GetTarget() const override;
229 
231  virtual void ClearTarget( RENDER_TARGET aTarget ) override;
232 
234  virtual void SetNegativeDrawMode( bool aSetting ) override {}
235 
236  // -------
237  // Cursor
238  // -------
239 
241  virtual void DrawCursor( const VECTOR2D& aCursorPosition ) override;
242 
248  void PostPaint()
249  {
250  if( paintListener )
251  {
252  wxPaintEvent redrawEvent;
253  wxPostEvent( paintListener, redrawEvent );
254  }
255  }
256 
257  void SetMouseListener( wxEvtHandler* aMouseListener )
258  {
259  mouseListener = aMouseListener;
260  }
261 
262  void SetPaintListener( wxEvtHandler* aPaintListener )
263  {
264  paintListener = aPaintListener;
265  }
266 
267  virtual void EnableDepthTest( bool aEnabled = false ) override;
268 
270  typedef struct
271  {
274 
276  std::deque< boost::shared_array<GLdouble> >& intersectPoints;
277  } TessParams;
278 
279 private:
281  typedef GAL super;
282 
283  static const int CIRCLE_POINTS = 64;
284  static const int CURVE_POINTS = 32;
285 
286  static wxGLContext* glMainContext;
287  wxGLContext* glPrivContext;
288  static int instanceCounter;
289  wxEvtHandler* mouseListener;
290  wxEvtHandler* paintListener;
291 
292  static GLuint fontTexture;
293 
294  // Vertex buffer objects related fields
295  typedef std::unordered_map< unsigned int, std::shared_ptr<VERTEX_ITEM> > GROUPS_MAP;
296  GROUPS_MAP groups;
297  unsigned int groupCounter;
302 
303  // Framebuffer & compositing
305  unsigned int mainBuffer;
306  unsigned int overlayBuffer;
308 
309  // Shader
310  static SHADER* shader;
311 
312  // Internal flags
314  static bool isBitmapFontLoaded;
317  bool isGrouping;
322 
323  std::unique_ptr<GL_BITMAP_CACHE> bitmapCache;
324 
325  void lockContext( int aClientCookie ) override;
326 
327  void unlockContext( int aClientCookie ) override;
328 
330  virtual void beginUpdate() override;
331 
333  virtual void endUpdate() override;
334 
336  virtual void beginDrawing() override;
337 
339  virtual void endDrawing() override;
340 
342  bool updatedGalDisplayOptions( const GAL_DISPLAY_OPTIONS& aOptions ) override;
343 
344  // Polygon tesselation
346  GLUtesselator* tesselator;
348  std::deque< boost::shared_array<GLdouble> > tessIntersects;
349 
356  void drawLineQuad( const VECTOR2D& aStartPoint, const VECTOR2D& aEndPoint );
357 
367  void drawSemiCircle( const VECTOR2D& aCenterPoint, double aRadius, double aAngle );
368 
377  void drawFilledSemiCircle( const VECTOR2D& aCenterPoint, double aRadius, double aAngle );
378 
387  void drawStrokedSemiCircle( const VECTOR2D& aCenterPoint, double aRadius, double aAngle );
388 
394  void drawPolyline( const std::function<VECTOR2D (int)>& aPointGetter, int aPointCount );
395 
402  void drawPolygon( GLdouble* aPoints, int aPointCount );
403 
407  void drawTriangulatedPolyset( const SHAPE_POLY_SET& aPoly );
408 
409 
417  int drawBitmapChar( unsigned long aChar );
418 
428  void drawBitmapOverbar( double aLength, double aHeight );
429 
437  std::pair<VECTOR2D, float> computeBitmapTextSize( const UTF8& aText ) const;
438 
439  // Event handling
445  void onPaint( wxPaintEvent& aEvent );
446 
452  void skipMouseEvent( wxMouseEvent& aEvent );
453 
457  void blitCursor();
458 
464  unsigned int getNewGroupNumber();
465 
469  double calcAngleStep( double aRadius ) const
470  {
471  // Bigger arcs need smaller alpha increment to make them look smooth
472  return std::min( 1e6 / aRadius, 2.0 * M_PI / CIRCLE_POINTS );
473  }
474 
475  double getWorldPixelSize() const;
476 
480  void init();
481 };
482 } // namespace KIGFX
483 
484 #endif // OPENGLGAL_H_
Class UTF8 is an 8 bit string that is assuredly encoded in UTF8, and supplies special conversion supp...
Definition: utf8.h:73
double getWorldPixelSize() const
Definition: opengl_gal.cpp:330
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:298
virtual void beginUpdate() override
Definition: opengl_gal.cpp:531
static SHADER * shader
There is only one shader used for different objects.
Definition: opengl_gal.h:310
virtual void DrawBitmap(const BITMAP_BASE &aBitmap) override
Draw a bitmap image.
static wxGLContext * glMainContext
Parent OpenGL context.
Definition: opengl_gal.h:286
double calcAngleStep(double aRadius) const
Compute the angle step when drawing arcs/circles approximated with lines.
Definition: opengl_gal.h:469
Class CAIRO_GAL is the cairo implementation of the graphics abstraction layer.
Definition: class_module.h:58
unsigned int overlayBuffer
Auxiliary rendering target (for menus etc.)
Definition: opengl_gal.h:306
std::deque< boost::shared_array< GLdouble > > & intersectPoints
Intersect points, that have to be freed after tessellation.
Definition: opengl_gal.h:276
virtual void Scale(const VECTOR2D &aScale) override
Scale the context.
virtual void ClearTarget(RENDER_TARGET aTarget) override
Clears the target for rendering.
virtual void Translate(const VECTOR2D &aTranslation) override
Translate the context.
RENDER_TARGET currentTarget
Current rendering target.
Definition: opengl_gal.h:307
bool isBitmapFontInitialized
Is the shader set to use bitmap fonts?
Definition: opengl_gal.h:315
void drawPolygon(GLdouble *aPoints, int aPointCount)
Draws a filled polygon.
static GLuint fontTexture
Bitmap font texture handle (shared)
Definition: opengl_gal.h:292
void drawLineQuad(const VECTOR2D &aStartPoint, const VECTOR2D &aEndPoint)
Draw a quad for the line.
VERTEX_MANAGER * overlayManager
Container for storing overlaid VERTEX_ITEMs.
Definition: opengl_gal.h:301
Class OpenGL_GAL is the OpenGL implementation of the Graphics Abstraction Layer.
Definition: opengl_gal.h:65
virtual void Restore() override
Restore the context.
virtual void ChangeGroupDepth(int aGroupNumber, int aDepth) override
Changes the depth (Z-axis position) of the group.
std::unique_ptr< GL_BITMAP_CACHE > bitmapCache
Definition: opengl_gal.h:323
virtual void EnableDepthTest(bool aEnabled=false) override
Parameters passed to the GLU tesselator.
wxGLCanvas wrapper for HiDPI/Retina support.
virtual int BeginGroup() override
Begin a group.
virtual void DrawPolygon(const std::deque< VECTOR2D > &aPointList) override
Draw a polygon.
Definition: opengl_gal.cpp:892
Class to control vertex container and GPU with possibility of emulating old-style OpenGL 1...
bool isContextLocked
Used for assertion checking.
Definition: opengl_gal.h:319
void SetPaintListener(wxEvtHandler *aPaintListener)
Definition: opengl_gal.h:262
CIRCLE_POINTS
Class that handles multitarget rendering (ie.
bool isGrouping
Was a group started?
Definition: opengl_gal.h:318
std::unordered_map< unsigned int, std::shared_ptr< VERTEX_ITEM > > GROUPS_MAP
Definition: opengl_gal.h:295
OPENGL_GAL(GAL_DISPLAY_OPTIONS &aDisplayOptions, wxWindow *aParent, wxEvtHandler *aMouseListener=nullptr, wxEvtHandler *aPaintListener=nullptr, const wxString &aName=wxT("GLCanvas"))
Constructor OPENGL_GAL.
Definition: opengl_gal.cpp:165
virtual void ResizeScreen(int aWidth, int aHeight) override
Resizes the canvas.
void unlockContext(int aClientCookie) override
Definition: opengl_gal.cpp:517
virtual void Transform(const MATRIX3x3D &aTransformation) override
Transform the context.
VERTEX_MANAGER * nonCachedManager
Container for storing non-cached VERTEX_ITEMs.
Definition: opengl_gal.h:300
static int instanceCounter
GL GAL instance counter.
Definition: opengl_gal.h:288
VERTEX_MANAGER * vboManager
Manager used for storing new vertices.
Definition: opengl_gal.h:273
virtual void DrawArcSegment(const VECTOR2D &aCenterPoint, double aRadius, double aStartAngle, double aEndAngle, double aWidth) override
Draw an arc segment.
Definition: opengl_gal.cpp:735
virtual RENDER_TARGET GetTarget() const override
Gets the currently used target for rendering.
static const int CURVE_POINTS
The number of points for curve approximation.
Definition: opengl_gal.h:284
This class handle bitmap images in KiCad.
Definition: bitmap_base.h:46
virtual void endUpdate() override
Definition: opengl_gal.cpp:547
virtual void Save() override
Save the context.
void init()
Basic OpenGL initialization.
OPENGL_COMPOSITOR * compositor
Handles multiple rendering targets.
Definition: opengl_gal.h:304
GROUPS_MAP groups
Stores informations about VBO objects (groups)
Definition: opengl_gal.h:296
std::pair< VECTOR2D, float > computeBitmapTextSize(const UTF8 &aText) const
Computes a size of text drawn using bitmap font with current text setting applied.
virtual void RestoreScreen() override
Restore the screen contents.
unsigned int mainBuffer
Main rendering target.
Definition: opengl_gal.h:305
virtual bool Show(bool aShow) override
Shows/hides the GAL canvas.
void SetMouseListener(wxEvtHandler *aMouseListener)
Definition: opengl_gal.h:257
Class SHAPE_POLY_SET.
virtual void EndGroup() override
End the group.
virtual void DeleteGroup(int aGroupNumber) override
Delete the group from the memory.
wxEvtHandler * mouseListener
Definition: opengl_gal.h:289
bool updatedGalDisplayOptions(const GAL_DISPLAY_OPTIONS &aOptions) override
Function updatedGalDisplayOptions.
Definition: opengl_gal.cpp:310
virtual void DrawGrid() override
>
virtual void DrawLine(const VECTOR2D &aStartPoint, const VECTOR2D &aEndPoint) override
Draw a line.
Definition: opengl_gal.cpp:556
void onPaint(wxPaintEvent &aEvent)
This is the OnPaint event handler.
virtual void endDrawing() override
Definition: opengl_gal.cpp:472
virtual void DrawGroup(int aGroupNumber) override
Draw the stored group.
bool isFramebufferInitialized
Are the framebuffers initialized?
Definition: opengl_gal.h:313
virtual bool IsInitialized() const override
Returns the initalization status for the canvas.
Definition: opengl_gal.h:90
virtual void ClearCache() override
Delete all data created during caching of graphic items.
void drawTriangulatedPolyset(const SHAPE_POLY_SET &aPoly)
Draws a set of polygons with a cached triangulation.
Definition: opengl_gal.cpp:926
Class SHADER provides the access to the OpenGL shaders.
Definition: shader.h:74
void lockContext(int aClientCookie) override
Private: use GAL_CONTEXT_LOCKER RAII object.
Definition: opengl_gal.cpp:507
GAL super
Super class definition.
Definition: opengl_gal.h:281
GLUtesselator * tesselator
The tessellator.
Definition: opengl_gal.h:346
virtual void Rotate(double aAngle) override
Rotate the context.
void drawStrokedSemiCircle(const VECTOR2D &aCenterPoint, double aRadius, double aAngle)
Draw a stroked semicircle.
void blitCursor()
Blits cursor into the current screen.
VERTEX_MANAGER * cachedManager
Container for storing cached VERTEX_ITEMs.
Definition: opengl_gal.h:299
virtual void DrawPolyline(const std::deque< VECTOR2D > &aPointList) override
Draw a polyline.
Definition: opengl_gal.cpp:869
virtual void DrawSegment(const VECTOR2D &aStartPoint, const VECTOR2D &aEndPoint, double aWidth) override
Draw a rounded segment.
Definition: opengl_gal.cpp:564
GLint ufm_worldPixelSize
Definition: opengl_gal.h:321
wxEvtHandler * paintListener
Definition: opengl_gal.h:290
std::deque< boost::shared_array< GLdouble > > tessIntersects
Storage for intersecting points.
Definition: opengl_gal.h:348
virtual void DrawArc(const VECTOR2D &aCenterPoint, double aRadius, double aStartAngle, double aEndAngle) override
Draw an arc.
Definition: opengl_gal.cpp:669
virtual void SaveScreen() override
Save the screen contents.
virtual void SetTarget(RENDER_TARGET aTarget) override
Sets the target for rendering.
Class to store instances of VERTEX without caching.
bool isInitialized
Basic initialization flag, has to be done when the window is visible.
Definition: opengl_gal.h:316
void PostPaint()
Function PostPaint posts an event to m_paint_listener.
Definition: opengl_gal.h:248
void drawSemiCircle(const VECTOR2D &aCenterPoint, double aRadius, double aAngle)
Draw a semicircle.
Class SHAPE_LINE_CHAIN.
Class to handle an item held in a container.
unsigned int groupCounter
Counter used for generating keys for groups.
Definition: opengl_gal.h:297
int drawBitmapChar(unsigned long aChar)
Draws a single character using bitmap font.
virtual void ClearScreen() override
Clear the screen.
unsigned int getNewGroupNumber()
Returns a valid key that can be used as a new group number.
wxGLContext * glPrivContext
Canvas-specific OpenGL context.
Definition: opengl_gal.h:287
virtual void DrawRectangle(const VECTOR2D &aStartPoint, const VECTOR2D &aEndPoint) override
Draw a rectangle.
Definition: opengl_gal.cpp:831
virtual void Flush() override
Force all remaining objects to be drawn.
virtual void DrawCursor(const VECTOR2D &aCursorPosition) override
Draw the cursor.
void drawPolyline(const std::function< VECTOR2D(int)> &aPointGetter, int aPointCount)
Generic way of drawing a polyline stored in different containers.
RENDER_TARGET
RENDER_TARGET: Possible rendering targets.
Definition: definitions.h:39
virtual void BitmapText(const wxString &aText, const VECTOR2D &aPosition, double aRotationAngle) override
Draws a text using a bitmap font.
virtual void SetNegativeDrawMode(bool aSetting) override
Sets negative draw mode in the renderer.
Definition: opengl_gal.h:234
virtual ~OPENGL_GAL()
Definition: opengl_gal.cpp:265
bool IsVisible() const override
>
Definition: opengl_gal.h:97
virtual void beginDrawing() override
Definition: opengl_gal.cpp:336
virtual void DrawCircle(const VECTOR2D &aCenterPoint, double aRadius) override
Draw a circle using world coordinates.
Definition: opengl_gal.cpp:609
static bool isBitmapFontLoaded
Is the bitmap font texture loaded?
Definition: opengl_gal.h:314
virtual void DrawCurve(const VECTOR2D &startPoint, const VECTOR2D &controlPointA, const VECTOR2D &controlPointB, const VECTOR2D &endPoint) override
Draw a cubic bezier spline.
Definition: opengl_gal.cpp:995
void skipMouseEvent(wxMouseEvent &aEvent)
Skip the mouse event to the parent.
void drawFilledSemiCircle(const VECTOR2D &aCenterPoint, double aRadius, double aAngle)
Draw a filled semicircle.
virtual void ChangeGroupColor(int aGroupNumber, const COLOR4D &aNewColor) override
Changes the color used to draw the group.
#define min(a, b)
Definition: auxiliary.h:85
Class GAL is the abstract interface for drawing on a 2D-surface.
Class COLOR4D is the color representation with 4 components: red, green, blue, alpha.
Definition: color4d.h:39
void drawBitmapOverbar(double aLength, double aHeight)
Draws an overbar over the currently drawn text.