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 DrawArcSegment (const VECTOR2D &aCenterPoint, double aRadius, double aStartAngle, double aEndAngle, double aWidth) override
 Draw an arc segment. 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, double aFilterValue=0.0) 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 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, int aMarkupFlags=0)
 Draws a vector type text using preloaded Newstroke font. More...
 
VECTOR2D GetTextLineSize (const UTF8 &aText, int aMarkupFlags=0) 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
 
void SetScaleFactor (double aFactor)
 Set the canvas scale factor, probably for a hi-DPI display. More...
 
double GetScaleFactor () const
 Get the current scale factor. More...
 

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...
 
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...
 
SHADERshader
 There is only one shader used for different objects. 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 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 295 of file opengl_gal.h.

◆ super

typedef GAL KIGFX::OPENGL_GAL::super
private

Super class definition.

Definition at line 281 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 191 of file opengl_gal.cpp.

193  :
194  GAL( aDisplayOptions ),
195  HIDPI_GL_CANVAS( aParent, wxID_ANY, (int*) glAttributes, wxDefaultPosition, wxDefaultSize,
196  wxEXPAND, aName ),
197  mouseListener( aMouseListener ),
198  paintListener( aPaintListener ),
199  currentManager( nullptr ),
200  cachedManager( nullptr ),
201  nonCachedManager( nullptr ),
202  overlayManager( nullptr ),
203  mainBuffer( 0 ),
204  overlayBuffer( 0 ),
205  isContextLocked( false ),
206  lockClientCookie( 0 )
207 {
208 // IsDisplayAttr() handles WX_GL_{MAJOR,MINOR}_VERSION correctly only in 3.0.4
209 // starting with 3.1.0 one should use wxGLContext::IsOk() (done by GL_CONTEXT_MANAGER)
210 #if wxCHECK_VERSION( 3, 0, 3 ) and !wxCHECK_VERSION( 3, 1, 0 )
211  const int attr[] = { WX_GL_MAJOR_VERSION, 2, WX_GL_MINOR_VERSION, 1, 0 };
212 
213  if( !IsDisplaySupported( attr ) )
214  throw std::runtime_error( "OpenGL 2.1 or higher is required!" );
215 #endif /* wxCHECK_VERSION( 3, 0, 3 ) */
216 
217  if( glMainContext == NULL )
218  {
220 
221  if( !glMainContext )
222  throw std::runtime_error( "Could not create the main OpenGL context" );
223 
225  }
226  else
227  {
229 
230  if( !glPrivContext )
231  throw std::runtime_error( "Could not create a private OpenGL context" );
232  }
233 
234  shader = new SHADER();
235  ++instanceCounter;
236 
237  bitmapCache = std::make_unique<GL_BITMAP_CACHE>( );
238 
241 
242  // Initialize the flags
243  isFramebufferInitialized = false;
244  isBitmapFontInitialized = false;
245  isInitialized = false;
246  isGrouping = false;
247  groupCounter = 0;
248 
249  // Connecting the event handlers
250  Connect( wxEVT_PAINT, wxPaintEventHandler( OPENGL_GAL::onPaint ) );
251 
252  // Mouse events are skipped to the parent
253  Connect( wxEVT_MOTION, wxMouseEventHandler( OPENGL_GAL::skipMouseEvent ) );
254  Connect( wxEVT_LEFT_DOWN, wxMouseEventHandler( OPENGL_GAL::skipMouseEvent ) );
255  Connect( wxEVT_LEFT_UP, wxMouseEventHandler( OPENGL_GAL::skipMouseEvent ) );
256  Connect( wxEVT_LEFT_DCLICK, wxMouseEventHandler( OPENGL_GAL::skipMouseEvent ) );
257  Connect( wxEVT_MIDDLE_DOWN, wxMouseEventHandler( OPENGL_GAL::skipMouseEvent ) );
258  Connect( wxEVT_MIDDLE_UP, wxMouseEventHandler( OPENGL_GAL::skipMouseEvent ) );
259  Connect( wxEVT_MIDDLE_DCLICK, wxMouseEventHandler( OPENGL_GAL::skipMouseEvent ) );
260  Connect( wxEVT_RIGHT_DOWN, wxMouseEventHandler( OPENGL_GAL::skipMouseEvent ) );
261  Connect( wxEVT_RIGHT_UP, wxMouseEventHandler( OPENGL_GAL::skipMouseEvent ) );
262  Connect( wxEVT_RIGHT_DCLICK, wxMouseEventHandler( OPENGL_GAL::skipMouseEvent ) );
263  Connect( wxEVT_MOUSEWHEEL, wxMouseEventHandler( OPENGL_GAL::skipMouseEvent ) );
264 #if wxCHECK_VERSION( 3, 1, 0 ) || defined( USE_OSX_MAGNIFY_EVENT )
265  Connect( wxEVT_MAGNIFY, wxMouseEventHandler( OPENGL_GAL::skipMouseEvent ) );
266 #endif
267 #if defined _WIN32 || defined _WIN64
268  Connect( wxEVT_ENTER_WINDOW, wxMouseEventHandler( OPENGL_GAL::skipMouseEvent ) );
269 #endif
270 
271  SetSize( aParent->GetClientSize() );
273 
274  // Grid color settings are different in Cairo and OpenGL
275  SetGridColor( COLOR4D( 0.8, 0.8, 0.8, 0.1 ) );
276  SetAxesColor( COLOR4D( BLUE ) );
277 
278  // Tesselator initialization
279  tesselator = gluNewTess();
281 
282  if( tesselator == NULL )
283  throw std::runtime_error( "Could not create the tesselator" );
284 
285  gluTessProperty( tesselator, GLU_TESS_WINDING_RULE, GLU_TESS_WINDING_POSITIVE );
286 
288 }
Definition: colors.h:57
virtual wxSize GetNativePixelSize() const
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:298
static wxGLContext * glMainContext
Parent OpenGL context.
Definition: opengl_gal.h:286
unsigned int overlayBuffer
Auxiliary rendering target (for menus etc.)
Definition: opengl_gal.h:306
bool isBitmapFontInitialized
Is the shader set to use bitmap fonts?
Definition: opengl_gal.h:315
VERTEX_MANAGER * overlayManager
Container for storing overlaid VERTEX_ITEMs.
Definition: opengl_gal.h:301
GAL_DISPLAY_OPTIONS & options
std::unique_ptr< GL_BITMAP_CACHE > bitmapCache
Definition: opengl_gal.h:325
static void InitTesselatorCallbacks(GLUtesselator *aTesselator)
bool isContextLocked
Used for assertion checking.
Definition: opengl_gal.h:319
SHADER * shader
There is only one shader used for different objects.
Definition: opengl_gal.h:310
VECTOR2< int > VECTOR2I
Definition: vector2d.h:594
bool isGrouping
Was a group started?
Definition: opengl_gal.h:318
OPENGL_ANTIALIASING_MODE gl_antialiasing_mode
VERTEX_MANAGER * nonCachedManager
Container for storing non-cached VERTEX_ITEMs.
Definition: opengl_gal.h:300
Auxiliary rendering target (noncached)
Definition: definitions.h:49
static int instanceCounter
GL GAL instance counter.
Definition: opengl_gal.h:288
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:304
#define NULL
unsigned int mainBuffer
Main rendering target.
Definition: opengl_gal.h:305
wxEvtHandler * mouseListener
Definition: opengl_gal.h:289
void SetAxesColor(const COLOR4D &aAxesColor)
Set the axes color.
static const int glAttributes[]
Definition: opengl_gal.cpp:74
void onPaint(wxPaintEvent &aEvent)
This is the OnPaint event handler.
bool isFramebufferInitialized
Are the framebuffers initialized?
Definition: opengl_gal.h:313
Class SHADER provides the access to the OpenGL shaders.
Definition: shader.h:76
GLUtesselator * tesselator
The tessellator.
Definition: opengl_gal.h:348
VERTEX_MANAGER * cachedManager
Container for storing cached VERTEX_ITEMs.
Definition: opengl_gal.h:299
wxEvtHandler * paintListener
Definition: opengl_gal.h:290
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:316
unsigned int groupCounter
Counter used for generating keys for groups.
Definition: opengl_gal.h:297
VECTOR2I screenSize
Screen size in screen coordinates.
wxGLContext * glPrivContext
Canvas-specific OpenGL context.
Definition: opengl_gal.h:287
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.
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, NULL, 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 291 of file opengl_gal.cpp.

292 {
294 
295  --instanceCounter;
296  glFlush();
297  gluDeleteTess( tesselator );
298  ClearCache();
299 
300  delete compositor;
301 
302  if( isInitialized )
303  {
304  delete cachedManager;
305  delete nonCachedManager;
306  delete overlayManager;
307  }
308 
310 
311  // If it was the main context, then it will be deleted
312  // when the last OpenGL GAL instance is destroyed (a few lines below)
315 
316  delete shader;
317 
318  // Are we destroying the last GAL instance?
319  if( instanceCounter == 0 )
320  {
322 
323  if( isBitmapFontLoaded )
324  {
325  glDeleteTextures( 1, &fontTexture );
326  isBitmapFontLoaded = false;
327  }
328 
332  }
333 }
static wxGLContext * glMainContext
Parent OpenGL context.
Definition: opengl_gal.h:286
static GLuint fontTexture
Bitmap font texture handle (shared)
Definition: opengl_gal.h:292
VERTEX_MANAGER * overlayManager
Container for storing overlaid VERTEX_ITEMs.
Definition: opengl_gal.h:301
SHADER * shader
There is only one shader used for different objects.
Definition: opengl_gal.h:310
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:300
static int instanceCounter
GL GAL instance counter.
Definition: opengl_gal.h:288
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:304
#define NULL
virtual void ClearCache() override
Delete all data created during caching of graphic items.
GLUtesselator * tesselator
The tessellator.
Definition: opengl_gal.h:348
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:299
bool isInitialized
Basic initialization flag, has to be done when the window is visible.
Definition: opengl_gal.h:316
wxGLContext * glPrivContext
Canvas-specific OpenGL context.
Definition: opengl_gal.h:287
void DestroyCtx(wxGLContext *aContext)
Function DestroyCtx destroys a managed OpenGL context.
static bool isBitmapFontLoaded
Is the bitmap font texture loaded?
Definition: opengl_gal.h:314

References cachedManager, ClearCache(), compositor, GL_CONTEXT_MANAGER::DestroyCtx(), fontTexture, GL_CONTEXT_MANAGER::Get(), glMainContext, glPrivContext, instanceCounter, isBitmapFontLoaded, isInitialized, GL_CONTEXT_MANAGER::LockCtx(), nonCachedManager, NULL, 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 1018 of file graphics_abstraction_layer.h.

1019  {
1020  layerDepth -= 0.05;
1021  }
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 377 of file opengl_gal.cpp.

