KiCad PCB EDA Suite
KIGFX::OPENGL_GAL Class Reference

Class OpenGL_GAL is the OpenGL implementation of the Graphics Abstraction Layer. More...

#include <opengl_gal.h>

Inheritance diagram for KIGFX::OPENGL_GAL:
KIGFX::GAL HIDPI_GL_CANVAS KIGFX::GAL_DISPLAY_OPTIONS_OBSERVER

Classes

struct  TessParams
 

Public Member Functions

 OPENGL_GAL (GAL_DISPLAY_OPTIONS &aDisplayOptions, wxWindow *aParent, wxEvtHandler *aMouseListener=nullptr, wxEvtHandler *aPaintListener=nullptr, const wxString &aName=wxT("GLCanvas"))
 Constructor OPENGL_GAL. More...
 
virtual ~OPENGL_GAL ()
 
virtual bool IsOpenGlEngine () override
 Returns true if the GAL engine is a opengl based type. More...
 
virtual bool IsInitialized () const override
 Returns the initalization status for the canvas. More...
 
bool IsVisible () const override
 

More...
 
virtual void DrawLine (const VECTOR2D &aStartPoint, const VECTOR2D &aEndPoint) override
 Draw a line. More...
 
virtual void DrawSegment (const VECTOR2D &aStartPoint, const VECTOR2D &aEndPoint, double aWidth) override
 Draw a rounded segment. More...
 
virtual void DrawCircle (const VECTOR2D &aCenterPoint, double aRadius) override
 Draw a circle using world coordinates. More...
 
virtual void DrawArc (const VECTOR2D &aCenterPoint, double aRadius, double aStartAngle, double aEndAngle) override
 Draw an arc. More...
 
virtual void DrawRectangle (const VECTOR2D &aStartPoint, const VECTOR2D &aEndPoint) override
 Draw a rectangle. More...
 
virtual void DrawPolyline (const std::deque< VECTOR2D > &aPointList) override
 Draw a polyline. More...
 
virtual void DrawPolyline (const VECTOR2D aPointList[], int aListSize) override
 
virtual void DrawPolyline (const SHAPE_LINE_CHAIN &aLineChain) override
 
virtual void DrawPolygon (const std::deque< VECTOR2D > &aPointList) override
 Draw a polygon. More...
 
virtual void DrawPolygon (const VECTOR2D aPointList[], int aListSize) override
 
virtual void DrawPolygon (const SHAPE_POLY_SET &aPolySet) override
 
virtual void DrawPolygon (const SHAPE_LINE_CHAIN &aPolySet) override
 
virtual void DrawCurve (const VECTOR2D &startPoint, const VECTOR2D &controlPointA, const VECTOR2D &controlPointB, const VECTOR2D &endPoint) override
 Draw a cubic bezier spline. More...
 
virtual void DrawBitmap (const BITMAP_BASE &aBitmap) override
 Draw a bitmap image. More...
 
virtual void BitmapText (const wxString &aText, const VECTOR2D &aPosition, double aRotationAngle) override
 Draws a text using a bitmap font. More...
 
virtual void DrawGrid () override
 

More...
 
virtual void ResizeScreen (int aWidth, int aHeight) override
 Resizes the canvas. More...
 
virtual bool Show (bool aShow) override
 Shows/hides the GAL canvas. More...
 
virtual void Flush () override
 Force all remaining objects to be drawn. More...
 
virtual void ClearScreen () override
 Clear the screen. More...
 
virtual void Transform (const MATRIX3x3D &aTransformation) override
 Transform the context. More...
 
virtual void Rotate (double aAngle) override
 Rotate the context. More...
 
virtual void Translate (const VECTOR2D &aTranslation) override
 Translate the context. More...
 
virtual void Scale (const VECTOR2D &aScale) override
 Scale the context. More...
 
virtual void Save () override
 Save the context. More...
 
virtual void Restore () override
 Restore the context. More...
 
virtual int BeginGroup () override
 Begin a group. More...
 
virtual void EndGroup () override
 End the group. More...
 
virtual void DrawGroup (int aGroupNumber) override
 Draw the stored group. More...
 
virtual void ChangeGroupColor (int aGroupNumber, const COLOR4D &aNewColor) override
 Changes the color used to draw the group. More...
 
virtual void ChangeGroupDepth (int aGroupNumber, int aDepth) override
 Changes the depth (Z-axis position) of the group. More...
 
virtual void DeleteGroup (int aGroupNumber) override
 Delete the group from the memory. More...
 
virtual void ClearCache () override
 Delete all data created during caching of graphic items. More...
 
virtual void SaveScreen () override
 Save the screen contents. More...
 
virtual void RestoreScreen () override
 Restore the screen contents. More...
 
virtual void SetTarget (RENDER_TARGET aTarget) override
 Sets the target for rendering. More...
 
virtual RENDER_TARGET GetTarget () const override
 Gets the currently used target for rendering. More...
 
virtual void ClearTarget (RENDER_TARGET aTarget) override
 Clears the target for rendering. More...
 
virtual void SetNegativeDrawMode (bool aSetting) override
 Sets negative draw mode in the renderer. More...
 
virtual void ComputeWorldScreenMatrix () override
 Compute the world <-> screen transformation matrix. More...
 
virtual void DrawCursor (const VECTOR2D &aCursorPosition) override
 Draw the cursor. More...
 
void PostPaint ()
 Function PostPaint posts an event to m_paint_listener. More...
 
void SetMouseListener (wxEvtHandler *aMouseListener)
 
void SetPaintListener (wxEvtHandler *aPaintListener)
 
virtual void EnableDepthTest (bool aEnabled=false) override
 Parameters passed to the GLU tesselator. More...
 
virtual bool IsCairoEngine ()
 Returns true if the GAL engine is a cairo based type. More...
 
const VECTOR2IGetScreenPixelSize () const
 Returns GAL canvas size in pixels. More...
 
void SetClearColor (const COLOR4D &aColor)
 
const COLOR4DGetClearColor () const
 
virtual void SetIsFill (bool aIsFillEnabled)
 Enable/disable fill. More...
 
virtual void SetIsStroke (bool aIsStrokeEnabled)
 Enable/disable stroked outlines. More...
 
virtual void SetFillColor (const COLOR4D &aColor)
 Set the fill color. More...
 
const COLOR4DGetFillColor () const
 Get the fill color. More...
 
virtual void SetStrokeColor (const COLOR4D &aColor)
 Set the stroke color. More...
 
const COLOR4DGetStrokeColor () const
 Get the stroke color. More...
 
virtual void SetLineWidth (float aLineWidth)
 Set the line width. More...
 
float GetLineWidth () const
 Get the line width. More...
 
virtual void SetLayerDepth (double aLayerDepth)
 Set the depth of the layer (position on the z-axis) More...
 
const STROKE_FONTGetStrokeFont () const
 
virtual void StrokeText (const wxString &aText, const VECTOR2D &aPosition, double aRotationAngle)
 Draws a vector type text using preloaded Newstroke font. More...
 
VECTOR2D GetTextLineSize (const UTF8 &aText) const
 Compute the X and Y size of a given text. More...
 
double GetOverbarVerticalPosition () const
 Compute the vertical position of an overbar, sometimes used in texts. More...
 
virtual void SetTextAttributes (const EDA_TEXT *aText)
 Loads attributes of the given text (bold/italic/underline/mirrored and so on). More...
 
void ResetTextAttributes ()
 Reset text attributes to default styling. More...
 
void SetGlyphSize (const VECTOR2D aGlyphSize)
 Set the font glyph size. More...
 
const VECTOR2DGetGlyphSize () const
 
void SetFontBold (const bool aBold)
 Set bold property of current font. More...
 
bool IsFontBold () const
 Returns true if current font has 'bold' attribute enabled. More...
 
void SetFontItalic (const bool aItalic)
 Set italic property of current font. More...
 
bool IsFontItalic () const
 Returns true if current font has 'italic' attribute enabled. More...
 
void SetTextMirrored (const bool aMirrored)
 Set a mirrored property of text. More...
 
bool IsTextMirrored () const
 Returns true if text should displayed mirrored. More...
 
void SetHorizontalJustify (const EDA_TEXT_HJUSTIFY_T aHorizontalJustify)
 Set the horizontal justify for text drawing. More...
 
EDA_TEXT_HJUSTIFY_T GetHorizontalJustify () const
 Returns current text horizontal justification setting. More...
 
void SetVerticalJustify (const EDA_TEXT_VJUSTIFY_T aVerticalJustify)
 Set the vertical justify for text drawing. More...
 
EDA_TEXT_VJUSTIFY_T GetVerticalJustify () const
 Returns current text vertical justification setting. More...
 
const MATRIX3x3DGetWorldScreenMatrix () const
 Get the world <-> screen transformation matrix. More...
 
const MATRIX3x3DGetScreenWorldMatrix () const
 Get the screen <-> world transformation matrix. More...
 
void SetWorldScreenMatrix (const MATRIX3x3D &aMatrix)
 Set the world <-> screen transformation matrix. More...
 
void SetWorldUnitLength (double aWorldUnitLength)
 Set the unit length. More...
 
void SetScreenSize (const VECTOR2I &aSize)
 
void SetScreenDPI (double aScreenDPI)
 Set the dots per inch of the screen. More...
 
void SetLookAtPoint (const VECTOR2D &aPoint)
 Set the Point in world space to look at. More...
 
const VECTOR2DGetLookAtPoint () const
 Get the look at point. More...
 
void SetZoomFactor (double aZoomFactor)
 Set the zoom factor of the scene. More...
 
double GetZoomFactor () const
 Get the zoom factor. More...
 
void SetRotation (double aRotation)
 Set the rotation angle. More...
 
double GetRotation () const
 Get the rotation angle. More...
 
void SetDepthRange (const VECTOR2D &aDepthRange)
 Set the range of the layer depth. More...
 
double GetMinDepth () const
 Returns the minimum depth in the currently used range (the top). More...
 
double GetMaxDepth () const
 Returns the maximum depth in the currently used range (the bottom). More...
 
double GetWorldScale () const
 Get the world scale. More...
 
void SetFlip (bool xAxis, bool yAxis)
 Sets flipping of the screen. More...
 
bool IsFlippedX () const
 Return true if flip flag for the X axis is set. More...
 
bool IsFlippedY () const
 Return true if flip flag for the Y axis is set. More...
 
void SetGridVisibility (bool aVisibility)
 Sets the visibility setting of the grid. More...
 
void SetGridOrigin (const VECTOR2D &aGridOrigin)
 Set the origin point for the grid. More...
 
void SetGridSize (const VECTOR2D &aGridSize)
 Set the grid size. More...
 
const VECTOR2DGetGridSize () const
 Returns the grid size. More...
 
void SetGridColor (const COLOR4D &aGridColor)
 Set the grid color. More...
 
void SetAxesColor (const COLOR4D &aAxesColor)
 Set the axes color. More...
 
void SetAxesEnabled (bool aAxesEnabled)
 Enables drawing the axes. More...
 
void SetCoarseGrid (int aInterval)
 Draw every tick line wider. More...
 
float GetGridLineWidth () const
 Get the grid line width. More...
 
VECTOR2D GetGridPoint (const VECTOR2D &aPoint) const
 Function GetGridPoint() For a given point it returns the nearest point belonging to the grid in world coordinates. More...
 
VECTOR2D ToWorld (const VECTOR2D &aPoint) const
 Compute the point position in world coordinates from given screen coordinates. More...
 
VECTOR2D ToScreen (const VECTOR2D &aPoint) const
 Compute the point position in screen coordinates from given world coordinates. More...
 
void SetCursorEnabled (bool aCursorEnabled)
 Enable/disable cursor. More...
 
bool IsCursorEnabled () const
 Returns information about cursor visibility. More...
 
void SetCursorColor (const COLOR4D &aCursorColor)
 Set the cursor color. More...
 
void AdvanceDepth ()
 Changes the current depth to deeper, so it is possible to draw objects right beneath other. More...
 
void PushDepth ()
 Stores current drawing depth on the depth stack. More...
 
void PopDepth ()
 Restores previously stored drawing depth for the depth stack. More...
 
virtual wxSize GetNativePixelSize () const
 
virtual float GetBackingScaleFactor () const
 

Protected Member Functions

void computeWorldScale ()
 Compute the scaling factor for the world->screen matrix. More...
 
double computeMinGridSpacing () const
 compute minimum grid spacing from the grid settings More...
 
virtual void drawGridLine (const VECTOR2D &aStartPoint, const VECTOR2D &aEndPoint)
 Draw a grid line (usually a simplified line function). More...
 
COLOR4D getCursorColor () const
 Gets the actual cursor color to draw. More...
 
void OnGalDisplayOptionsChanged (const GAL_DISPLAY_OPTIONS &aOptions) override
 Handler for observer settings changes. More...
 

Protected Attributes

GAL_DISPLAY_OPTIONSoptions
 
UTIL::LINK observerLink
 
std::stack< double > depthStack
 Stored depth values. More...
 
VECTOR2I screenSize
 Screen size in screen coordinates. More...
 
double worldUnitLength
 The unit length of the world coordinates [inch]. More...
 
double screenDPI
 The dots per inch of the screen. More...
 
VECTOR2D lookAtPoint
 Point to be looked at in world space. More...
 
double zoomFactor
 The zoom factor. More...
 
double rotation
 Rotation transformation (radians) More...
 
MATRIX3x3D worldScreenMatrix
 World transformation. More...
 
MATRIX3x3D screenWorldMatrix
 Screen transformation. More...
 
double worldScale
 The scale factor world->screen. More...
 
bool globalFlipX
 Flag for X axis flipping. More...
 
bool globalFlipY
 Flag for Y axis flipping. More...
 
float lineWidth
 The line width. More...
 
bool isFillEnabled
 Is filling of graphic objects enabled ? More...
 
bool isStrokeEnabled
 Are the outlines stroked ? More...
 
COLOR4D fillColor
 The fill color. More...
 
COLOR4D strokeColor
 The color of the outlines. More...
 
COLOR4D m_clearColor
 
double layerDepth
 The actual layer depth. More...
 
VECTOR2D depthRange
 Range of the depth. More...
 
bool gridVisibility
 Should the grid be shown. More...
 
GRID_STYLE gridStyle
 Grid display style. More...
 
VECTOR2D gridSize
 The grid size. More...
 
VECTOR2D gridOrigin
 The grid origin. More...
 
VECTOR2D gridOffset
 The grid offset to compensate cursor position. More...
 
COLOR4D gridColor
 Color of the grid. More...
 
COLOR4D axesColor
 Color of the axes. More...
 
bool axesEnabled
 Should the axes be drawn. More...
 
int gridTick
 Every tick line gets the double width. More...
 
float gridLineWidth
 Line width of the grid. More...
 
int gridMinSpacing
 Minimum screen size of the grid (pixels) below which the grid is not drawn. More...
 
bool isCursorEnabled
 Is the cursor enabled? More...
 
bool forceDisplayCursor
 Always show cursor. More...
 
COLOR4D cursorColor
 Cursor color. More...
 
bool fullscreenCursor
 Shape of the cursor (fullscreen or small cross) More...
 
VECTOR2D cursorPosition
 Current cursor position (world coordinates) More...
 
STROKE_FONT strokeFont
 Instance of object that stores information about how to draw texts. More...
 

Static Protected Attributes

static const int MIN_DEPTH = -1024
 Possible depth range. More...
 
static const int MAX_DEPTH = 1023
 
static const int GRID_DEPTH = MAX_DEPTH - 1
 Depth level on which the grid is drawn. More...
 

Private Types

typedef GAL super
 Super class definition. More...
 
typedef std::unordered_map< unsigned int, std::shared_ptr< VERTEX_ITEM > > GROUPS_MAP
 

Private Member Functions

void lockContext (int aClientCookie) override
 Private: use GAL_CONTEXT_LOCKER RAII object. More...
 
void unlockContext (int aClientCookie) override
 
virtual void beginUpdate () override
 
virtual void endUpdate () override
 
virtual void beginDrawing () override
 
virtual void endDrawing () override
 
bool updatedGalDisplayOptions (const GAL_DISPLAY_OPTIONS &aOptions) override
 Function updatedGalDisplayOptions. More...
 
void drawLineQuad (const VECTOR2D &aStartPoint, const VECTOR2D &aEndPoint)
 Draw a quad for the line. More...
 
void drawSemiCircle (const VECTOR2D &aCenterPoint, double aRadius, double aAngle)
 Draw a semicircle. More...
 
void drawFilledSemiCircle (const VECTOR2D &aCenterPoint, double aRadius, double aAngle)
 Draw a filled semicircle. More...
 
void drawStrokedSemiCircle (const VECTOR2D &aCenterPoint, double aRadius, double aAngle)
 Draw a stroked semicircle. More...
 
void drawPolyline (const std::function< VECTOR2D(int)> &aPointGetter, int aPointCount)
 Generic way of drawing a polyline stored in different containers. More...
 
void drawPolygon (GLdouble *aPoints, int aPointCount)
 Draws a filled polygon. More...
 
void drawTriangulatedPolyset (const SHAPE_POLY_SET &aPoly)
 Draws a set of polygons with a cached triangulation. More...
 
int drawBitmapChar (unsigned long aChar)
 Draws a single character using bitmap font. More...
 
void drawBitmapOverbar (double aLength, double aHeight)
 Draws an overbar over the currently drawn text. More...
 
std::pair< VECTOR2D, float > computeBitmapTextSize (const UTF8 &aText) const
 Computes a size of text drawn using bitmap font with current text setting applied. More...
 
void onPaint (wxPaintEvent &aEvent)
 This is the OnPaint event handler. More...
 
void skipMouseEvent (wxMouseEvent &aEvent)
 Skip the mouse event to the parent. More...
 
void blitCursor ()
 Blits cursor into the current screen. More...
 
unsigned int getNewGroupNumber ()
 Returns a valid key that can be used as a new group number. More...
 
double calcAngleStep (double aRadius) const
 Compute the angle step when drawing arcs/circles approximated with lines. More...
 
double getWorldPixelSize () const
 
VECTOR2D getScreenPixelSize () const
 
void init ()
 Basic OpenGL initialization. More...
 

Private Attributes

wxGLContext * glPrivContext
 Canvas-specific OpenGL context. More...
 
wxEvtHandler * mouseListener
 
wxEvtHandler * paintListener
 
GROUPS_MAP groups
 Stores informations about VBO objects (groups) More...
 
unsigned int groupCounter
 Counter used for generating keys for groups. More...
 
VERTEX_MANAGERcurrentManager
 Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs) More...
 
VERTEX_MANAGERcachedManager
 Container for storing cached VERTEX_ITEMs. More...
 
VERTEX_MANAGERnonCachedManager
 Container for storing non-cached VERTEX_ITEMs. More...
 
VERTEX_MANAGERoverlayManager
 Container for storing overlaid VERTEX_ITEMs. More...
 
OPENGL_COMPOSITORcompositor
 Handles multiple rendering targets. More...
 
unsigned int mainBuffer
 Main rendering target. More...
 
unsigned int overlayBuffer
 Auxiliary rendering target (for menus etc.) More...
 
RENDER_TARGET currentTarget
 Current rendering target. More...
 
bool isFramebufferInitialized
 Are the framebuffers initialized? More...
 
bool isBitmapFontInitialized
 Is the shader set to use bitmap fonts? More...
 
bool isInitialized
 Basic initialization flag, has to be done when the window is visible. More...
 
bool isGrouping
 Was a group started? More...
 
bool isContextLocked
 Used for assertion checking. More...
 
int lockClientCookie
 
GLint ufm_worldPixelSize
 
GLint ufm_screenPixelSize
 
GLint ufm_pixelSizeMultiplier
 
std::unique_ptr< GL_BITMAP_CACHEbitmapCache
 
GLUtesselator * tesselator
 The tessellator. More...
 
std::deque< boost::shared_array< GLdouble > > tessIntersects
 Storage for intersecting points. More...
 

Static Private Attributes

static const int CIRCLE_POINTS = 64
 The number of points for circle approximation. More...
 
static const int CURVE_POINTS = 32
 The number of points for curve approximation. More...
 
static wxGLContext * glMainContext = NULL
 Parent OpenGL context. More...
 
static int instanceCounter = 0
 GL GAL instance counter. More...
 
static GLuint fontTexture = 0
 Bitmap font texture handle (shared) More...
 
static SHADERshader = NULL
 There is only one shader used for different objects. More...
 
static bool isBitmapFontLoaded = false
 Is the bitmap font texture loaded? More...
 

Detailed Description

Class OpenGL_GAL is the OpenGL implementation of the Graphics Abstraction Layer.

This is a direct OpenGL-implementation and uses low-level graphics primitives like triangles and quads. The purpose is to provide a fast graphics interface, that takes advantage of modern graphics card GPUs. All methods here benefit thus from the hardware acceleration.

Definition at line 65 of file opengl_gal.h.

Member Typedef Documentation

◆ GROUPS_MAP

typedef std::unordered_map< unsigned int, std::shared_ptr<VERTEX_ITEM> > KIGFX::OPENGL_GAL::GROUPS_MAP
private

Definition at line 296 of file opengl_gal.h.

◆ super

typedef GAL KIGFX::OPENGL_GAL::super
private

Super class definition.

Definition at line 282 of file opengl_gal.h.

Constructor & Destructor Documentation

◆ OPENGL_GAL()

OPENGL_GAL::OPENGL_GAL ( GAL_DISPLAY_OPTIONS aDisplayOptions,
wxWindow *  aParent,
wxEvtHandler *  aMouseListener = nullptr,
wxEvtHandler *  aPaintListener = nullptr,
const wxString &  aName = wxT( "GLCanvas" ) 
)

Constructor OPENGL_GAL.

Parameters
aParentis the wxWidgets immediate wxWindow parent of this object.
aMouseListeneris the wxEvtHandler that should receive the mouse events, this can be can be any wxWindow, but is often a wxFrame container.
aPaintListeneris the wxEvtHandler that should receive the paint event. This can be any wxWindow, but is often a derived instance of this class or a containing wxFrame. The "paint event" here is a wxCommandEvent holding EVT_GAL_REDRAW, as sent by PostPaint().
aNameis the name of this window for use by wxWindow::FindWindowByName()

Definition at line 184 of file opengl_gal.cpp.