378 {
379 #ifdef __WXDEBUG__
380  PROF_COUNTER totalRealTime( "OPENGL_GAL::beginDrawing()", true );
381 #endif /* __WXDEBUG__ */
382 
383  wxASSERT_MSG( isContextLocked, "GAL_DRAWING_CONTEXT RAII object should have locked context. "
384  "Calling GAL::beginDrawing() directly is not allowed." );
385 
386  wxASSERT_MSG( IsVisible(), "GAL::beginDrawing() must not be entered when GAL is not visible. "
387  "Other drawing routines will expect everything to be initialized "
388  "which will not be the case." );
389 
390  if( !isInitialized )
391  init();
392 
393  // Set up the view port
394  glMatrixMode( GL_PROJECTION );
395  glLoadIdentity();
396 
397  // Create the screen transformation (Do the RH-LH conversion here)
398  glOrtho( 0, (GLint) screenSize.x, (GLsizei) screenSize.y, 0, -depthRange.x, -depthRange.y );
399 
401  {
402  // Prepare rendering target buffers
406 
408  }
409 
410  compositor->Begin();
411 
412  // Disable 2D Textures
413  glDisable( GL_TEXTURE_2D );
414 
415  glShadeModel( GL_FLAT );
416 
417  // Enable the depth buffer
418  glEnable( GL_DEPTH_TEST );
419  glDepthFunc( GL_LESS );
420 
421  // Setup blending, required for transparent objects
422  glEnable( GL_BLEND );
423  glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
424 
425  glMatrixMode( GL_MODELVIEW );
426 
427  // Set up the world <-> screen transformation
429  GLdouble matrixData[16] = { 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1 };
430  matrixData[0] = worldScreenMatrix.m_data[0][0];
431  matrixData[1] = worldScreenMatrix.m_data[1][0];
432  matrixData[2] = worldScreenMatrix.m_data[2][0];
433  matrixData[4] = worldScreenMatrix.m_data[0][1];
434  matrixData[5] = worldScreenMatrix.m_data[1][1];
435  matrixData[6] = worldScreenMatrix.m_data[2][1];
436  matrixData[12] = worldScreenMatrix.m_data[0][2];
437  matrixData[13] = worldScreenMatrix.m_data[1][2];
438  matrixData[14] = worldScreenMatrix.m_data[2][2];
439  glLoadMatrixd( matrixData );
440 
441  // Set defaults
444 
445  // Remove all previously stored items
448 
452 
454  {
455  // Keep bitmap font texture always bound to the second texturing unit
456  const GLint FONT_TEXTURE_UNIT = 2;
457 
458  // Either load the font atlas to video memory, or simply bind it to a texture unit
459  if( !isBitmapFontLoaded )
460  {
461  glActiveTexture( GL_TEXTURE0 + FONT_TEXTURE_UNIT );
462  glGenTextures( 1, &fontTexture );
463  glBindTexture( GL_TEXTURE_2D, fontTexture );
464  glTexImage2D( GL_TEXTURE_2D, 0, GL_RGB8, font_image.width, font_image.height,
465  0, GL_RGB, GL_UNSIGNED_BYTE, font_image.pixels );
466  glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
467  glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
468  checkGlError( "loading bitmap font" );
469 
470  glActiveTexture( GL_TEXTURE0 );
471 
472  isBitmapFontLoaded = true;
473  }
474  else
475  {
476  glActiveTexture( GL_TEXTURE0 + FONT_TEXTURE_UNIT );
477  glBindTexture( GL_TEXTURE_2D, fontTexture );
478  glActiveTexture( GL_TEXTURE0 );
479  }
480 
481  // Set shader parameter
482  GLint ufm_fontTexture = shader->AddParameter( "fontTexture" );
483  GLint ufm_fontTextureWidth = shader->AddParameter( "fontTextureWidth" );
484  ufm_worldPixelSize = shader->AddParameter( "worldPixelSize" );
485  ufm_screenPixelSize = shader->AddParameter( "screenPixelSize" );
486  ufm_pixelSizeMultiplier = shader->AddParameter( "pixelSizeMultiplier" );
487 
488  shader->Use();
489  shader->SetParameter( ufm_fontTexture, (int) FONT_TEXTURE_UNIT );
490  shader->SetParameter( ufm_fontTextureWidth, (int) font_image.width );
491  shader->Deactivate();
492  checkGlError( "setting bitmap font sampler as shader parameter" );
493 
495  }
496 
497  shader->Use();
500  double pixelSizeMultiplier = compositor->GetAntialiasSupersamplingFactor();
501  shader->SetParameter( ufm_pixelSizeMultiplier, (float) pixelSizeMultiplier );
502  shader->Deactivate();
503 
504  // Something betreen BeginDrawing and EndDrawing seems to depend on
505  // this texture unit being active, but it does not assure it itself.
506  glActiveTexture( GL_TEXTURE0 );
507 
508  // Unbind buffers - set compositor for direct drawing
510 
511 #ifdef __WXDEBUG__
512  totalRealTime.Stop();
513  wxLogTrace( "GAL_PROFILE", wxT( "OPENGL_GAL::beginDrawing(): %.1f ms" ), totalRealTime.msecs() );
514 #endif /* __WXDEBUG__ */
515 }
virtual void SetFillColor(const COLOR4D &aColor)
Set the fill color.
int GetAntialiasSupersamplingFactor() const
unsigned int overlayBuffer
Auxiliary rendering target (for menus etc.)
Definition: opengl_gal.h:306
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:315
void Use()
Use the shader.
Definition: shader.h:132
static GLuint fontTexture
Bitmap font texture handle (shared)
Definition: opengl_gal.h:292
VERTEX_MANAGER * overlayManager
Container for storing overlaid VERTEX_ITEMs.
Definition: opengl_gal.h:301
VECTOR2D getScreenPixelSize() const
Definition: opengl_gal.cpp:370
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:319
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
SHADER * shader
There is only one shader used for different objects.
Definition: opengl_gal.h:310
static const unsigned int DIRECT_RENDERING
The class PROF_COUNTER is a small class to help profiling.
Definition: profile.h:44
VERTEX_MANAGER * nonCachedManager
Container for storing non-cached VERTEX_ITEMs.
Definition: opengl_gal.h:300
T m_data[3][3]
Definition: matrix3x3.h:64
double getWorldPixelSize() const
Definition: opengl_gal.cpp:363
void init()
Basic OpenGL initialization.
OPENGL_COMPOSITOR * compositor
Handles multiple rendering targets.
Definition: opengl_gal.h:304
unsigned int mainBuffer
Main rendering target.
Definition: opengl_gal.h:305
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:322
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:313
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:299
virtual void Initialize() override
Function Reset() performs primary initialiation, necessary to use the object.
GLint ufm_worldPixelSize
Definition: opengl_gal.h:321
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:316
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:323
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:314

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 1488 of file opengl_gal.cpp.

1489 {
1490  isGrouping = true;
1491 
1492  std::shared_ptr<VERTEX_ITEM> newItem = std::make_shared<VERTEX_ITEM>( *cachedManager );
1493  int groupNumber = getNewGroupNumber();
1494  groups.insert( std::make_pair( groupNumber, newItem ) );
1495 
1496  return groupNumber;
1497 }
bool isGrouping
Was a group started?
Definition: opengl_gal.h:318
GROUPS_MAP groups
Stores informations about VBO objects (groups)
Definition: opengl_gal.h:296
VERTEX_MANAGER * cachedManager
Container for storing cached VERTEX_ITEMs.
Definition: opengl_gal.h:299
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 577 of file opengl_gal.cpp.

578 {
579  wxASSERT_MSG( isContextLocked, "GAL_UPDATE_CONTEXT RAII object should have locked context. "
580  "Calling this from anywhere else is not allowed." );
581 
582  wxASSERT_MSG( IsVisible(), "GAL::beginUpdate() must not be entered when GAL is not visible. "
583  "Other update routines will expect everything to be initialized "
584  "which will not be the case." );
585 
586  if( !isInitialized )
587  init();
588 
589  cachedManager->Map();
590 }
bool isContextLocked
Used for assertion checking.
Definition: opengl_gal.h:319
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:299
bool isInitialized
Basic initialization flag, has to be done when the window is visible.
Definition: opengl_gal.h:316
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 1118 of file opengl_gal.cpp.

1120 {
1121  wxASSERT_MSG( !IsTextMirrored(), "No support for mirrored text using bitmap fonts." );
1122 
1123  const UTF8 text( aText );
1124  // Compute text size, so it can be properly justified
1125  VECTOR2D textSize;
1126  float commonOffset;
1127  std::tie( textSize, commonOffset ) = computeBitmapTextSize( text );
1128 
1129  const double SCALE = 1.4 * GetGlyphSize().y / textSize.y;
1130  bool overbar = false;
1131 
1132  int overbarLength = 0;
1133  double overbarHeight = textSize.y;
1134 
1135  Save();
1136 
1138  currentManager->Translate( aPosition.x, aPosition.y, layerDepth );
1139  currentManager->Rotate( aRotationAngle, 0.0f, 0.0f, -1.0f );
1140 
1141  double sx = SCALE * ( globalFlipX ? -1.0 : 1.0 );
1142  double sy = SCALE * ( globalFlipY ? -1.0 : 1.0 );
1143 
1144  currentManager->Scale( sx, sy, 0 );
1145  currentManager->Translate( 0, -commonOffset, 0 );
1146 
1147  switch( GetHorizontalJustify() )
1148  {
1150  Translate( VECTOR2D( -textSize.x / 2.0, 0 ) );
1151  break;
1152 
1154  //if( !IsTextMirrored() )
1155  Translate( VECTOR2D( -textSize.x, 0 ) );
1156  break;
1157 
1158  case GR_TEXT_HJUSTIFY_LEFT:
1159  //if( IsTextMirrored() )
1160  //Translate( VECTOR2D( -textSize.x, 0 ) );
1161  break;
1162  }
1163 
1164  switch( GetVerticalJustify() )
1165  {
1166  case GR_TEXT_VJUSTIFY_TOP:
1167  Translate( VECTOR2D( 0, -textSize.y ) );
1168  overbarHeight = -textSize.y / 2.0;
1169  break;
1170 
1172  Translate( VECTOR2D( 0, -textSize.y / 2.0 ) );
1173  overbarHeight = 0;
1174  break;
1175 
1177  break;
1178  }
1179 
1180  int i = 0;
1181 
1182  for( UTF8::uni_iter chIt = text.ubegin(), end = text.uend(); chIt < end; ++chIt )
1183  {
1184  unsigned int c = *chIt;
1185  wxASSERT_MSG( c != '\n' && c != '\r', wxT( "No support for multiline bitmap text yet" ) );
1186 
1187  bool wasOverbar = overbar;
1188 
1189  if( c == '~' )
1190  {
1191  if( ++chIt == end )
1192  break;
1193 
1194  c = *chIt;
1195 
1196  if( c == '~' )
1197  {
1198  // double ~ is really a ~ so go ahead and process the second one
1199 
1200  // so what's a triple ~? It could be a real ~ followed by an overbar, or
1201  // it could be an overbar followed by a real ~. The old algorithm did the
1202  // later so we will too....
1203  auto tempIt = chIt;
1204 
1205  if( ++tempIt < end && *tempIt == '~' )
1206  {
1207  // eat the first two, toggle overbar, and then process the third
1208  ++chIt;
1209  overbar = !overbar;
1210  }
1211  }
1212  else
1213  {
1214  overbar = !overbar;
1215  }
1216  }
1217 
1218  if( wasOverbar && !overbar )
1219  {
1220  drawBitmapOverbar( overbarLength, overbarHeight );
1221  overbarLength = 0;
1222  }
1223 
1224  if( overbar )
1225  overbarLength += drawBitmapChar( c );
1226  else
1227  drawBitmapChar( c );
1228 
1229  ++i;
1230  }
1231 
1232  // Handle the case when overbar is active till the end of the drawn text
1233  currentManager->Translate( 0, commonOffset, 0 );
1234 
1235  if( overbar && overbarLength > 0 )
1236  drawBitmapOverbar( overbarLength, overbarHeight );
1237 
1238  Restore();
1239 }
UTF8 is an 8 bit string that is assuredly encoded in UTF8, and supplies special conversion support to...
Definition: utf8.h:73
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:298
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:302
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:303
const VECTOR2D & GetGlyphSize() const
virtual void Save() override
Save the context.
double a
Alpha component.
Definition: color4d.h:304
VECTOR2< double > VECTOR2D
Definition: vector2d.h:593
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.
uni_iter is a non-mutating iterator that walks through unicode code points in the UTF8 encoded string...
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.
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:301
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, KIGFX::GAL::IsTextMirrored(), KIGFX::GAL::layerDepth, KIGFX::COLOR4D::r, Restore(), KIGFX::VERTEX_MANAGER::Rotate(), Save(), KIGFX::VERTEX_MANAGER::Scale(), KIGFX::GAL::strokeColor, Translate(), KIGFX::VERTEX_MANAGER::Translate(), UTF8::ubegin(), UTF8::uend(), VECTOR2< T >::x, and VECTOR2< T >::y.

◆ blitCursor()

void OPENGL_GAL::blitCursor ( )
private

Blits cursor into the current screen.

Definition at line 1945 of file opengl_gal.cpp.

1946 {
1947  if( !IsCursorEnabled() )
1948  return;
1949 
1951 
1952  const int cursorSize = fullscreenCursor ? 8000 : 80;
1953 
1954  VECTOR2D cursorBegin = cursorPosition - cursorSize / ( 2 * worldScale );
1955  VECTOR2D cursorEnd = cursorPosition + cursorSize / ( 2 * worldScale );
1956  VECTOR2D cursorCenter = ( cursorBegin + cursorEnd ) / 2;
1957 
1958  const COLOR4D cColor = getCursorColor();
1959  const COLOR4D color( cColor.r * cColor.a, cColor.g * cColor.a,
1960  cColor.b * cColor.a, 1.0 );
1961 
1962  glActiveTexture( GL_TEXTURE0 );
1963  glDisable( GL_TEXTURE_2D );
1964  glLineWidth( 1.0 );
1965  glColor4d( color.r, color.g, color.b, color.a );
1966 
1967  glBegin( GL_LINES );
1968  glVertex2d( cursorCenter.x, cursorBegin.y );
1969  glVertex2d( cursorCenter.x, cursorEnd.y );
1970 
1971  glVertex2d( cursorBegin.x, cursorCenter.y );
1972  glVertex2d( cursorEnd.x, cursorCenter.y );
1973  glEnd();
1974 }
VECTOR2D cursorPosition
Current cursor position (world coordinates)
int color
Definition: DXF_plotter.cpp:61
double g
Green component.
Definition: color4d.h:302
static const unsigned int DIRECT_RENDERING
double b
Blue component.
Definition: color4d.h:303
double a
Alpha component.
Definition: color4d.h:304
OPENGL_COMPOSITOR * compositor
Handles multiple rendering targets.
Definition: opengl_gal.h:304
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:301
bool IsCursorEnabled() const
Returns information about cursor visibility.
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 471 of file opengl_gal.h.

472  {
473  // Bigger arcs need smaller alpha increment to make them look smooth
474  return std::min( 1e6 / aRadius, 2.0 * M_PI / CIRCLE_POINTS );
475  }
CIRCLE_POINTS

Referenced by DrawArc(), and DrawArcSegment().

◆ 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 1514 of file opengl_gal.cpp.

1515 {
1516  if( groups[aGroupNumber] )
1517  cachedManager->ChangeItemColor( *groups[aGroupNumber], aNewColor );
1518 }
GROUPS_MAP groups
Stores informations about VBO objects (groups)
Definition: opengl_gal.h:296
VERTEX_MANAGER * cachedManager
Container for storing cached VERTEX_ITEMs.
Definition: opengl_gal.h:299
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 1521 of file opengl_gal.cpp.

1522 {
1523  if( groups[aGroupNumber] )
1524  cachedManager->ChangeItemDepth( *groups[aGroupNumber], aDepth );
1525 }
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:296
VERTEX_MANAGER * cachedManager
Container for storing cached VERTEX_ITEMs.
Definition: opengl_gal.h:299

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 1535 of file opengl_gal.cpp.

1536 {
1537  bitmapCache = std::make_unique<GL_BITMAP_CACHE>( );
1538 
1539  groups.clear();
1540 
1541  if( isInitialized )
1542  cachedManager->Clear();
1543 }
std::unique_ptr< GL_BITMAP_CACHE > bitmapCache
Definition: opengl_gal.h:325
GROUPS_MAP groups
Stores informations about VBO objects (groups)
Definition: opengl_gal.h:296
VERTEX_MANAGER * cachedManager
Container for storing cached VERTEX_ITEMs.
Definition: opengl_gal.h:299
bool isInitialized
Basic initialization flag, has to be done when the window is visible.
Definition: opengl_gal.h:316
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 1430 of file opengl_gal.cpp.

1431 {
1432  // Clear screen
1434  // NOTE: Black used here instead of m_clearColor; it will be composited later
1435  glClearColor( 0, 0, 0, 1 );
1436  glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT );
1437 }
static const unsigned int DIRECT_RENDERING
OPENGL_COMPOSITOR * compositor
Handles multiple rendering targets.
Definition: opengl_gal.h:304
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 1574 of file opengl_gal.cpp.

1575 {
1576  // Save the current state
1577  unsigned int oldTarget = compositor->GetBuffer();
1578 
1579  switch( aTarget )
1580  {
1581  // Cached and noncached items are rendered to the same buffer
1582  default:
1583  case TARGET_CACHED:
1584  case TARGET_NONCACHED:
1586  break;
1587 
1588  case TARGET_OVERLAY:
1590  break;
1591  }
1592 
1593 
1594  if( aTarget != TARGET_OVERLAY )
1596  else
1598 
1599  // Restore the previous state
1600  compositor->SetBuffer( oldTarget );
1601 }
unsigned int overlayBuffer
Auxiliary rendering target (for menus etc.)
Definition: opengl_gal.h:306
Auxiliary rendering target (noncached)
Definition: definitions.h:49
static const COLOR4D BLACK
Definition: color4d.h:311
OPENGL_COMPOSITOR * compositor
Handles multiple rendering targets.
Definition: opengl_gal.h:304
unsigned int mainBuffer
Main rendering target.
Definition: opengl_gal.h:305
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 1895 of file opengl_gal.cpp.

1896 {
1897  VECTOR2D textSize( 0, 0 );
1898  float commonOffset = std::numeric_limits<float>::max();
1899  static const auto defaultGlyph = LookupGlyph( '(' ); // for strange chars
1900 
1901  for( UTF8::uni_iter chIt = aText.ubegin(), end = aText.uend(); chIt < end; ++chIt )
1902  {
1903  unsigned int c = *chIt;
1904 
1905  const FONT_GLYPH_TYPE* glyph = LookupGlyph( c );
1906  // Debug: show not coded char in the atlas
1907  // Be carefull before allowing the assert: it usually crash kicad
1908  // when the assert is made during a paint event.
1909  // wxASSERT_MSG( glyph, wxString::Format( "missing char in font: code 0x%x <%c>", c, c ) );
1910 
1911  if( !glyph || // Not coded in font
1912  c == '-' || c == '_' ) // Strange size of these 2 chars
1913  {
1914  glyph = defaultGlyph;
1915  }
1916 
1917  if( glyph )
1918  {
1919  textSize.x += glyph->advance;
1920  }
1921  }
1922 
1923  textSize.y = std::max<float>( textSize.y, font_information.max_y - defaultGlyph->miny );
1924  commonOffset = std::min<float>( font_information.max_y - defaultGlyph->maxy, commonOffset );
1925  textSize.y -= commonOffset;
1926 
1927  return std::make_pair( textSize, commonOffset );
1928 }
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
uni_iter is a non-mutating iterator that walks through unicode code points in the UTF8 encoded string...
Definition: utf8.h:207

References KIGFX::BUILTIN_FONT::FONT_GLYPH_TYPE::advance, KIGFX::BUILTIN_FONT::font_information, KIGFX::BUILTIN_FONT::LookupGlyph(), 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 210 of file graphics_abstraction_layer.cpp.

211 {
212  // just return the current value. This could be cleverer and take
213  // into account other settings in future
214  return gridMinSpacing;
215 }
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 1120 of file graphics_abstraction_layer.h.

1121  {
1123  }
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 2118 of file opengl_gal.cpp.

2119 {
2120  auto pixelSize = worldScale;
2121 
2122  lookAtPoint.x = roundr( lookAtPoint.x, pixelSize );
2123  lookAtPoint.y = roundr( lookAtPoint.y, pixelSize );
2124 
2126 }
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 1528 of file opengl_gal.cpp.

1529 {
1530  // Frees memory in the container as well
1531  groups.erase( aGroupNumber );
1532 }
GROUPS_MAP groups
Stores informations about VBO objects (groups)
Definition: opengl_gal.h:296

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 712 of file opengl_gal.cpp.

714 {
715  if( aRadius <= 0 )
716  return;
717 
718  // Swap the angles, if start angle is greater than end angle
719  SWAP( aStartAngle, >, aEndAngle );
720 
721  const double alphaIncrement = calcAngleStep( aRadius );
722 
723  Save();
724  currentManager->Translate( aCenterPoint.x, aCenterPoint.y, 0.0 );
725 
726  if( isFillEnabled )
727  {
728  double alpha;
731 
732  // Triangle fan
733  for( alpha = aStartAngle; ( alpha + alphaIncrement ) < aEndAngle; )
734  {
735  currentManager->Reserve( 3 );
736  currentManager->Vertex( 0.0, 0.0, layerDepth );
737  currentManager->Vertex( cos( alpha ) * aRadius, sin( alpha ) * aRadius, layerDepth );
738  alpha += alphaIncrement;
739  currentManager->Vertex( cos( alpha ) * aRadius, sin( alpha ) * aRadius, layerDepth );
740  }
741 
742  // The last missing triangle
743  const VECTOR2D endPoint( cos( aEndAngle ) * aRadius, sin( aEndAngle ) * aRadius );
744 
745  currentManager->Reserve( 3 );
746  currentManager->Vertex( 0.0, 0.0, layerDepth );
747  currentManager->Vertex( cos( alpha ) * aRadius, sin( alpha ) * aRadius, layerDepth );
748  currentManager->Vertex( endPoint.x, endPoint.y, layerDepth );
749  }
750 
751  if( isStrokeEnabled )
752  {
754 
755  VECTOR2D p( cos( aStartAngle ) * aRadius, sin( aStartAngle ) * aRadius );
756  double alpha;
757 
758  for( alpha = aStartAngle + alphaIncrement; alpha <= aEndAngle; alpha += alphaIncrement )
759  {
760  VECTOR2D p_next( cos( alpha ) * aRadius, sin( alpha ) * aRadius );
761  DrawLine( p, p_next );
762 
763  p = p_next;
764  }
765 
766  // Draw the last missing part
767  if( alpha != aEndAngle )
768  {
769  VECTOR2D p_last( cos( aEndAngle ) * aRadius, sin( aEndAngle ) * aRadius );
770  DrawLine( p, p_last );
771  }
772  }
773 
774  Restore();
775 }
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:298
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:302
COLOR4D fillColor
The fill color.
double b
Blue component.
Definition: color4d.h:303
virtual void Save() override
Save the context.
double a
Alpha component.
Definition: color4d.h:304
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:471
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:602
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:301

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.

◆ DrawArcSegment()

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

Draw an arc segment.

This method differs from DrawArc() in what happens when fill/stroke are on or off. DrawArc() draws a "pie piece" when fill is turned on, and a thick stroke when fill is off. DrawArcSegment() with fill on behaves like DrawArc() with fill off. DrawArcSegment() with fill off draws the outline of what it would have drawn with fill on.

TODO: Unify Arc routines

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.
aWidthis the thickness of the arc (pen size).

Reimplemented from KIGFX::GAL.

Definition at line 778 of file opengl_gal.cpp.