186  :
187  GAL( aDisplayOptions ),
188  HIDPI_GL_CANVAS( aParent, wxID_ANY, (int*) glAttributes, wxDefaultPosition, wxDefaultSize,
189  wxEXPAND, aName ),
190  mouseListener( aMouseListener ),
191  paintListener( aPaintListener ),
192  currentManager( nullptr ),
193  cachedManager( nullptr ),
194  nonCachedManager( nullptr ),
195  overlayManager( nullptr ),
196  mainBuffer( 0 ),
197  overlayBuffer( 0 ),
198  isContextLocked( false ),
199  lockClientCookie( 0 )
200 {
201 // IsDisplayAttr() handles WX_GL_{MAJOR,MINOR}_VERSION correctly only in 3.0.4
202 // starting with 3.1.0 one should use wxGLContext::IsOk() (done by GL_CONTEXT_MANAGER)
203 #if wxCHECK_VERSION( 3, 0, 3 ) and !wxCHECK_VERSION( 3, 1, 0 )
204  const int attr[] = { WX_GL_MAJOR_VERSION, 2, WX_GL_MINOR_VERSION, 1, 0 };
205 
206  if( !IsDisplaySupported( attr ) )
207  throw std::runtime_error( "OpenGL 2.1 or higher is required!" );
208 #endif /* wxCHECK_VERSION( 3, 0, 3 ) */
209 
210  if( glMainContext == NULL )
211  {
213 
214  if( !glMainContext )
215  throw std::runtime_error( "Could not create the main OpenGL context" );
216 
218  shader = new SHADER();
219  }
220  else
221  {
223 
224  if( !glPrivContext )
225  throw std::runtime_error( "Could not create a private OpenGL context" );
226  }
227 
228  ++instanceCounter;
229 
230  bitmapCache.reset( new GL_BITMAP_CACHE );
231 
234 
235  // Initialize the flags
236  isFramebufferInitialized = false;
237  isBitmapFontInitialized = false;
238  isInitialized = false;
239  isGrouping = false;
240  groupCounter = 0;
241 
242  // Connecting the event handlers
243  Connect( wxEVT_PAINT, wxPaintEventHandler( OPENGL_GAL::onPaint ) );
244 
245  // Mouse events are skipped to the parent
246  Connect( wxEVT_MOTION, wxMouseEventHandler( OPENGL_GAL::skipMouseEvent ) );
247  Connect( wxEVT_LEFT_DOWN, wxMouseEventHandler( OPENGL_GAL::skipMouseEvent ) );
248  Connect( wxEVT_LEFT_UP, wxMouseEventHandler( OPENGL_GAL::skipMouseEvent ) );
249  Connect( wxEVT_LEFT_DCLICK, wxMouseEventHandler( OPENGL_GAL::skipMouseEvent ) );
250  Connect( wxEVT_MIDDLE_DOWN, wxMouseEventHandler( OPENGL_GAL::skipMouseEvent ) );
251  Connect( wxEVT_MIDDLE_UP, wxMouseEventHandler( OPENGL_GAL::skipMouseEvent ) );
252  Connect( wxEVT_MIDDLE_DCLICK, wxMouseEventHandler( OPENGL_GAL::skipMouseEvent ) );
253  Connect( wxEVT_RIGHT_DOWN, wxMouseEventHandler( OPENGL_GAL::skipMouseEvent ) );
254  Connect( wxEVT_RIGHT_UP, wxMouseEventHandler( OPENGL_GAL::skipMouseEvent ) );
255  Connect( wxEVT_RIGHT_DCLICK, wxMouseEventHandler( OPENGL_GAL::skipMouseEvent ) );
256  Connect( wxEVT_MOUSEWHEEL, wxMouseEventHandler( OPENGL_GAL::skipMouseEvent ) );
257 #if wxCHECK_VERSION( 3, 1, 0 ) || defined( USE_OSX_MAGNIFY_EVENT )
258  Connect( wxEVT_MAGNIFY, wxMouseEventHandler( OPENGL_GAL::skipMouseEvent ) );
259 #endif
260 #if defined _WIN32 || defined _WIN64
261  Connect( wxEVT_ENTER_WINDOW, wxMouseEventHandler( OPENGL_GAL::skipMouseEvent ) );
262 #endif
263 
264  SetSize( aParent->GetClientSize() );
266 
267  // Grid color settings are different in Cairo and OpenGL
268  SetGridColor( COLOR4D( 0.8, 0.8, 0.8, 0.1 ) );
269  SetAxesColor( COLOR4D( BLUE ) );
270 
271  // Tesselator initialization
272  tesselator = gluNewTess();
274 
275  if( tesselator == NULL )
276  throw std::runtime_error( "Could not create the tesselator" );
277 
278  gluTessProperty( tesselator, GLU_TESS_WINDING_RULE, GLU_TESS_WINDING_POSITIVE );
279 
281 }
Definition: colors.h:57
virtual wxSize GetNativePixelSize() const
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:299
static SHADER * shader
There is only one shader used for different objects.
Definition: opengl_gal.h:311
static wxGLContext * glMainContext
Parent OpenGL context.
Definition: opengl_gal.h:287
unsigned int overlayBuffer
Auxiliary rendering target (for menus etc.)
Definition: opengl_gal.h:307
bool isBitmapFontInitialized
Is the shader set to use bitmap fonts?
Definition: opengl_gal.h:316
VERTEX_MANAGER * overlayManager
Container for storing overlaid VERTEX_ITEMs.
Definition: opengl_gal.h:302
GAL_DISPLAY_OPTIONS & options
std::unique_ptr< GL_BITMAP_CACHE > bitmapCache
Definition: opengl_gal.h:326
static void InitTesselatorCallbacks(GLUtesselator *aTesselator)
bool isContextLocked
Used for assertion checking.
Definition: opengl_gal.h:320
VECTOR2< int > VECTOR2I
Definition: vector2d.h:587
bool isGrouping
Was a group started?
Definition: opengl_gal.h:319
OPENGL_ANTIALIASING_MODE gl_antialiasing_mode
VERTEX_MANAGER * nonCachedManager
Container for storing non-cached VERTEX_ITEMs.
Definition: opengl_gal.h:301
Auxiliary rendering target (noncached)
Definition: definitions.h:49
static int instanceCounter
GL GAL instance counter.
Definition: opengl_gal.h:289
void SetAntialiasingMode(OPENGL_ANTIALIASING_MODE aMode)
HIDPI_GL_CANVAS(wxWindow *parent, wxWindowID id=wxID_ANY, const int *attribList=NULL, const wxPoint &pos=wxDefaultPosition, const wxSize &size=wxDefaultSize, long style=0, const wxString &name=wxGLCanvasName, const wxPalette &palette=wxNullPalette)
static GL_CONTEXT_MANAGER & Get()
Function Get returns the GL_CONTEXT_MANAGER instance (singleton).
GAL(GAL_DISPLAY_OPTIONS &aOptions)
void SetGridColor(const COLOR4D &aGridColor)
Set the grid color.
OPENGL_COMPOSITOR * compositor
Handles multiple rendering targets.
Definition: opengl_gal.h:305
unsigned int mainBuffer
Main rendering target.
Definition: opengl_gal.h:306
wxEvtHandler * mouseListener
Definition: opengl_gal.h:290
void SetAxesColor(const COLOR4D &aAxesColor)
Set the axes color.
static const int glAttributes[]
Definition: opengl_gal.cpp:66
void onPaint(wxPaintEvent &aEvent)
This is the OnPaint event handler.
bool isFramebufferInitialized
Are the framebuffers initialized?
Definition: opengl_gal.h:314
Class SHADER provides the access to the OpenGL shaders.
Definition: shader.h:76
GLUtesselator * tesselator
The tessellator.
Definition: opengl_gal.h:349
VERTEX_MANAGER * cachedManager
Container for storing cached VERTEX_ITEMs.
Definition: opengl_gal.h:300
wxEvtHandler * paintListener
Definition: opengl_gal.h:291
virtual void SetTarget(RENDER_TARGET aTarget) override
Sets the target for rendering.
bool isInitialized
Basic initialization flag, has to be done when the window is visible.
Definition: opengl_gal.h:317
unsigned int groupCounter
Counter used for generating keys for groups.
Definition: opengl_gal.h:298
VECTOR2I screenSize
Screen size in screen coordinates.
wxGLContext * glPrivContext
Canvas-specific OpenGL context.
Definition: opengl_gal.h:288
wxGLContext * CreateCtx(wxGLCanvas *aCanvas, const wxGLContext *aOther=NULL)
Function CreateCtx creates a managed OpenGL context.
void skipMouseEvent(wxMouseEvent &aEvent)
Skip the mouse event to the parent.
Class COLOR4D is the color representation with 4 components: red, green, blue, alpha.
Definition: color4d.h:39

References bitmapCache, BLUE, compositor, GL_CONTEXT_MANAGER::CreateCtx(), GL_CONTEXT_MANAGER::Get(), HIDPI_GL_CANVAS::GetNativePixelSize(), KIGFX::GAL_DISPLAY_OPTIONS::gl_antialiasing_mode, glMainContext, glPrivContext, groupCounter, InitTesselatorCallbacks(), instanceCounter, isBitmapFontInitialized, isFramebufferInitialized, isGrouping, isInitialized, onPaint(), KIGFX::GAL::options, KIGFX::GAL::screenSize, KIGFX::OPENGL_COMPOSITOR::SetAntialiasingMode(), KIGFX::GAL::SetAxesColor(), KIGFX::GAL::SetGridColor(), SetTarget(), shader, skipMouseEvent(), KIGFX::TARGET_NONCACHED, and tesselator.

◆ ~OPENGL_GAL()

OPENGL_GAL::~OPENGL_GAL ( )
virtual

Definition at line 284 of file opengl_gal.cpp.

285 {
287 
288  --instanceCounter;
289  glFlush();
290  gluDeleteTess( tesselator );
291  ClearCache();
292 
293  delete compositor;
294 
295  if( isInitialized )
296  {
297  delete cachedManager;
298  delete nonCachedManager;
299  delete overlayManager;
300  }
301 
303 
304  // If it was the main context, then it will be deleted
305  // when the last OpenGL GAL instance is destroyed (a few lines below)
308 
309  // Are we destroying the last GAL instance?
310  if( instanceCounter == 0 )
311  {
313 
314  if( isBitmapFontLoaded )
315  {
316  glDeleteTextures( 1, &fontTexture );
317  isBitmapFontLoaded = false;
318  }
319 
320  delete shader;
321 
324  glMainContext = NULL;
325  }
326 }
static SHADER * shader
There is only one shader used for different objects.
Definition: opengl_gal.h:311
static wxGLContext * glMainContext
Parent OpenGL context.
Definition: opengl_gal.h:287
static GLuint fontTexture
Bitmap font texture handle (shared)
Definition: opengl_gal.h:293
VERTEX_MANAGER * overlayManager
Container for storing overlaid VERTEX_ITEMs.
Definition: opengl_gal.h:302
void UnlockCtx(wxGLContext *aContext)
Function UnlockCtx allows other canvases to bind an OpenGL context.
VERTEX_MANAGER * nonCachedManager
Container for storing non-cached VERTEX_ITEMs.
Definition: opengl_gal.h:301
static int instanceCounter
GL GAL instance counter.
Definition: opengl_gal.h:289
static GL_CONTEXT_MANAGER & Get()
Function Get returns the GL_CONTEXT_MANAGER instance (singleton).
OPENGL_COMPOSITOR * compositor
Handles multiple rendering targets.
Definition: opengl_gal.h:305
virtual void ClearCache() override
Delete all data created during caching of graphic items.
GLUtesselator * tesselator
The tessellator.
Definition: opengl_gal.h:349
void LockCtx(wxGLContext *aContext, wxGLCanvas *aCanvas)
Function LockCtx sets a context as current and prevents other canvases from switching it.
VERTEX_MANAGER * cachedManager
Container for storing cached VERTEX_ITEMs.
Definition: opengl_gal.h:300
bool isInitialized
Basic initialization flag, has to be done when the window is visible.
Definition: opengl_gal.h:317
wxGLContext * glPrivContext
Canvas-specific OpenGL context.
Definition: opengl_gal.h:288
void DestroyCtx(wxGLContext *aContext)
Function DestroyCtx destroys a managed OpenGL context.
static bool isBitmapFontLoaded
Is the bitmap font texture loaded?
Definition: opengl_gal.h:315

References cachedManager, ClearCache(), compositor, GL_CONTEXT_MANAGER::DestroyCtx(), fontTexture, GL_CONTEXT_MANAGER::Get(), glMainContext, glPrivContext, instanceCounter, isBitmapFontLoaded, isInitialized, GL_CONTEXT_MANAGER::LockCtx(), nonCachedManager, overlayManager, shader, tesselator, and GL_CONTEXT_MANAGER::UnlockCtx().

Member Function Documentation

◆ AdvanceDepth()

void KIGFX::GAL::AdvanceDepth ( )
inlineinherited

Changes the current depth to deeper, so it is possible to draw objects right beneath other.

Definition at line 1002 of file graphics_abstraction_layer.h.

1003  {
1004  layerDepth -= 0.05;
1005  }
double layerDepth
The actual layer depth.

References KIGFX::GAL::layerDepth.

Referenced by KIGFX::VIEW_GROUP::ViewDraw().

◆ beginDrawing()

void OPENGL_GAL::beginDrawing ( )
overrideprivatevirtual

Reimplemented from KIGFX::GAL.

Definition at line 364 of file opengl_gal.cpp.

365 {
366 #ifdef __WXDEBUG__
367  PROF_COUNTER totalRealTime( "OPENGL_GAL::beginDrawing()", true );
368 #endif /* __WXDEBUG__ */
369 
370  wxASSERT_MSG( isContextLocked, "GAL_DRAWING_CONTEXT RAII object should have locked context. "
371  "Calling GAL::beginDrawing() directly is not allowed." );
372 
373  wxASSERT_MSG( IsVisible(), "GAL::beginDrawing() must not be entered when GAL is not visible. "
374  "Other drawing routines will expect everything to be initialized "
375  "which will not be the case." );
376 
377  if( !isInitialized )
378  init();
379 
380  // Set up the view port
381  glMatrixMode( GL_PROJECTION );
382  glLoadIdentity();
383 
384  // Create the screen transformation (Do the RH-LH conversion here)
385  glOrtho( 0, (GLint) screenSize.x, (GLsizei) screenSize.y, 0, -depthRange.x, -depthRange.y );
386 
388  {
389  // Prepare rendering target buffers
393 
395  }
396 
397  compositor->Begin();
398 
399  // Disable 2D Textures
400  glDisable( GL_TEXTURE_2D );
401 
402  glShadeModel( GL_FLAT );
403 
404  // Enable the depth buffer
405  glEnable( GL_DEPTH_TEST );
406  glDepthFunc( GL_LESS );
407 
408  // Setup blending, required for transparent objects
409  glEnable( GL_BLEND );
410  glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
411 
412  glMatrixMode( GL_MODELVIEW );
413 
414  // Set up the world <-> screen transformation
416  GLdouble matrixData[16] = { 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1 };
417  matrixData[0] = worldScreenMatrix.m_data[0][0];
418  matrixData[1] = worldScreenMatrix.m_data[1][0];
419  matrixData[2] = worldScreenMatrix.m_data[2][0];
420  matrixData[4] = worldScreenMatrix.m_data[0][1];
421  matrixData[5] = worldScreenMatrix.m_data[1][1];
422  matrixData[6] = worldScreenMatrix.m_data[2][1];
423  matrixData[12] = worldScreenMatrix.m_data[0][2];
424  matrixData[13] = worldScreenMatrix.m_data[1][2];
425  matrixData[14] = worldScreenMatrix.m_data[2][2];
426  glLoadMatrixd( matrixData );
427 
428  // Set defaults
431 
432  // Remove all previously stored items
435 
439 
441  {
442  // Keep bitmap font texture always bound to the second texturing unit
443  const GLint FONT_TEXTURE_UNIT = 2;
444 
445  // Either load the font atlas to video memory, or simply bind it to a texture unit
446  if( !isBitmapFontLoaded )
447  {
448  glActiveTexture( GL_TEXTURE0 + FONT_TEXTURE_UNIT );
449  glGenTextures( 1, &fontTexture );
450  glBindTexture( GL_TEXTURE_2D, fontTexture );
451  glTexImage2D( GL_TEXTURE_2D, 0, GL_RGB8, font_image.width, font_image.height,
452  0, GL_RGB, GL_UNSIGNED_BYTE, font_image.pixels );
453  glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
454  glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
455  checkGlError( "loading bitmap font" );
456 
457  glActiveTexture( GL_TEXTURE0 );
458 
459  isBitmapFontLoaded = true;
460  }
461  else
462  {
463  glActiveTexture( GL_TEXTURE0 + FONT_TEXTURE_UNIT );
464  glBindTexture( GL_TEXTURE_2D, fontTexture );
465  glActiveTexture( GL_TEXTURE0 );
466  }
467 
468  // Set shader parameter
469  GLint ufm_fontTexture = shader->AddParameter( "fontTexture" );
470  GLint ufm_fontTextureWidth = shader->AddParameter( "fontTextureWidth" );
471  ufm_worldPixelSize = shader->AddParameter( "worldPixelSize" );
472  ufm_screenPixelSize = shader->AddParameter( "screenPixelSize" );
473  ufm_pixelSizeMultiplier = shader->AddParameter( "pixelSizeMultiplier" );
474 
475  shader->Use();
476  shader->SetParameter( ufm_fontTexture, (int) FONT_TEXTURE_UNIT );
477  shader->SetParameter( ufm_fontTextureWidth, (int) font_image.width );
478  shader->Deactivate();
479  checkGlError( "setting bitmap font sampler as shader parameter" );
480 
482  }
483 
484  shader->Use();
487  double pixelSizeMultiplier = compositor->GetAntialiasSupersamplingFactor();
488  shader->SetParameter( ufm_pixelSizeMultiplier, (float) pixelSizeMultiplier );
489  shader->Deactivate();
490 
491  // Something betreen BeginDrawing and EndDrawing seems to depend on
492  // this texture unit being active, but it does not assure it itself.
493  glActiveTexture( GL_TEXTURE0 );
494 
495  // Unbind buffers - set compositor for direct drawing
497 
498 #ifdef __WXDEBUG__
499  totalRealTime.Stop();
500  wxLogTrace( "GAL_PROFILE", wxT( "OPENGL_GAL::beginDrawing(): %.1f ms" ), totalRealTime.msecs() );
501 #endif /* __WXDEBUG__ */
502 }
virtual void SetFillColor(const COLOR4D &aColor)
Set the fill color.
static SHADER * shader
There is only one shader used for different objects.
Definition: opengl_gal.h:311
int GetAntialiasSupersamplingFactor() const
unsigned int overlayBuffer
Auxiliary rendering target (for menus etc.)
Definition: opengl_gal.h:307
virtual void Begin() override
Function Begin() Call this at the beginning of each frame.
void BeginDrawing() const
Function BeginDrawing() prepares buffers and items to start drawing.
bool isBitmapFontInitialized
Is the shader set to use bitmap fonts?
Definition: opengl_gal.h:316
void Use()
Use the shader.
Definition: shader.h:132
static GLuint fontTexture
Bitmap font texture handle (shared)
Definition: opengl_gal.h:293
VERTEX_MANAGER * overlayManager
Container for storing overlaid VERTEX_ITEMs.
Definition: opengl_gal.h:302
VECTOR2D getScreenPixelSize() const
Definition: opengl_gal.cpp:357
virtual void ComputeWorldScreenMatrix() override
Compute the world <-> screen transformation matrix.
void SetParameter(int aParameterNumber, float aValue) const
Set a parameter of the shader.
Definition: shader.cpp:138
bool isContextLocked
Used for assertion checking.
Definition: opengl_gal.h:320
COLOR4D fillColor
The fill color.
VECTOR2D depthRange
Range of the depth.
int checkGlError(const std::string &aInfo, bool aThrow)
Checks if one of recent OpenGL operations has failed.
Definition: utils.cpp:30
static const unsigned int DIRECT_RENDERING
The class PROF_COUNTER is a small class to help profiling.
Definition: profile.h:45
VERTEX_MANAGER * nonCachedManager
Container for storing non-cached VERTEX_ITEMs.
Definition: opengl_gal.h:301
T m_data[3][3]
Definition: matrix3x3.h:64
double getWorldPixelSize() const
Definition: opengl_gal.cpp:350
void init()
Basic OpenGL initialization.
OPENGL_COMPOSITOR * compositor
Handles multiple rendering targets.
Definition: opengl_gal.h:305
unsigned int mainBuffer
Main rendering target.
Definition: opengl_gal.h:306
COLOR4D strokeColor
The color of the outlines.
int AddParameter(const std::string &aParameterName)
Add a parameter to the parameter queue.
Definition: shader.cpp:125
GLint ufm_screenPixelSize
Definition: opengl_gal.h:323
void Deactivate()
Deactivate the shader and use the default OpenGL program.
Definition: shader.h:141
bool isFramebufferInitialized
Are the framebuffers initialized?
Definition: opengl_gal.h:314
FONT_IMAGE_TYPE font_image
Definition: gl_resources.cpp:4
unsigned char pixels[1024 *1024 *3]
Definition: gl_resources.h:38
MATRIX3x3D worldScreenMatrix
World transformation.
virtual void SetBuffer(unsigned int aBufferHandle) override
Function SetBuffer() sets the selected buffer as the rendering target.
VERTEX_MANAGER * cachedManager
Container for storing cached VERTEX_ITEMs.
Definition: opengl_gal.h:300
virtual void Initialize() override
Function Reset() performs primary initialiation, necessary to use the object.
GLint ufm_worldPixelSize
Definition: opengl_gal.h:322
virtual void SetStrokeColor(const COLOR4D &aColor)
Set the stroke color.
bool isInitialized
Basic initialization flag, has to be done when the window is visible.
Definition: opengl_gal.h:317
virtual float GetBackingScaleFactor() const
VECTOR2I screenSize
Screen size in screen coordinates.
virtual unsigned int CreateBuffer() override
Function CreateBuffer() prepares a new buffer that may be used as a rendering target.
bool IsVisible() const override
Definition: opengl_gal.h:99
GLint ufm_pixelSizeMultiplier
Definition: opengl_gal.h:324
void Clear() const
Function Clear() removes all the stored vertices from the container.
static bool isBitmapFontLoaded
Is the bitmap font texture loaded?
Definition: opengl_gal.h:315

References KIGFX::SHADER::AddParameter(), KIGFX::OPENGL_COMPOSITOR::Begin(), KIGFX::VERTEX_MANAGER::BeginDrawing(), cachedManager, checkGlError(), KIGFX::VERTEX_MANAGER::Clear(), compositor, ComputeWorldScreenMatrix(), KIGFX::OPENGL_COMPOSITOR::CreateBuffer(), KIGFX::SHADER::Deactivate(), KIGFX::GAL::depthRange, KIGFX::OPENGL_COMPOSITOR::DIRECT_RENDERING, KIGFX::GAL::fillColor, KIGFX::BUILTIN_FONT::font_image, fontTexture, KIGFX::OPENGL_COMPOSITOR::GetAntialiasSupersamplingFactor(), HIDPI_GL_CANVAS::GetBackingScaleFactor(), getScreenPixelSize(), getWorldPixelSize(), KIGFX::BUILTIN_FONT::FONT_IMAGE_TYPE::height, init(), KIGFX::OPENGL_COMPOSITOR::Initialize(), isBitmapFontInitialized, isBitmapFontLoaded, isContextLocked, isFramebufferInitialized, isInitialized, IsVisible(), MATRIX3x3< T >::m_data, mainBuffer, PROF_COUNTER::msecs(), nonCachedManager, overlayBuffer, overlayManager, KIGFX::BUILTIN_FONT::FONT_IMAGE_TYPE::pixels, KIGFX::GAL::screenSize, KIGFX::OPENGL_COMPOSITOR::SetBuffer(), KIGFX::GAL::SetFillColor(), KIGFX::SHADER::SetParameter(), KIGFX::GAL::SetStrokeColor(), shader, PROF_COUNTER::Stop(), KIGFX::GAL::strokeColor, ufm_pixelSizeMultiplier, ufm_screenPixelSize, ufm_worldPixelSize, KIGFX::SHADER::Use(), KIGFX::BUILTIN_FONT::FONT_IMAGE_TYPE::width, KIGFX::GAL::worldScreenMatrix, VECTOR2< T >::x, and VECTOR2< T >::y.

◆ BeginGroup()

int OPENGL_GAL::BeginGroup ( )
overridevirtual

Begin a group.

A group is a collection of graphic items. Hierarchical groups are possible, attributes and transformations can be used.

Returns
the number of the group.

Reimplemented from KIGFX::GAL.

Definition at line 1392 of file opengl_gal.cpp.

1393 {
1394  isGrouping = true;
1395 
1396  std::shared_ptr<VERTEX_ITEM> newItem = std::make_shared<VERTEX_ITEM>( *cachedManager );
1397  int groupNumber = getNewGroupNumber();
1398  groups.insert( std::make_pair( groupNumber, newItem ) );
1399 
1400  return groupNumber;
1401 }
bool isGrouping
Was a group started?
Definition: opengl_gal.h:319
GROUPS_MAP groups
Stores informations about VBO objects (groups)
Definition: opengl_gal.h:297
VERTEX_MANAGER * cachedManager
Container for storing cached VERTEX_ITEMs.
Definition: opengl_gal.h:300
unsigned int getNewGroupNumber()
Returns a valid key that can be used as a new group number.

References cachedManager, getNewGroupNumber(), groups, and isGrouping.

◆ beginUpdate()

void OPENGL_GAL::beginUpdate ( )
overrideprivatevirtual

Reimplemented from KIGFX::GAL.

Definition at line 564 of file opengl_gal.cpp.

565 {
566  wxASSERT_MSG( isContextLocked, "GAL_UPDATE_CONTEXT RAII object should have locked context. "
567  "Calling this from anywhere else is not allowed." );
568 
569  wxASSERT_MSG( IsVisible(), "GAL::beginUpdate() must not be entered when GAL is not visible. "
570  "Other update routines will expect everything to be initialized "
571  "which will not be the case." );
572 
573  if( !isInitialized )
574  init();
575 
576  cachedManager->Map();
577 }
bool isContextLocked
Used for assertion checking.
Definition: opengl_gal.h:320
void init()
Basic OpenGL initialization.
void Map()
Function Map() maps vertex buffer.
VERTEX_MANAGER * cachedManager
Container for storing cached VERTEX_ITEMs.
Definition: opengl_gal.h:300
bool isInitialized
Basic initialization flag, has to be done when the window is visible.
Definition: opengl_gal.h:317
bool IsVisible() const override
Definition: opengl_gal.h:99