780 {
781  if( aRadius <= 0 )
782  {
783  // Arcs of zero radius are a circle of aWidth diameter
784  if( aWidth > 0 )
785  DrawCircle( aCenterPoint, aWidth / 2.0 );
786 
787  return;
788  }
789 
790  // Swap the angles, if start angle is greater than end angle
791  SWAP( aStartAngle, >, aEndAngle );
792 
793  const double alphaIncrement = calcAngleStep( aRadius );
794 
795  Save();
796  currentManager->Translate( aCenterPoint.x, aCenterPoint.y, 0.0 );
797 
798  if( isStrokeEnabled )
799  {
801 
802  double width = aWidth / 2.0;
803  VECTOR2D startPoint( cos( aStartAngle ) * aRadius,
804  sin( aStartAngle ) * aRadius );
805  VECTOR2D endPoint( cos( aEndAngle ) * aRadius,
806  sin( aEndAngle ) * aRadius );
807 
808  drawStrokedSemiCircle( startPoint, width, aStartAngle + M_PI );
809  drawStrokedSemiCircle( endPoint, width, aEndAngle );
810 
811  VECTOR2D pOuter( cos( aStartAngle ) * ( aRadius + width ),
812  sin( aStartAngle ) * ( aRadius + width ) );
813 
814  VECTOR2D pInner( cos( aStartAngle ) * ( aRadius - width ),
815  sin( aStartAngle ) * ( aRadius - width ) );
816 
817  double alpha;
818 
819  for( alpha = aStartAngle + alphaIncrement; alpha <= aEndAngle; alpha += alphaIncrement )
820  {
821  VECTOR2D pNextOuter( cos( alpha ) * ( aRadius + width ),
822  sin( alpha ) * ( aRadius + width ) );
823  VECTOR2D pNextInner( cos( alpha ) * ( aRadius - width ),
824  sin( alpha ) * ( aRadius - width ) );
825 
826  DrawLine( pOuter, pNextOuter );
827  DrawLine( pInner, pNextInner );
828 
829  pOuter = pNextOuter;
830  pInner = pNextInner;
831  }
832 
833  // Draw the last missing part
834  if( alpha != aEndAngle )
835  {
836  VECTOR2D pLastOuter( cos( aEndAngle ) * ( aRadius + width ),
837  sin( aEndAngle ) * ( aRadius + width ) );
838  VECTOR2D pLastInner( cos( aEndAngle ) * ( aRadius - width ),
839  sin( aEndAngle ) * ( aRadius - width ) );
840 
841  DrawLine( pOuter, pLastOuter );
842  DrawLine( pInner, pLastInner );
843  }
844  }
845 
846  if( isFillEnabled )
847  {
849  SetLineWidth( aWidth );
850 
851  VECTOR2D p( cos( aStartAngle ) * aRadius, sin( aStartAngle ) * aRadius );
852  double alpha;
853 
854  for( alpha = aStartAngle + alphaIncrement; alpha <= aEndAngle; alpha += alphaIncrement )
855  {
856  VECTOR2D p_next( cos( alpha ) * aRadius, sin( alpha ) * aRadius );
857  DrawLine( p, p_next );
858 
859  p = p_next;
860  }
861 
862  // Draw the last missing part
863  if( alpha != aEndAngle )
864  {
865  VECTOR2D p_last( cos( aEndAngle ) * aRadius, sin( aEndAngle ) * aRadius );
866  DrawLine( p, p_last );
867  }
868  }
869 
870  Restore();
871 }
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:298
virtual void Restore() override
Restore the context.
double g
Green component.
Definition: color4d.h:302
COLOR4D fillColor
The fill color.
virtual void SetLineWidth(float aLineWidth)
Set the line width.
double b
Blue component.
Definition: color4d.h:303
virtual void Save() override
Save the context.
double a
Alpha component.
Definition: color4d.h:304
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:471
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:602
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 ?
#define SWAP(varA, condition, varB)
Swap the variables if a condition is met.
Definition: definitions.h:31
double r
Red component.
Definition: color4d.h:301
virtual void DrawCircle(const VECTOR2D &aCenterPoint, double aRadius) override
Draw a circle using world coordinates.
Definition: opengl_gal.cpp:656

References KIGFX::COLOR4D::a, KIGFX::COLOR4D::b, calcAngleStep(), KIGFX::VERTEX_MANAGER::Color(), currentManager, DrawCircle(), DrawLine(), drawStrokedSemiCircle(), KIGFX::GAL::fillColor, KIGFX::COLOR4D::g, KIGFX::GAL::isFillEnabled, KIGFX::GAL::isStrokeEnabled, KIGFX::COLOR4D::r, Restore(), Save(), KIGFX::GAL::SetLineWidth(), KIGFX::GAL::strokeColor, SWAP, KIGFX::VERTEX_MANAGER::Translate(), 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 1063 of file opengl_gal.cpp.

1064 {
1065  // We have to calculate the pixel size in users units to draw the image.
1066  // worldUnitLength is a factor used for converting IU to inches
1067  double scale = 1.0 / ( aBitmap.GetPPI() * worldUnitLength );
1068  double w = (double) aBitmap.GetSizePixels().x * scale;
1069  double h = (double) aBitmap.GetSizePixels().y * scale;
1070 
1071  auto xform = currentManager->GetTransformation();
1072 
1073  glm::vec4 v0 = xform * glm::vec4( -w/2, -h/2, 0.0, 0.0 );
1074  glm::vec4 v1 = xform * glm::vec4( w/2, h/2, 0.0, 0.0 );
1075  glm::vec4 trans = xform[3];
1076 
1077  auto texture_id = bitmapCache->RequestBitmap( &aBitmap );
1078 
1079  if( !glIsTexture( texture_id ) ) // ensure the bitmap texture is still valid
1080  return;
1081 
1082  auto oldTarget = GetTarget();
1083 
1084  glPushMatrix();
1085  glTranslated( trans.x, trans.y, trans.z );
1086 
1088  glEnable(GL_TEXTURE_2D);
1089  glActiveTexture( GL_TEXTURE0 );
1090  glBindTexture( GL_TEXTURE_2D, texture_id );
1091 
1092  glBegin( GL_QUADS );
1093  glColor4f( 1.0, 1.0, 1.0, 1.0 );
1094  glTexCoord2f( 0.0, 0.0 );
1095  glVertex3f( v0.x, v0.y, layerDepth );
1096  glColor4f( 1.0, 1.0, 1.0, 1.0 );
1097  glTexCoord2f( 1.0, 0.0 );
1098  glVertex3f( v1.x, v0.y, layerDepth );
1099  glColor4f( 1.0, 1.0, 1.0, 1.0 );
1100  glTexCoord2f( 1.0, 1.0 );
1101  glVertex3f( v1.x, v1.y, layerDepth );
1102  glColor4f( 1.0, 1.0, 1.0, 1.0 );
1103  glTexCoord2f( 0.0, 1.0 );
1104  glVertex3f( v0.x, v1.y, layerDepth );
1105  glEnd();
1106 
1107  SetTarget( oldTarget );
1108  glBindTexture( GL_TEXTURE_2D, 0 );
1109 
1110 #ifdef DISABLE_BITMAP_CACHE
1111  glDeleteTextures( 1, &texture_id );
1112 #endif
1113 
1114  glPopMatrix();
1115 }
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:298
const glm::mat4 & GetTransformation() const
double layerDepth
The actual layer depth.
std::unique_ptr< GL_BITMAP_CACHE > bitmapCache
Definition: opengl_gal.h:325
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:141
int GetPPI() const
Definition: bitmap_base.h:153

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 1794 of file opengl_gal.cpp.

1795 {
1796  const float TEX_X = font_image.width;
1797  const float TEX_Y = font_image.height;
1798 
1799  // handle space
1800  if( aChar == ' ' )
1801  {
1802  const FONT_GLYPH_TYPE* g = LookupGlyph( 'x' );
1803  wxASSERT( g );
1804  Translate( VECTOR2D( g->advance, 0 ) );
1805  return g->advance;
1806  }
1807 
1808  const FONT_GLYPH_TYPE* glyph = LookupGlyph( aChar );
1809 
1810  // If the glyph is not found (happens for many esotheric unicode chars)
1811  // shows a '?' instead.
1812  if( !glyph )
1813  glyph = LookupGlyph( '?' );
1814 
1815  if( !glyph ) // Should not happen.
1816  return 0;
1817 
1818  const float X = glyph->atlas_x + font_information.smooth_pixels;
1819  const float Y = glyph->atlas_y + font_information.smooth_pixels;
1820  const float XOFF = glyph->minx;
1821 
1822  // adjust for height rounding
1823  const float round_adjust = ( glyph->maxy - glyph->miny )
1824  - float( glyph->atlas_h - font_information.smooth_pixels * 2 );
1825  const float top_adjust = font_information.max_y - glyph->maxy;
1826  const float YOFF = round_adjust + top_adjust;
1827  const float W = glyph->atlas_w - font_information.smooth_pixels *2;
1828  const float H = glyph->atlas_h - font_information.smooth_pixels *2;
1829  const float B = 0;
1830 
1831  currentManager->Reserve( 6 );
1832  Translate( VECTOR2D( XOFF, YOFF ) );
1833  /* Glyph:
1834  * v0 v1
1835  * +--+
1836  * | /|
1837  * |/ |
1838  * +--+
1839  * v2 v3
1840  */
1841  currentManager->Shader( SHADER_FONT, X / TEX_X, ( Y + H ) / TEX_Y );
1842  currentManager->Vertex( -B, -B, 0 ); // v0
1843 
1844  currentManager->Shader( SHADER_FONT, ( X + W ) / TEX_X, ( Y + H ) / TEX_Y );
1845  currentManager->Vertex( W + B, -B, 0 ); // v1
1846 
1847  currentManager->Shader( SHADER_FONT, X / TEX_X, Y / TEX_Y );
1848  currentManager->Vertex( -B, H + B, 0 ); // v2
1849 
1850 
1851  currentManager->Shader( SHADER_FONT, ( X + W ) / TEX_X, ( Y + H ) / TEX_Y );
1852  currentManager->Vertex( W + B, -B, 0 ); // v1
1853 
1854  currentManager->Shader( SHADER_FONT, X / TEX_X, Y / TEX_Y );
1855  currentManager->Vertex( -B, H + B, 0 ); // v2
1856 
1857  currentManager->Shader( SHADER_FONT, ( X + W ) / TEX_X, Y / TEX_Y );
1858  currentManager->Vertex( W + B, H + B, 0 ); // v3
1859 
1860  Translate( VECTOR2D( -XOFF + glyph->advance, -YOFF ) );
1861 
1862  return glyph->advance;
1863 }
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:298
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:593
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 1866 of file opengl_gal.cpp.

1867 {
1868  // To draw an overbar, simply draw an overbar
1869  const FONT_GLYPH_TYPE* glyph = LookupGlyph( '_' );
1870  wxCHECK( glyph, /* void */ );
1871 
1872  const float H = glyph->maxy - glyph->miny;
1873 
1874  Save();
1875 
1876  Translate( VECTOR2D( -aLength, -aHeight-1.5*H ) );
1877 
1878  currentManager->Reserve( 6 );
1880 
1881  currentManager->Shader( 0 );
1882 
1883  currentManager->Vertex( 0, 0, 0 ); // v0
1884  currentManager->Vertex( aLength, 0, 0 ); // v1
1885  currentManager->Vertex( 0, H, 0 ); // v2
1886 
1887  currentManager->Vertex( aLength, 0, 0 ); // v1
1888  currentManager->Vertex( 0, H, 0 ); // v2
1889  currentManager->Vertex( aLength, H, 0 ); // v3
1890 
1891  Restore();
1892 }
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:298
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:302
const FONT_GLYPH_TYPE * LookupGlyph(unsigned int aCodepoint)
double b
Blue component.
Definition: color4d.h:303
virtual void Save() override
Save the context.
VECTOR2< double > VECTOR2D
Definition: vector2d.h:593
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:301

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 656 of file opengl_gal.cpp.

657 {
658  if( isFillEnabled )
659  {
660  currentManager->Reserve( 3 );
662 
663  /* Draw a triangle that contains the circle, then shade it leaving only the circle.
664  * Parameters given to Shader() are indices of the triangle's vertices
665  * (if you want to understand more, check the vertex shader source [shader.vert]).
666  * Shader uses this coordinates to determine if fragments are inside the circle or not.
667  * Does the calculations in the vertex shader now (pixel alignment)
668  * v2
669  * /\
670  * //\\
671  * v0 /_\/_\ v1
672  */
673  currentManager->Shader( SHADER_FILLED_CIRCLE, 1.0, aRadius );
674  currentManager->Vertex( aCenterPoint.x, aCenterPoint.y, layerDepth );
675 
676  currentManager->Shader( SHADER_FILLED_CIRCLE, 2.0, aRadius );
677  currentManager->Vertex( aCenterPoint.x, aCenterPoint.y, layerDepth );
678 
679  currentManager->Shader( SHADER_FILLED_CIRCLE, 3.0, aRadius );
680  currentManager->Vertex( aCenterPoint.x, aCenterPoint.y, layerDepth );
681  }
682  if( isStrokeEnabled )
683  {
684  currentManager->Reserve( 3 );
686 
687  /* Draw a triangle that contains the circle, then shade it leaving only the circle.
688  * Parameters given to Shader() are indices of the triangle's vertices
689  * (if you want to understand more, check the vertex shader source [shader.vert]).
690  * and the line width. Shader uses this coordinates to determine if fragments are
691  * inside the circle or not.
692  * v2
693  * /\
694  * //\\
695  * v0 /_\/_\ v1
696  */
698  currentManager->Vertex( aCenterPoint.x, // v0
699  aCenterPoint.y, layerDepth );
700 
702  currentManager->Vertex( aCenterPoint.x, // v1
703  aCenterPoint.y, layerDepth );
704 
706  currentManager->Vertex( aCenterPoint.x, aCenterPoint.y, // v2
707  layerDepth );
708  }
709 }
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:298
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:302
COLOR4D fillColor
The fill color.
double b
Blue component.
Definition: color4d.h:303
double a
Alpha component.
Definition: color4d.h:304
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:301

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 DrawArcSegment(), and 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 1604 of file opengl_gal.cpp.

1605 {
1606  // Now we should only store the position of the mouse cursor
1607  // The real drawing routines are in blitCursor()
1608  //VECTOR2D screenCursor = worldScreenMatrix * aCursorPosition;
1609  //cursorPosition = screenWorldMatrix * VECTOR2D( screenCursor.x, screenCursor.y );
1610  cursorPosition = aCursorPosition;
1611 }
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,
double  aFilterValue = 0.0 
)
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.
aFilterValueis used by Bezier to segments approximation, if the Bezier curve is not supported and needs a curve to polyline conversion. aFilterValue = 0 means no filtering.

Reimplemented from KIGFX::GAL.

Definition at line 1044 of file opengl_gal.cpp.

1047 {
1048  std::vector<VECTOR2D> output;
1049  std::vector<VECTOR2D> pointCtrl;
1050 
1051  pointCtrl.push_back( aStartPoint );
1052  pointCtrl.push_back( aControlPointA );
1053  pointCtrl.push_back( aControlPointB );
1054  pointCtrl.push_back( aEndPoint );
1055 
1056  BEZIER_POLY converter( pointCtrl );
1057  converter.GetPoly( output, aFilterValue );
1058 
1059  DrawPolyline( &output[0], output.size() );
1060 }
virtual void DrawPolyline(const std::deque< VECTOR2D > &aPointList) override
Draw a polyline.
Definition: opengl_gal.cpp:912
Bezier curves to polygon converter.
Definition: bezier_curves.h:35

References DrawPolyline(), and BEZIER_POLY::GetPoly().

◆ 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 1675 of file opengl_gal.cpp.

1677 {
1678  Save();
1679 
1680  currentManager->Reserve( 3 );
1681  currentManager->Translate( aCenterPoint.x, aCenterPoint.y, 0.0f );
1682  currentManager->Rotate( aAngle, 0.0f, 0.0f, 1.0f );
1683 
1684  /* Draw a triangle that contains the semicircle, then shade it to leave only
1685  * the semicircle. Parameters given to Shader() are indices of the triangle's vertices
1686  * (if you want to understand more, check the vertex shader source [shader.vert]).
1687  * Shader uses these coordinates to determine if fragments are inside the semicircle or not.
1688  * v2
1689  * /\
1690  * /__\
1691  * v0 //__\\ v1
1692  */
1694  currentManager->Vertex( -aRadius * 3.0f / sqrt( 3.0f ), 0.0f, layerDepth ); // v0
1695 
1697  currentManager->Vertex( aRadius * 3.0f / sqrt( 3.0f ), 0.0f, layerDepth ); // v1
1698 
1700  currentManager->Vertex( 0.0f, aRadius * 2.0f, layerDepth ); // v2
1701 
1702  Restore();
1703 }
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:298
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 1242 of file opengl_gal.cpp.

1243 {
1246 
1248 
1249  // sub-pixel lines all render the same
1250  float minorLineWidth =
1251  std::fmax( 1.0f, gridLineWidth ) * getWorldPixelSize() / GetBackingScaleFactor();
1252  float majorLineWidth = minorLineWidth * 2.0f;
1253 
1254  // Draw the axis and grid
1255  // For the drawing the start points, end points and increments have
1256  // to be calculated in world coordinates
1257  VECTOR2D worldStartPoint = screenWorldMatrix * VECTOR2D( 0.0, 0.0 );
1258  VECTOR2D worldEndPoint = screenWorldMatrix * VECTOR2D( screenSize );
1259 
1260  // Draw axes if desired
1261  if( axesEnabled )
1262  {
1263  SetLineWidth( minorLineWidth );
1265 
1266  DrawLine( VECTOR2D( worldStartPoint.x, 0 ), VECTOR2D( worldEndPoint.x, 0 ) );
1267  DrawLine( VECTOR2D( 0, worldStartPoint.y ), VECTOR2D( 0, worldEndPoint.y ) );
1268  }
1269 
1270  // force flush
1272 
1273  if( !gridVisibility || gridSize.x == 0 || gridSize.y == 0 )
1274  return;
1275 
1276  VECTOR2D gridScreenSize( gridSize );
1277 
1278  double gridThreshold = computeMinGridSpacing() / worldScale;
1279 
1281  gridThreshold *= 2.0;
1282 
1283  // If we cannot display the grid density, scale down by a tick size and
1284  // try again. Eventually, we get some representation of the grid
1285  while( std::min( gridScreenSize.x, gridScreenSize.y ) <= gridThreshold )
1286  {
1287  gridScreenSize = gridScreenSize * static_cast<double>( gridTick );
1288  }
1289 
1290  // Compute grid starting and ending indexes to draw grid points on the
1291  // visible screen area
1292  // Note: later any point coordinate will be offsetted by gridOrigin
1293  int gridStartX = KiROUND( ( worldStartPoint.x - gridOrigin.x ) / gridScreenSize.x );
1294  int gridEndX = KiROUND( ( worldEndPoint.x - gridOrigin.x ) / gridScreenSize.x );
1295  int gridStartY = KiROUND( ( worldStartPoint.y - gridOrigin.y ) / gridScreenSize.y );
1296  int gridEndY = KiROUND( ( worldEndPoint.y - gridOrigin.y ) / gridScreenSize.y );
1297 
1298  // Ensure start coordinate > end coordinate
1299  SWAP( gridStartX, >, gridEndX );
1300  SWAP( gridStartY, >, gridEndY );
1301 
1302  // Ensure the grid fills the screen
1303  --gridStartX; ++gridEndX;
1304  --gridStartY; ++gridEndY;
1305 
1306  glDisable( GL_DEPTH_TEST );
1307  glDisable( GL_TEXTURE_2D );
1308 
1309  if( gridStyle == GRID_STYLE::DOTS )
1310  {
1311  glEnable( GL_STENCIL_TEST );
1312  glStencilFunc( GL_ALWAYS, 1, 1 );
1313  glStencilOp( GL_KEEP, GL_KEEP, GL_INCR );
1314  glColor4d( 0.0, 0.0, 0.0, 0.0 );
1315  SetStrokeColor( COLOR4D( 0.0, 0.0, 0.0, 0.0 ) );
1316  }
1317  else
1318  {
1319  glColor4d( gridColor.r, gridColor.g, gridColor.b, gridColor.a );
1321  }
1322 
1324  {
1325 
1326  // Vertical positions
1327  for( int j = gridStartY; j <= gridEndY; j++ )
1328  {
1329  bool tickY = ( j % gridTick == 0 );
1330  const double posY = j * gridScreenSize.y + gridOrigin.y;
1331 
1332  // Horizontal positions
1333  for( int i = gridStartX; i <= gridEndX; i++ )
1334  {
1335  bool tickX = ( i % gridTick == 0 );
1336  SetLineWidth( ( ( tickX && tickY ) ? majorLineWidth : minorLineWidth ) );
1337  auto lineLen = 2.0 * GetLineWidth();
1338  auto posX = i * gridScreenSize.x + gridOrigin.x;
1339 
1340  DrawLine( VECTOR2D( posX - lineLen, posY ), VECTOR2D( posX + lineLen, posY ) );
1341  DrawLine( VECTOR2D( posX, posY - lineLen ), VECTOR2D( posX, posY + lineLen ) );
1342  }
1343  }
1344 
1346  }
1347  else
1348  {
1349  // Vertical lines
1350  for( int j = gridStartY; j <= gridEndY; j++ )
1351  {
1352  const double y = j * gridScreenSize.y + gridOrigin.y;
1353 
1354  // If axes are drawn, skip the lines that would cover them
1355  if( axesEnabled && y == 0.0 )
1356  continue;
1357 
1358  SetLineWidth( ( j % gridTick == 0 ) ? majorLineWidth : minorLineWidth );
1359  VECTOR2D a ( gridStartX * gridScreenSize.x + gridOrigin.x, y );
1360  VECTOR2D b ( gridEndX * gridScreenSize.x + gridOrigin.x, y );
1361 
1362  DrawLine( a, b );
1363  }
1364 
1366 
1367  if( gridStyle == GRID_STYLE::DOTS )
1368  {
1369  glStencilFunc( GL_NOTEQUAL, 0, 1 );
1370  glColor4d( gridColor.r, gridColor.g, gridColor.b, gridColor.a );
1372  }
1373 
1374  // Horizontal lines
1375  for( int i = gridStartX; i <= gridEndX; i++ )
1376  {
1377  const double x = i * gridScreenSize.x + gridOrigin.x;
1378 
1379  // If axes are drawn, skip the lines that would cover them
1380  if( axesEnabled && x == 0.0 )
1381  continue;
1382 
1383  SetLineWidth( ( i % gridTick == 0 ) ? majorLineWidth : minorLineWidth );
1384  VECTOR2D a ( x, gridStartY * gridScreenSize.y + gridOrigin.y );
1385  VECTOR2D b ( x, gridEndY * gridScreenSize.y + gridOrigin.y );
1386  DrawLine( a, b );
1387  }
1388 
1390 
1391  if( gridStyle == GRID_STYLE::DOTS )
1392  glDisable( GL_STENCIL_TEST );
1393  }
1394 
1395  glEnable( GL_DEPTH_TEST );
1396  glEnable( GL_TEXTURE_2D );
1397 }
int gridTick
Every tick line gets the double width.
float GetLineWidth() const
Get the line width.
bool axesEnabled
Should the axes be drawn.
double computeMinGridSpacing() const
compute minimum grid spacing from the grid settings
GRID_STYLE gridStyle
Grid display style.
double g
Green component.
Definition: color4d.h:302
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:300
double b
Blue component.
Definition: color4d.h:303
Auxiliary rendering target (noncached)
Definition: definitions.h:49
double getWorldPixelSize() const
Definition: opengl_gal.cpp:363
double a
Alpha component.
Definition: color4d.h:304
OPENGL_COMPOSITOR * compositor
Handles multiple rendering targets.
Definition: opengl_gal.h:304
VECTOR2< double > VECTOR2D
Definition: vector2d.h:593
unsigned int mainBuffer
Main rendering target.
Definition: opengl_gal.h:305
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:602
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.
virtual float GetBackingScaleFactor() const
double worldScale
The scale factor world->screen.
VECTOR2D gridSize
The grid size.
VECTOR2I screenSize
Screen size in screen coordinates.
constexpr ret_type KiROUND(fp_type v)
Round a floating point number to an integer using "round halfway cases away from zero".
Definition: util.h:61
#define SWAP(varA, condition, varB)
Swap the variables if a condition is met.
Definition: definitions.h:31
double r
Red component.
Definition: color4d.h:301
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, HIDPI_GL_CANVAS::GetBackingScaleFactor(), KIGFX::GAL::GetLineWidth(), getWorldPixelSize(), KIGFX::GAL::gridColor, KIGFX::GAL::gridLineWidth, KIGFX::GAL::gridOrigin, KIGFX::GAL::gridSize, KIGFX::GAL::gridStyle, KIGFX::GAL::gridTick, KIGFX::GAL::gridVisibility, KiROUND(), mainBuffer, nonCachedManager, KIGFX::COLOR4D::r, KIGFX::GAL::screenSize, KIGFX::GAL::screenWorldMatrix, KIGFX::OPENGL_COMPOSITOR::SetBuffer(), KIGFX::GAL::SetLineWidth(), KIGFX::GAL::SetStrokeColor(), SetTarget(), KIGFX::SMALL_CROSS, SWAP, KIGFX::TARGET_NONCACHED, KIGFX::GAL::worldScale, VECTOR2< T >::x, and VECTOR2< T >::y.