References cachedManager, init(), isContextLocked, isInitialized, IsVisible(), and KIGFX::VERTEX_MANAGER::Map().

◆ BitmapText()

void OPENGL_GAL::BitmapText ( const wxString &  aText,
const VECTOR2D aPosition,
double  aRotationAngle 
)
overridevirtual

Draws a text using a bitmap font.

It should be faster than StrokeText(), but can be used only for non-Gerber elements.

Parameters
aTextis the text to be drawn.
aPositionis the text position in world coordinates.
aRotationAngleis the text rotation angle.

Reimplemented from KIGFX::GAL.

Definition at line 1022 of file opengl_gal.cpp.

1024 {
1025  wxASSERT_MSG( !IsTextMirrored(), "No support for mirrored text using bitmap fonts." );
1026 
1027  auto processedText = ProcessOverbars( aText );
1028  const auto& text = processedText.first;
1029  const auto& overbars = processedText.second;
1030 
1031  // Compute text size, so it can be properly justified
1032  VECTOR2D textSize;
1033  float commonOffset;
1034  std::tie( textSize, commonOffset ) = computeBitmapTextSize( text );
1035 
1036  const double SCALE = 1.4 * GetGlyphSize().y / textSize.y;
1037  bool overbar = false;
1038 
1039  int overbarLength = 0;
1040  double overbarHeight = textSize.y;
1041 
1042  Save();
1043 
1045  currentManager->Translate( aPosition.x, aPosition.y, layerDepth );
1046  currentManager->Rotate( aRotationAngle, 0.0f, 0.0f, -1.0f );
1047 
1048  double sx = SCALE * ( globalFlipX ? -1.0 : 1.0 );
1049  double sy = SCALE * ( globalFlipY ? -1.0 : 1.0 );
1050 
1051  currentManager->Scale( sx, sy, 0 );
1052  currentManager->Translate( 0, -commonOffset, 0 );
1053 
1054  switch( GetHorizontalJustify() )
1055  {
1057  Translate( VECTOR2D( -textSize.x / 2.0, 0 ) );
1058  break;
1059 
1061  //if( !IsTextMirrored() )
1062  Translate( VECTOR2D( -textSize.x, 0 ) );
1063  break;
1064 
1065  case GR_TEXT_HJUSTIFY_LEFT:
1066  //if( IsTextMirrored() )
1067  //Translate( VECTOR2D( -textSize.x, 0 ) );
1068  break;
1069  }
1070 
1071  switch( GetVerticalJustify() )
1072  {
1073  case GR_TEXT_VJUSTIFY_TOP:
1074  Translate( VECTOR2D( 0, -textSize.y ) );
1075  overbarHeight = -textSize.y / 2.0;
1076  break;
1077 
1079  Translate( VECTOR2D( 0, -textSize.y / 2.0 ) );
1080  overbarHeight = 0;
1081  break;
1082 
1084  break;
1085  }
1086 
1087  int i = 0;
1088 
1089  for( UTF8::uni_iter chIt = text.ubegin(), end = text.uend(); chIt < end; ++chIt )
1090  {
1091  unsigned int c = *chIt;
1092  wxASSERT_MSG( c != '\n' && c != '\r', wxT( "No support for multiline bitmap text yet" ) );
1093 
1094  // Handle overbar
1095  if( overbars[i] && !overbar )
1096  {
1097  overbar = true; // beginning of an overbar
1098  }
1099  else if( overbar && !overbars[i] )
1100  {
1101  overbar = false; // end of an overbar
1102  drawBitmapOverbar( overbarLength, overbarHeight );
1103  overbarLength = 0;
1104  }
1105 
1106  if( overbar )
1107  overbarLength += drawBitmapChar( c );
1108  else
1109  drawBitmapChar( c );
1110 
1111  ++i;
1112  }
1113 
1114  // Handle the case when overbar is active till the end of the drawn text
1115  currentManager->Translate( 0, commonOffset, 0 );
1116 
1117  if( overbar && overbarLength > 0 )
1118  drawBitmapOverbar( overbarLength, overbarHeight );
1119 
1120  Restore();
1121 }
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:299
std::pair< UTF8, std::vector< bool > > ProcessOverbars(const UTF8 &aText)
Processes a text to extract the raw text and overbar flags.
Definition: text_utils.cpp:27
double layerDepth
The actual layer depth.
bool IsTextMirrored() const
Returns true if text should displayed mirrored.
virtual void Translate(const VECTOR2D &aTranslation) override
Translate the context.
virtual void Restore() override
Restore the context.
void Rotate(GLfloat aAngle, GLfloat aX, GLfloat aY, GLfloat aZ)
Function Rotate() multiplies the current matrix by a rotation matrix, so the newly vertices will be r...
double g
Green component.
Definition: color4d.h:310
bool globalFlipX
Flag for X axis flipping.
EDA_TEXT_HJUSTIFY_T GetHorizontalJustify() const
Returns current text horizontal justification setting.
double b
Blue component.
Definition: color4d.h:311
const VECTOR2D & GetGlyphSize() const
virtual void Save() override
Save the context.
double a
Alpha component.
Definition: color4d.h:312
VECTOR2< double > VECTOR2D
Definition: vector2d.h:586
COLOR4D strokeColor
The color of the outlines.
void Translate(GLfloat aX, GLfloat aY, GLfloat aZ)
Function Translate() multiplies the current matrix by a translation matrix, so newly vertices will be...
void Color(const COLOR4D &aColor)
Function Color() changes currently used color that will be applied to newly added vertices.
class uni_iter is a non-mutating iterator that walks through unicode code points in the UTF8 encoded ...
Definition: utf8.h:207
bool globalFlipY
Flag for Y axis flipping.
EDA_TEXT_VJUSTIFY_T GetVerticalJustify() const
Returns current text vertical justification setting.
int drawBitmapChar(unsigned long aChar)
Draws a single character using bitmap font.
size_t i
Definition: json11.cpp:597
void Scale(GLfloat aX, GLfloat aY, GLfloat aZ)
Function Scale() multiplies the current matrix by a scaling matrix, so the newly vertices will be sca...
double r
Red component.
Definition: color4d.h:309
std::pair< VECTOR2D, float > computeBitmapTextSize(const UTF8 &aText) const
Computes a size of text drawn using bitmap font with current text setting applied.
void drawBitmapOverbar(double aLength, double aHeight)
Draws an overbar over the currently drawn text.

References KIGFX::COLOR4D::a, KIGFX::COLOR4D::b, KIGFX::VERTEX_MANAGER::Color(), computeBitmapTextSize(), currentManager, drawBitmapChar(), drawBitmapOverbar(), KIGFX::COLOR4D::g, KIGFX::GAL::GetGlyphSize(), KIGFX::GAL::GetHorizontalJustify(), KIGFX::GAL::GetVerticalJustify(), KIGFX::GAL::globalFlipX, KIGFX::GAL::globalFlipY, GR_TEXT_HJUSTIFY_CENTER, GR_TEXT_HJUSTIFY_LEFT, GR_TEXT_HJUSTIFY_RIGHT, GR_TEXT_VJUSTIFY_BOTTOM, GR_TEXT_VJUSTIFY_CENTER, GR_TEXT_VJUSTIFY_TOP, i, KIGFX::GAL::IsTextMirrored(), KIGFX::GAL::layerDepth, ProcessOverbars(), KIGFX::COLOR4D::r, Restore(), KIGFX::VERTEX_MANAGER::Rotate(), Save(), KIGFX::VERTEX_MANAGER::Scale(), KIGFX::GAL::strokeColor, Translate(), KIGFX::VERTEX_MANAGER::Translate(), VECTOR2< T >::x, and VECTOR2< T >::y.

◆ blitCursor()

void OPENGL_GAL::blitCursor ( )
private

Blits cursor into the current screen.

Definition at line 1861 of file opengl_gal.cpp.

1862 {
1863  if( !IsCursorEnabled() )
1864  return;
1865 
1867 
1868  const int cursorSize = fullscreenCursor ? 8000 : 80;
1869 
1870  VECTOR2D cursorBegin = cursorPosition - cursorSize / ( 2 * worldScale );
1871  VECTOR2D cursorEnd = cursorPosition + cursorSize / ( 2 * worldScale );
1872  VECTOR2D cursorCenter = ( cursorBegin + cursorEnd ) / 2;
1873 
1874  const COLOR4D cColor = getCursorColor();
1875  const COLOR4D color( cColor.r * cColor.a, cColor.g * cColor.a,
1876  cColor.b * cColor.a, 1.0 );
1877 
1878  glActiveTexture( GL_TEXTURE0 );
1879  glDisable( GL_TEXTURE_2D );
1880  glLineWidth( 1.0 );
1881  glColor4d( color.r, color.g, color.b, color.a );
1882 
1883  glBegin( GL_LINES );
1884  glVertex2d( cursorCenter.x, cursorBegin.y );
1885  glVertex2d( cursorCenter.x, cursorEnd.y );
1886 
1887  glVertex2d( cursorBegin.x, cursorCenter.y );
1888  glVertex2d( cursorEnd.x, cursorCenter.y );
1889  glEnd();
1890 }
VECTOR2D cursorPosition
Current cursor position (world coordinates)
int color
Definition: DXF_plotter.cpp:62
double g
Green component.
Definition: color4d.h:310
static const unsigned int DIRECT_RENDERING
double b
Blue component.
Definition: color4d.h:311
double a
Alpha component.
Definition: color4d.h:312
OPENGL_COMPOSITOR * compositor
Handles multiple rendering targets.
Definition: opengl_gal.h:305
bool fullscreenCursor
Shape of the cursor (fullscreen or small cross)
virtual void SetBuffer(unsigned int aBufferHandle) override
Function SetBuffer() sets the selected buffer as the rendering target.
COLOR4D getCursorColor() const
Gets the actual cursor color to draw.
double worldScale
The scale factor world->screen.
double r
Red component.
Definition: color4d.h:309
bool IsCursorEnabled() const
Returns information about cursor visibility.
Class COLOR4D is the color representation with 4 components: red, green, blue, alpha.
Definition: color4d.h:39

References KIGFX::COLOR4D::a, KIGFX::COLOR4D::b, color, compositor, KIGFX::GAL::cursorPosition, KIGFX::OPENGL_COMPOSITOR::DIRECT_RENDERING, KIGFX::GAL::fullscreenCursor, KIGFX::COLOR4D::g, KIGFX::GAL::getCursorColor(), KIGFX::GAL::IsCursorEnabled(), KIGFX::COLOR4D::r, KIGFX::OPENGL_COMPOSITOR::SetBuffer(), KIGFX::GAL::worldScale, VECTOR2< T >::x, and VECTOR2< T >::y.

Referenced by endDrawing().

◆ calcAngleStep()

double KIGFX::OPENGL_GAL::calcAngleStep ( double  aRadius) const
inlineprivate

Compute the angle step when drawing arcs/circles approximated with lines.

Definition at line 472 of file opengl_gal.h.

473  {
474  // Bigger arcs need smaller alpha increment to make them look smooth
475  return std::min( 1e6 / aRadius, 2.0 * M_PI / CIRCLE_POINTS );
476  }
CIRCLE_POINTS
#define min(a, b)
Definition: auxiliary.h:85

References min.

Referenced by DrawArc().

◆ ChangeGroupColor()

void OPENGL_GAL::ChangeGroupColor ( int  aGroupNumber,
const COLOR4D aNewColor 
)
overridevirtual

Changes the color used to draw the group.

Parameters
aGroupNumberis the group number.
aNewColoris the new color.

Reimplemented from KIGFX::GAL.

Definition at line 1418 of file opengl_gal.cpp.

1419 {
1420  if( groups[aGroupNumber] )
1421  cachedManager->ChangeItemColor( *groups[aGroupNumber], aNewColor );
1422 }
GROUPS_MAP groups
Stores informations about VBO objects (groups)
Definition: opengl_gal.h:297
VERTEX_MANAGER * cachedManager
Container for storing cached VERTEX_ITEMs.
Definition: opengl_gal.h:300
void ChangeItemColor(const VERTEX_ITEM &aItem, const COLOR4D &aColor) const
Function ChangeItemColor() changes the color of all vertices owned by an item.

References cachedManager, KIGFX::VERTEX_MANAGER::ChangeItemColor(), and groups.

◆ ChangeGroupDepth()

void OPENGL_GAL::ChangeGroupDepth ( int  aGroupNumber,
int  aDepth 
)
overridevirtual

Changes the depth (Z-axis position) of the group.

Parameters
aGroupNumberis the group number.
aDepthis the new depth.

Reimplemented from KIGFX::GAL.

Definition at line 1425 of file opengl_gal.cpp.

1426 {
1427  if( groups[aGroupNumber] )
1428  cachedManager->ChangeItemDepth( *groups[aGroupNumber], aDepth );
1429 }
void ChangeItemDepth(const VERTEX_ITEM &aItem, GLfloat aDepth) const
Function ChangeItemDepth() changes the depth of all vertices owned by an item.
GROUPS_MAP groups
Stores informations about VBO objects (groups)
Definition: opengl_gal.h:297
VERTEX_MANAGER * cachedManager
Container for storing cached VERTEX_ITEMs.
Definition: opengl_gal.h:300

References cachedManager, KIGFX::VERTEX_MANAGER::ChangeItemDepth(), and groups.

◆ ClearCache()

void OPENGL_GAL::ClearCache ( )
overridevirtual

Delete all data created during caching of graphic items.

Reimplemented from KIGFX::GAL.

Definition at line 1439 of file opengl_gal.cpp.

1440 {
1441  bitmapCache.reset( new GL_BITMAP_CACHE );
1442 
1443  groups.clear();
1444 
1445  if( isInitialized )
1446  cachedManager->Clear();
1447 }
std::unique_ptr< GL_BITMAP_CACHE > bitmapCache
Definition: opengl_gal.h:326
GROUPS_MAP groups
Stores informations about VBO objects (groups)
Definition: opengl_gal.h:297
VERTEX_MANAGER * cachedManager
Container for storing cached VERTEX_ITEMs.
Definition: opengl_gal.h:300
bool isInitialized
Basic initialization flag, has to be done when the window is visible.
Definition: opengl_gal.h:317
void Clear() const
Function Clear() removes all the stored vertices from the container.

References bitmapCache, cachedManager, KIGFX::VERTEX_MANAGER::Clear(), groups, and isInitialized.

Referenced by ~OPENGL_GAL().

◆ ClearScreen()

void OPENGL_GAL::ClearScreen ( )
overridevirtual

Clear the screen.

Parameters
aColoris the color used for clearing.

Reimplemented from KIGFX::GAL.

Definition at line 1334 of file opengl_gal.cpp.

1335 {
1336  // Clear screen
1338  // NOTE: Black used here instead of m_clearColor; it will be composited later
1339  glClearColor( 0, 0, 0, 1 );
1340  glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT );
1341 }
static const unsigned int DIRECT_RENDERING
OPENGL_COMPOSITOR * compositor
Handles multiple rendering targets.
Definition: opengl_gal.h:305
virtual void SetBuffer(unsigned int aBufferHandle) override
Function SetBuffer() sets the selected buffer as the rendering target.

References compositor, KIGFX::OPENGL_COMPOSITOR::DIRECT_RENDERING, and KIGFX::OPENGL_COMPOSITOR::SetBuffer().

◆ ClearTarget()

void OPENGL_GAL::ClearTarget ( RENDER_TARGET  aTarget)
overridevirtual

Clears the target for rendering.

Parameters
aTargetis the target to be cleared.

Reimplemented from KIGFX::GAL.

Definition at line 1490 of file opengl_gal.cpp.

1491 {
1492  // Save the current state
1493  unsigned int oldTarget = compositor->GetBuffer();
1494 
1495  switch( aTarget )
1496  {
1497  // Cached and noncached items are rendered to the same buffer
1498  default:
1499  case TARGET_CACHED:
1500  case TARGET_NONCACHED:
1502  break;
1503 
1504  case TARGET_OVERLAY:
1506  break;
1507  }
1508 
1509 
1510  if( aTarget != TARGET_OVERLAY )
1512  else
1514 
1515  // Restore the previous state
1516  compositor->SetBuffer( oldTarget );
1517 }
unsigned int overlayBuffer
Auxiliary rendering target (for menus etc.)
Definition: opengl_gal.h:307
static const COLOR4D BLACK
Definition: color4d.h:319
Auxiliary rendering target (noncached)
Definition: definitions.h:49
OPENGL_COMPOSITOR * compositor
Handles multiple rendering targets.
Definition: opengl_gal.h:305
unsigned int mainBuffer
Main rendering target.
Definition: opengl_gal.h:306
virtual void ClearBuffer(const COLOR4D &aColor) override
Function ClearBuffer() clears the selected buffer (set by the SetBuffer() function).
Items that may change while the view stays the same (noncached)
Definition: definitions.h:50
virtual void SetBuffer(unsigned int aBufferHandle) override
Function SetBuffer() sets the selected buffer as the rendering target.
Main rendering target (cached)
Definition: definitions.h:48
virtual unsigned int GetBuffer() const override
Function GetBuffer() returns currently used buffer handle.

References KIGFX::COLOR4D::BLACK, KIGFX::OPENGL_COMPOSITOR::ClearBuffer(), compositor, KIGFX::OPENGL_COMPOSITOR::GetBuffer(), KIGFX::GAL::m_clearColor, mainBuffer, overlayBuffer, KIGFX::OPENGL_COMPOSITOR::SetBuffer(), KIGFX::TARGET_CACHED, KIGFX::TARGET_NONCACHED, and KIGFX::TARGET_OVERLAY.

◆ computeBitmapTextSize()

std::pair< VECTOR2D, float > OPENGL_GAL::computeBitmapTextSize ( const UTF8 aText) const
private

Computes a size of text drawn using bitmap font with current text setting applied.

Parameters
aTextis the text to be drawn.
Returns
Pair containing text bounding box and common Y axis offset. The values are expressed as a number of pixels on the bitmap font texture and need to be scaled before drawing.

Definition at line 1811 of file opengl_gal.cpp.

1812 {
1813  VECTOR2D textSize( 0, 0 );
1814  float commonOffset = std::numeric_limits<float>::max();
1815  static const auto defaultGlyph = LookupGlyph( '(' ); // for strange chars
1816 
1817  for( UTF8::uni_iter chIt = aText.ubegin(), end = aText.uend(); chIt < end; ++chIt )
1818  {
1819  unsigned int c = *chIt;
1820 
1821  const FONT_GLYPH_TYPE* glyph = LookupGlyph( c );
1822  // Debug: show not coded char in the atlas
1823  // Be carefull before allowing the assert: it usually crash kicad
1824  // when the assert is made during a paint event.
1825  // wxASSERT_MSG( glyph, wxString::Format( "missing char in font: code 0x%x <%c>", c, c ) );
1826 
1827  if( !glyph || // Not coded in font
1828  c == '-' || c == '_' ) // Strange size of these 2 chars
1829  {
1830  glyph = defaultGlyph;
1831  }
1832 
1833  if( glyph )
1834  {
1835  textSize.x += glyph->advance;
1836  }
1837  }
1838 
1839  textSize.y = std::max<float>( textSize.y, font_information.max_y - defaultGlyph->miny );
1840  commonOffset = std::min<float>( font_information.max_y - defaultGlyph->maxy, commonOffset );
1841  textSize.y -= commonOffset;
1842 
1843  return std::make_pair( textSize, commonOffset );
1844 }
uni_iter uend() const
Function uend returns a uni_iter initialized to the end of "this" UTF8 byte sequence.
Definition: utf8.h:294
const FONT_GLYPH_TYPE * LookupGlyph(unsigned int aCodepoint)
uni_iter ubegin() const
Function ubegin returns a uni_iter initialized to the start of "this" UTF8 byte sequence.
Definition: utf8.h:285
FONT_INFO_TYPE font_information
Definition: gl_resources.cpp:3
class uni_iter is a non-mutating iterator that walks through unicode code points in the UTF8 encoded ...
Definition: utf8.h:207
#define max(a, b)
Definition: auxiliary.h:86

References KIGFX::BUILTIN_FONT::FONT_GLYPH_TYPE::advance, KIGFX::BUILTIN_FONT::font_information, KIGFX::BUILTIN_FONT::LookupGlyph(), max, KIGFX::BUILTIN_FONT::FONT_INFO_TYPE::max_y, UTF8::ubegin(), UTF8::uend(), VECTOR2< T >::x, and VECTOR2< T >::y.

Referenced by BitmapText().

◆ computeMinGridSpacing()

double GAL::computeMinGridSpacing ( ) const
protectedinherited

compute minimum grid spacing from the grid settings

Returns
the minimum spacing to use for drawing the grid

Definition at line 208 of file graphics_abstraction_layer.cpp.

209 {
210  // just return the current value. This could be cleverer and take
211  // into account other settings in future
212  return gridMinSpacing;
213 }
int gridMinSpacing
Minimum screen size of the grid (pixels) below which the grid is not drawn.

References KIGFX::GAL::gridMinSpacing.

Referenced by DrawGrid(), and KIGFX::CAIRO_GAL_BASE::DrawGrid().

◆ computeWorldScale()

void KIGFX::GAL::computeWorldScale ( )
inlineprotectedinherited

Compute the scaling factor for the world->screen matrix.

Definition at line 1104 of file graphics_abstraction_layer.h.

1105  {
1107  }
double zoomFactor
The zoom factor.
double worldUnitLength
The unit length of the world coordinates [inch].
double worldScale
The scale factor world->screen.
double screenDPI
The dots per inch of the screen.

References KIGFX::GAL::screenDPI, KIGFX::GAL::worldScale, KIGFX::GAL::worldUnitLength, and KIGFX::GAL::zoomFactor.

Referenced by KIGFX::GAL::ComputeWorldScreenMatrix(), and KIGFX::GAL::GAL().

◆ ComputeWorldScreenMatrix()

void OPENGL_GAL::ComputeWorldScreenMatrix ( )
overridevirtual

Compute the world <-> screen transformation matrix.

Reimplemented from KIGFX::GAL.

Definition at line 2034 of file opengl_gal.cpp.

2035 {
2036  auto pixelSize = worldScale;
2037 
2038  lookAtPoint.x = roundr( lookAtPoint.x, pixelSize );
2039  lookAtPoint.y = roundr( lookAtPoint.y, pixelSize );
2040 
2042 }
virtual void ComputeWorldScreenMatrix()
Compute the world <-> screen transformation matrix.
VECTOR2D lookAtPoint
Point to be looked at in world space.
double worldScale
The scale factor world->screen.
static double roundr(double f, double r)

References KIGFX::GAL::ComputeWorldScreenMatrix(), KIGFX::GAL::lookAtPoint, roundr(), KIGFX::GAL::worldScale, VECTOR2< T >::x, and VECTOR2< T >::y.

Referenced by beginDrawing().

◆ DeleteGroup()

void OPENGL_GAL::DeleteGroup ( int  aGroupNumber)
overridevirtual

Delete the group from the memory.

Parameters
aGroupNumberis the group number.

Reimplemented from KIGFX::GAL.

Definition at line 1432 of file opengl_gal.cpp.

1433 {
1434  // Frees memory in the container as well
1435  groups.erase( aGroupNumber );
1436 }
GROUPS_MAP groups
Stores informations about VBO objects (groups)
Definition: opengl_gal.h:297

References groups.

◆ DrawArc()

void OPENGL_GAL::DrawArc ( const VECTOR2D aCenterPoint,
double  aRadius,
double  aStartAngle,
double  aEndAngle 
)
overridevirtual

Draw an arc.

Parameters
aCenterPointis the center point of the arc.
aRadiusis the arc radius.
aStartAngleis the start angle of the arc.
aEndAngleis the end angle of the arc.

Reimplemented from KIGFX::GAL.

Definition at line 699 of file opengl_gal.cpp.