◆ DrawGroup()

void OPENGL_GAL::DrawGroup ( int  aGroupNumber)
overridevirtual

Draw the stored group.

Parameters
aGroupNumberis the group number.

Reimplemented from KIGFX::GAL.

Definition at line 1507 of file opengl_gal.cpp.

1508 {
1509  if( groups[aGroupNumber] )
1510  cachedManager->DrawItem( *groups[aGroupNumber] );
1511 }
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:296
VERTEX_MANAGER * cachedManager
Container for storing cached VERTEX_ITEMs.
Definition: opengl_gal.h:299

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 602 of file opengl_gal.cpp.

603 {
605 
606  drawLineQuad( aStartPoint, aEndPoint );
607 }
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:298
void drawLineQuad(const VECTOR2D &aStartPoint, const VECTOR2D &aEndPoint)
Draw a quad for the line.
double g
Green component.
Definition: color4d.h:302
double b
Blue component.
Definition: color4d.h:303
double a
Alpha component.
Definition: color4d.h:304
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:301

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(), DrawArcSegment(), 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 1614 of file opengl_gal.cpp.

1615 {
1616  /* Helper drawing: ____--- v3 ^
1617  * ____---- ... \ \
1618  * ____---- ... \ end \
1619  * v1 ____---- ... ____---- \ width
1620  * ---- ...___---- \ \
1621  * \ ___...-- \ v
1622  * \ ____----... ____---- v2
1623  * ---- ... ____----
1624  * start \ ... ____----
1625  * \... ____----
1626  * ----
1627  * v0
1628  * dots mark triangles' hypotenuses
1629  */
1630 
1631  auto v1 = currentManager->GetTransformation() * glm::vec4( aStartPoint.x, aStartPoint.y, 0.0, 0.0 );
1632  auto v2 = currentManager->GetTransformation() * glm::vec4( aEndPoint.x, aEndPoint.y, 0.0, 0.0 );
1633 
1634  VECTOR2D vs( v2.x - v1.x, v2.y - v1.y );
1635 
1636  currentManager->Reserve( 6 );
1637 
1638  // Line width is maintained by the vertex shader
1639  currentManager->Shader( SHADER_LINE_A, lineWidth, vs.x, vs.y );
1640  currentManager->Vertex( aStartPoint, layerDepth );
1641 
1642  currentManager->Shader( SHADER_LINE_B, lineWidth, vs.x, vs.y );
1643  currentManager->Vertex( aStartPoint, layerDepth );
1644 
1645  currentManager->Shader( SHADER_LINE_C, lineWidth, vs.x, vs.y );
1646  currentManager->Vertex( aEndPoint, layerDepth );
1647 
1648  currentManager->Shader( SHADER_LINE_D, lineWidth, vs.x, vs.y );
1649  currentManager->Vertex( aEndPoint, layerDepth );
1650 
1651  currentManager->Shader( SHADER_LINE_E, lineWidth, vs.x, vs.y );
1652  currentManager->Vertex( aEndPoint, layerDepth );
1653 
1654  currentManager->Shader( SHADER_LINE_F, lineWidth, vs.x, vs.y );
1655  currentManager->Vertex( aStartPoint, layerDepth );
1656 }
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:298
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 935 of file opengl_gal.cpp.

936 {
937  auto points = std::unique_ptr<GLdouble[]>( new GLdouble[3 * aPointList.size()] );
938  GLdouble* ptr = points.get();
939 
940  for( const VECTOR2D& p : aPointList )
941  {
942  *ptr++ = p.x;
943  *ptr++ = p.y;
944  *ptr++ = layerDepth;
945  }
946 
947  drawPolygon( points.get(), aPointList.size() );
948 }
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 951 of file opengl_gal.cpp.

952 {
953  auto points = std::unique_ptr<GLdouble[]>( new GLdouble[3 * aListSize] );
954  GLdouble* target = points.get();
955  const VECTOR2D* src = aPointList;
956 
957  for( int i = 0; i < aListSize; ++i )
958  {
959  *target++ = src->x;
960  *target++ = src->y;
961  *target++ = layerDepth;
962  ++src;
963  }
964 
965  drawPolygon( points.get(), aListSize );
966 }
double layerDepth
The actual layer depth.
void drawPolygon(GLdouble *aPoints, int aPointCount)
Draws a filled polygon.

References drawPolygon(), 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 1006 of file opengl_gal.cpp.

1007 {
1008  if ( aPolySet.IsTriangulationUpToDate() )
1009  {
1010  drawTriangulatedPolyset( aPolySet );
1011  return;
1012  }
1013 
1014  for( int j = 0; j < aPolySet.OutlineCount(); ++j )
1015  {
1016  const SHAPE_LINE_CHAIN& outline = aPolySet.COutline( j );
1017  DrawPolygon( outline );
1018  }
1019 }
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:935
bool IsTriangulationUpToDate() const
void drawTriangulatedPolyset(const SHAPE_POLY_SET &aPoly)
Draws a set of polygons with a cached triangulation.
Definition: opengl_gal.cpp:969
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 1023 of file opengl_gal.cpp.

1024 {
1025  if( aPolygon.SegmentCount() == 0 )
1026  return;
1027 
1028  const int pointCount = aPolygon.SegmentCount() + 1;
1029  std::unique_ptr<GLdouble[]> points( new GLdouble[3 * pointCount] );
1030  GLdouble* ptr = points.get();
1031 
1032  for( int i = 0; i < pointCount; ++i )
1033  {
1034  const VECTOR2I& p = aPolygon.CPoint( i );
1035  *ptr++ = p.x;
1036  *ptr++ = p.y;
1037  *ptr++ = layerDepth;
1038  }
1039 
1040  drawPolygon( points.get(), pointCount );
1041 }
double layerDepth
The actual layer depth.
void drawPolygon(GLdouble *aPoints, int aPointCount)
Draws a filled polygon.

References SHAPE_LINE_CHAIN::CPoint(), drawPolygon(), 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 1740 of file opengl_gal.cpp.

1741 {
1742  if( isFillEnabled )
1743  {
1746 
1747  // Any non convex polygon needs to be tesselated
1748  // for this purpose the GLU standard functions are used
1749  TessParams params = { currentManager, tessIntersects };
1750  gluTessBeginPolygon( tesselator, &params );
1751  gluTessBeginContour( tesselator );
1752 
1753  GLdouble* point = aPoints;
1754 
1755  for( int i = 0; i < aPointCount; ++i )
1756  {
1757  gluTessVertex( tesselator, point, point );
1758  point += 3; // 3 coordinates
1759  }
1760 
1761  gluTessEndContour( tesselator );
1762  gluTessEndPolygon( tesselator );
1763 
1764  // Free allocated intersecting points
1765  tessIntersects.clear();
1766  }
1767 
1768  if( isStrokeEnabled )
1769  {
1770  drawPolyline( [&](int idx) { return VECTOR2D( aPoints[idx * 3], aPoints[idx * 3 + 1] ); },
1771  aPointCount );
1772  }
1773 }
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:298
double g
Green component.
Definition: color4d.h:302
COLOR4D fillColor
The fill color.
double b
Blue component.
Definition: color4d.h:303
double a
Alpha component.
Definition: color4d.h:304
bool isStrokeEnabled
Are the outlines stroked ?
VECTOR2< double > VECTOR2D
Definition: vector2d.h:593
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:348
bool isFillEnabled
Is filling of graphic objects enabled ?
std::deque< boost::shared_array< GLdouble > > tessIntersects
Storage for intersecting points.
Definition: opengl_gal.h:350
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:301

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::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 912 of file opengl_gal.cpp.

913 {
914  drawPolyline( [&](int idx) { return aPointList[idx]; }, aPointList.size() );
915 }
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 918 of file opengl_gal.cpp.

919 {
920  drawPolyline( [&](int idx) { return aPointList[idx]; }, aListSize );
921 }
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 924 of file opengl_gal.cpp.

925 {
926  auto numPoints = aLineChain.PointCount();
927 
928  if( aLineChain.IsClosed() )
929  numPoints += 1;
930 
931  drawPolyline( [&](int idx) { return aLineChain.CPoint(idx); }, numPoints );
932 }
int PointCount() const
Function PointCount()
const VECTOR2I & CPoint(int aIndex) const
Function Point()
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 1776 of file opengl_gal.cpp.

1777 {
1778  if( aPointCount < 2 )
1779  return;
1780 
1782  int i;
1783 
1784  for( i = 1; i < aPointCount; ++i )
1785  {
1786  auto start = aPointGetter( i - 1 );
1787  auto end = aPointGetter( i );
1788 
1789  drawLineQuad( start, end );
1790  }
1791 }
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:298
void drawLineQuad(const VECTOR2D &aStartPoint, const VECTOR2D &aEndPoint)
Draw a quad for the line.
double g
Green component.
Definition: color4d.h:302
double b
Blue component.
Definition: color4d.h:303
double a
Alpha component.
Definition: color4d.h:304
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:301

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 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 874 of file opengl_gal.cpp.

875 {
876  // Compute the diagonal points of the rectangle
877  VECTOR2D diagonalPointA( aEndPoint.x, aStartPoint.y );
878  VECTOR2D diagonalPointB( aStartPoint.x, aEndPoint.y );
879 
880  // Fill the rectangle
881  if( isFillEnabled )
882  {
883  currentManager->Reserve( 6 );
886 
887  currentManager->Vertex( aStartPoint.x, aStartPoint.y, layerDepth );
888  currentManager->Vertex( diagonalPointA.x, diagonalPointA.y, layerDepth );
889  currentManager->Vertex( aEndPoint.x, aEndPoint.y, layerDepth );
890 
891  currentManager->Vertex( aStartPoint.x, aStartPoint.y, layerDepth );
892  currentManager->Vertex( aEndPoint.x, aEndPoint.y, layerDepth );
893  currentManager->Vertex( diagonalPointB.x, diagonalPointB.y, layerDepth );
894  }
895 
896  // Stroke the outline
897  if( isStrokeEnabled )
898  {
900 
901  std::deque<VECTOR2D> pointList;
902  pointList.push_back( aStartPoint );
903  pointList.push_back( diagonalPointA );
904  pointList.push_back( aEndPoint );
905  pointList.push_back( diagonalPointB );
906  pointList.push_back( aStartPoint );
907  DrawPolyline( pointList );
908  }
909 }
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:298
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:302
COLOR4D fillColor
The fill color.
double b
Blue component.
Definition: color4d.h:303
double a
Alpha component.
Definition: color4d.h:304
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:912
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:301

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 610 of file opengl_gal.cpp.

612 {
613  if( aStartPoint == aEndPoint ) // 0 length segments are just a circle.
614  {
615  DrawCircle( aStartPoint, aWidth/2 );
616  return;
617  }
618 
619  if( isFillEnabled || aWidth == 1.0 )
620  {
622 
623  SetLineWidth( aWidth );
624  drawLineQuad( aStartPoint, aEndPoint );
625  }
626  else
627  {
628  auto startEndVector = aEndPoint - aStartPoint;
629  auto lineAngle = startEndVector.Angle();
630  // Outlined tracks
631  double lineLength = startEndVector.EuclideanNorm();
632 
633  SetLineWidth( 1.0 );
635 
636  Save();
637 
638  currentManager->Translate( aStartPoint.x, aStartPoint.y, 0.0 );
639  currentManager->Rotate( lineAngle, 0.0f, 0.0f, 1.0f );
640 
641  drawLineQuad( VECTOR2D( 0.0, aWidth / 2.0 ),
642  VECTOR2D( lineLength, aWidth / 2.0 ) );
643 
644  drawLineQuad( VECTOR2D( 0.0, -aWidth / 2.0 ),
645  VECTOR2D( lineLength, -aWidth / 2.0 ) );
646 
647  // Draw line caps
648  drawStrokedSemiCircle( VECTOR2D( 0.0, 0.0 ), aWidth / 2, M_PI / 2 );
649  drawStrokedSemiCircle( VECTOR2D( lineLength, 0.0 ), aWidth / 2, -M_PI / 2 );
650 
651  Restore();
652  }
653 }
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:298
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:302
COLOR4D fillColor
The fill color.
virtual void SetLineWidth(float aLineWidth)
Set the line width.
double b
Blue component.
Definition: color4d.h:303
virtual void Save() override
Save the context.
double a
Alpha component.
Definition: color4d.h:304
VECTOR2< double > VECTOR2D
Definition: vector2d.h:593
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:313
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:301
virtual void DrawCircle(const VECTOR2D &aCenterPoint, double aRadius) override
Draw a circle using world coordinates.
Definition: opengl_gal.cpp:656

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 1659 of file opengl_gal.cpp.

1660 {
1661  if( isFillEnabled )
1662  {
1664  drawFilledSemiCircle( aCenterPoint, aRadius, aAngle );
1665  }
1666 
1667  if( isStrokeEnabled )
1668  {
1670  drawStrokedSemiCircle( aCenterPoint, aRadius, aAngle );
1671  }
1672 }
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:298
double g
Green component.
Definition: color4d.h:302
COLOR4D fillColor
The fill color.
double b
Blue component.
Definition: color4d.h:303
double a
Alpha component.
Definition: color4d.h:304
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:301
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 1706 of file opengl_gal.cpp.

1708 {
1709  double outerRadius = aRadius + ( lineWidth / 2 );
1710 
1711  Save();
1712 
1713  currentManager->Reserve( 3 );
1714  currentManager->Translate( aCenterPoint.x, aCenterPoint.y, 0.0f );
1715  currentManager->Rotate( aAngle, 0.0f, 0.0f, 1.0f );
1716 
1717  /* Draw a triangle that contains the semicircle, then shade it to leave only
1718  * the semicircle. Parameters given to Shader() are indices of the triangle's vertices
1719  * (if you want to understand more, check the vertex shader source [shader.vert]), the
1720  * radius and the line width. Shader uses these coordinates to determine if fragments are
1721  * inside the semicircle or not.
1722  * v2
1723  * /\
1724  * /__\
1725  * v0 //__\\ v1
1726  */
1728  currentManager->Vertex( -outerRadius * 3.0f / sqrt( 3.0f ), 0.0f, layerDepth ); // v0
1729 
1731  currentManager->Vertex( outerRadius * 3.0f / sqrt( 3.0f ), 0.0f, layerDepth ); // v1
1732 
1734  currentManager->Vertex( 0.0f, outerRadius * 2.0f, layerDepth ); // v2
1735 
1736  Restore();
1737 }
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:298
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 DrawArcSegment(), 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 969 of file opengl_gal.cpp.

970 {
973 
974  if( isFillEnabled )
975  {
976  for( unsigned int j = 0; j < aPolySet.TriangulatedPolyCount(); ++j )
977  {
978  auto triPoly = aPolySet.TriangulatedPolygon( j );
979 
980  for( size_t i = 0; i < triPoly->GetTriangleCount(); i++ )
981  {
982  VECTOR2I a, b, c;
983  triPoly->GetTriangle( i, a, b, c );
984  currentManager->Vertex( a.x, a.y, layerDepth );
985  currentManager->Vertex( b.x, b.y, layerDepth );
986  currentManager->Vertex( c.x, c.y, layerDepth );
987  }
988  }
989  }
990 
991  if( isStrokeEnabled )
992  {
993  for( int j = 0; j < aPolySet.OutlineCount(); ++j )
994  {
995  const auto& poly = aPolySet.Polygon( j );
996 
997  for( const auto& lc : poly )
998  {
999  DrawPolyline( lc );
1000  }
1001  }
1002  }
1003 }
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:298
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:302
COLOR4D fillColor
The fill color.
double b
Blue component.
Definition: color4d.h:303
double a
Alpha component.
Definition: color4d.h:304
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:912
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:301

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, 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 2104 of file opengl_gal.cpp.

2105 {
2106  cachedManager->EnableDepthTest( aEnabled );
2107  nonCachedManager->EnableDepthTest( aEnabled );
2108  overlayManager->EnableDepthTest( aEnabled );
2109 }
VERTEX_MANAGER * overlayManager
Container for storing overlaid VERTEX_ITEMs.
Definition: opengl_gal.h:301
VERTEX_MANAGER * nonCachedManager
Container for storing non-cached VERTEX_ITEMs.
Definition: opengl_gal.h:300
VERTEX_MANAGER * cachedManager
Container for storing cached VERTEX_ITEMs.
Definition: opengl_gal.h:299
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 518 of file opengl_gal.cpp.

519 {
520  wxASSERT_MSG( isContextLocked, "What happened to the context lock?" );
521 
522 #ifdef __WXDEBUG__
523  PROF_COUNTER totalRealTime( "OPENGL_GAL::endDrawing()", true );
524 #endif /* __WXDEBUG__ */
525 
526  // Cached & non-cached containers are rendered to the same buffer
530 
531  // Overlay container is rendered to a different buffer
534 
535  // Be sure that the framebuffer is not colorized (happens on specific GPU&drivers combinations)
536  glColor4d( 1.0, 1.0, 1.0, 1.0 );
537 
538  // Draw the remaining contents, blit the rendering targets to the screen, swap the buffers
541  compositor->Present();
542  blitCursor();
543 
544  SwapBuffers();
545 
546 #ifdef __WXDEBUG__
547  totalRealTime.Stop();
548  wxLogTrace( "GAL_PROFILE", wxT( "OPENGL_GAL::endDrawing(): %.1f ms" ), totalRealTime.msecs() );
549 #endif /* __WXDEBUG__ */
550 }
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:306
VERTEX_MANAGER * overlayManager
Container for storing overlaid VERTEX_ITEMs.
Definition: opengl_gal.h:301
bool isContextLocked
Used for assertion checking.
Definition: opengl_gal.h:319
The class PROF_COUNTER is a small class to help profiling.
Definition: profile.h:44
VERTEX_MANAGER * nonCachedManager
Container for storing non-cached VERTEX_ITEMs.
Definition: opengl_gal.h:300
OPENGL_COMPOSITOR * compositor
Handles multiple rendering targets.
Definition: opengl_gal.h:304
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:305
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:299
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 1500 of file opengl_gal.cpp.

1501 {
1503  isGrouping = false;
1504 }
bool isGrouping
Was a group started?
Definition: opengl_gal.h:318
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:299

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

◆ endUpdate()

void OPENGL_GAL::endUpdate ( )
overrideprivatevirtual

Reimplemented from KIGFX::GAL.

Definition at line 593 of file opengl_gal.cpp.

594 {
595  if( !isInitialized )
596  return;
597 
598  cachedManager->Unmap();
599 }
void Unmap()
Function Unmap() unmaps vertex buffer.
VERTEX_MANAGER * cachedManager
Container for storing cached VERTEX_ITEMs.
Definition: opengl_gal.h:299
bool isInitialized
Basic initialization flag, has to be done when the window is visible.
Definition: opengl_gal.h:316

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 1424 of file opengl_gal.cpp.

1425 {
1426  glFlush();
1427 }

◆ GetBackingScaleFactor()

float HIDPI_GL_CANVAS::GetBackingScaleFactor ( ) const
virtualinherited

Definition at line 56 of file hidpi_gl_canvas.cpp.