701 {
702  if( aRadius <= 0 )
703  return;
704 
705  // Swap the angles, if start angle is greater than end angle
706  SWAP( aStartAngle, >, aEndAngle );
707 
708  const double alphaIncrement = calcAngleStep( aRadius );
709 
710  Save();
711  currentManager->Translate( aCenterPoint.x, aCenterPoint.y, 0.0 );
712 
713  if( isFillEnabled )
714  {
715  double alpha;
718 
719  // Triangle fan
720  for( alpha = aStartAngle; ( alpha + alphaIncrement ) < aEndAngle; )
721  {
722  currentManager->Reserve( 3 );
723  currentManager->Vertex( 0.0, 0.0, layerDepth );
724  currentManager->Vertex( cos( alpha ) * aRadius, sin( alpha ) * aRadius, layerDepth );
725  alpha += alphaIncrement;
726  currentManager->Vertex( cos( alpha ) * aRadius, sin( alpha ) * aRadius, layerDepth );
727  }
728 
729  // The last missing triangle
730  const VECTOR2D endPoint( cos( aEndAngle ) * aRadius, sin( aEndAngle ) * aRadius );
731 
732  currentManager->Reserve( 3 );
733  currentManager->Vertex( 0.0, 0.0, layerDepth );
734  currentManager->Vertex( cos( alpha ) * aRadius, sin( alpha ) * aRadius, layerDepth );
735  currentManager->Vertex( endPoint.x, endPoint.y, layerDepth );
736  }
737 
738  if( isStrokeEnabled )
739  {
741 
742  VECTOR2D p( cos( aStartAngle ) * aRadius, sin( aStartAngle ) * aRadius );
743  double alpha;
744 
745  for( alpha = aStartAngle + alphaIncrement; alpha <= aEndAngle; alpha += alphaIncrement )
746  {
747  VECTOR2D p_next( cos( alpha ) * aRadius, sin( alpha ) * aRadius );
748  DrawLine( p, p_next );
749 
750  p = p_next;
751  }
752 
753  // Draw the last missing part
754  if( alpha != aEndAngle )
755  {
756  VECTOR2D p_last( cos( aEndAngle ) * aRadius, sin( aEndAngle ) * aRadius );
757  DrawLine( p, p_last );
758  }
759  }
760 
761  Restore();
762 }
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:299
double layerDepth
The actual layer depth.
bool Reserve(unsigned int aSize)
Function Reserve() allocates space for vertices, so it will be used with subsequent Vertex() calls.
virtual void Restore() override
Restore the context.
bool Vertex(const VERTEX &aVertex)
Function Vertex() adds a vertex with the given coordinates to the currently set item.
double g
Green component.
Definition: color4d.h:310
COLOR4D fillColor
The fill color.
double b
Blue component.
Definition: color4d.h:311
virtual void Save() override
Save the context.
double a
Alpha component.
Definition: color4d.h:312
bool isStrokeEnabled
Are the outlines stroked ?
double calcAngleStep(double aRadius) const
Compute the angle step when drawing arcs/circles approximated with lines.
Definition: opengl_gal.h:472
COLOR4D strokeColor
The color of the outlines.
void Translate(GLfloat aX, GLfloat aY, GLfloat aZ)
Function Translate() multiplies the current matrix by a translation matrix, so newly vertices will be...
virtual void DrawLine(const VECTOR2D &aStartPoint, const VECTOR2D &aEndPoint) override
Draw a line.
Definition: opengl_gal.cpp:589
void Color(const COLOR4D &aColor)
Function Color() changes currently used color that will be applied to newly added vertices.
bool isFillEnabled
Is filling of graphic objects enabled ?
#define SWAP(varA, condition, varB)
Swap the variables if a condition is met.
Definition: definitions.h:31
void Shader(GLfloat aShaderType, GLfloat aParam1=0.0f, GLfloat aParam2=0.0f, GLfloat aParam3=0.0f)
Function Shader() changes currently used shader and its parameters that will be applied to newly adde...
double r
Red component.
Definition: color4d.h:309

References KIGFX::COLOR4D::a, KIGFX::COLOR4D::b, calcAngleStep(), KIGFX::VERTEX_MANAGER::Color(), currentManager, DrawLine(), KIGFX::GAL::fillColor, KIGFX::COLOR4D::g, KIGFX::GAL::isFillEnabled, KIGFX::GAL::isStrokeEnabled, KIGFX::GAL::layerDepth, KIGFX::COLOR4D::r, KIGFX::VERTEX_MANAGER::Reserve(), Restore(), Save(), KIGFX::VERTEX_MANAGER::Shader(), KIGFX::SHADER_NONE, KIGFX::GAL::strokeColor, SWAP, KIGFX::VERTEX_MANAGER::Translate(), KIGFX::VERTEX_MANAGER::Vertex(), VECTOR2< T >::x, and VECTOR2< T >::y.

◆ DrawBitmap()

void OPENGL_GAL::DrawBitmap ( const BITMAP_BASE aBitmap)
overridevirtual

Draw a bitmap image.

Reimplemented from KIGFX::GAL.

Definition at line 967 of file opengl_gal.cpp.

968 {
969  // We have to calculate the pixel size in users units to draw the image.
970  // worldUnitLength is a factor used for converting IU to inches
971  double scale = 1.0 / ( aBitmap.GetPPI() * worldUnitLength );
972  double w = (double) aBitmap.GetSizePixels().x * scale;
973  double h = (double) aBitmap.GetSizePixels().y * scale;
974 
975  auto xform = currentManager->GetTransformation();
976 
977  glm::vec4 v0 = xform * glm::vec4( -w/2, -h/2, 0.0, 0.0 );
978  glm::vec4 v1 = xform * glm::vec4( w/2, h/2, 0.0, 0.0 );
979  glm::vec4 trans = xform[3];
980 
981  auto texture_id = bitmapCache->RequestBitmap( &aBitmap );
982 
983  if( !glIsTexture( texture_id ) ) // ensure the bitmap texture is still valid
984  return;
985 
986  auto oldTarget = GetTarget();
987 
988  glPushMatrix();
989  glTranslated( trans.x, trans.y, trans.z );
990 
992  glEnable(GL_TEXTURE_2D);
993  glActiveTexture( GL_TEXTURE0 );
994  glBindTexture( GL_TEXTURE_2D, texture_id );
995 
996  glBegin( GL_QUADS );
997  glColor4f( 1.0, 1.0, 1.0, 1.0 );
998  glTexCoord2f( 0.0, 0.0 );
999  glVertex3f( v0.x, v0.y, layerDepth );
1000  glColor4f( 1.0, 1.0, 1.0, 1.0 );
1001  glTexCoord2f( 1.0, 0.0 );
1002  glVertex3f( v1.x, v0.y, layerDepth );
1003  glColor4f( 1.0, 1.0, 1.0, 1.0 );
1004  glTexCoord2f( 1.0, 1.0 );
1005  glVertex3f( v1.x, v1.y, layerDepth );
1006  glColor4f( 1.0, 1.0, 1.0, 1.0 );
1007  glTexCoord2f( 0.0, 1.0 );
1008  glVertex3f( v0.x, v1.y, layerDepth );
1009  glEnd();
1010 
1011  SetTarget( oldTarget );
1012  glBindTexture( GL_TEXTURE_2D, 0 );
1013 
1014 #ifdef DISABLE_BITMAP_CACHE
1015  glDeleteTextures( 1, &texture_id );
1016 #endif
1017 
1018  glPopMatrix();
1019 }
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:299
const glm::mat4 & GetTransformation() const
double layerDepth
The actual layer depth.
std::unique_ptr< GL_BITMAP_CACHE > bitmapCache
Definition: opengl_gal.h:326
Auxiliary rendering target (noncached)
Definition: definitions.h:49
virtual RENDER_TARGET GetTarget() const override
Gets the currently used target for rendering.
double worldUnitLength
The unit length of the world coordinates [inch].
virtual void SetTarget(RENDER_TARGET aTarget) override
Sets the target for rendering.
const int scale
wxSize GetSizePixels() const
Function GetSizePixels.
Definition: bitmap_base.h:133
int GetPPI() const
Definition: bitmap_base.h:145

References bitmapCache, currentManager, BITMAP_BASE::GetPPI(), BITMAP_BASE::GetSizePixels(), GetTarget(), KIGFX::VERTEX_MANAGER::GetTransformation(), KIGFX::GAL::layerDepth, scale, SetTarget(), KIGFX::TARGET_NONCACHED, and KIGFX::GAL::worldUnitLength.

◆ drawBitmapChar()

int OPENGL_GAL::drawBitmapChar ( unsigned long  aChar)
private

Draws a single character using bitmap font.

Its main purpose is to be used in BitmapText() function.

Parameters
aCharis the character to be drawn.
Returns
Width of the drawn glyph.

Definition at line 1710 of file opengl_gal.cpp.

1711 {
1712  const float TEX_X = font_image.width;
1713  const float TEX_Y = font_image.height;
1714 
1715  // handle space
1716  if( aChar == ' ' )
1717  {
1718  const FONT_GLYPH_TYPE* g = LookupGlyph( 'x' );
1719  wxASSERT( g );
1720  Translate( VECTOR2D( g->advance, 0 ) );
1721  return g->advance;
1722  }
1723 
1724  const FONT_GLYPH_TYPE* glyph = LookupGlyph( aChar );
1725 
1726  // If the glyph is not found (happens for many esotheric unicode chars)
1727  // shows a '?' instead.
1728  if( !glyph )
1729  glyph = LookupGlyph( '?' );
1730 
1731  if( !glyph ) // Should not happen.
1732  return 0;
1733 
1734  const float X = glyph->atlas_x + font_information.smooth_pixels;
1735  const float Y = glyph->atlas_y + font_information.smooth_pixels;
1736  const float XOFF = glyph->minx;
1737 
1738  // adjust for height rounding
1739  const float round_adjust = ( glyph->maxy - glyph->miny )
1740  - float( glyph->atlas_h - font_information.smooth_pixels * 2 );
1741  const float top_adjust = font_information.max_y - glyph->maxy;
1742  const float YOFF = round_adjust + top_adjust;
1743  const float W = glyph->atlas_w - font_information.smooth_pixels *2;
1744  const float H = glyph->atlas_h - font_information.smooth_pixels *2;
1745  const float B = 0;
1746 
1747  currentManager->Reserve( 6 );
1748  Translate( VECTOR2D( XOFF, YOFF ) );
1749  /* Glyph:
1750  * v0 v1
1751  * +--+
1752  * | /|
1753  * |/ |
1754  * +--+
1755  * v2 v3
1756  */
1757  currentManager->Shader( SHADER_FONT, X / TEX_X, ( Y + H ) / TEX_Y );
1758  currentManager->Vertex( -B, -B, 0 ); // v0
1759 
1760  currentManager->Shader( SHADER_FONT, ( X + W ) / TEX_X, ( Y + H ) / TEX_Y );
1761  currentManager->Vertex( W + B, -B, 0 ); // v1
1762 
1763  currentManager->Shader( SHADER_FONT, X / TEX_X, Y / TEX_Y );
1764  currentManager->Vertex( -B, H + B, 0 ); // v2
1765 
1766 
1767  currentManager->Shader( SHADER_FONT, ( X + W ) / TEX_X, ( Y + H ) / TEX_Y );
1768  currentManager->Vertex( W + B, -B, 0 ); // v1
1769 
1770  currentManager->Shader( SHADER_FONT, X / TEX_X, Y / TEX_Y );
1771  currentManager->Vertex( -B, H + B, 0 ); // v2
1772 
1773  currentManager->Shader( SHADER_FONT, ( X + W ) / TEX_X, Y / TEX_Y );
1774  currentManager->Vertex( W + B, H + B, 0 ); // v3
1775 
1776  Translate( VECTOR2D( -XOFF + glyph->advance, -YOFF ) );
1777 
1778  return glyph->advance;
1779 }
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:299
virtual void Translate(const VECTOR2D &aTranslation) override
Translate the context.
bool Reserve(unsigned int aSize)
Function Reserve() allocates space for vertices, so it will be used with subsequent Vertex() calls.
bool Vertex(const VERTEX &aVertex)
Function Vertex() adds a vertex with the given coordinates to the currently set item.
const FONT_GLYPH_TYPE * LookupGlyph(unsigned int aCodepoint)
VECTOR2< double > VECTOR2D
Definition: vector2d.h:586
FONT_IMAGE_TYPE font_image
Definition: gl_resources.cpp:4
FONT_INFO_TYPE font_information
Definition: gl_resources.cpp:3
#define H(x, y, z)
Definition: md5_hash.cpp:17
void Shader(GLfloat aShaderType, GLfloat aParam1=0.0f, GLfloat aParam2=0.0f, GLfloat aParam3=0.0f)
Function Shader() changes currently used shader and its parameters that will be applied to newly adde...

References KIGFX::BUILTIN_FONT::FONT_GLYPH_TYPE::advance, KIGFX::BUILTIN_FONT::FONT_GLYPH_TYPE::atlas_h, KIGFX::BUILTIN_FONT::FONT_GLYPH_TYPE::atlas_w, KIGFX::BUILTIN_FONT::FONT_GLYPH_TYPE::atlas_x, KIGFX::BUILTIN_FONT::FONT_GLYPH_TYPE::atlas_y, currentManager, KIGFX::BUILTIN_FONT::font_image, KIGFX::BUILTIN_FONT::font_information, H, KIGFX::BUILTIN_FONT::FONT_IMAGE_TYPE::height, KIGFX::BUILTIN_FONT::LookupGlyph(), KIGFX::BUILTIN_FONT::FONT_INFO_TYPE::max_y, KIGFX::BUILTIN_FONT::FONT_GLYPH_TYPE::maxy, KIGFX::BUILTIN_FONT::FONT_GLYPH_TYPE::minx, KIGFX::BUILTIN_FONT::FONT_GLYPH_TYPE::miny, KIGFX::VERTEX_MANAGER::Reserve(), KIGFX::VERTEX_MANAGER::Shader(), KIGFX::SHADER_FONT, KIGFX::BUILTIN_FONT::FONT_INFO_TYPE::smooth_pixels, Translate(), KIGFX::VERTEX_MANAGER::Vertex(), and KIGFX::BUILTIN_FONT::FONT_IMAGE_TYPE::width.

Referenced by BitmapText().

◆ drawBitmapOverbar()

void OPENGL_GAL::drawBitmapOverbar ( double  aLength,
double  aHeight 
)
private

Draws an overbar over the currently drawn text.

Its main purpose is to be used in BitmapText() function. This method requires appropriate scaling to be applied (as is done in BitmapText() function). The current X coordinate will be the overbar ending.

Parameters
aLengthis the width of the overbar.
aHeightis the height for the overbar.

Definition at line 1782 of file opengl_gal.cpp.

1783 {
1784  // To draw an overbar, simply draw an overbar
1785  const FONT_GLYPH_TYPE* glyph = LookupGlyph( '_' );
1786  wxCHECK( glyph, /* void */ );
1787 
1788  const float H = glyph->maxy - glyph->miny;
1789 
1790  Save();
1791 
1792  Translate( VECTOR2D( -aLength, -aHeight-1.5*H ) );
1793 
1794  currentManager->Reserve( 6 );
1796 
1797  currentManager->Shader( 0 );
1798 
1799  currentManager->Vertex( 0, 0, 0 ); // v0
1800  currentManager->Vertex( aLength, 0, 0 ); // v1
1801  currentManager->Vertex( 0, H, 0 ); // v2
1802 
1803  currentManager->Vertex( aLength, 0, 0 ); // v1
1804  currentManager->Vertex( 0, H, 0 ); // v2
1805  currentManager->Vertex( aLength, H, 0 ); // v3
1806 
1807  Restore();
1808 }
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:299
virtual void Translate(const VECTOR2D &aTranslation) override
Translate the context.
bool Reserve(unsigned int aSize)
Function Reserve() allocates space for vertices, so it will be used with subsequent Vertex() calls.
virtual void Restore() override
Restore the context.
bool Vertex(const VERTEX &aVertex)
Function Vertex() adds a vertex with the given coordinates to the currently set item.
double g
Green component.
Definition: color4d.h:310
const FONT_GLYPH_TYPE * LookupGlyph(unsigned int aCodepoint)
double b
Blue component.
Definition: color4d.h:311
virtual void Save() override
Save the context.
VECTOR2< double > VECTOR2D
Definition: vector2d.h:586
COLOR4D strokeColor
The color of the outlines.
void Color(const COLOR4D &aColor)
Function Color() changes currently used color that will be applied to newly added vertices.
#define H(x, y, z)
Definition: md5_hash.cpp:17
void Shader(GLfloat aShaderType, GLfloat aParam1=0.0f, GLfloat aParam2=0.0f, GLfloat aParam3=0.0f)
Function Shader() changes currently used shader and its parameters that will be applied to newly adde...
double r
Red component.
Definition: color4d.h:309

References KIGFX::COLOR4D::b, KIGFX::VERTEX_MANAGER::Color(), currentManager, KIGFX::COLOR4D::g, H, KIGFX::BUILTIN_FONT::LookupGlyph(), KIGFX::BUILTIN_FONT::FONT_GLYPH_TYPE::maxy, KIGFX::BUILTIN_FONT::FONT_GLYPH_TYPE::miny, KIGFX::COLOR4D::r, KIGFX::VERTEX_MANAGER::Reserve(), Restore(), Save(), KIGFX::VERTEX_MANAGER::Shader(), KIGFX::GAL::strokeColor, Translate(), and KIGFX::VERTEX_MANAGER::Vertex().

Referenced by BitmapText().

◆ DrawCircle()

void OPENGL_GAL::DrawCircle ( const VECTOR2D aCenterPoint,
double  aRadius 
)
overridevirtual

Draw a circle using world coordinates.

Parameters
aCenterPointis the center point of the circle.
aRadiusis the radius of the circle.

Reimplemented from KIGFX::GAL.

Definition at line 643 of file opengl_gal.cpp.

644 {
645  if( isFillEnabled )
646  {
647  currentManager->Reserve( 3 );
649 
650  /* Draw a triangle that contains the circle, then shade it leaving only the circle.
651  * Parameters given to Shader() are indices of the triangle's vertices
652  * (if you want to understand more, check the vertex shader source [shader.vert]).
653  * Shader uses this coordinates to determine if fragments are inside the circle or not.
654  * Does the calculations in the vertex shader now (pixel alignment)
655  * v2
656  * /\
657  * //\\
658  * v0 /_\/_\ v1
659  */
660  currentManager->Shader( SHADER_FILLED_CIRCLE, 1.0, aRadius );
661  currentManager->Vertex( aCenterPoint.x, aCenterPoint.y, layerDepth );
662 
663  currentManager->Shader( SHADER_FILLED_CIRCLE, 2.0, aRadius );
664  currentManager->Vertex( aCenterPoint.x, aCenterPoint.y, layerDepth );
665 
666  currentManager->Shader( SHADER_FILLED_CIRCLE, 3.0, aRadius );
667  currentManager->Vertex( aCenterPoint.x, aCenterPoint.y, layerDepth );
668  }
669  if( isStrokeEnabled )
670  {
671  currentManager->Reserve( 3 );
673 
674  /* Draw a triangle that contains the circle, then shade it leaving only the circle.
675  * Parameters given to Shader() are indices of the triangle's vertices
676  * (if you want to understand more, check the vertex shader source [shader.vert]).
677  * and the line width. Shader uses this coordinates to determine if fragments are
678  * inside the circle or not.
679  * v2
680  * /\
681  * //\\
682  * v0 /_\/_\ v1
683  */
685  currentManager->Vertex( aCenterPoint.x, // v0
686  aCenterPoint.y, layerDepth );
687 
689  currentManager->Vertex( aCenterPoint.x, // v1
690  aCenterPoint.y, layerDepth );
691 
693  currentManager->Vertex( aCenterPoint.x, aCenterPoint.y, // v2
694  layerDepth );
695  }
696 }
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:299
double layerDepth
The actual layer depth.
bool Reserve(unsigned int aSize)
Function Reserve() allocates space for vertices, so it will be used with subsequent Vertex() calls.
bool Vertex(const VERTEX &aVertex)
Function Vertex() adds a vertex with the given coordinates to the currently set item.
double g
Green component.
Definition: color4d.h:310
COLOR4D fillColor
The fill color.
double b
Blue component.
Definition: color4d.h:311
double a
Alpha component.
Definition: color4d.h:312
bool isStrokeEnabled
Are the outlines stroked ?
COLOR4D strokeColor
The color of the outlines.
void Color(const COLOR4D &aColor)
Function Color() changes currently used color that will be applied to newly added vertices.
float lineWidth
The line width.
bool isFillEnabled
Is filling of graphic objects enabled ?
void Shader(GLfloat aShaderType, GLfloat aParam1=0.0f, GLfloat aParam2=0.0f, GLfloat aParam3=0.0f)
Function Shader() changes currently used shader and its parameters that will be applied to newly adde...
double r
Red component.
Definition: color4d.h:309

References KIGFX::COLOR4D::a, KIGFX::COLOR4D::b, KIGFX::VERTEX_MANAGER::Color(), currentManager, KIGFX::GAL::fillColor, KIGFX::COLOR4D::g, KIGFX::GAL::isFillEnabled, KIGFX::GAL::isStrokeEnabled, KIGFX::GAL::layerDepth, KIGFX::GAL::lineWidth, KIGFX::COLOR4D::r, KIGFX::VERTEX_MANAGER::Reserve(), KIGFX::VERTEX_MANAGER::Shader(), KIGFX::SHADER_FILLED_CIRCLE, KIGFX::SHADER_STROKED_CIRCLE, KIGFX::GAL::strokeColor, KIGFX::VERTEX_MANAGER::Vertex(), VECTOR2< T >::x, and VECTOR2< T >::y.

Referenced by DrawSegment().

◆ DrawCursor()

void OPENGL_GAL::DrawCursor ( const VECTOR2D aCursorPosition)
overridevirtual

Draw the cursor.

Parameters
aCursorPositionis the cursor position in screen coordinates.

Reimplemented from KIGFX::GAL.

Definition at line 1520 of file opengl_gal.cpp.

1521 {
1522  // Now we should only store the position of the mouse cursor
1523  // The real drawing routines are in blitCursor()
1524  //VECTOR2D screenCursor = worldScreenMatrix * aCursorPosition;
1525  //cursorPosition = screenWorldMatrix * VECTOR2D( screenCursor.x, screenCursor.y );
1526  cursorPosition = aCursorPosition;
1527 }
VECTOR2D cursorPosition
Current cursor position (world coordinates)

References KIGFX::GAL::cursorPosition.

◆ DrawCurve()

void OPENGL_GAL::DrawCurve ( const VECTOR2D startPoint,
const VECTOR2D controlPointA,
const VECTOR2D controlPointB,
const VECTOR2D endPoint 
)
overridevirtual

Draw a cubic bezier spline.

Parameters
startPointis the start point of the spline.
controlPointAis the first control point.
controlPointBis the second control point.
endPointis the end point of the spline.

Reimplemented from KIGFX::GAL.

Definition at line 935 of file opengl_gal.cpp.

937 {
938  // FIXME The drawing quality needs to be improved
939  // FIXME Perhaps choose a quad/triangle strip instead?
940  // FIXME Brute force method, use a better (recursive?) algorithm
941 
942  std::deque<VECTOR2D> pointList;
943 
944  double t = 0.0;
945  double dt = 1.0 / (double) CURVE_POINTS;
946 
947  for( int i = 0; i <= CURVE_POINTS; i++ )
948  {
949  double omt = 1.0 - t;
950  double omt2 = omt * omt;
951  double omt3 = omt * omt2;
952  double t2 = t * t;
953  double t3 = t * t2;
954 
955  VECTOR2D vertex = omt3 * aStartPoint + 3.0 * t * omt2 * aControlPointA
956  + 3.0 * t2 * omt * aControlPointB + t3 * aEndPoint;
957 
958  pointList.push_back( vertex );
959 
960  t += dt;
961  }
962 
963  DrawPolyline( pointList );
964 }
static const int CURVE_POINTS
The number of points for curve approximation.
Definition: opengl_gal.h:285
virtual void DrawPolyline(const std::deque< VECTOR2D > &aPointList) override
Draw a polyline.
Definition: opengl_gal.cpp:803
size_t i
Definition: json11.cpp:597

References CURVE_POINTS, DrawPolyline(), and i.

◆ drawFilledSemiCircle()

void OPENGL_GAL::drawFilledSemiCircle ( const VECTOR2D aCenterPoint,
double  aRadius,
double  aAngle 
)
private

Draw a filled semicircle.

Parameters
aCenterPointis the center point.
aRadiusis the radius of the semicircle.
aAngleis the angle of the semicircle.

Definition at line 1591 of file opengl_gal.cpp.