57 {
58 #ifdef RETINA_OPENGL_PATCH
59  // this is ugly, but original method isn't marked const although it doesn't modify anything
60  // => clean up when it officially has arrived in wxWidgets
61  return static_cast< wxGLCanvas* >( const_cast< HIDPI_GL_CANVAS* >( this ))->GetBackingScaleFactor();
62 #else
63 
64  // Return the cached value (which originally was set from config or automatically)
65  return m_scale_factor;
66 #endif
67 }
double m_scale_factor
The current scale factor (e.g.

References HIDPI_GL_CANVAS::m_scale_factor.

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

◆ GetClearColor()

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

Definition at line 219 of file graphics_abstraction_layer.h.

220  {
221  return m_clearColor;
222  }

References KIGFX::GAL::m_clearColor.

Referenced by EDIT_POINTS::ViewDraw().

◆ getCursorColor()

COLOR4D GAL::getCursorColor ( ) const
protectedinherited

Gets the actual cursor color to draw.

Definition at line 240 of file graphics_abstraction_layer.cpp.

241 {
242  auto color = cursorColor;
243 
244  // dim the cursor if it's only on because it was forced
245  // (this helps to provide a hint for active tools)
246  if( !isCursorEnabled )
247  {
248  color.a = color.a * 0.5;
249  }
250 
251  return color;
252 }
bool isCursorEnabled
Is the cursor enabled?
int color
Definition: DXF_plotter.cpp:61
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 269 of file graphics_abstraction_layer.h.

270  {
271  return fillColor;
272  }
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 939 of file graphics_abstraction_layer.h.

940  {
941  return gridLineWidth;
942  }
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 218 of file graphics_abstraction_layer.cpp.

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

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 891 of file graphics_abstraction_layer.h.

892  {
893  return gridSize;
894  }
VECTOR2D gridSize
The grid size.

References KIGFX::GAL::gridSize.

Referenced by SCH_DRAW_PANEL::SwitchBackend().

◆ GetHorizontalJustify()

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

Returns current text horizontal justification setting.

Definition at line 493 of file graphics_abstraction_layer.h.

494  {
496  }
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 693 of file graphics_abstraction_layer.h.

694  {
695  return lookAtPoint;
696  }
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 762 of file graphics_abstraction_layer.h.

763  {
764  return depthRange.y;
765  }
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 754 of file graphics_abstraction_layer.h.

755  {
756  return depthRange.x;
757  }
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 44 of file hidpi_gl_canvas.cpp.

45 {
46  wxSize size = wxGLCanvas::GetClientSize();
47 
48  const float scaleFactor = GetBackingScaleFactor();
49  size.x *= scaleFactor;
50  size.y *= scaleFactor;
51 
52  return size;
53 }
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 1977 of file opengl_gal.cpp.

1978 {
1979  wxASSERT_MSG( groups.size() < std::numeric_limits<unsigned int>::max(),
1980  wxT( "There are no free slots to store a group" ) );
1981 
1982  while( groups.find( groupCounter ) != groups.end() )
1983  {
1984  groupCounter++;
1985  }
1986 
1987  return groupCounter++;
1988 }
GROUPS_MAP groups
Stores informations about VBO objects (groups)
Definition: opengl_gal.h:296
unsigned int groupCounter
Counter used for generating keys for groups.
Definition: opengl_gal.h:297

References groupCounter, and groups.

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 388 of file graphics_abstraction_layer.h.

389  {
391  }
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 733 of file graphics_abstraction_layer.h.

734  {
735  return rotation;
736  }
double rotation
Rotation transformation (radians)

References KIGFX::GAL::rotation.

◆ GetScaleFactor()

double HIDPI_GL_CANVAS::GetScaleFactor ( ) const
inherited

Get the current scale factor.

Definition at line 76 of file hidpi_gl_canvas.cpp.

77 {
78  return m_scale_factor;
79 }
double m_scale_factor
The current scale factor (e.g.

References HIDPI_GL_CANVAS::m_scale_factor.

Referenced by updatedGalDisplayOptions().

◆ GetScreenPixelSize()

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

◆ getScreenPixelSize()

VECTOR2D OPENGL_GAL::getScreenPixelSize ( ) const
private

Definition at line 370 of file opengl_gal.cpp.

371 {
372  auto sf = GetBackingScaleFactor();
373  return VECTOR2D( 2.0 / (double) ( screenSize.x * sf ), 2.0 / (double) ( screenSize.y * sf ) );
374 }
VECTOR2< double > VECTOR2D
Definition: vector2d.h:593
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 629 of file graphics_abstraction_layer.h.

630  {
631  return screenWorldMatrix;
632  }
MATRIX3x3D screenWorldMatrix
Screen transformation.

References KIGFX::GAL::screenWorldMatrix.

Referenced by KIGFX::SCH_PAINTER::getShadowWidth(), getWorldPixelSize(), screenSpaceCircle(), screenSpaceLine(), 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 289 of file graphics_abstraction_layer.h.

290  {
291  return strokeColor;
292  }
COLOR4D strokeColor
The color of the outlines.

References KIGFX::GAL::strokeColor.

◆ GetStrokeFont()

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

Definition at line 331 of file graphics_abstraction_layer.h.

332  {
333  return strokeFont;
334  }
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 1568 of file opengl_gal.cpp.

1569 {
1570  return currentTarget;
1571 }
RENDER_TARGET currentTarget
Current rendering target.
Definition: opengl_gal.h:307

References currentTarget.

Referenced by DrawBitmap().

◆ GetTextLineSize()

VECTOR2D GAL::GetTextLineSize ( const UTF8 aText,
int  aMarkupFlags = 0 
) 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).
aMarkupFlagsa bitset of TEXT_MARKUP_FLAGS.
Returns
is the text size.

Definition at line 172 of file graphics_abstraction_layer.cpp.

173 {
174  // Compute the X and Y size of a given text.
175  // Because computeTextLineSize expects a one line text,
176  // aText is expected to be only one line text.
177  return strokeFont.computeTextLineSize( aText, aMarkupFlags );
178 }
STROKE_FONT strokeFont
Instance of object that stores information about how to draw texts.
VECTOR2D computeTextLineSize(const UTF8 &aText, int aMarkupFlags) 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 511 of file graphics_abstraction_layer.h.

512  {
514  }
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 363 of file opengl_gal.cpp.

364 {
365  auto matrix = GetScreenWorldMatrix();
366  return std::min( std::abs( matrix.GetScale().x ), std::abs( matrix.GetScale().y ) );
367 }
const MATRIX3x3D & GetScreenWorldMatrix() const
Get the screen <-> world transformation matrix.

References KIGFX::GAL::GetScreenWorldMatrix().

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 772 of file graphics_abstraction_layer.h.

773  {
774  return worldScale;
775  }
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(), 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 619 of file graphics_abstraction_layer.h.

620  {
621  return worldScreenMatrix;
622  }
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 713 of file graphics_abstraction_layer.h.

714  {
715  return zoomFactor;
716  }
double zoomFactor
The zoom factor.

References KIGFX::GAL::zoomFactor.

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

◆ init()

void OPENGL_GAL::init ( )
private

Basic OpenGL initialization.

Definition at line 1991 of file opengl_gal.cpp.

1992 {
1993  wxASSERT( IsShownOnScreen() );
1994 
1995  wxASSERT_MSG( isContextLocked, "This should only be called from within a locked context." );
1996 
1997  GLenum err = glewInit();
1998 
1999  if( GLEW_OK != err )
2000  throw std::runtime_error( (const char*) glewGetErrorString( err ) );
2001 
2002  // Check the OpenGL version (minimum 2.1 is required)
2003  if( !GLEW_VERSION_2_1 )
2004  throw std::runtime_error( "OpenGL 2.1 or higher is required!" );
2005 
2006 #if defined (__LINUX__) // calling enableGlDebug crashes opengl on some OS (OSX and some Windows)
2007 #ifdef DEBUG
2008  if( GLEW_ARB_debug_output )
2009  enableGlDebug( true );
2010 #endif
2011 #endif
2012 
2013  // Framebuffers have to be supported
2014  if( !GLEW_EXT_framebuffer_object )
2015  throw std::runtime_error( "Framebuffer objects are not supported!" );
2016 
2017  // Vertex buffer has to be supported
2018  if( !GLEW_ARB_vertex_buffer_object )
2019  throw std::runtime_error( "Vertex buffer objects are not supported!" );
2020 
2021  // Prepare shaders
2023  throw std::runtime_error( "Cannot compile vertex shader!" );
2024 
2026  throw std::runtime_error( "Cannot compile fragment shader!" );
2027 
2028  if( !shader->IsLinked() && !shader->Link() )
2029  throw std::runtime_error( "Cannot link the shaders!" );
2030 
2031  // Check if video card supports textures big enough to fit the font atlas
2032  int maxTextureSize;
2033  glGetIntegerv( GL_MAX_TEXTURE_SIZE, &maxTextureSize );
2034 
2035  if( maxTextureSize < (int) font_image.width || maxTextureSize < (int)font_image.height )
2036  {
2037  // TODO implement software texture scaling
2038  // for bitmap fonts and use a higher resolution texture?
2039  throw std::runtime_error( "Requested texture size is not supported" );
2040  }
2041 
2042  cachedManager = new VERTEX_MANAGER( true );
2043  nonCachedManager = new VERTEX_MANAGER( false );
2044  overlayManager = new VERTEX_MANAGER( false );
2045 
2046  // Make VBOs use shaders
2050 
2051  isInitialized = true;
2052 }
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:301
bool isContextLocked
Used for assertion checking.
Definition: opengl_gal.h:319
Fragment shader.
Definition: shader.h:47
bool Link()
Link the shaders.
Definition: shader.cpp:97
SHADER * shader
There is only one shader used for different objects.
Definition: opengl_gal.h:310
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:300
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
VERTEX_MANAGER * cachedManager
Container for storing cached VERTEX_ITEMs.
Definition: opengl_gal.h:299
bool isInitialized
Basic initialization flag, has to be done when the window is visible.
Definition: opengl_gal.h:316

References cachedManager, enableGlDebug(), 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 992 of file graphics_abstraction_layer.h.

993  {
995  }
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 792 of file graphics_abstraction_layer.h.

793  {
794  return globalFlipX;
795  }
bool globalFlipX
Flag for X axis flipping.

References KIGFX::GAL::globalFlipX.

Referenced by KIGFX::CAIRO_GAL_BASE::angle_xform(), and KIGFX::CAIRO_GAL_BASE::arc_angles_xform_and_normalize().

◆ IsFlippedY()

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

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

Definition at line 800 of file graphics_abstraction_layer.h.

801  {
802  return globalFlipY;
803  }
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 439 of file graphics_abstraction_layer.h.

440  {
441  return textProperties.m_bold;
442  }
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 457 of file graphics_abstraction_layer.h.

458  {
459  return textProperties.m_italic;
460  }
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 475 of file graphics_abstraction_layer.h.

476  {
477  return textProperties.m_mirrored;
478  }
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 553 of file opengl_gal.cpp.

554 {
555  wxASSERT_MSG( !isContextLocked, "Context already locked." );
556  isContextLocked = true;
557  lockClientCookie = aClientCookie;
558 
560 }
bool isContextLocked
Used for assertion checking.
Definition: opengl_gal.h:319
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:287

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 92 of file graphics_abstraction_layer.cpp.

93 {
94  // defer to the child class first
95  updatedGalDisplayOptions( aOptions );
96 
97  // there is no refresh to do at this level
98 }
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 1931 of file opengl_gal.cpp.

1932 {
1933  PostPaint();
1934 }
void PostPaint()
Function PostPaint posts an event to m_paint_listener.
Definition: opengl_gal.h:248

References PostPaint().

Referenced by OPENGL_GAL().

◆ PopDepth()

void KIGFX::GAL::PopDepth ( )
inlineinherited

Restores previously stored drawing depth for the depth stack.

Definition at line 1034 of file graphics_abstraction_layer.h.

1035  {
1036  layerDepth = depthStack.top();
1037  depthStack.pop();
1038  }
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 248 of file opengl_gal.h.

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

References paintListener.

Referenced by onPaint().

◆ PushDepth()

void KIGFX::GAL::PushDepth ( )
inlineinherited

Stores current drawing depth on the depth stack.

Definition at line 1026 of file graphics_abstraction_layer.h.

1027  {
1028  depthStack.push( layerDepth );
1029  }
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 157 of file graphics_abstraction_layer.cpp.

158 {
159  // Tiny but non-zero - this will always need setting
160  // there is no built-in default
161  SetGlyphSize( { 1.0, 1.0 } );
162 
165 
166  SetFontBold( false );
167  SetFontItalic( false );
168  SetTextMirrored( false );
169 }
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(), KIGFX::GAL::GAL(), and KIGFX::PREVIEW::ARC_ASSISTANT::ViewDraw().

◆ ResizeScreen()

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

Resizes the canvas.

Reimplemented from KIGFX::GAL.

Definition at line 1400 of file opengl_gal.cpp.

1401 {
1402  screenSize = VECTOR2I( aWidth, aHeight );
1403 
1404  // Resize framebuffers
1405  const float scaleFactor = GetBackingScaleFactor();
1406  compositor->Resize( aWidth * scaleFactor, aHeight * scaleFactor );
1407  isFramebufferInitialized = false;
1408 
1409  wxGLCanvas::SetSize( aWidth, aHeight );
1410 }
VECTOR2< int > VECTOR2I
Definition: vector2d.h:594
OPENGL_COMPOSITOR * compositor
Handles multiple rendering targets.
Definition: opengl_gal.h:304
bool isFramebufferInitialized
Are the framebuffers initialized?
Definition: opengl_gal.h:313
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 1482 of file opengl_gal.cpp.

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

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

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

◆ 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 1458 of file opengl_gal.cpp.

1459 {
1460  currentManager->Rotate( aAngle, 0.0f, 0.0f, 1.0f );
1461 }
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:298
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 1476 of file opengl_gal.cpp.

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

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

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

◆ 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 1470 of file opengl_gal.cpp.

1471 {
1472  currentManager->Scale( aScale.x, aScale.y, 0.0f );
1473 }
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:298
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 911 of file graphics_abstraction_layer.h.

912  {
913  axesColor = aAxesColor;
914  }
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

◆ 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 929 of file graphics_abstraction_layer.h.

930  {
931  gridTick = aInterval;
932  }
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 1002 of file graphics_abstraction_layer.h.

1003  {
1004  cursorColor = aCursorColor;
1005  }
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 983 of file graphics_abstraction_layer.h.

984  {
985  isCursorEnabled = aCursorEnabled;
986  }
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 746 of file graphics_abstraction_layer.h.

747  {
748  depthRange = aDepthRange;
749  }
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 783 of file graphics_abstraction_layer.h.

784  {
785  globalFlipX = xAxis;
786  globalFlipY = yAxis;
787  }
bool globalFlipX
Flag for X axis flipping.