1593 {
1594  Save();
1595 
1596  currentManager->Reserve( 3 );
1597  currentManager->Translate( aCenterPoint.x, aCenterPoint.y, 0.0f );
1598  currentManager->Rotate( aAngle, 0.0f, 0.0f, 1.0f );
1599 
1600  /* Draw a triangle that contains the semicircle, then shade it to leave only
1601  * the semicircle. Parameters given to Shader() are indices of the triangle's vertices
1602  * (if you want to understand more, check the vertex shader source [shader.vert]).
1603  * Shader uses these coordinates to determine if fragments are inside the semicircle or not.
1604  * v2
1605  * /\
1606  * /__\
1607  * v0 //__\\ v1
1608  */
1610  currentManager->Vertex( -aRadius * 3.0f / sqrt( 3.0f ), 0.0f, layerDepth ); // v0
1611 
1613  currentManager->Vertex( aRadius * 3.0f / sqrt( 3.0f ), 0.0f, layerDepth ); // v1
1614 
1616  currentManager->Vertex( 0.0f, aRadius * 2.0f, layerDepth ); // v2
1617 
1618  Restore();
1619 }
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:299
double layerDepth
The actual layer depth.
bool Reserve(unsigned int aSize)
Function Reserve() allocates space for vertices, so it will be used with subsequent Vertex() calls.
virtual void Restore() override
Restore the context.
bool Vertex(const VERTEX &aVertex)
Function Vertex() adds a vertex with the given coordinates to the currently set item.
void Rotate(GLfloat aAngle, GLfloat aX, GLfloat aY, GLfloat aZ)
Function Rotate() multiplies the current matrix by a rotation matrix, so the newly vertices will be r...
virtual void Save() override
Save the context.
void Translate(GLfloat aX, GLfloat aY, GLfloat aZ)
Function Translate() multiplies the current matrix by a translation matrix, so newly vertices will be...
void Shader(GLfloat aShaderType, GLfloat aParam1=0.0f, GLfloat aParam2=0.0f, GLfloat aParam3=0.0f)
Function Shader() changes currently used shader and its parameters that will be applied to newly adde...

References currentManager, KIGFX::GAL::layerDepth, KIGFX::VERTEX_MANAGER::Reserve(), Restore(), KIGFX::VERTEX_MANAGER::Rotate(), Save(), KIGFX::VERTEX_MANAGER::Shader(), KIGFX::SHADER_FILLED_CIRCLE, KIGFX::VERTEX_MANAGER::Translate(), KIGFX::VERTEX_MANAGER::Vertex(), VECTOR2< T >::x, and VECTOR2< T >::y.

Referenced by drawSemiCircle().

◆ DrawGrid()

void OPENGL_GAL::DrawGrid ( )
overridevirtual

Draw the grid

Reimplemented from KIGFX::GAL.

Definition at line 1124 of file opengl_gal.cpp.

1125 {
1128 
1130 
1131  // sub-pixel lines all render the same
1132  float minorLineWidth = std::fmax( 1.0f, gridLineWidth ) * getWorldPixelSize();
1133  float majorLineWidth = minorLineWidth * 2.0f;
1134 
1135  // Draw the axis and grid
1136  // For the drawing the start points, end points and increments have
1137  // to be calculated in world coordinates
1138  VECTOR2D worldStartPoint = screenWorldMatrix * VECTOR2D( 0.0, 0.0 );
1139  VECTOR2D worldEndPoint = screenWorldMatrix * VECTOR2D( screenSize );
1140 
1141  // Draw axes if desired
1142  if( axesEnabled )
1143  {
1144  SetLineWidth( minorLineWidth );
1146 
1147  DrawLine( VECTOR2D( worldStartPoint.x, 0 ), VECTOR2D( worldEndPoint.x, 0 ) );
1148  DrawLine( VECTOR2D( 0, worldStartPoint.y ), VECTOR2D( 0, worldEndPoint.y ) );
1149  }
1150 
1151  // force flush
1153 
1154  if( !gridVisibility )
1155  return;
1156 
1157  int gridScreenSizeDense = KiROUND( gridSize.x * worldScale );
1158  int gridScreenSizeCoarse = KiROUND( gridSize.x * static_cast<double>( gridTick ) * worldScale );
1159 
1160  const double gridThreshold = computeMinGridSpacing();
1161 
1162  // Check if the grid would not be too dense
1163  if( std::max( gridScreenSizeDense, gridScreenSizeCoarse ) < gridThreshold )
1164  return;
1165 
1166  // Compute grid staring and ending indexes to draw grid points on the
1167  // visible screen area
1168  // Note: later any point coordinate will be offsetted by gridOrigin
1169  int gridStartX = KiROUND( ( worldStartPoint.x - gridOrigin.x ) / gridSize.x );
1170  int gridEndX = KiROUND( ( worldEndPoint.x - gridOrigin.x ) / gridSize.x );
1171  int gridStartY = KiROUND( ( worldStartPoint.y - gridOrigin.y ) / gridSize.y );
1172  int gridEndY = KiROUND( ( worldEndPoint.y - gridOrigin.y ) / gridSize.y );
1173 
1174  // Ensure start coordinate > end coordinate
1175  if( gridStartX > gridEndX )
1176  std::swap( gridStartX, gridEndX );
1177 
1178  if( gridStartY > gridEndY )
1179  std::swap( gridStartY, gridEndY );
1180 
1181  // Ensure the grid fills the screen
1182  --gridStartX; ++gridEndX;
1183  --gridStartY; ++gridEndY;
1184 
1185  glDisable( GL_DEPTH_TEST );
1186  glDisable( GL_TEXTURE_2D );
1187 
1188  if( gridStyle == GRID_STYLE::DOTS )
1189  {
1190  glEnable( GL_STENCIL_TEST );
1191  glStencilFunc( GL_ALWAYS, 1, 1 );
1192  glStencilOp( GL_KEEP, GL_KEEP, GL_INCR );
1193  glColor4d( 0.0, 0.0, 0.0, 0.0 );
1194  SetStrokeColor( COLOR4D( 0.0, 0.0, 0.0, 0.0 ) );
1195  }
1196  else
1197  {
1198  glColor4d( gridColor.r, gridColor.g, gridColor.b, gridColor.a );
1200  }
1201 
1203  {
1204  SetLineWidth( minorLineWidth );
1205 
1206  // calculate a line len = 2 minorLineWidth, in internal unit value
1207  // (in fact the size of cross is lineLen*2)
1208  int lineLen = KiROUND( minorLineWidth * 2.0 );
1209 
1210  // Vertical positions
1211  for( int j = gridStartY; j <= gridEndY; j++ )
1212  {
1213  if( ( j % gridTick == 0 && gridScreenSizeCoarse > gridThreshold )
1214  || gridScreenSizeDense > gridThreshold )
1215  {
1216  int posY = j * gridSize.y + gridOrigin.y;
1217 
1218  // Horizontal positions
1219  for( int i = gridStartX; i <= gridEndX; i++ )
1220  {
1221  if( ( i % gridTick == 0 && gridScreenSizeCoarse > gridThreshold )
1222  || gridScreenSizeDense > gridThreshold )
1223  {
1224  int posX = i * gridSize.x + gridOrigin.x;
1225 
1226  DrawLine( VECTOR2D( posX - lineLen, posY ), VECTOR2D( posX + lineLen, posY ) );
1227  DrawLine( VECTOR2D( posX, posY - lineLen ), VECTOR2D( posX, posY + lineLen ) );
1228  }
1229  }
1230  }
1231  }
1232 
1234  }
1235  else
1236  {
1237  // Vertical lines
1238  for( int j = gridStartY; j <= gridEndY; j++ )
1239  {
1240  const double y = j * gridSize.y + gridOrigin.y;
1241 
1242  // If axes are drawn, skip the lines that would cover them
1243  if( axesEnabled && y == 0 )
1244  continue;
1245 
1246  if( j % gridTick == 0 && gridScreenSizeDense > gridThreshold )
1247  SetLineWidth( majorLineWidth );
1248  else
1249  SetLineWidth( minorLineWidth );
1250 
1251  if( ( j % gridTick == 0 && gridScreenSizeCoarse > gridThreshold )
1252  || gridScreenSizeDense > gridThreshold )
1253  {
1254  VECTOR2D a ( gridStartX * gridSize.x + gridOrigin.x, y );
1255  VECTOR2D b ( gridEndX * gridSize.x + gridOrigin.x, y );
1256 
1257  DrawLine( a, b );
1258  }
1259  }
1260 
1262 
1263  if( gridStyle == GRID_STYLE::DOTS )
1264  {
1265  glStencilFunc( GL_NOTEQUAL, 0, 1 );
1266  glColor4d( gridColor.r, gridColor.g, gridColor.b, gridColor.a );
1268  }
1269 
1270  // Horizontal lines
1271  for( int i = gridStartX; i <= gridEndX; i++ )
1272  {
1273  const double x = i * gridSize.x + gridOrigin.x;
1274 
1275  // If axes are drawn, skip the lines that would cover them
1276  if( axesEnabled && x == 0 )
1277  continue;
1278 
1279  if( i % gridTick == 0 && gridScreenSizeDense > gridThreshold )
1280  SetLineWidth( majorLineWidth );
1281  else
1282  SetLineWidth( minorLineWidth );
1283 
1284  if( ( i % gridTick == 0 && gridScreenSizeCoarse > gridThreshold )
1285  || gridScreenSizeDense > gridThreshold )
1286  {
1287  VECTOR2D a ( x, gridStartY * gridSize.y + gridOrigin.y );
1288  VECTOR2D b ( x, gridEndY * gridSize.y + gridOrigin.y );
1289  DrawLine( a, b );
1290  }
1291  }
1292 
1294 
1295  if( gridStyle == GRID_STYLE::DOTS )
1296  glDisable( GL_STENCIL_TEST );
1297  }
1298 
1299  glEnable( GL_DEPTH_TEST );
1300  glEnable( GL_TEXTURE_2D );
1301 }
int gridTick
Every tick line gets the double width.
bool axesEnabled
Should the axes be drawn.
static int KiROUND(double v)
Round a floating point number to an integer using "round halfway cases away from zero".
Definition: common.h:121
double computeMinGridSpacing() const
compute minimum grid spacing from the grid settings
GRID_STYLE gridStyle
Grid display style.
double g
Green component.
Definition: color4d.h:310
MATRIX3x3D screenWorldMatrix
Screen transformation.
virtual void SetLineWidth(float aLineWidth)
Set the line width.
VERTEX_MANAGER * nonCachedManager
Container for storing non-cached VERTEX_ITEMs.
Definition: opengl_gal.h:301
double b
Blue component.
Definition: color4d.h:311
Auxiliary rendering target (noncached)
Definition: definitions.h:49
double getWorldPixelSize() const
Definition: opengl_gal.cpp:350
double a
Alpha component.
Definition: color4d.h:312
OPENGL_COMPOSITOR * compositor
Handles multiple rendering targets.
Definition: opengl_gal.h:305
VECTOR2< double > VECTOR2D
Definition: vector2d.h:586
unsigned int mainBuffer
Main rendering target.
Definition: opengl_gal.h:306
COLOR4D axesColor
Color of the axes.
float gridLineWidth
Line width of the grid.
virtual void DrawLine(const VECTOR2D &aStartPoint, const VECTOR2D &aEndPoint) override
Draw a line.
Definition: opengl_gal.cpp:589
VECTOR2D gridOrigin
The grid origin.
virtual void SetBuffer(unsigned int aBufferHandle) override
Function SetBuffer() sets the selected buffer as the rendering target.
Use dots for the grid.
Use small cross instead of dots for the grid.
void EndDrawing() const
Function EndDrawing() finishes drawing operations.
virtual void SetTarget(RENDER_TARGET aTarget) override
Sets the target for rendering.
virtual void SetStrokeColor(const COLOR4D &aColor)
Set the stroke color.
COLOR4D gridColor
Color of the grid.
bool gridVisibility
Should the grid be shown.
void EnableDepthTest(bool aEnabled)
Function EnableDepthTest() Enables/disables Z buffer depth test.
#define max(a, b)
Definition: auxiliary.h:86
double worldScale
The scale factor world->screen.
VECTOR2D gridSize
The grid size.
size_t i
Definition: json11.cpp:597
VECTOR2I screenSize
Screen size in screen coordinates.
double r
Red component.
Definition: color4d.h:309
Class COLOR4D is the color representation with 4 components: red, green, blue, alpha.
Definition: color4d.h:39

References KIGFX::COLOR4D::a, KIGFX::GAL::axesColor, KIGFX::GAL::axesEnabled, KIGFX::COLOR4D::b, compositor, KIGFX::GAL::computeMinGridSpacing(), KIGFX::DOTS, DrawLine(), KIGFX::VERTEX_MANAGER::EnableDepthTest(), KIGFX::VERTEX_MANAGER::EndDrawing(), KIGFX::COLOR4D::g, getWorldPixelSize(), KIGFX::GAL::gridColor, KIGFX::GAL::gridLineWidth, KIGFX::GAL::gridOrigin, KIGFX::GAL::gridSize, KIGFX::GAL::gridStyle, KIGFX::GAL::gridTick, KIGFX::GAL::gridVisibility, i, KiROUND(), mainBuffer, max, nonCachedManager, KIGFX::COLOR4D::r, KIGFX::GAL::screenSize, KIGFX::GAL::screenWorldMatrix, KIGFX::OPENGL_COMPOSITOR::SetBuffer(), KIGFX::GAL::SetLineWidth(), KIGFX::GAL::SetStrokeColor(), SetTarget(), KIGFX::SMALL_CROSS, KIGFX::TARGET_NONCACHED, KIGFX::GAL::worldScale, VECTOR2< T >::x, and VECTOR2< T >::y.

◆ drawGridLine()

virtual void KIGFX::GAL::drawGridLine ( const VECTOR2D aStartPoint,
const VECTOR2D aEndPoint 
)
inlineprotectedvirtualinherited

Draw a grid line (usually a simplified line function).

Parameters
aStartPointis the start point of the line.
aEndPointis the end point of the line.

Reimplemented in KIGFX::CAIRO_GAL_BASE.

Definition at line 1122 of file graphics_abstraction_layer.h.

1122 {};

◆ DrawGroup()

void OPENGL_GAL::DrawGroup ( int  aGroupNumber)
overridevirtual

Draw the stored group.

Parameters
aGroupNumberis the group number.

Reimplemented from KIGFX::GAL.

Definition at line 1411 of file opengl_gal.cpp.

1412 {
1413  if( groups[aGroupNumber] )
1414  cachedManager->DrawItem( *groups[aGroupNumber] );
1415 }
void DrawItem(const VERTEX_ITEM &aItem) const
Function DrawItem() draws an item to the buffer.
GROUPS_MAP groups
Stores informations about VBO objects (groups)
Definition: opengl_gal.h:297
VERTEX_MANAGER * cachedManager
Container for storing cached VERTEX_ITEMs.
Definition: opengl_gal.h:300

References cachedManager, KIGFX::VERTEX_MANAGER::DrawItem(), and groups.

◆ DrawLine()

void OPENGL_GAL::DrawLine ( const VECTOR2D aStartPoint,
const VECTOR2D aEndPoint 
)
overridevirtual

Draw a line.

Start and end points are defined as 2D-Vectors.

Parameters
aStartPointis the start point of the line.
aEndPointis the end point of the line.

Reimplemented from KIGFX::GAL.

Definition at line 589 of file opengl_gal.cpp.

590 {
592 
593  drawLineQuad( aStartPoint, aEndPoint );
594 }
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:299
void drawLineQuad(const VECTOR2D &aStartPoint, const VECTOR2D &aEndPoint)
Draw a quad for the line.
double g
Green component.
Definition: color4d.h:310
double b
Blue component.
Definition: color4d.h:311
double a
Alpha component.
Definition: color4d.h:312
COLOR4D strokeColor
The color of the outlines.
void Color(const COLOR4D &aColor)
Function Color() changes currently used color that will be applied to newly added vertices.
double r
Red component.
Definition: color4d.h:309

References KIGFX::COLOR4D::a, KIGFX::COLOR4D::b, KIGFX::VERTEX_MANAGER::Color(), currentManager, drawLineQuad(), KIGFX::COLOR4D::g, KIGFX::COLOR4D::r, and KIGFX::GAL::strokeColor.

Referenced by DrawArc(), and DrawGrid().

◆ drawLineQuad()

void OPENGL_GAL::drawLineQuad ( const VECTOR2D aStartPoint,
const VECTOR2D aEndPoint 
)
private

Draw a quad for the line.

Parameters
aStartPointis the start point of the line.
aEndPointis the end point of the line.

Definition at line 1530 of file opengl_gal.cpp.

1531 {
1532  /* Helper drawing: ____--- v3 ^
1533  * ____---- ... \ \
1534  * ____---- ... \ end \
1535  * v1 ____---- ... ____---- \ width
1536  * ---- ...___---- \ \
1537  * \ ___...-- \ v
1538  * \ ____----... ____---- v2
1539  * ---- ... ____----
1540  * start \ ... ____----
1541  * \... ____----
1542  * ----
1543  * v0
1544  * dots mark triangles' hypotenuses
1545  */
1546 
1547  auto v1 = currentManager->GetTransformation() * glm::vec4( aStartPoint.x, aStartPoint.y, 0.0, 0.0 );
1548  auto v2 = currentManager->GetTransformation() * glm::vec4( aEndPoint.x, aEndPoint.y, 0.0, 0.0 );
1549 
1550  VECTOR2D vs( v2.x - v1.x, v2.y - v1.y );
1551 
1552  currentManager->Reserve( 6 );
1553 
1554  // Line width is maintained by the vertex shader
1555  currentManager->Shader( SHADER_LINE_A, lineWidth, vs.x, vs.y );
1556  currentManager->Vertex( aStartPoint, layerDepth );
1557 
1558  currentManager->Shader( SHADER_LINE_B, lineWidth, vs.x, vs.y );
1559  currentManager->Vertex( aStartPoint, layerDepth );
1560 
1561  currentManager->Shader( SHADER_LINE_C, lineWidth, vs.x, vs.y );
1562  currentManager->Vertex( aEndPoint, layerDepth );
1563 
1564  currentManager->Shader( SHADER_LINE_D, lineWidth, vs.x, vs.y );
1565  currentManager->Vertex( aEndPoint, layerDepth );
1566 
1567  currentManager->Shader( SHADER_LINE_E, lineWidth, vs.x, vs.y );
1568  currentManager->Vertex( aEndPoint, layerDepth );
1569 
1570  currentManager->Shader( SHADER_LINE_F, lineWidth, vs.x, vs.y );
1571  currentManager->Vertex( aStartPoint, layerDepth );
1572 }
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:299
const glm::mat4 & GetTransformation() const
double layerDepth
The actual layer depth.
bool Reserve(unsigned int aSize)
Function Reserve() allocates space for vertices, so it will be used with subsequent Vertex() calls.
bool Vertex(const VERTEX &aVertex)
Function Vertex() adds a vertex with the given coordinates to the currently set item.
float lineWidth
The line width.
void Shader(GLfloat aShaderType, GLfloat aParam1=0.0f, GLfloat aParam2=0.0f, GLfloat aParam3=0.0f)
Function Shader() changes currently used shader and its parameters that will be applied to newly adde...

References currentManager, KIGFX::VERTEX_MANAGER::GetTransformation(), KIGFX::GAL::layerDepth, KIGFX::GAL::lineWidth, KIGFX::VERTEX_MANAGER::Reserve(), KIGFX::VERTEX_MANAGER::Shader(), KIGFX::SHADER_LINE_A, KIGFX::SHADER_LINE_B, KIGFX::SHADER_LINE_C, KIGFX::SHADER_LINE_D, KIGFX::SHADER_LINE_E, KIGFX::SHADER_LINE_F, KIGFX::VERTEX_MANAGER::Vertex(), VECTOR2< T >::x, and VECTOR2< T >::y.

Referenced by DrawLine(), drawPolyline(), and DrawSegment().

◆ DrawPolygon() [1/4]

void OPENGL_GAL::DrawPolygon ( const std::deque< VECTOR2D > &  aPointList)
overridevirtual

Draw a polygon.

Parameters
aPointListis the list of the polygon points.

Reimplemented from KIGFX::GAL.

Definition at line 826 of file opengl_gal.cpp.

827 {
828  auto points = std::unique_ptr<GLdouble[]>( new GLdouble[3 * aPointList.size()] );
829  GLdouble* ptr = points.get();
830 
831  for( const VECTOR2D& p : aPointList )
832  {
833  *ptr++ = p.x;
834  *ptr++ = p.y;
835  *ptr++ = layerDepth;
836  }
837 
838  drawPolygon( points.get(), aPointList.size() );
839 }
double layerDepth
The actual layer depth.
void drawPolygon(GLdouble *aPoints, int aPointCount)
Draws a filled polygon.

References drawPolygon(), and KIGFX::GAL::layerDepth.

Referenced by DrawPolygon().

◆ DrawPolygon() [2/4]

void OPENGL_GAL::DrawPolygon ( const VECTOR2D  aPointList[],
int  aListSize 
)
overridevirtual

Reimplemented from KIGFX::GAL.

Definition at line 842 of file opengl_gal.cpp.

843 {
844  auto points = std::unique_ptr<GLdouble[]>( new GLdouble[3 * aListSize] );
845  GLdouble* target = points.get();
846  const VECTOR2D* src = aPointList;
847 
848  for( int i = 0; i < aListSize; ++i )
849  {
850  *target++ = src->x;
851  *target++ = src->y;
852  *target++ = layerDepth;
853  ++src;
854  }
855 
856  drawPolygon( points.get(), aListSize );
857 }
double layerDepth
The actual layer depth.
void drawPolygon(GLdouble *aPoints, int aPointCount)
Draws a filled polygon.
size_t i
Definition: json11.cpp:597

References drawPolygon(), i, KIGFX::GAL::layerDepth, VECTOR2< T >::x, and VECTOR2< T >::y.

◆ DrawPolygon() [3/4]

void OPENGL_GAL::DrawPolygon ( const SHAPE_POLY_SET aPolySet)
overridevirtual

Reimplemented from KIGFX::GAL.

Definition at line 897 of file opengl_gal.cpp.

898 {
899  if ( aPolySet.IsTriangulationUpToDate() )
900  {
901  drawTriangulatedPolyset( aPolySet );
902  return;
903  }
904 
905  for( int j = 0; j < aPolySet.OutlineCount(); ++j )
906  {
907  const SHAPE_LINE_CHAIN& outline = aPolySet.COutline( j );
908  DrawPolygon( outline );
909  }
910 }
int OutlineCount() const
Returns the number of outlines in the set
virtual void DrawPolygon(const std::deque< VECTOR2D > &aPointList) override
Draw a polygon.
Definition: opengl_gal.cpp:826
bool IsTriangulationUpToDate() const
void drawTriangulatedPolyset(const SHAPE_POLY_SET &aPoly)
Draws a set of polygons with a cached triangulation.
Definition: opengl_gal.cpp:860
Class SHAPE_LINE_CHAIN.
const SHAPE_LINE_CHAIN & COutline(int aIndex) const

References SHAPE_POLY_SET::COutline(), DrawPolygon(), drawTriangulatedPolyset(), SHAPE_POLY_SET::IsTriangulationUpToDate(), and SHAPE_POLY_SET::OutlineCount().

◆ DrawPolygon() [4/4]

void OPENGL_GAL::DrawPolygon ( const SHAPE_LINE_CHAIN aPolySet)
overridevirtual

Reimplemented from KIGFX::GAL.

Definition at line 914 of file opengl_gal.cpp.

915 {
916  if( aPolygon.SegmentCount() == 0 )
917  return;
918 
919  const int pointCount = aPolygon.SegmentCount() + 1;
920  std::unique_ptr<GLdouble[]> points( new GLdouble[3 * pointCount] );
921  GLdouble* ptr = points.get();
922 
923  for( int i = 0; i < pointCount; ++i )
924  {
925  const VECTOR2I& p = aPolygon.CPoint( i );
926  *ptr++ = p.x;
927  *ptr++ = p.y;
928  *ptr++ = layerDepth;
929  }
930 
931  drawPolygon( points.get(), pointCount );
932 }
double layerDepth
The actual layer depth.
void drawPolygon(GLdouble *aPoints, int aPointCount)
Draws a filled polygon.
size_t i
Definition: json11.cpp:597

References SHAPE_LINE_CHAIN::CPoint(), drawPolygon(), i, KIGFX::GAL::layerDepth, SHAPE_LINE_CHAIN::SegmentCount(), VECTOR2< T >::x, and VECTOR2< T >::y.

◆ drawPolygon()

void OPENGL_GAL::drawPolygon ( GLdouble *  aPoints,
int  aPointCount 
)
private

Draws a filled polygon.

It does not need the last point to have the same coordinates as the first one.

Parameters
aPointsis the vertices data (3 coordinates: x, y, z).
aPointCountis the number of points.

Definition at line 1656 of file opengl_gal.cpp.

1657 {
1658  if( isFillEnabled )
1659  {
1662 
1663  // Any non convex polygon needs to be tesselated
1664  // for this purpose the GLU standard functions are used
1665  TessParams params = { currentManager, tessIntersects };
1666  gluTessBeginPolygon( tesselator, &params );
1667  gluTessBeginContour( tesselator );
1668 
1669  GLdouble* point = aPoints;
1670 
1671  for( int i = 0; i < aPointCount; ++i )
1672  {
1673  gluTessVertex( tesselator, point, point );
1674  point += 3; // 3 coordinates
1675  }
1676 
1677  gluTessEndContour( tesselator );
1678  gluTessEndPolygon( tesselator );
1679 
1680  // Free allocated intersecting points
1681  tessIntersects.clear();
1682  }
1683 
1684  if( isStrokeEnabled )
1685  {
1686  drawPolyline( [&](int idx) { return VECTOR2D( aPoints[idx * 3], aPoints[idx * 3 + 1] ); },
1687  aPointCount );
1688  }
1689 }
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:299
double g
Green component.
Definition: color4d.h:310
COLOR4D fillColor
The fill color.
double b
Blue component.
Definition: color4d.h:311
double a
Alpha component.
Definition: color4d.h:312
bool isStrokeEnabled
Are the outlines stroked ?
VECTOR2< double > VECTOR2D
Definition: vector2d.h:586
void Color(const COLOR4D &aColor)
Function Color() changes currently used color that will be applied to newly added vertices.
GLUtesselator * tesselator
The tessellator.
Definition: opengl_gal.h:349
bool isFillEnabled
Is filling of graphic objects enabled ?
std::deque< boost::shared_array< GLdouble > > tessIntersects
Storage for intersecting points.
Definition: opengl_gal.h:351
size_t i
Definition: json11.cpp:597
void drawPolyline(const std::function< VECTOR2D(int)> &aPointGetter, int aPointCount)
Generic way of drawing a polyline stored in different containers.
void Shader(GLfloat aShaderType, GLfloat aParam1=0.0f, GLfloat aParam2=0.0f, GLfloat aParam3=0.0f)
Function Shader() changes currently used shader and its parameters that will be applied to newly adde...
double r
Red component.
Definition: color4d.h:309

References KIGFX::COLOR4D::a, KIGFX::COLOR4D::b, KIGFX::VERTEX_MANAGER::Color(), currentManager, drawPolyline(), KIGFX::GAL::fillColor, KIGFX::COLOR4D::g, i, KIGFX::GAL::isFillEnabled, KIGFX::GAL::isStrokeEnabled, KIGFX::COLOR4D::r, KIGFX::VERTEX_MANAGER::Shader(), KIGFX::SHADER_NONE, tesselator, and tessIntersects.

Referenced by DrawPolygon().

◆ DrawPolyline() [1/3]

void OPENGL_GAL::DrawPolyline ( const std::deque< VECTOR2D > &  aPointList)
overridevirtual

Draw a polyline.

Parameters
aPointListis a list of 2D-Vectors containing the polyline points.

Reimplemented from KIGFX::GAL.

Definition at line 803 of file opengl_gal.cpp.

804 {
805  drawPolyline( [&](int idx) { return aPointList[idx]; }, aPointList.size() );
806 }
void drawPolyline(const std::function< VECTOR2D(int)> &aPointGetter, int aPointCount)
Generic way of drawing a polyline stored in different containers.

References drawPolyline().

Referenced by DrawCurve(), DrawRectangle(), and drawTriangulatedPolyset().

◆ DrawPolyline() [2/3]

void OPENGL_GAL::DrawPolyline ( const VECTOR2D  aPointList[],
int  aListSize 
)
overridevirtual

Reimplemented from KIGFX::GAL.

Definition at line 809 of file opengl_gal.cpp.

810 {
811  drawPolyline( [&](int idx) { return aPointList[idx]; }, aListSize );
812 }
void drawPolyline(const std::function< VECTOR2D(int)> &aPointGetter, int aPointCount)
Generic way of drawing a polyline stored in different containers.

References drawPolyline().

◆ DrawPolyline() [3/3]

void OPENGL_GAL::DrawPolyline ( const SHAPE_LINE_CHAIN aLineChain)
overridevirtual

Reimplemented from KIGFX::GAL.

Definition at line 815 of file opengl_gal.cpp.

816 {
817  auto numPoints = aLineChain.PointCount();
818 
819  if( aLineChain.IsClosed() )
820  numPoints += 1;
821 
822  drawPolyline( [&](int idx) { return aLineChain.CPoint(idx); }, numPoints );
823 }
int PointCount() const
Function PointCount()
const VECTOR2I & CPoint(int aIndex) const
Function CPoint()
void drawPolyline(const std::function< VECTOR2D(int)> &aPointGetter, int aPointCount)
Generic way of drawing a polyline stored in different containers.
bool IsClosed() const
Function IsClosed()

References SHAPE_LINE_CHAIN::CPoint(), drawPolyline(), SHAPE_LINE_CHAIN::IsClosed(), and SHAPE_LINE_CHAIN::PointCount().

◆ drawPolyline()

void OPENGL_GAL::drawPolyline ( const std::function< VECTOR2D(int)> &  aPointGetter,
int  aPointCount 
)
private

Generic way of drawing a polyline stored in different containers.

Parameters
aPointGetteris a function to obtain coordinates of n-th vertex.
aPointCountis the number of points to be drawn.

Definition at line 1692 of file opengl_gal.cpp.

1693 {
1694  if( aPointCount < 2 )
1695  return;
1696 
1698  int i;
1699 
1700  for( i = 1; i < aPointCount; ++i )
1701  {
1702  auto start = aPointGetter( i - 1 );
1703  auto end = aPointGetter( i );
1704 
1705  drawLineQuad( start, end );
1706  }
1707 }
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:299
void drawLineQuad(const VECTOR2D &aStartPoint, const VECTOR2D &aEndPoint)
Draw a quad for the line.
double g
Green component.
Definition: color4d.h:310
double b
Blue component.
Definition: color4d.h:311
double a
Alpha component.
Definition: color4d.h:312
COLOR4D strokeColor
The color of the outlines.
void Color(const COLOR4D &aColor)
Function Color() changes currently used color that will be applied to newly added vertices.
size_t i
Definition: json11.cpp:597
double r
Red component.
Definition: color4d.h:309

References KIGFX::COLOR4D::a, KIGFX::COLOR4D::b, KIGFX::VERTEX_MANAGER::Color(), currentManager, drawLineQuad(), KIGFX::COLOR4D::g, i, KIGFX::COLOR4D::r, and KIGFX::GAL::strokeColor.

Referenced by drawPolygon(), and DrawPolyline().

◆ DrawRectangle()

void OPENGL_GAL::DrawRectangle ( const VECTOR2D aStartPoint,
const VECTOR2D aEndPoint 
)
overridevirtual

Draw a rectangle.

Parameters
aStartPointis the start point of the rectangle.
aEndPointis the end point of the rectangle.

Reimplemented from KIGFX::GAL.

Definition at line 765 of file opengl_gal.cpp.

766 {
767  // Compute the diagonal points of the rectangle
768  VECTOR2D diagonalPointA( aEndPoint.x, aStartPoint.y );
769  VECTOR2D diagonalPointB( aStartPoint.x, aEndPoint.y );
770 
771  // Fill the rectangle
772  if( isFillEnabled )
773  {
774  currentManager->Reserve( 6 );
777 
778  currentManager->Vertex( aStartPoint.x, aStartPoint.y, layerDepth );
779  currentManager->Vertex( diagonalPointA.x, diagonalPointA.y, layerDepth );
780  currentManager->Vertex( aEndPoint.x, aEndPoint.y, layerDepth );
781 
782  currentManager->Vertex( aStartPoint.x, aStartPoint.y, layerDepth );
783  currentManager->Vertex( aEndPoint.x, aEndPoint.y, layerDepth );
784  currentManager->Vertex( diagonalPointB.x, diagonalPointB.y, layerDepth );
785  }
786 
787  // Stroke the outline
788  if( isStrokeEnabled )
789  {
791 
792  std::deque<VECTOR2D> pointList;
793  pointList.push_back( aStartPoint );
794  pointList.push_back( diagonalPointA );
795  pointList.push_back( aEndPoint );
796  pointList.push_back( diagonalPointB );
797  pointList.push_back( aStartPoint );
798  DrawPolyline( pointList );
799  }
800 }
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:299
double layerDepth
The actual layer depth.
bool Reserve(unsigned int aSize)
Function Reserve() allocates space for vertices, so it will be used with subsequent Vertex() calls.
bool Vertex(const VERTEX &aVertex)
Function Vertex() adds a vertex with the given coordinates to the currently set item.
double g
Green component.
Definition: color4d.h:310
COLOR4D fillColor
The fill color.
double b
Blue component.
Definition: color4d.h:311
double a
Alpha component.
Definition: color4d.h:312
bool isStrokeEnabled
Are the outlines stroked ?
COLOR4D strokeColor
The color of the outlines.
void Color(const COLOR4D &aColor)
Function Color() changes currently used color that will be applied to newly added vertices.
bool isFillEnabled
Is filling of graphic objects enabled ?
virtual void DrawPolyline(const std::deque< VECTOR2D > &aPointList) override
Draw a polyline.
Definition: opengl_gal.cpp:803
void Shader(GLfloat aShaderType, GLfloat aParam1=0.0f, GLfloat aParam2=0.0f, GLfloat aParam3=0.0f)
Function Shader() changes currently used shader and its parameters that will be applied to newly adde...
double r
Red component.
Definition: color4d.h:309

References KIGFX::COLOR4D::a, KIGFX::COLOR4D::b, KIGFX::VERTEX_MANAGER::Color(), currentManager, DrawPolyline(), KIGFX::GAL::fillColor, KIGFX::COLOR4D::g, KIGFX::GAL::isFillEnabled, KIGFX::GAL::isStrokeEnabled, KIGFX::GAL::layerDepth, KIGFX::COLOR4D::r, KIGFX::VERTEX_MANAGER::Reserve(), KIGFX::VERTEX_MANAGER::Shader(), KIGFX::SHADER_NONE, KIGFX::GAL::strokeColor, KIGFX::VERTEX_MANAGER::Vertex(), VECTOR2< T >::x, and VECTOR2< T >::y.

◆ DrawSegment()

void OPENGL_GAL::DrawSegment ( const VECTOR2D aStartPoint,
const VECTOR2D aEndPoint,
double  aWidth 
)
overridevirtual

Draw a rounded segment.

Start and end points are defined as 2D-Vectors.

Parameters
aStartPointis the start point of the segment.
aEndPointis the end point of the segment.
aWidthis a width of the segment

Reimplemented from KIGFX::GAL.

Definition at line 597 of file opengl_gal.cpp.

599 {
600  if( aStartPoint == aEndPoint ) // 0 length segments are just a circle.
601  {
602  DrawCircle( aStartPoint, aWidth/2 );
603  return;
604  }
605 
606  if( isFillEnabled || aWidth == 1.0 )
607  {
609 
610  SetLineWidth( aWidth );
611  drawLineQuad( aStartPoint, aEndPoint );
612  }
613  else
614  {
615  auto startEndVector = aEndPoint - aStartPoint;
616  auto lineAngle = startEndVector.Angle();
617  // Outlined tracks
618  double lineLength = startEndVector.EuclideanNorm();
619 
620  SetLineWidth( 1.0 );
622 
623  Save();
624 
625  currentManager->Translate( aStartPoint.x, aStartPoint.y, 0.0 );
626  currentManager->Rotate( lineAngle, 0.0f, 0.0f, 1.0f );
627 
628  drawLineQuad( VECTOR2D( 0.0, aWidth / 2.0 ),
629  VECTOR2D( lineLength, aWidth / 2.0 ) );
630 
631  drawLineQuad( VECTOR2D( 0.0, -aWidth / 2.0 ),
632  VECTOR2D( lineLength, -aWidth / 2.0 ) );
633 
634  // Draw line caps
635  drawStrokedSemiCircle( VECTOR2D( 0.0, 0.0 ), aWidth / 2, M_PI / 2 );
636  drawStrokedSemiCircle( VECTOR2D( lineLength, 0.0 ), aWidth / 2, -M_PI / 2 );
637 
638  Restore();
639  }
640 }
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:299
void drawLineQuad(const VECTOR2D &aStartPoint, const VECTOR2D &aEndPoint)
Draw a quad for the line.
virtual void Restore() override
Restore the context.
void Rotate(GLfloat aAngle, GLfloat aX, GLfloat aY, GLfloat aZ)
Function Rotate() multiplies the current matrix by a rotation matrix, so the newly vertices will be r...
double g
Green component.
Definition: color4d.h:310
COLOR4D fillColor
The fill color.
virtual void SetLineWidth(float aLineWidth)
Set the line width.
double b
Blue component.
Definition: color4d.h:311
virtual void Save() override
Save the context.
double a
Alpha component.
Definition: color4d.h:312
VECTOR2< double > VECTOR2D
Definition: vector2d.h:586
COLOR4D strokeColor
The color of the outlines.
void Translate(GLfloat aX, GLfloat aY, GLfloat aZ)
Function Translate() multiplies the current matrix by a translation matrix, so newly vertices will be...
double Angle() const
Function Angle computes the angle of the vector.
Definition: vector2d.h:306
void Color(const COLOR4D &aColor)
Function Color() changes currently used color that will be applied to newly added vertices.
void drawStrokedSemiCircle(const VECTOR2D &aCenterPoint, double aRadius, double aAngle)
Draw a stroked semicircle.
bool isFillEnabled
Is filling of graphic objects enabled ?
double r
Red component.
Definition: color4d.h:309
virtual void DrawCircle(const VECTOR2D &aCenterPoint, double aRadius) override
Draw a circle using world coordinates.
Definition: opengl_gal.cpp:643

References KIGFX::COLOR4D::a, VECTOR2< T >::Angle(), KIGFX::COLOR4D::b, KIGFX::VERTEX_MANAGER::Color(), currentManager, DrawCircle(), drawLineQuad(), drawStrokedSemiCircle(), KIGFX::GAL::fillColor, KIGFX::COLOR4D::g, KIGFX::GAL::isFillEnabled, KIGFX::COLOR4D::r, Restore(), KIGFX::VERTEX_MANAGER::Rotate(), Save(), KIGFX::GAL::SetLineWidth(), KIGFX::GAL::strokeColor, and KIGFX::VERTEX_MANAGER::Translate().

◆ drawSemiCircle()

void OPENGL_GAL::drawSemiCircle ( const VECTOR2D aCenterPoint,
double  aRadius,
double  aAngle 
)
private

Draw a semicircle.

Depending on settings (isStrokeEnabled & isFilledEnabled) it runs the proper function (drawStrokedSemiCircle or drawFilledSemiCircle).

Parameters
aCenterPointis the center point.
aRadiusis the radius of the semicircle.
aAngleis the angle of the semicircle.

Definition at line 1575 of file opengl_gal.cpp.

1576 {
1577  if( isFillEnabled )
1578  {
1580  drawFilledSemiCircle( aCenterPoint, aRadius, aAngle );
1581  }
1582 
1583  if( isStrokeEnabled )
1584  {
1586  drawStrokedSemiCircle( aCenterPoint, aRadius, aAngle );
1587  }
1588 }
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:299
double g
Green component.
Definition: color4d.h:310
COLOR4D fillColor
The fill color.
double b
Blue component.
Definition: color4d.h:311
double a
Alpha component.
Definition: color4d.h:312
bool isStrokeEnabled
Are the outlines stroked ?
COLOR4D strokeColor
The color of the outlines.
void Color(const COLOR4D &aColor)
Function Color() changes currently used color that will be applied to newly added vertices.
void drawStrokedSemiCircle(const VECTOR2D &aCenterPoint, double aRadius, double aAngle)
Draw a stroked semicircle.
bool isFillEnabled
Is filling of graphic objects enabled ?
double r
Red component.
Definition: color4d.h:309
void drawFilledSemiCircle(const VECTOR2D &aCenterPoint, double aRadius, double aAngle)
Draw a filled semicircle.

References KIGFX::COLOR4D::a, KIGFX::COLOR4D::b, KIGFX::VERTEX_MANAGER::Color(), currentManager, drawFilledSemiCircle(), drawStrokedSemiCircle(), KIGFX::GAL::fillColor, KIGFX::COLOR4D::g, KIGFX::GAL::isFillEnabled, KIGFX::GAL::isStrokeEnabled, KIGFX::COLOR4D::r, and KIGFX::GAL::strokeColor.

◆ drawStrokedSemiCircle()

void OPENGL_GAL::drawStrokedSemiCircle ( const VECTOR2D aCenterPoint,
double  aRadius,
double  aAngle 
)
private

Draw a stroked semicircle.

Parameters
aCenterPointis the center point.
aRadiusis the radius of the semicircle.
aAngleis the angle of the semicircle.

Definition at line 1622 of file opengl_gal.cpp.

1624 {
1625  double outerRadius = aRadius + ( lineWidth / 2 );
1626 
1627  Save();
1628 
1629  currentManager->Reserve( 3 );
1630  currentManager->Translate( aCenterPoint.x, aCenterPoint.y, 0.0f );
1631  currentManager->Rotate( aAngle, 0.0f, 0.0f, 1.0f );
1632 
1633  /* Draw a triangle that contains the semicircle, then shade it to leave only
1634  * the semicircle. Parameters given to Shader() are indices of the triangle's vertices
1635  * (if you want to understand more, check the vertex shader source [shader.vert]), the
1636  * radius and the line width. Shader uses these coordinates to determine if fragments are
1637  * inside the semicircle or not.
1638  * v2
1639  * /\
1640  * /__\
1641  * v0 //__\\ v1
1642  */
1644  currentManager->Vertex( -outerRadius * 3.0f / sqrt( 3.0f ), 0.0f, layerDepth ); // v0
1645 
1647  currentManager->Vertex( outerRadius * 3.0f / sqrt( 3.0f ), 0.0f, layerDepth ); // v1
1648 
1650  currentManager->Vertex( 0.0f, outerRadius * 2.0f, layerDepth ); // v2
1651 
1652  Restore();
1653 }
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:299
double layerDepth
The actual layer depth.
bool Reserve(unsigned int aSize)
Function Reserve() allocates space for vertices, so it will be used with subsequent Vertex() calls.
virtual void Restore() override
Restore the context.
bool Vertex(const VERTEX &aVertex)
Function Vertex() adds a vertex with the given coordinates to the currently set item.
void Rotate(GLfloat aAngle, GLfloat aX, GLfloat aY, GLfloat aZ)
Function Rotate() multiplies the current matrix by a rotation matrix, so the newly vertices will be r...
virtual void Save() override
Save the context.
void Translate(GLfloat aX, GLfloat aY, GLfloat aZ)
Function Translate() multiplies the current matrix by a translation matrix, so newly vertices will be...
float lineWidth
The line width.
void Shader(GLfloat aShaderType, GLfloat aParam1=0.0f, GLfloat aParam2=0.0f, GLfloat aParam3=0.0f)
Function Shader() changes currently used shader and its parameters that will be applied to newly adde...

References currentManager, KIGFX::GAL::layerDepth, KIGFX::GAL::lineWidth, KIGFX::VERTEX_MANAGER::Reserve(), Restore(), KIGFX::VERTEX_MANAGER::Rotate(), Save(), KIGFX::VERTEX_MANAGER::Shader(), KIGFX::SHADER_STROKED_CIRCLE, KIGFX::VERTEX_MANAGER::Translate(), KIGFX::VERTEX_MANAGER::Vertex(), VECTOR2< T >::x, and VECTOR2< T >::y.

Referenced by DrawSegment(), and drawSemiCircle().

◆ drawTriangulatedPolyset()

void OPENGL_GAL::drawTriangulatedPolyset ( const SHAPE_POLY_SET aPoly)
private

Draws a set of polygons with a cached triangulation.

Way faster than drawPolygon.

Definition at line 860 of file opengl_gal.cpp.

861 {
864 
865  if( isFillEnabled )
866  {
867  for( unsigned int j = 0; j < aPolySet.TriangulatedPolyCount(); ++j )
868  {
869  auto triPoly = aPolySet.TriangulatedPolygon( j );
870 
871  for( size_t i = 0; i < triPoly->GetTriangleCount(); i++ )
872  {
873  VECTOR2I a, b, c;
874  triPoly->GetTriangle( i, a, b, c );
875  currentManager->Vertex( a.x, a.y, layerDepth );
876  currentManager->Vertex( b.x, b.y, layerDepth );
877  currentManager->Vertex( c.x, c.y, layerDepth );
878  }
879  }
880  }
881 
882  if( isStrokeEnabled )
883  {
884  for( int j = 0; j < aPolySet.OutlineCount(); ++j )
885  {
886  const auto& poly = aPolySet.Polygon( j );
887 
888  for( const auto& lc : poly )
889  {
890  DrawPolyline( lc );
891  }
892  }
893  }
894 }
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:299
double layerDepth
The actual layer depth.
bool Vertex(const VERTEX &aVertex)
Function Vertex() adds a vertex with the given coordinates to the currently set item.
double g
Green component.
Definition: color4d.h:310
COLOR4D fillColor
The fill color.
double b
Blue component.
Definition: color4d.h:311
double a
Alpha component.
Definition: color4d.h:312
bool isStrokeEnabled
Are the outlines stroked ?
void Color(const COLOR4D &aColor)
Function Color() changes currently used color that will be applied to newly added vertices.
bool isFillEnabled
Is filling of graphic objects enabled ?
virtual void DrawPolyline(const std::deque< VECTOR2D > &aPointList) override
Draw a polyline.
Definition: opengl_gal.cpp:803
size_t i
Definition: json11.cpp:597
void Shader(GLfloat aShaderType, GLfloat aParam1=0.0f, GLfloat aParam2=0.0f, GLfloat aParam3=0.0f)
Function Shader() changes currently used shader and its parameters that will be applied to newly adde...
double r
Red component.
Definition: color4d.h:309

References KIGFX::COLOR4D::a, KIGFX::COLOR4D::b, KIGFX::VERTEX_MANAGER::Color(), currentManager, DrawPolyline(), KIGFX::GAL::fillColor, KIGFX::COLOR4D::g, i, KIGFX::GAL::isFillEnabled, KIGFX::GAL::isStrokeEnabled, KIGFX::GAL::layerDepth, SHAPE_POLY_SET::OutlineCount(), SHAPE_POLY_SET::Polygon(), KIGFX::COLOR4D::r, KIGFX::VERTEX_MANAGER::Shader(), KIGFX::SHADER_NONE, SHAPE_POLY_SET::TriangulatedPolyCount(), SHAPE_POLY_SET::TriangulatedPolygon(), KIGFX::VERTEX_MANAGER::Vertex(), VECTOR2< T >::x, and VECTOR2< T >::y.

Referenced by DrawPolygon().

◆ EnableDepthTest()

void OPENGL_GAL::EnableDepthTest ( bool  aEnabled = false)
overridevirtual

Parameters passed to the GLU tesselator.

Reimplemented from KIGFX::GAL.

Definition at line 2020 of file opengl_gal.cpp.

2021 {
2022  cachedManager->EnableDepthTest( aEnabled );
2023  nonCachedManager->EnableDepthTest( aEnabled );
2024  overlayManager->EnableDepthTest( aEnabled );
2025 }
VERTEX_MANAGER * overlayManager
Container for storing overlaid VERTEX_ITEMs.
Definition: opengl_gal.h:302
VERTEX_MANAGER * nonCachedManager
Container for storing non-cached VERTEX_ITEMs.
Definition: opengl_gal.h:301
VERTEX_MANAGER * cachedManager
Container for storing cached VERTEX_ITEMs.
Definition: opengl_gal.h:300
void EnableDepthTest(bool aEnabled)
Function EnableDepthTest() Enables/disables Z buffer depth test.

References cachedManager, KIGFX::VERTEX_MANAGER::EnableDepthTest(), nonCachedManager, and overlayManager.

◆ endDrawing()

void OPENGL_GAL::endDrawing ( )
overrideprivatevirtual

Update handler for OpenGL settings

Reimplemented from KIGFX::GAL.

Definition at line 505 of file opengl_gal.cpp.

506 {
507  wxASSERT_MSG( isContextLocked, "What happened to the context lock?" );
508 
509 #ifdef __WXDEBUG__
510  PROF_COUNTER totalRealTime( "OPENGL_GAL::endDrawing()", true );
511 #endif /* __WXDEBUG__ */
512 
513  // Cached & non-cached containers are rendered to the same buffer
517 
518  // Overlay container is rendered to a different buffer
521 
522  // Be sure that the framebuffer is not colorized (happens on specific GPU&drivers combinations)
523  glColor4d( 1.0, 1.0, 1.0, 1.0 );
524 
525  // Draw the remaining contents, blit the rendering targets to the screen, swap the buffers
528  compositor->Present();
529  blitCursor();
530 
531  SwapBuffers();
532 
533 #ifdef __WXDEBUG__
534  totalRealTime.Stop();
535  wxLogTrace( "GAL_PROFILE", wxT( "OPENGL_GAL::endDrawing(): %.1f ms" ), totalRealTime.msecs() );
536 #endif /* __WXDEBUG__ */
537 }
virtual void DrawBuffer(unsigned int aBufferHandle) override
Function DrawBuffer() draws the selected buffer to the output buffer.
unsigned int overlayBuffer
Auxiliary rendering target (for menus etc.)
Definition: opengl_gal.h:307
VERTEX_MANAGER * overlayManager
Container for storing overlaid VERTEX_ITEMs.
Definition: opengl_gal.h:302
bool isContextLocked
Used for assertion checking.
Definition: opengl_gal.h:320
The class PROF_COUNTER is a small class to help profiling.
Definition: profile.h:45
VERTEX_MANAGER * nonCachedManager
Container for storing non-cached VERTEX_ITEMs.
Definition: opengl_gal.h:301
OPENGL_COMPOSITOR * compositor
Handles multiple rendering targets.
Definition: opengl_gal.h:305
virtual void Present() override
Function Present() Call this to present the output buffer to the screen.
unsigned int mainBuffer
Main rendering target.
Definition: opengl_gal.h:306
virtual void SetBuffer(unsigned int aBufferHandle) override
Function SetBuffer() sets the selected buffer as the rendering target.
void blitCursor()
Blits cursor into the current screen.
VERTEX_MANAGER * cachedManager
Container for storing cached VERTEX_ITEMs.
Definition: opengl_gal.h:300
void EndDrawing() const
Function EndDrawing() finishes drawing operations.

References blitCursor(), cachedManager, compositor, KIGFX::OPENGL_COMPOSITOR::DrawBuffer(), KIGFX::VERTEX_MANAGER::EndDrawing(), isContextLocked, mainBuffer, PROF_COUNTER::msecs(), nonCachedManager, overlayBuffer, overlayManager, KIGFX::OPENGL_COMPOSITOR::Present(), KIGFX::OPENGL_COMPOSITOR::SetBuffer(), and PROF_COUNTER::Stop().

◆ EndGroup()

void OPENGL_GAL::EndGroup ( )
overridevirtual

End the group.

Reimplemented from KIGFX::GAL.

Definition at line 1404 of file opengl_gal.cpp.

1405 {
1407  isGrouping = false;
1408 }
bool isGrouping
Was a group started?
Definition: opengl_gal.h:319
void FinishItem() const
Function FinishItem() does the cleaning after adding an item.
VERTEX_MANAGER * cachedManager
Container for storing cached VERTEX_ITEMs.
Definition: opengl_gal.h:300

References cachedManager, KIGFX::VERTEX_MANAGER::FinishItem(), and isGrouping.

◆ endUpdate()

void OPENGL_GAL::endUpdate ( )
overrideprivatevirtual

Reimplemented from KIGFX::GAL.

Definition at line 580 of file opengl_gal.cpp.

581 {
582  if( !isInitialized )
583  return;
584 
585  cachedManager->Unmap();
586 }
void Unmap()
Function Unmap() unmaps vertex buffer.
VERTEX_MANAGER * cachedManager
Container for storing cached VERTEX_ITEMs.
Definition: opengl_gal.h:300
bool isInitialized
Basic initialization flag, has to be done when the window is visible.
Definition: opengl_gal.h:317

References cachedManager, isInitialized, and KIGFX::VERTEX_MANAGER::Unmap().

◆ Flush()

void OPENGL_GAL::Flush ( )
overridevirtual

Force all remaining objects to be drawn.

Reimplemented from KIGFX::GAL.

Definition at line 1328 of file opengl_gal.cpp.

1329 {
1330  glFlush();
1331 }

◆ GetBackingScaleFactor()

float HIDPI_GL_CANVAS::GetBackingScaleFactor ( ) const
virtualinherited

Definition at line 59 of file hidpi_gl_canvas.cpp.

60 {
61 #ifdef RETINA_OPENGL_PATCH
62  // this is ugly, but original method isn't marked const although it doesn't modify anything
63  // => clean up when it officially has arrived in wxWidgets
64  return static_cast< wxGLCanvas* >( const_cast< HIDPI_GL_CANVAS* >( this ))->GetBackingScaleFactor();
65 #else
66  return 1.0f;
67 #endif
68 }

Referenced by beginDrawing(), HIDPI_GL_CANVAS::GetNativePixelSize(), getScreenPixelSize(), and ResizeScreen().

◆ GetClearColor()

const COLOR4D& KIGFX::GAL::GetClearColor ( ) const
inlineinherited

Definition at line 195 of file graphics_abstraction_layer.h.

196  {
197  return m_clearColor;
198  }

References KIGFX::GAL::m_clearColor.

◆ getCursorColor()

COLOR4D GAL::getCursorColor ( ) const
protectedinherited

Gets the actual cursor color to draw.

Definition at line 238 of file graphics_abstraction_layer.cpp.

239 {
240  auto color = cursorColor;
241 
242  // dim the cursor if it's only on because it was forced
243  // (this helps to provide a hint for active tools)
244  if( !isCursorEnabled )
245  {
246  color.a = color.a * 0.5;
247  }
248 
249  return color;
250 }
bool isCursorEnabled
Is the cursor enabled?
int color
Definition: DXF_plotter.cpp:62
COLOR4D cursorColor
Cursor color.

References color, KIGFX::GAL::cursorColor, and KIGFX::GAL::isCursorEnabled.

Referenced by KIGFX::CAIRO_GAL_BASE::blitCursor(), and blitCursor().

◆ GetFillColor()

const COLOR4D& KIGFX::GAL::GetFillColor ( ) const
inlineinherited

Get the fill color.

Returns
the color for filling a outline.

Definition at line 245 of file graphics_abstraction_layer.h.

246  {
247  return fillColor;
248  }
COLOR4D fillColor
The fill color.

References KIGFX::GAL::fillColor.

◆ GetGlyphSize()

◆ GetGridLineWidth()

float KIGFX::GAL::GetGridLineWidth ( ) const
inlineinherited

Get the grid line width.

Returns
the grid line width

Definition at line 923 of file graphics_abstraction_layer.h.

924  {
925  return gridLineWidth;
926  }
float gridLineWidth
Line width of the grid.

References KIGFX::GAL::gridLineWidth.

◆ GetGridPoint()

VECTOR2D GAL::GetGridPoint ( const VECTOR2D aPoint) const
inherited

Function GetGridPoint() For a given point it returns the nearest point belonging to the grid in world coordinates.

Parameters
aPointis the point for which the grid point is searched.
Returns
The nearest grid point in world coordinates.

Definition at line 216 of file graphics_abstraction_layer.cpp.

217 {
218 #if 0
219  // This old code expects a non zero grid size, which can be wrong here.
220  return VECTOR2D( KiROUND( ( aPoint.x - gridOffset.x ) / gridSize.x ) * gridSize.x + gridOffset.x,
221  KiROUND( ( aPoint.y - gridOffset.y ) / gridSize.y ) * gridSize.y + gridOffset.y );
222 #else
223  // if grid size == 0.0 there is no grid, so use aPoint as grid reference position
224  double cx = gridSize.x > 0.0 ? KiROUND( ( aPoint.x - gridOffset.x ) / gridSize.x ) * gridSize.x + gridOffset.x
225  : aPoint.x;
226  double cy = gridSize.y > 0.0 ? KiROUND( ( aPoint.y - gridOffset.y ) / gridSize.y ) * gridSize.y + gridOffset.y
227  : aPoint.y;
228 
229  return VECTOR2D( cx, cy );
230 #endif
231 }
VECTOR2D gridOffset
The grid offset to compensate cursor position.
static int KiROUND(double v)
Round a floating point number to an integer using "round halfway cases away from zero".
Definition: common.h:121
VECTOR2< double > VECTOR2D
Definition: vector2d.h:586
VECTOR2D gridSize
The grid size.

References KIGFX::GAL::gridOffset, KIGFX::GAL::gridSize, KiROUND(), VECTOR2< T >::x, and VECTOR2< T >::y.

Referenced by EDIT_POINTS_FACTORY::buildForPolyOutline(), and KIGFX::WX_VIEW_CONTROLS::GetRawCursorPosition().

◆ GetGridSize()

const VECTOR2D& KIGFX::GAL::GetGridSize ( ) const
inlineinherited

Returns the grid size.

Returns
A vector containing the grid size in x and y direction.

Definition at line 875 of file graphics_abstraction_layer.h.

876  {
877  return gridSize;
878  }
VECTOR2D gridSize
The grid size.

References KIGFX::GAL::gridSize.

Referenced by SCH_BASE_FRAME::SyncView().

◆ GetHorizontalJustify()

EDA_TEXT_HJUSTIFY_T KIGFX::GAL::GetHorizontalJustify ( ) const
inlineinherited

Returns current text horizontal justification setting.

Definition at line 467 of file graphics_abstraction_layer.h.

468  {
470  }
struct KIGFX::GAL::TEXT_PROPERTIES textProperties
EDA_TEXT_HJUSTIFY_T m_horizontalJustify
Horizontal justification.

References KIGFX::GAL::TEXT_PROPERTIES::m_horizontalJustify, and KIGFX::GAL::textProperties.

Referenced by BitmapText(), and KIGFX::STROKE_FONT::drawSingleLineText().

◆ GetLineWidth()

float KIGFX::GAL::GetLineWidth ( ) const
inlineinherited

◆ GetLookAtPoint()

const VECTOR2D& KIGFX::GAL::GetLookAtPoint ( ) const
inlineinherited

Get the look at point.

Returns
the look at point.

Definition at line 667 of file graphics_abstraction_layer.h.

668  {
669  return lookAtPoint;
670  }
VECTOR2D lookAtPoint
Point to be looked at in world space.

References KIGFX::GAL::lookAtPoint.

◆ GetMaxDepth()

double KIGFX::GAL::GetMaxDepth ( ) const
inlineinherited

Returns the maximum depth in the currently used range (the bottom).

Definition at line 736 of file graphics_abstraction_layer.h.

737  {
738  return depthRange.y;
739  }
VECTOR2D depthRange
Range of the depth.

References KIGFX::GAL::depthRange, and VECTOR2< T >::y.

◆ GetMinDepth()

double KIGFX::GAL::GetMinDepth ( ) const
inlineinherited

Returns the minimum depth in the currently used range (the top).

Definition at line 728 of file graphics_abstraction_layer.h.

729  {
730  return depthRange.x;
731  }
VECTOR2D depthRange
Range of the depth.

References KIGFX::GAL::depthRange, and VECTOR2< T >::x.

◆ GetNativePixelSize()

wxSize HIDPI_GL_CANVAS::GetNativePixelSize ( ) const
virtualinherited

Definition at line 46 of file hidpi_gl_canvas.cpp.

47 {
48  wxSize size = wxGLCanvas::GetClientSize();
49 
50 #ifdef RETINA_OPENGL_PATCH
51  const float scaleFactor = GetBackingScaleFactor();
52  size.x *= scaleFactor;
53  size.y *= scaleFactor;
54 #endif
55 
56  return size;
57 }
virtual float GetBackingScaleFactor() const

References HIDPI_GL_CANVAS::GetBackingScaleFactor().

Referenced by EDA_3D_CANVAS::OnMouseMove(), EDA_3D_CANVAS::OnPaint(), and OPENGL_GAL().

◆ getNewGroupNumber()

unsigned int OPENGL_GAL::getNewGroupNumber ( )
private

Returns a valid key that can be used as a new group number.

Returns
An unique group number that is not used by any other group.

Definition at line 1893 of file opengl_gal.cpp.

1894 {
1895  wxASSERT_MSG( groups.size() < std::numeric_limits<unsigned int>::max(),
1896  wxT( "There are no free slots to store a group" ) );
1897 
1898  while( groups.find( groupCounter ) != groups.end() )
1899  {
1900  groupCounter++;
1901  }
1902 
1903  return groupCounter++;
1904 }
GROUPS_MAP groups
Stores informations about VBO objects (groups)
Definition: opengl_gal.h:297
#define max(a, b)
Definition: auxiliary.h:86
unsigned int groupCounter
Counter used for generating keys for groups.
Definition: opengl_gal.h:298

References groupCounter, groups, and max.

Referenced by BeginGroup().

◆ GetOverbarVerticalPosition()

double KIGFX::GAL::GetOverbarVerticalPosition ( ) const
inlineinherited

Compute the vertical position of an overbar, sometimes used in texts.

This is the distance between the text base line and the overbar.

Returns
the relative position of the overbar axis.

Definition at line 362 of file graphics_abstraction_layer.h.

363  {
365  }
STROKE_FONT strokeFont
Instance of object that stores information about how to draw texts.
double computeOverbarVerticalPosition() const
Compute the vertical position of an overbar, sometimes used in texts.

References KIGFX::STROKE_FONT::computeOverbarVerticalPosition(), and KIGFX::GAL::strokeFont.

◆ GetRotation()

double KIGFX::GAL::GetRotation ( ) const
inlineinherited

Get the rotation angle.

Returns
The rotation angle (radians).

Definition at line 707 of file graphics_abstraction_layer.h.

708  {
709  return rotation;
710  }
double rotation
Rotation transformation (radians)

References KIGFX::GAL::rotation.

◆ GetScreenPixelSize()

const VECTOR2I& KIGFX::GAL::GetScreenPixelSize ( ) const
inlineinherited

◆ getScreenPixelSize()

VECTOR2D OPENGL_GAL::getScreenPixelSize ( ) const
private

Definition at line 357 of file opengl_gal.cpp.

358 {
359  auto sf = GetBackingScaleFactor();
360  return VECTOR2D( 2.0 / (double) ( screenSize.x * sf ), 2.0 / (double) ( screenSize.y * sf ) );
361 }
VECTOR2< double > VECTOR2D
Definition: vector2d.h:586
virtual float GetBackingScaleFactor() const
VECTOR2I screenSize
Screen size in screen coordinates.

References HIDPI_GL_CANVAS::GetBackingScaleFactor(), KIGFX::GAL::screenSize, VECTOR2< T >::x, and VECTOR2< T >::y.

Referenced by beginDrawing().

◆ GetScreenWorldMatrix()

const MATRIX3x3D& KIGFX::GAL::GetScreenWorldMatrix ( ) const
inlineinherited

Get the screen <-> world transformation matrix.

Returns
the transformation matrix.

Definition at line 603 of file graphics_abstraction_layer.h.

604  {
605  return screenWorldMatrix;
606  }
MATRIX3x3D screenWorldMatrix
Screen transformation.

References KIGFX::GAL::screenWorldMatrix.

Referenced by getWorldPixelSize(), and KIGFX::VIEW::ToWorld().

◆ GetStrokeColor()

const COLOR4D& KIGFX::GAL::GetStrokeColor ( ) const
inlineinherited

Get the stroke color.

Returns
the color for stroking the outline.

Definition at line 265 of file graphics_abstraction_layer.h.

266  {
267  return strokeColor;
268  }
COLOR4D strokeColor
The color of the outlines.

References KIGFX::GAL::strokeColor.

◆ GetStrokeFont()

const STROKE_FONT& KIGFX::GAL::GetStrokeFont ( ) const
inlineinherited

Definition at line 307 of file graphics_abstraction_layer.h.

308  {
309  return strokeFont;
310  }
STROKE_FONT strokeFont
Instance of object that stores information about how to draw texts.

References KIGFX::GAL::strokeFont.

Referenced by EDA_TEXT::GetTextBox().

◆ GetTarget()

RENDER_TARGET OPENGL_GAL::GetTarget ( ) const
overridevirtual

Gets the currently used target for rendering.

Returns
The current rendering target.

Reimplemented from KIGFX::GAL.

Definition at line 1484 of file opengl_gal.cpp.

1485 {
1486  return currentTarget;
1487 }
RENDER_TARGET currentTarget
Current rendering target.
Definition: opengl_gal.h:308

References currentTarget.

Referenced by DrawBitmap().

◆ GetTextLineSize()

VECTOR2D GAL::GetTextLineSize ( const UTF8 aText) const
inherited

Compute the X and Y size of a given text.

The text is expected to be a only one line text.

Parameters
aTextis the text string (one line).
Returns
is the text size.

Definition at line 170 of file graphics_abstraction_layer.cpp.

171 {
172  // Compute the X and Y size of a given text.
173  // Because computeTextLineSize expects a one line text,
174  // aText is expected to be only one line text.
175  return strokeFont.computeTextLineSize( aText );
176 }
STROKE_FONT strokeFont
Instance of object that stores information about how to draw texts.
VECTOR2D computeTextLineSize(const UTF8 &aText) const
Compute the X and Y size of a given text.

References KIGFX::STROKE_FONT::computeTextLineSize(), and KIGFX::GAL::strokeFont.

Referenced by GraphicTextWidth(), and EDA_TEXT::LenSize().

◆ GetVerticalJustify()

EDA_TEXT_VJUSTIFY_T KIGFX::GAL::GetVerticalJustify ( ) const
inlineinherited

Returns current text vertical justification setting.

Definition at line 485 of file graphics_abstraction_layer.h.

486  {
488  }
EDA_TEXT_VJUSTIFY_T m_verticalJustify
Vertical justification.
struct KIGFX::GAL::TEXT_PROPERTIES textProperties

References KIGFX::GAL::TEXT_PROPERTIES::m_verticalJustify, and KIGFX::GAL::textProperties.

Referenced by BitmapText(), and KIGFX::STROKE_FONT::Draw().

◆ getWorldPixelSize()

double OPENGL_GAL::getWorldPixelSize ( ) const
private

Definition at line 350 of file opengl_gal.cpp.

351 {
352  auto matrix = GetScreenWorldMatrix();
353  return std::min( std::abs( matrix.GetScale().x ), std::abs( matrix.GetScale().y ) );
354 }
const MATRIX3x3D & GetScreenWorldMatrix() const
Get the screen <-> world transformation matrix.
#define abs(a)
Definition: auxiliary.h:84
#define min(a, b)
Definition: auxiliary.h:85

References abs, KIGFX::GAL::GetScreenWorldMatrix(), and min.

Referenced by beginDrawing(), and DrawGrid().

◆ GetWorldScale()

double KIGFX::GAL::GetWorldScale ( ) const
inlineinherited

Get the world scale.

Returns
the actual world scale factor.

Definition at line 746 of file graphics_abstraction_layer.h.

747  {
748  return worldScale;
749  }
double worldScale
The scale factor world->screen.

References KIGFX::GAL::worldScale.

Referenced by GRID_HELPER::BestDragOrigin(), GRID_HELPER::BestSnapAnchor(), KIGFX::PCB_PAINTER::draw(), SCH_BASE_FRAME::RedrawScreen(), SCH_BASE_FRAME::RedrawScreen2(), and KIGFX::PREVIEW::SetConstantGlyphHeight().

◆ GetWorldScreenMatrix()

const MATRIX3x3D& KIGFX::GAL::GetWorldScreenMatrix ( ) const
inlineinherited

Get the world <-> screen transformation matrix.

Returns
the transformation matrix.

Definition at line 593 of file graphics_abstraction_layer.h.

594  {
595  return worldScreenMatrix;
596  }
MATRIX3x3D worldScreenMatrix
World transformation.

References KIGFX::GAL::worldScreenMatrix.

Referenced by KIGFX::VIEW::ToScreen().

◆ GetZoomFactor()

double KIGFX::GAL::GetZoomFactor ( ) const
inlineinherited

Get the zoom factor.

Returns
the zoom factor.

Definition at line 687 of file graphics_abstraction_layer.h.

688  {
689  return zoomFactor;
690  }
double zoomFactor
The zoom factor.

References KIGFX::GAL::zoomFactor.

Referenced by EDA_DRAW_PANEL_GAL::GetLegacyZoom(), EDA_DRAW_FRAME::GetZoomLevelIndicator(), SCH_BASE_FRAME::RedrawScreen(), and SCH_BASE_FRAME::RedrawScreen2().

◆ init()

void OPENGL_GAL::init ( )
private

Basic OpenGL initialization.

Definition at line 1907 of file opengl_gal.cpp.

1908 {
1909  wxASSERT( IsShownOnScreen() );
1910 
1911  wxASSERT_MSG( isContextLocked, "This should only be called from within a locked context." );
1912 
1913  GLenum err = glewInit();
1914 
1915  if( GLEW_OK != err )
1916  throw std::runtime_error( (const char*) glewGetErrorString( err ) );
1917 
1918  // Check the OpenGL version (minimum 2.1 is required)
1919  if( !GLEW_VERSION_2_1 )
1920  throw std::runtime_error( "OpenGL 2.1 or higher is required!" );
1921 
1922 #if defined (__LINUX__) // calling enableGlDebug crashes opengl on some OS (OSX and some Windows)
1923 #ifdef DEBUG
1924  if( GLEW_ARB_debug_output )
1925  enableGlDebug( true );
1926 #endif
1927 #endif
1928 
1929  // Framebuffers have to be supported
1930  if( !GLEW_EXT_framebuffer_object )
1931  throw std::runtime_error( "Framebuffer objects are not supported!" );
1932 
1933  // Vertex buffer has to be supported
1934  if( !GLEW_ARB_vertex_buffer_object )
1935  throw std::runtime_error( "Vertex buffer objects are not supported!" );
1936 
1937  // Prepare shaders
1939  throw std::runtime_error( "Cannot compile vertex shader!" );
1940 
1942  throw std::runtime_error( "Cannot compile fragment shader!" );
1943 
1944  if( !shader->IsLinked() && !shader->Link() )
1945  throw std::runtime_error( "Cannot link the shaders!" );
1946 
1947  // Check if video card supports textures big enough to fit the font atlas
1948  int maxTextureSize;
1949  glGetIntegerv( GL_MAX_TEXTURE_SIZE, &maxTextureSize );
1950 
1951  if( maxTextureSize < (int) font_image.width || maxTextureSize < (int)font_image.height )
1952  {
1953  // TODO implement software texture scaling
1954  // for bitmap fonts and use a higher resolution texture?
1955  throw std::runtime_error( "Requested texture size is not supported" );
1956  }
1957 
1958  cachedManager = new VERTEX_MANAGER( true );
1959  nonCachedManager = new VERTEX_MANAGER( false );
1960  overlayManager = new VERTEX_MANAGER( false );
1961 
1962  // Make VBOs use shaders
1966 
1967  isInitialized = true;
1968 }
static SHADER * shader
There is only one shader used for different objects.
Definition: opengl_gal.h:311
bool IsLinked() const
Returns true if shaders are linked correctly.
Definition: shader.h:124
bool LoadShaderFromStrings(SHADER_TYPE aShaderType, Args &&... aArgs)
Add a shader and compile the shader sources.
Definition: shader.h:99
VERTEX_MANAGER * overlayManager
Container for storing overlaid VERTEX_ITEMs.
Definition: opengl_gal.h:302
bool isContextLocked
Used for assertion checking.
Definition: opengl_gal.h:320
Fragment shader.
Definition: shader.h:47
bool Link()
Link the shaders.
Definition: shader.cpp:97
void enableGlDebug(bool aEnable)
Enables/disables OpenGL driver messages output.
Definition: utils.cpp:140
VERTEX_MANAGER * nonCachedManager
Container for storing non-cached VERTEX_ITEMs.
Definition: opengl_gal.h:301
void SetShader(SHADER &aShader) const
Function SetShader() sets a shader program that is going to be used during rendering.
FONT_IMAGE_TYPE font_image
Definition: gl_resources.cpp:4
Vertex shader.
Definition: shader.h:46
string & err
Definition: json11.cpp:598
VERTEX_MANAGER * cachedManager
Container for storing cached VERTEX_ITEMs.
Definition: opengl_gal.h:300
bool isInitialized
Basic initialization flag, has to be done when the window is visible.
Definition: opengl_gal.h:317

References cachedManager, enableGlDebug(), err, KIGFX::BUILTIN_FONT::font_image, KIGFX::BUILTIN_FONT::FONT_IMAGE_TYPE::height, isContextLocked, isInitialized, KIGFX::SHADER::IsLinked(), KIGFX::BUILTIN_SHADERS::kicad_fragment_shader, KIGFX::BUILTIN_SHADERS::kicad_vertex_shader, KIGFX::SHADER::Link(), KIGFX::SHADER::LoadShaderFromStrings(), nonCachedManager, overlayManager, KIGFX::VERTEX_MANAGER::SetShader(), shader, KIGFX::SHADER_TYPE_FRAGMENT, KIGFX::SHADER_TYPE_VERTEX, and KIGFX::BUILTIN_FONT::FONT_IMAGE_TYPE::width.

Referenced by beginDrawing(), and beginUpdate().

◆ IsCairoEngine()

virtual bool KIGFX::GAL::IsCairoEngine ( )
inlinevirtualinherited

Returns true if the GAL engine is a cairo based type.

Reimplemented in KIGFX::CAIRO_GAL_BASE.

Definition at line 79 of file graphics_abstraction_layer.h.

79 { return false; }

◆ IsCursorEnabled()

bool KIGFX::GAL::IsCursorEnabled ( ) const
inlineinherited

Returns information about cursor visibility.

Returns
True if cursor is visible.

Definition at line 976 of file graphics_abstraction_layer.h.

977  {
979  }
bool isCursorEnabled
Is the cursor enabled?
bool forceDisplayCursor
Always show cursor.

References KIGFX::GAL::forceDisplayCursor, and KIGFX::GAL::isCursorEnabled.

Referenced by KIGFX::CAIRO_GAL_BASE::blitCursor(), and blitCursor().

◆ IsFlippedX()

bool KIGFX::GAL::IsFlippedX ( ) const
inlineinherited

Return true if flip flag for the X axis is set.

Definition at line 766 of file graphics_abstraction_layer.h.

767  {
768  return globalFlipX;
769  }
bool globalFlipX
Flag for X axis flipping.

References KIGFX::GAL::globalFlipX.

◆ IsFlippedY()

bool KIGFX::GAL::IsFlippedY ( ) const
inlineinherited

Return true if flip flag for the Y axis is set.

Definition at line 774 of file graphics_abstraction_layer.h.

775  {
776  return globalFlipY;
777  }
bool globalFlipY
Flag for Y axis flipping.

References KIGFX::GAL::globalFlipY.

◆ IsFontBold()

bool KIGFX::GAL::IsFontBold ( ) const
inlineinherited

Returns true if current font has 'bold' attribute enabled.

Definition at line 413 of file graphics_abstraction_layer.h.

414  {
415  return textProperties.m_bold;
416  }
struct KIGFX::GAL::TEXT_PROPERTIES textProperties

References KIGFX::GAL::TEXT_PROPERTIES::m_bold, and KIGFX::GAL::textProperties.

Referenced by KIGFX::STROKE_FONT::Draw().

◆ IsFontItalic()

bool KIGFX::GAL::IsFontItalic ( ) const
inlineinherited

Returns true if current font has 'italic' attribute enabled.

Definition at line 431 of file graphics_abstraction_layer.h.

432  {
433  return textProperties.m_italic;
434  }
struct KIGFX::GAL::TEXT_PROPERTIES textProperties

References KIGFX::GAL::TEXT_PROPERTIES::m_italic, and KIGFX::GAL::textProperties.

Referenced by KIGFX::STROKE_FONT::ComputeStringBoundaryLimits(), and KIGFX::STROKE_FONT::drawSingleLineText().

◆ IsInitialized()

virtual bool KIGFX::OPENGL_GAL::IsInitialized ( ) const
inlineoverridevirtual

Returns the initalization status for the canvas.

Reimplemented from KIGFX::GAL.

Definition at line 92 of file opengl_gal.h.

93  {
94  // is*Initialized flags, but it is enough for OpenGL to show up
95  return IsShownOnScreen() && !GetClientRect().IsEmpty();
96  }

◆ IsOpenGlEngine()

virtual bool KIGFX::OPENGL_GAL::IsOpenGlEngine ( )
inlineoverridevirtual

Returns true if the GAL engine is a opengl based type.

Reimplemented from KIGFX::GAL.

Definition at line 89 of file opengl_gal.h.

89 { return true; }

◆ IsTextMirrored()

bool KIGFX::GAL::IsTextMirrored ( ) const
inlineinherited

Returns true if text should displayed mirrored.

Definition at line 449 of file graphics_abstraction_layer.h.

450  {
451  return textProperties.m_mirrored;
452  }
struct KIGFX::GAL::TEXT_PROPERTIES textProperties

References KIGFX::GAL::TEXT_PROPERTIES::m_mirrored, and KIGFX::GAL::textProperties.

Referenced by BitmapText(), and KIGFX::STROKE_FONT::drawSingleLineText().

◆ IsVisible()

bool KIGFX::OPENGL_GAL::IsVisible ( ) const
inlineoverridevirtual

Reimplemented from KIGFX::GAL.

Definition at line 99 of file opengl_gal.h.

100  {
101  return IsShownOnScreen() && !GetClientRect().IsEmpty();
102  }

Referenced by beginDrawing(), and beginUpdate().

◆ lockContext()

void OPENGL_GAL::lockContext ( int  aClientCookie)
overrideprivatevirtual

Private: use GAL_CONTEXT_LOCKER RAII object.

Reimplemented from KIGFX::GAL.

Definition at line 540 of file opengl_gal.cpp.

541 {
542  wxASSERT_MSG( !isContextLocked, "Context already locked." );
543  isContextLocked = true;
544  lockClientCookie = aClientCookie;
545 
547 }
bool isContextLocked
Used for assertion checking.
Definition: opengl_gal.h:320
static GL_CONTEXT_MANAGER & Get()
Function Get returns the GL_CONTEXT_MANAGER instance (singleton).
void LockCtx(wxGLContext *aContext, wxGLCanvas *aCanvas)
Function LockCtx sets a context as current and prevents other canvases from switching it.
wxGLContext * glPrivContext
Canvas-specific OpenGL context.
Definition: opengl_gal.h:288

References GL_CONTEXT_MANAGER::Get(), glPrivContext, isContextLocked, lockClientCookie, and GL_CONTEXT_MANAGER::LockCtx().

◆ OnGalDisplayOptionsChanged()

void GAL::OnGalDisplayOptionsChanged ( const GAL_DISPLAY_OPTIONS aOptions)
overrideprotectedvirtualinherited

Handler for observer settings changes.

Implements KIGFX::GAL_DISPLAY_OPTIONS_OBSERVER.

Definition at line 90 of file graphics_abstraction_layer.cpp.

91 {
92  // defer to the child class first
93  updatedGalDisplayOptions( aOptions );
94 
95  // there is no refresh to do at this level
96 }
virtual bool updatedGalDisplayOptions(const GAL_DISPLAY_OPTIONS &aOptions)
Function updatedGalDisplayOptions.

References KIGFX::GAL::updatedGalDisplayOptions().

◆ onPaint()

void OPENGL_GAL::onPaint ( wxPaintEvent &  aEvent)
private

This is the OnPaint event handler.

Parameters
aEventis the OnPaint event.

Definition at line 1847 of file opengl_gal.cpp.

1848 {
1849  PostPaint();
1850 }
void PostPaint()
Function PostPaint posts an event to m_paint_listener.
Definition: opengl_gal.h:249

References PostPaint().

Referenced by OPENGL_GAL().

◆ PopDepth()

void KIGFX::GAL::PopDepth ( )
inlineinherited

Restores previously stored drawing depth for the depth stack.

Definition at line 1018 of file graphics_abstraction_layer.h.

1019  {
1020  layerDepth = depthStack.top();
1021  depthStack.pop();
1022  }
double layerDepth
The actual layer depth.
std::stack< double > depthStack
Stored depth values.

References KIGFX::GAL::depthStack, and KIGFX::GAL::layerDepth.

Referenced by KIGFX::VIEW_GROUP::ViewDraw().

◆ PostPaint()

void KIGFX::OPENGL_GAL::PostPaint ( )
inline

Function PostPaint posts an event to m_paint_listener.

A post is used so that the actual drawing function can use a device context type that is not specific to the wxEVT_PAINT event.

Definition at line 249 of file opengl_gal.h.

250  {
251  if( paintListener )
252  {
253  wxPaintEvent redrawEvent;
254  wxPostEvent( paintListener, redrawEvent );
255  }
256  }
wxEvtHandler * paintListener
Definition: opengl_gal.h:291

References paintListener.

Referenced by onPaint().

◆ PushDepth()

void KIGFX::GAL::PushDepth ( )
inlineinherited

Stores current drawing depth on the depth stack.

Definition at line 1010 of file graphics_abstraction_layer.h.

1011  {
1012  depthStack.push( layerDepth );
1013  }
double layerDepth
The actual layer depth.
std::stack< double > depthStack
Stored depth values.

References KIGFX::GAL::depthStack, and KIGFX::GAL::layerDepth.

Referenced by KIGFX::VIEW_GROUP::ViewDraw().

◆ ResetTextAttributes()

void GAL::ResetTextAttributes ( )
inherited

Reset text attributes to default styling.

Normally, custom attributes will be set individually after this, otherwise you can use SetTextAttributes()

Definition at line 155 of file graphics_abstraction_layer.cpp.

156 {
157  // Tiny but non-zero - this will always need setting
158  // there is no built-in default
159  SetGlyphSize( { 1.0, 1.0 } );
160 
163 
164  SetFontBold( false );
165  SetFontItalic( false );
166  SetTextMirrored( false );
167 }
void SetFontItalic(const bool aItalic)
Set italic property of current font.
void SetFontBold(const bool aBold)
Set bold property of current font.
void SetTextMirrored(const bool aMirrored)
Set a mirrored property of text.
void SetVerticalJustify(const EDA_TEXT_VJUSTIFY_T aVerticalJustify)
Set the vertical justify for text drawing.
void SetGlyphSize(const VECTOR2D aGlyphSize)
Set the font glyph size.
void SetHorizontalJustify(const EDA_TEXT_HJUSTIFY_T aHorizontalJustify)
Set the horizontal justify for text drawing.

References GR_TEXT_HJUSTIFY_CENTER, GR_TEXT_VJUSTIFY_CENTER, KIGFX::GAL::SetFontBold(), KIGFX::GAL::SetFontItalic(), KIGFX::GAL::SetGlyphSize(), KIGFX::GAL::SetHorizontalJustify(), KIGFX::GAL::SetTextMirrored(), and KIGFX::GAL::SetVerticalJustify().

Referenced by KIGFX::PCB_PAINTER::draw(), and KIGFX::GAL::GAL().

◆ ResizeScreen()

void OPENGL_GAL::ResizeScreen ( int  aWidth,
int  aHeight 
)
overridevirtual

Resizes the canvas.

Reimplemented from KIGFX::GAL.

Definition at line 1304 of file opengl_gal.cpp.

1305 {
1306  screenSize = VECTOR2I( aWidth, aHeight );
1307 
1308  // Resize framebuffers
1309  const float scaleFactor = GetBackingScaleFactor();
1310  compositor->Resize( aWidth * scaleFactor, aHeight * scaleFactor );
1311  isFramebufferInitialized = false;
1312 
1313  wxGLCanvas::SetSize( aWidth, aHeight );
1314 }
VECTOR2< int > VECTOR2I
Definition: vector2d.h:587
OPENGL_COMPOSITOR * compositor
Handles multiple rendering targets.
Definition: opengl_gal.h:305
bool isFramebufferInitialized
Are the framebuffers initialized?
Definition: opengl_gal.h:314
virtual void Resize(unsigned int aWidth, unsigned int aHeight) override
Function Resize() clears the state of COMPOSITOR, so it has to be reinitialized again with the new di...
virtual float GetBackingScaleFactor() const
VECTOR2I screenSize
Screen size in screen coordinates.

References compositor, HIDPI_GL_CANVAS::GetBackingScaleFactor(), isFramebufferInitialized, KIGFX::OPENGL_COMPOSITOR::Resize(), and KIGFX::GAL::screenSize.

◆ Restore()

void OPENGL_GAL::Restore ( )
overridevirtual

Restore the context.

Reimplemented from KIGFX::GAL.

Definition at line 1386 of file opengl_gal.cpp.

1387 {
1389 }
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:299
void PopMatrix()
Function PopMatrix() pops the current transformation matrix stack.

References currentManager, and KIGFX::VERTEX_MANAGER::PopMatrix().

Referenced by BitmapText(), DrawArc(), drawBitmapOverbar(), drawFilledSemiCircle(), DrawSegment(), and drawStrokedSemiCircle().

◆ RestoreScreen()

void OPENGL_GAL::RestoreScreen ( )
overridevirtual

Restore the screen contents.

Reimplemented from KIGFX::GAL.

Definition at line 1456 of file opengl_gal.cpp.

1457 {
1458  wxASSERT_MSG( false, wxT( "Not implemented yet" ) );
1459 }

◆ Rotate()

void OPENGL_GAL::Rotate ( double  aAngle)
overridevirtual

Rotate the context.

Parameters
aAngleis the rotation angle in radians.

Reimplemented from KIGFX::GAL.

Definition at line 1362 of file opengl_gal.cpp.

1363 {
1364  currentManager->Rotate( aAngle, 0.0f, 0.0f, 1.0f );
1365 }
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:299
void Rotate(GLfloat aAngle, GLfloat aX, GLfloat aY, GLfloat aZ)
Function Rotate() multiplies the current matrix by a rotation matrix, so the newly vertices will be r...

References currentManager, and KIGFX::VERTEX_MANAGER::Rotate().

◆ Save()

void OPENGL_GAL::Save ( )
overridevirtual

Save the context.

Reimplemented from KIGFX::GAL.

Definition at line 1380 of file opengl_gal.cpp.

1381 {
1383 }
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:299
void PushMatrix()
Function PushMatrix() pushes the current transformation matrix stack.

References currentManager, and KIGFX::VERTEX_MANAGER::PushMatrix().

Referenced by BitmapText(), DrawArc(), drawBitmapOverbar(), drawFilledSemiCircle(), DrawSegment(), and drawStrokedSemiCircle().

◆ SaveScreen()

void OPENGL_GAL::SaveScreen ( )
overridevirtual

Save the screen contents.

Reimplemented from KIGFX::GAL.

Definition at line 1450 of file opengl_gal.cpp.

1451 {
1452  wxASSERT_MSG( false, wxT( "Not implemented yet" ) );
1453 }

◆ Scale()

void OPENGL_GAL::Scale ( const VECTOR2D aScale)
overridevirtual

Scale the context.

Parameters
aScaleis the scale factor for the x- and y-axis.

Reimplemented from KIGFX::GAL.

Definition at line 1374 of file opengl_gal.cpp.

1375 {
1376  currentManager->Scale( aScale.x, aScale.y, 0.0f );
1377 }
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:299
void Scale(GLfloat aX, GLfloat aY, GLfloat aZ)
Function Scale() multiplies the current matrix by a scaling matrix, so the newly vertices will be sca...

References currentManager, KIGFX::VERTEX_MANAGER::Scale(), VECTOR2< T >::x, and VECTOR2< T >::y.

◆ SetAxesColor()

void KIGFX::GAL::SetAxesColor ( const COLOR4D aAxesColor)
inlineinherited

Set the axes color.

Parameters
aAxesColoris the color to draw the axes if enabled.

Definition at line 895 of file graphics_abstraction_layer.h.

896  {
897  axesColor = aAxesColor;
898  }
COLOR4D axesColor
Color of the axes.

References KIGFX::GAL::axesColor.

Referenced by KIGFX::CAIRO_GAL_BASE::CAIRO_GAL_BASE(), and OPENGL_GAL().

◆ SetAxesEnabled()

void KIGFX::GAL::SetAxesEnabled ( bool  aAxesEnabled)
inlineinherited

Enables drawing the axes.

Definition at line 903 of file graphics_abstraction_layer.h.

904  {
905  axesEnabled = aAxesEnabled;
906  }
bool axesEnabled
Should the axes be drawn.

References KIGFX::GAL::axesEnabled.

Referenced by FOOTPRINT_VIEWER_FRAME::FOOTPRINT_VIEWER_FRAME(), KIGFX::GAL::GAL(), and FOOTPRINT_EDIT_FRAME::UseGalCanvas().

◆ SetClearColor()

void KIGFX::GAL::SetClearColor ( const COLOR4D aColor)
inlineinherited

◆ SetCoarseGrid()

void KIGFX::GAL::SetCoarseGrid ( int  aInterval)
inlineinherited

Draw every tick line wider.

Parameters
aIntervalincrease the width of every aInterval line, if 0 do not use this feature.

Definition at line 913 of file graphics_abstraction_layer.h.

914  {
915  gridTick = aInterval;
916  }
int gridTick
Every tick line gets the double width.

References KIGFX::GAL::gridTick.

Referenced by KIGFX::GAL::GAL().

◆ SetCursorColor()

void KIGFX::GAL::SetCursorColor ( const COLOR4D aCursorColor)
inlineinherited

Set the cursor color.

Parameters
aCursorColoris the color of the cursor.

Definition at line 986 of file graphics_abstraction_layer.h.

987  {
988  cursorColor = aCursorColor;
989  }
COLOR4D cursorColor
Cursor color.

References KIGFX::GAL::cursorColor.

Referenced by KIGFX::GAL::GAL(), EDA_DRAW_PANEL_GAL::onPaint(), SCH_PREVIEW_PANEL::SCH_PREVIEW_PANEL(), and PCB_DRAW_PANEL_GAL::UseColorScheme().

◆ SetCursorEnabled()

void KIGFX::GAL::SetCursorEnabled ( bool  aCursorEnabled)
inlineinherited

Enable/disable cursor.

Parameters
aCursorEnabledis true if the cursor should be drawn, else false.

Definition at line 967 of file graphics_abstraction_layer.h.

968  {
969  isCursorEnabled = aCursorEnabled;
970  }
bool isCursorEnabled
Is the cursor enabled?

References KIGFX::GAL::isCursorEnabled.

Referenced by KIGFX::GAL::GAL(), and KIGFX::VIEW_CONTROLS::ShowCursor().

◆ SetDepthRange()

void KIGFX::GAL::SetDepthRange ( const VECTOR2D aDepthRange)
inlineinherited

Set the range of the layer depth.

Usually required for the OpenGL implementation, any object outside this range is not drawn.

Parameters
aDepthRangeis the depth range where component x is the near clipping plane and y is the far clipping plane.

Definition at line 720 of file graphics_abstraction_layer.h.

721  {
722  depthRange = aDepthRange;
723  }
VECTOR2D depthRange
Range of the depth.

References KIGFX::GAL::depthRange.

Referenced by KIGFX::GAL::GAL().

◆ SetFillColor()

virtual void KIGFX::GAL::SetFillColor ( const COLOR4D aColor)
inlinevirtualinherited

◆ SetFlip()

void KIGFX::GAL::SetFlip ( bool  xAxis,
bool  yAxis 
)
inlineinherited

Sets flipping of the screen.

Parameters
xAxisis the flip flag for the X axis.
yAxisis the flip flag for the Y axis.

Definition at line 757 of file graphics_abstraction_layer.h.

758  {
759  globalFlipX = xAxis;
760  globalFlipY = yAxis;
761  }
bool globalFlipX
Flag for X axis flipping.
bool globalFlipY
Flag for Y axis flipping.

References KIGFX::GAL::globalFlipX, and KIGFX::GAL::globalFlipY.

Referenced by KIGFX::GAL::GAL(), KIGFX::VIEW::SetMirror(), and BOARD_PRINTOUT::setupGal().

◆ SetFontBold()

void KIGFX::GAL::SetFontBold ( const bool  aBold)
inlineinherited

Set bold property of current font.

Parameters
aBoldtells if the font should be bold or not.

Definition at line 405 of file graphics_abstraction_layer.h.

406  {
407  textProperties.m_bold = aBold;
408  }
struct KIGFX::GAL::TEXT_PROPERTIES textProperties

References KIGFX::GAL::TEXT_PROPERTIES::m_bold, and KIGFX::GAL::textProperties.

Referenced by KIGFX::SCH_PAINTER::draw(), KIGFX::GERBVIEW_PAINTER::draw(), KIGFX::PCB_PAINTER::draw(), GraphicTextWidth(), EDA_TEXT::LenSize(), KIGFX::GAL::ResetTextAttributes(), and KIGFX::GAL::SetTextAttributes().

◆ SetFontItalic()

void KIGFX::GAL::SetFontItalic ( const bool  aItalic)
inlineinherited

Set italic property of current font.

Parameters
aItalictells if the font should be italic or not.

Definition at line 423 of file graphics_abstraction_layer.h.

424  {
425  textProperties.m_italic = aItalic;
426  }
struct KIGFX::GAL::TEXT_PROPERTIES textProperties

References KIGFX::GAL::TEXT_PROPERTIES::m_italic, and KIGFX::GAL::textProperties.

Referenced by KIGFX::SCH_PAINTER::draw(), KIGFX::GERBVIEW_PAINTER::draw(), KIGFX::PCB_PAINTER::draw(), GraphicTextWidth(), EDA_TEXT::LenSize(), KIGFX::GAL::ResetTextAttributes(), and KIGFX::GAL::SetTextAttributes().

◆ SetGlyphSize()

void KIGFX::GAL::SetGlyphSize ( const VECTOR2D  aGlyphSize)
inlineinherited

Set the font glyph size.

Parameters
aGlyphSizeis the new font glyph size.

Definition at line 387 of file graphics_abstraction_layer.h.

388  {
389  textProperties.m_glyphSize = aGlyphSize;
390  }
struct KIGFX::GAL::TEXT_PROPERTIES textProperties
VECTOR2D m_glyphSize
Size of the glyphs.

References KIGFX::GAL::TEXT_PROPERTIES::m_glyphSize, and KIGFX::GAL::textProperties.

Referenced by KIGFX::SCH_PAINTER::draw(), KIGFX::GERBVIEW_PAINTER::draw(), KIGFX::PCB_PAINTER::draw(), GraphicTextWidth(), EDA_TEXT::LenSize(), KIGFX::GAL::ResetTextAttributes(), KIGFX::PREVIEW::SetConstantGlyphHeight(), and KIGFX::GAL::SetTextAttributes().

◆ SetGridColor()

void KIGFX::GAL::SetGridColor ( const COLOR4D aGridColor)
inlineinherited

Set the grid color.

Parameters
aGridColoris the grid color, it should have a low alpha value for the best effect.

Definition at line 885 of file graphics_abstraction_layer.h.

886  {
887  gridColor = aGridColor;
888  }
COLOR4D gridColor
Color of the grid.

References KIGFX::GAL::gridColor.

Referenced by KIGFX::CAIRO_GAL_BASE::CAIRO_GAL_BASE(), EDA_DRAW_PANEL_GAL::onPaint(), PCB_LAYER_WIDGET::OnRenderColorChange(), OPENGL_GAL(), SCH_PREVIEW_PANEL::SCH_PREVIEW_PANEL(), GERBVIEW_FRAME::SetGridColor(), PCB_DRAW_PANEL_GAL::UseColorScheme(), and GERBVIEW_FRAME::UseGalCanvas().

◆ SetGridOrigin()

void KIGFX::GAL::SetGridOrigin ( const VECTOR2D aGridOrigin)
inlineinherited

Set the origin point for the grid.

Parameters
aGridOriginis a vector containing the grid origin point, in world coordinates.

Definition at line 846 of file graphics_abstraction_layer.h.

847  {
848  gridOrigin = aGridOrigin;
849 
850  if( gridSize.x == 0.0 || gridSize.y == 0.0 )
851  gridOffset = VECTOR2D(0.0, 0.0);
852  else
853  gridOffset =