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...
 
 ~OPENGL_GAL ()
 
bool IsOpenGlEngine () override
 Returns true if the GAL engine is a opengl based type. More...
 
bool IsInitialized () const override
 Returns the initalization status for the canvas. More...
 
bool IsVisible () const override
 

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

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

Static Public Member Functions

static wxString CheckFeatures (GAL_DISPLAY_OPTIONS &aOptions)
 Checks OpenGL features. 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
 
void beginUpdate () override
 
void endUpdate () override
 
void beginDrawing () override
 
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 and feature checks. 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 299 of file opengl_gal.h.

◆ super

typedef GAL KIGFX::OPENGL_GAL::super
private

Super class definition.

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

195  :
196  GAL( aDisplayOptions ),
197  HIDPI_GL_CANVAS( aParent, wxID_ANY, (int*) glAttributes, wxDefaultPosition, wxDefaultSize,
198  wxEXPAND, aName ),
199  mouseListener( aMouseListener ),
200  paintListener( aPaintListener ),
201  currentManager( nullptr ),
202  cachedManager( nullptr ),
203  nonCachedManager( nullptr ),
204  overlayManager( nullptr ),
205  mainBuffer( 0 ),
206  overlayBuffer( 0 ),
207  isContextLocked( false ),
208  lockClientCookie( 0 )
209 {
210  if( glMainContext == NULL )
211  {
213 
215  }
216  else
217  {
219  }
220 
221  shader = new SHADER();
222  ++instanceCounter;
223 
224  bitmapCache = std::make_unique<GL_BITMAP_CACHE>( );
225 
228 
229  // Initialize the flags
230  isFramebufferInitialized = false;
231  isBitmapFontInitialized = false;
232  isInitialized = false;
233  isGrouping = false;
234  groupCounter = 0;
235 
236  // Connecting the event handlers
237  Connect( wxEVT_PAINT, wxPaintEventHandler( OPENGL_GAL::onPaint ) );
238 
239  // Mouse events are skipped to the parent
240  Connect( wxEVT_MOTION, wxMouseEventHandler( OPENGL_GAL::skipMouseEvent ) );
241  Connect( wxEVT_LEFT_DOWN, wxMouseEventHandler( OPENGL_GAL::skipMouseEvent ) );
242  Connect( wxEVT_LEFT_UP, wxMouseEventHandler( OPENGL_GAL::skipMouseEvent ) );
243  Connect( wxEVT_LEFT_DCLICK, wxMouseEventHandler( OPENGL_GAL::skipMouseEvent ) );
244  Connect( wxEVT_MIDDLE_DOWN, wxMouseEventHandler( OPENGL_GAL::skipMouseEvent ) );
245  Connect( wxEVT_MIDDLE_UP, wxMouseEventHandler( OPENGL_GAL::skipMouseEvent ) );
246  Connect( wxEVT_MIDDLE_DCLICK, wxMouseEventHandler( OPENGL_GAL::skipMouseEvent ) );
247  Connect( wxEVT_RIGHT_DOWN, wxMouseEventHandler( OPENGL_GAL::skipMouseEvent ) );
248  Connect( wxEVT_RIGHT_UP, wxMouseEventHandler( OPENGL_GAL::skipMouseEvent ) );
249  Connect( wxEVT_RIGHT_DCLICK, wxMouseEventHandler( OPENGL_GAL::skipMouseEvent ) );
250  Connect( wxEVT_MOUSEWHEEL, wxMouseEventHandler( OPENGL_GAL::skipMouseEvent ) );
251 #if wxCHECK_VERSION( 3, 1, 0 ) || defined( USE_OSX_MAGNIFY_EVENT )
252  Connect( wxEVT_MAGNIFY, wxMouseEventHandler( OPENGL_GAL::skipMouseEvent ) );
253 #endif
254 #if defined _WIN32 || defined _WIN64
255  Connect( wxEVT_ENTER_WINDOW, wxMouseEventHandler( OPENGL_GAL::skipMouseEvent ) );
256 #endif
257 
258  SetSize( aParent->GetClientSize() );
260 
261  // Grid color settings are different in Cairo and OpenGL
262  SetGridColor( COLOR4D( 0.8, 0.8, 0.8, 0.1 ) );
263  SetAxesColor( COLOR4D( BLUE ) );
264 
265  // Tesselator initialization
266  tesselator = gluNewTess();
268 
269  gluTessProperty( tesselator, GLU_TESS_WINDING_RULE, GLU_TESS_WINDING_POSITIVE );
270 
272 
273  // Avoid unitialized variables:
274  ufm_worldPixelSize = 1;
277 }
virtual wxSize GetNativePixelSize() const
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:302
static wxGLContext * glMainContext
Parent OpenGL context.
Definition: opengl_gal.h:290
unsigned int overlayBuffer
Auxiliary rendering target (for menus etc.)
Definition: opengl_gal.h:310
bool isBitmapFontInitialized
Is the shader set to use bitmap fonts?
Definition: opengl_gal.h:319
VERTEX_MANAGER * overlayManager
Container for storing overlaid VERTEX_ITEMs.
Definition: opengl_gal.h:305
GAL_DISPLAY_OPTIONS & options
std::unique_ptr< GL_BITMAP_CACHE > bitmapCache
Definition: opengl_gal.h:329
static void InitTesselatorCallbacks(GLUtesselator *aTesselator)
bool isContextLocked
Used for assertion checking.
Definition: opengl_gal.h:323
SHADER * shader
There is only one shader used for different objects.
Definition: opengl_gal.h:314
VECTOR2< int > VECTOR2I
Definition: vector2d.h:594
bool isGrouping
Was a group started?
Definition: opengl_gal.h:322
OPENGL_ANTIALIASING_MODE gl_antialiasing_mode
VERTEX_MANAGER * nonCachedManager
Container for storing non-cached VERTEX_ITEMs.
Definition: opengl_gal.h:304
Auxiliary rendering target (noncached)
Definition: definitions.h:49
static int instanceCounter
GL GAL instance counter.
Definition: opengl_gal.h:292
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:308
#define NULL
unsigned int mainBuffer
Main rendering target.
Definition: opengl_gal.h:309
wxEvtHandler * mouseListener
Definition: opengl_gal.h:293
void SetAxesColor(const COLOR4D &aAxesColor)
Set the axes color.
static const int glAttributes[]
Definition: opengl_gal.cpp:76
void onPaint(wxPaintEvent &aEvent)
This is the OnPaint event handler.
GLint ufm_screenPixelSize
Definition: opengl_gal.h:326
bool isFramebufferInitialized
Are the framebuffers initialized?
Definition: opengl_gal.h:317
Class SHADER provides the access to the OpenGL shaders.
Definition: shader.h:76
GLUtesselator * tesselator
The tessellator.
Definition: opengl_gal.h:352
VERTEX_MANAGER * cachedManager
Container for storing cached VERTEX_ITEMs.
Definition: opengl_gal.h:303
GLint ufm_worldPixelSize
Definition: opengl_gal.h:325
wxEvtHandler * paintListener
Definition: opengl_gal.h:294
void SetTarget(RENDER_TARGET aTarget) override
Sets the target for rendering.
Definition: color4d.h:56
bool isInitialized
Basic initialization flag, has to be done when the window is visible.
Definition: opengl_gal.h:320
unsigned int groupCounter
Counter used for generating keys for groups.
Definition: opengl_gal.h:301
VECTOR2I screenSize
Screen size in screen coordinates.
wxGLContext * glPrivContext
Canvas-specific OpenGL context.
Definition: opengl_gal.h:291
wxGLContext * CreateCtx(wxGLCanvas *aCanvas, const wxGLContext *aOther=NULL)
Function CreateCtx creates a managed OpenGL context.
GLint ufm_pixelSizeMultiplier
Definition: opengl_gal.h:327
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:99

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, tesselator, ufm_pixelSizeMultiplier, ufm_screenPixelSize, and ufm_worldPixelSize.

◆ ~OPENGL_GAL()

OPENGL_GAL::~OPENGL_GAL ( )

Definition at line 280 of file opengl_gal.cpp.

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

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

1035  {
1036  layerDepth -= 0.05;
1037  }
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 406 of file opengl_gal.cpp.

407 {
408 #ifdef __WXDEBUG__
409  PROF_COUNTER totalRealTime( "OPENGL_GAL::beginDrawing()", true );
410 #endif /* __WXDEBUG__ */
411 
412  wxASSERT_MSG( isContextLocked, "GAL_DRAWING_CONTEXT RAII object should have locked context. "
413  "Calling GAL::beginDrawing() directly is not allowed." );
414 
415  wxASSERT_MSG( IsVisible(), "GAL::beginDrawing() must not be entered when GAL is not visible. "
416  "Other drawing routines will expect everything to be initialized "
417  "which will not be the case." );
418 
419  if( !isInitialized )
420  init();
421 
422  // Set up the view port
423  glMatrixMode( GL_PROJECTION );
424  glLoadIdentity();
425 
426  // Create the screen transformation (Do the RH-LH conversion here)
427  glOrtho( 0, (GLint) screenSize.x, (GLsizei) screenSize.y, 0, -depthRange.x, -depthRange.y );
428 
430  {
431  // Prepare rendering target buffers
434  try
435  {
437  }
438  catch( const std::runtime_error& error )
439  {
440  wxLogVerbose( "Could not create a framebuffer for overlays.\n" );
441  overlayBuffer = 0;
442  }
444  }
445 
446  compositor->Begin();
447 
448  // Disable 2D Textures
449  glDisable( GL_TEXTURE_2D );
450 
451  glShadeModel( GL_FLAT );
452 
453  // Enable the depth buffer
454  glEnable( GL_DEPTH_TEST );
455  glDepthFunc( GL_LESS );
456 
457  // Setup blending, required for transparent objects
458  glEnable( GL_BLEND );
459  glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
460 
461  glMatrixMode( GL_MODELVIEW );
462 
463  // Set up the world <-> screen transformation
465  GLdouble matrixData[16] = { 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1 };
466  matrixData[0] = worldScreenMatrix.m_data[0][0];
467  matrixData[1] = worldScreenMatrix.m_data[1][0];
468  matrixData[2] = worldScreenMatrix.m_data[2][0];
469  matrixData[4] = worldScreenMatrix.m_data[0][1];
470  matrixData[5] = worldScreenMatrix.m_data[1][1];
471  matrixData[6] = worldScreenMatrix.m_data[2][1];
472  matrixData[12] = worldScreenMatrix.m_data[0][2];
473  matrixData[13] = worldScreenMatrix.m_data[1][2];
474  matrixData[14] = worldScreenMatrix.m_data[2][2];
475  glLoadMatrixd( matrixData );
476 
477  // Set defaults
480 
481  // Remove all previously stored items
484 
488 
490  {
491  // Keep bitmap font texture always bound to the second texturing unit
492  const GLint FONT_TEXTURE_UNIT = 2;
493 
494  // Either load the font atlas to video memory, or simply bind it to a texture unit
495  if( !isBitmapFontLoaded )
496  {
497  glActiveTexture( GL_TEXTURE0 + FONT_TEXTURE_UNIT );
498  glGenTextures( 1, &fontTexture );
499  glBindTexture( GL_TEXTURE_2D, fontTexture );
500  glTexImage2D( GL_TEXTURE_2D, 0, GL_RGB8, font_image.width, font_image.height,
501  0, GL_RGB, GL_UNSIGNED_BYTE, font_image.pixels );
502  glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
503  glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
504  checkGlError( "loading bitmap font" );
505 
506  glActiveTexture( GL_TEXTURE0 );
507 
508  isBitmapFontLoaded = true;
509  }
510  else
511  {
512  glActiveTexture( GL_TEXTURE0 + FONT_TEXTURE_UNIT );
513  glBindTexture( GL_TEXTURE_2D, fontTexture );
514  glActiveTexture( GL_TEXTURE0 );
515  }
516 
517  // Set shader parameter
518  GLint ufm_fontTexture = shader->AddParameter( "fontTexture" );
519  GLint ufm_fontTextureWidth = shader->AddParameter( "fontTextureWidth" );
520  ufm_worldPixelSize = shader->AddParameter( "worldPixelSize" );
521  ufm_screenPixelSize = shader->AddParameter( "screenPixelSize" );
522  ufm_pixelSizeMultiplier = shader->AddParameter( "pixelSizeMultiplier" );
523 
524  shader->Use();
525  shader->SetParameter( ufm_fontTexture, (int) FONT_TEXTURE_UNIT );
526  shader->SetParameter( ufm_fontTextureWidth, (int) font_image.width );
527  shader->Deactivate();
528  checkGlError( "setting bitmap font sampler as shader parameter" );
529 
531  }
532 
533  shader->Use();
536  double pixelSizeMultiplier = compositor->GetAntialiasSupersamplingFactor();
537  shader->SetParameter( ufm_pixelSizeMultiplier, (float) pixelSizeMultiplier );
538  shader->Deactivate();
539 
540  // Something betreen BeginDrawing and EndDrawing seems to depend on
541  // this texture unit being active, but it does not assure it itself.
542  glActiveTexture( GL_TEXTURE0 );
543 
544  // Unbind buffers - set compositor for direct drawing
546 
547 #ifdef __WXDEBUG__
548  totalRealTime.Stop();
549  wxLogTrace( "GAL_PROFILE", wxT( "OPENGL_GAL::beginDrawing(): %.1f ms" ), totalRealTime.msecs() );
550 #endif /* __WXDEBUG__ */
551 }
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:310
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:319
void Use()
Use the shader.
Definition: shader.h:132
static GLuint fontTexture
Bitmap font texture handle (shared)
Definition: opengl_gal.h:296
VERTEX_MANAGER * overlayManager
Container for storing overlaid VERTEX_ITEMs.
Definition: opengl_gal.h:305
VECTOR2D getScreenPixelSize() const
Definition: opengl_gal.cpp:399
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:139
double GetScaleFactor() const
Get the current scale factor.
bool isContextLocked
Used for assertion checking.
Definition: opengl_gal.h:323
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:314
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:304
T m_data[3][3]
Definition: matrix3x3.h:64
double getWorldPixelSize() const
Definition: opengl_gal.cpp:392
void init()
Basic OpenGL initialization and feature checks.
OPENGL_COMPOSITOR * compositor
Handles multiple rendering targets.
Definition: opengl_gal.h:308
unsigned int mainBuffer
Main rendering target.
Definition: opengl_gal.h:309
COLOR4D strokeColor
The color of the outlines.
int AddParameter(const std::string &aParameterName)
Add a parameter to the parameter queue.
Definition: shader.cpp:126
GLint ufm_screenPixelSize
Definition: opengl_gal.h:326
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:317
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:303
virtual void Initialize() override
Function Reset() performs primary initialiation, necessary to use the object.
GLint ufm_worldPixelSize
Definition: opengl_gal.h:325
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:320
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:106
GLint ufm_pixelSizeMultiplier
Definition: opengl_gal.h:327
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:318

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::GetScaleFactor(), 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 1523 of file opengl_gal.cpp.

1524 {
1525  isGrouping = true;
1526 
1527  std::shared_ptr<VERTEX_ITEM> newItem = std::make_shared<VERTEX_ITEM>( *cachedManager );
1528  int groupNumber = getNewGroupNumber();
1529  groups.insert( std::make_pair( groupNumber, newItem ) );
1530 
1531  return groupNumber;
1532 }
bool isGrouping
Was a group started?
Definition: opengl_gal.h:322
GROUPS_MAP groups
Stores informations about VBO objects (groups)
Definition: opengl_gal.h:300
VERTEX_MANAGER * cachedManager
Container for storing cached VERTEX_ITEMs.
Definition: opengl_gal.h:303
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 617 of file opengl_gal.cpp.

618 {
619  wxASSERT_MSG( isContextLocked, "GAL_UPDATE_CONTEXT RAII object should have locked context. "
620  "Calling this from anywhere else is not allowed." );
621 
622  wxASSERT_MSG( IsVisible(), "GAL::beginUpdate() must not be entered when GAL is not visible. "
623  "Other update routines will expect everything to be initialized "
624  "which will not be the case." );
625 
626  if( !isInitialized )
627  init();
628 
629  cachedManager->Map();
630 }
bool isContextLocked
Used for assertion checking.
Definition: opengl_gal.h:323
void init()
Basic OpenGL initialization and feature checks.
void Map()
Function Map() maps vertex buffer.
VERTEX_MANAGER * cachedManager
Container for storing cached VERTEX_ITEMs.
Definition: opengl_gal.h:303
bool isInitialized
Basic initialization flag, has to be done when the window is visible.
Definition: opengl_gal.h:320
bool IsVisible() const override
Definition: opengl_gal.h:106

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

1163 {
1164  wxASSERT_MSG( !IsTextMirrored(), "No support for mirrored text using bitmap fonts." );
1165 
1166  const UTF8 text( aText );
1167  // Compute text size, so it can be properly justified
1168  VECTOR2D textSize;
1169  float commonOffset;
1170  std::tie( textSize, commonOffset ) = computeBitmapTextSize( text );
1171 
1172  const double SCALE = 1.4 * GetGlyphSize().y / textSize.y;
1173  bool overbar = false;
1174 
1175  int overbarLength = 0;
1176  double overbarHeight = textSize.y;
1177 
1178  Save();
1179 
1181  currentManager->Translate( aPosition.x, aPosition.y, layerDepth );
1182  currentManager->Rotate( aRotationAngle, 0.0f, 0.0f, -1.0f );
1183 
1184  double sx = SCALE * ( globalFlipX ? -1.0 : 1.0 );
1185  double sy = SCALE * ( globalFlipY ? -1.0 : 1.0 );
1186 
1187  currentManager->Scale( sx, sy, 0 );
1188  currentManager->Translate( 0, -commonOffset, 0 );
1189 
1190  switch( GetHorizontalJustify() )
1191  {
1193  Translate( VECTOR2D( -textSize.x / 2.0, 0 ) );
1194  break;
1195 
1197  //if( !IsTextMirrored() )
1198  Translate( VECTOR2D( -textSize.x, 0 ) );
1199  break;
1200 
1201  case GR_TEXT_HJUSTIFY_LEFT:
1202  //if( IsTextMirrored() )
1203  //Translate( VECTOR2D( -textSize.x, 0 ) );
1204  break;
1205  }
1206 
1207  switch( GetVerticalJustify() )
1208  {
1209  case GR_TEXT_VJUSTIFY_TOP:
1210  Translate( VECTOR2D( 0, -textSize.y ) );
1211  overbarHeight = -textSize.y / 2.0;
1212  break;
1213 
1215  Translate( VECTOR2D( 0, -textSize.y / 2.0 ) );
1216  overbarHeight = 0;
1217  break;
1218 
1220  break;
1221  }
1222 
1223  int i = 0;
1224 
1225  for( UTF8::uni_iter chIt = text.ubegin(), end = text.uend(); chIt < end; ++chIt )
1226  {
1227  unsigned int c = *chIt;
1228  wxASSERT_MSG( c != '\n' && c != '\r', wxT( "No support for multiline bitmap text yet" ) );
1229 
1230  bool wasOverbar = overbar;
1231 
1232  if( c == '~' )
1233  {
1234  if( ++chIt == end )
1235  break;
1236 
1237  c = *chIt;
1238 
1239  if( c == '~' )
1240  {
1241  // double ~ is really a ~ so go ahead and process the second one
1242 
1243  // so what's a triple ~? It could be a real ~ followed by an overbar, or
1244  // it could be an overbar followed by a real ~. The old algorithm did the
1245  // former so we will too....
1246  }
1247  else
1248  {
1249  overbar = !overbar;
1250  }
1251  }
1252 
1253  if( wasOverbar && !overbar )
1254  {
1255  drawBitmapOverbar( overbarLength, overbarHeight );
1256  overbarLength = 0;
1257  }
1258 
1259  if( overbar )
1260  overbarLength += drawBitmapChar( c );
1261  else
1262  drawBitmapChar( c );
1263 
1264  ++i;
1265  }
1266 
1267  // Handle the case when overbar is active till the end of the drawn text
1268  currentManager->Translate( 0, commonOffset, 0 );
1269 
1270  if( overbar && overbarLength > 0 )
1271  drawBitmapOverbar( overbarLength, overbarHeight );
1272 
1273  Restore();
1274 }
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:302
double layerDepth
The actual layer depth.
bool IsTextMirrored() const
Returns true if text should displayed mirrored.
void Translate(const VECTOR2D &aTranslation) override
Translate the context.
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:367
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:368
const VECTOR2D & GetGlyphSize() const
void Save() override
Save the context.
double a
Alpha component.
Definition: color4d.h:369
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:366
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 2000 of file opengl_gal.cpp.

2001 {
2002  if( !IsCursorEnabled() )
2003  return;
2004 
2006 
2007  const int cursorSize = fullscreenCursor ? 8000 : 80;
2008 
2009  VECTOR2D cursorBegin = cursorPosition - cursorSize / ( 2 * worldScale );
2010  VECTOR2D cursorEnd = cursorPosition + cursorSize / ( 2 * worldScale );
2011  VECTOR2D cursorCenter = ( cursorBegin + cursorEnd ) / 2;
2012 
2013  const COLOR4D cColor = getCursorColor();
2014  const COLOR4D color( cColor.r * cColor.a, cColor.g * cColor.a,
2015  cColor.b * cColor.a, 1.0 );
2016 
2017  glActiveTexture( GL_TEXTURE0 );
2018  glDisable( GL_TEXTURE_2D );
2019  glLineWidth( 1.0 );
2020  glColor4d( color.r, color.g, color.b, color.a );
2021 
2022  glBegin( GL_LINES );
2023  glVertex2d( cursorCenter.x, cursorBegin.y );
2024  glVertex2d( cursorCenter.x, cursorEnd.y );
2025 
2026  glVertex2d( cursorBegin.x, cursorCenter.y );
2027  glVertex2d( cursorEnd.x, cursorCenter.y );
2028  glEnd();
2029 }
VECTOR2D cursorPosition
Current cursor position (world coordinates)
int color
Definition: DXF_plotter.cpp:61
double g
Green component.
Definition: color4d.h:367
static const unsigned int DIRECT_RENDERING
double b
Blue component.
Definition: color4d.h:368
double a
Alpha component.
Definition: color4d.h:369
OPENGL_COMPOSITOR * compositor
Handles multiple rendering targets.
Definition: opengl_gal.h:308
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:366
bool IsCursorEnabled() const
Returns information about cursor visibility.
COLOR4D is the color representation with 4 components: red, green, blue, alpha.
Definition: color4d.h:99

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 475 of file opengl_gal.h.

476  {
477  // Bigger arcs need smaller alpha increment to make them look smooth
478  return std::min( 1e6 / aRadius, 2.0 * M_PI / CIRCLE_POINTS );
479  }
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 1549 of file opengl_gal.cpp.

1550 {
1551  if( groups[aGroupNumber] )
1552  cachedManager->ChangeItemColor( *groups[aGroupNumber], aNewColor );
1553 }
GROUPS_MAP groups
Stores informations about VBO objects (groups)
Definition: opengl_gal.h:300
VERTEX_MANAGER * cachedManager
Container for storing cached VERTEX_ITEMs.
Definition: opengl_gal.h:303
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 1556 of file opengl_gal.cpp.

1557 {
1558  if( groups[aGroupNumber] )
1559  cachedManager->ChangeItemDepth( *groups[aGroupNumber], aDepth );
1560 }
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:300
VERTEX_MANAGER * cachedManager
Container for storing cached VERTEX_ITEMs.
Definition: opengl_gal.h:303

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

◆ CheckFeatures()

wxString OPENGL_GAL::CheckFeatures ( GAL_DISPLAY_OPTIONS aOptions)
static

Checks OpenGL features.

Parameters
aOptions
Returns
wxEmptyString if OpenGL 2.1 or greater is available, otherwise returns error message

Definition at line 325 of file opengl_gal.cpp.

326 {
327 
328  wxFrame* testFrame =
329  new wxFrame( NULL, wxID_ANY, wxT( "" ), wxDefaultPosition, wxSize( 1, 1 ) );
330  KIGFX::OPENGL_GAL* opengl_gal = new KIGFX::OPENGL_GAL( aOptions, testFrame );
331 
332  testFrame->Raise();
333  testFrame->Show();
334 
335  try
336  {
337  GAL_CONTEXT_LOCKER lock( opengl_gal );
338  opengl_gal->init();
339  }
340  catch( std::runtime_error& err )
341  {
342  //Test failed
343  delete opengl_gal;
344  delete testFrame;
345  return wxString( err.what() );
346  }
347 
348  //Test passed
349  delete opengl_gal;
350  delete testFrame;
351  return wxEmptyString;
352 }
Class OpenGL_GAL is the OpenGL implementation of the Graphics Abstraction Layer.
Definition: opengl_gal.h:65
void init()
Basic OpenGL initialization and feature checks.
#define NULL

References init(), and NULL.

Referenced by EDA_DRAW_PANEL_GAL::SwitchBackend().

◆ ClearCache()

void OPENGL_GAL::ClearCache ( )
overridevirtual

Delete all data created during caching of graphic items.

Reimplemented from KIGFX::GAL.

Definition at line 1570 of file opengl_gal.cpp.

1571 {
1572  bitmapCache = std::make_unique<GL_BITMAP_CACHE>( );
1573 
1574  groups.clear();
1575 
1576  if( isInitialized )
1577  cachedManager->Clear();
1578 }
std::unique_ptr< GL_BITMAP_CACHE > bitmapCache
Definition: opengl_gal.h:329
GROUPS_MAP groups
Stores informations about VBO objects (groups)
Definition: opengl_gal.h:300
VERTEX_MANAGER * cachedManager
Container for storing cached VERTEX_ITEMs.
Definition: opengl_gal.h:303
bool isInitialized
Basic initialization flag, has to be done when the window is visible.
Definition: opengl_gal.h:320
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 1465 of file opengl_gal.cpp.

1466 {
1467  // Clear screen
1469  // NOTE: Black used here instead of m_clearColor; it will be composited later
1470  glClearColor( 0, 0, 0, 1 );
1471  glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT );
1472 }
static const unsigned int DIRECT_RENDERING
OPENGL_COMPOSITOR * compositor
Handles multiple rendering targets.
Definition: opengl_gal.h:308
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 1609 of file opengl_gal.cpp.

1610 {
1611  // Save the current state
1612  unsigned int oldTarget = compositor->GetBuffer();
1613 
1614  switch( aTarget )
1615  {
1616  // Cached and noncached items are rendered to the same buffer
1617  default:
1618  case TARGET_CACHED:
1619  case TARGET_NONCACHED:
1621  break;
1622 
1623  case TARGET_OVERLAY:
1624  if( overlayBuffer )
1626  break;
1627  }
1628 
1629 
1630  if( aTarget != TARGET_OVERLAY )
1632  else if( overlayBuffer )
1634 
1635  // Restore the previous state
1636  compositor->SetBuffer( oldTarget );
1637 }
unsigned int overlayBuffer
Auxiliary rendering target (for menus etc.)
Definition: opengl_gal.h:310
Auxiliary rendering target (noncached)
Definition: definitions.h:49
static const COLOR4D BLACK
Definition: color4d.h:376
OPENGL_COMPOSITOR * compositor
Handles multiple rendering targets.
Definition: opengl_gal.h:308
unsigned int mainBuffer
Main rendering target.
Definition: opengl_gal.h:309
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 1950 of file opengl_gal.cpp.

1951 {
1952  VECTOR2D textSize( 0, 0 );
1953  float commonOffset = std::numeric_limits<float>::max();
1954  static const auto defaultGlyph = LookupGlyph( '(' ); // for strange chars
1955 
1956  for( UTF8::uni_iter chIt = aText.ubegin(), end = aText.uend(); chIt < end; ++chIt )
1957  {
1958  unsigned int c = *chIt;
1959 
1960  const FONT_GLYPH_TYPE* glyph = LookupGlyph( c );
1961  // Debug: show not coded char in the atlas
1962  // Be carefull before allowing the assert: it usually crash kicad
1963  // when the assert is made during a paint event.
1964  // wxASSERT_MSG( glyph, wxString::Format( "missing char in font: code 0x%x <%c>", c, c ) );
1965 
1966  if( !glyph || // Not coded in font
1967  c == '-' || c == '_' ) // Strange size of these 2 chars
1968  {
1969  glyph = defaultGlyph;
1970  }
1971 
1972  if( glyph )
1973  {
1974  textSize.x += glyph->advance;
1975  }
1976  }
1977 
1978  textSize.y = std::max<float>( textSize.y, font_information.max_y - defaultGlyph->miny );
1979  commonOffset = std::min<float>( font_information.max_y - defaultGlyph->maxy, commonOffset );
1980  textSize.y -= commonOffset;
1981 
1982  return std::make_pair( textSize, commonOffset );
1983 }
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 1136 of file graphics_abstraction_layer.h.

1137  {
1139  }
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 2196 of file opengl_gal.cpp.

2197 {
2198  auto pixelSize = worldScale;
2199 
2200  lookAtPoint.x = roundr( lookAtPoint.x, pixelSize );
2201  lookAtPoint.y = roundr( lookAtPoint.y, pixelSize );
2202 
2204 }
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 1563 of file opengl_gal.cpp.

1564 {
1565  // Frees memory in the container as well
1566  groups.erase( aGroupNumber );
1567 }
GROUPS_MAP groups
Stores informations about VBO objects (groups)
Definition: opengl_gal.h:300

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

757 {
758  if( aRadius <= 0 )
759  return;
760 
761  // Swap the angles, if start angle is greater than end angle
762  SWAP( aStartAngle, >, aEndAngle );
763 
764  const double alphaIncrement = calcAngleStep( aRadius );
765 
766  Save();
767  currentManager->Translate( aCenterPoint.x, aCenterPoint.y, 0.0 );
768 
769  if( isFillEnabled )
770  {
771  double alpha;
774 
775  // Triangle fan
776  for( alpha = aStartAngle; ( alpha + alphaIncrement ) < aEndAngle; )
777  {
778  currentManager->Reserve( 3 );
779  currentManager->Vertex( 0.0, 0.0, layerDepth );
780  currentManager->Vertex( cos( alpha ) * aRadius, sin( alpha ) * aRadius, layerDepth );
781  alpha += alphaIncrement;
782  currentManager->Vertex( cos( alpha ) * aRadius, sin( alpha ) * aRadius, layerDepth );
783  }
784 
785  // The last missing triangle
786  const VECTOR2D endPoint( cos( aEndAngle ) * aRadius, sin( aEndAngle ) * aRadius );
787 
788  currentManager->Reserve( 3 );
789  currentManager->Vertex( 0.0, 0.0, layerDepth );
790  currentManager->Vertex( cos( alpha ) * aRadius, sin( alpha ) * aRadius, layerDepth );
791  currentManager->Vertex( endPoint.x, endPoint.y, layerDepth );
792  }
793 
794  if( isStrokeEnabled )
795  {
797 
798  VECTOR2D p( cos( aStartAngle ) * aRadius, sin( aStartAngle ) * aRadius );
799  double alpha;
800 
801  for( alpha = aStartAngle + alphaIncrement; alpha <= aEndAngle; alpha += alphaIncrement )
802  {
803  VECTOR2D p_next( cos( alpha ) * aRadius, sin( alpha ) * aRadius );
804  DrawLine( p, p_next );
805 
806  p = p_next;
807  }
808 
809  // Draw the last missing part
810  if( alpha != aEndAngle )
811  {
812  VECTOR2D p_last( cos( aEndAngle ) * aRadius, sin( aEndAngle ) * aRadius );
813  DrawLine( p, p_last );
814  }
815  }
816 
817  Restore();
818 }
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:302
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.
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:367
COLOR4D fillColor
The fill color.
double b
Blue component.
Definition: color4d.h:368
void Save() override
Save the context.
double a
Alpha component.
Definition: color4d.h:369
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:475
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 DrawLine(const VECTOR2D &aStartPoint, const VECTOR2D &aEndPoint) override
Draw a line.
Definition: opengl_gal.cpp:642
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:366

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

823 {
824  if( aRadius <= 0 )
825  {
826  // Arcs of zero radius are a circle of aWidth diameter
827  if( aWidth > 0 )
828  DrawCircle( aCenterPoint, aWidth / 2.0 );
829 
830  return;
831  }
832 
833  // Swap the angles, if start angle is greater than end angle
834  SWAP( aStartAngle, >, aEndAngle );
835 
836  const double alphaIncrement = calcAngleStep( aRadius );
837 
838  Save();
839  currentManager->Translate( aCenterPoint.x, aCenterPoint.y, 0.0 );
840 
841  if( isStrokeEnabled )
842  {
844 
845  double width = aWidth / 2.0;
846  VECTOR2D startPoint( cos( aStartAngle ) * aRadius,
847  sin( aStartAngle ) * aRadius );
848  VECTOR2D endPoint( cos( aEndAngle ) * aRadius,
849  sin( aEndAngle ) * aRadius );
850 
851  drawStrokedSemiCircle( startPoint, width, aStartAngle + M_PI );
852  drawStrokedSemiCircle( endPoint, width, aEndAngle );
853 
854  VECTOR2D pOuter( cos( aStartAngle ) * ( aRadius + width ),
855  sin( aStartAngle ) * ( aRadius + width ) );
856 
857  VECTOR2D pInner( cos( aStartAngle ) * ( aRadius - width ),
858  sin( aStartAngle ) * ( aRadius - width ) );
859 
860  double alpha;
861 
862  for( alpha = aStartAngle + alphaIncrement; alpha <= aEndAngle; alpha += alphaIncrement )
863  {
864  VECTOR2D pNextOuter( cos( alpha ) * ( aRadius + width ),
865  sin( alpha ) * ( aRadius + width ) );
866  VECTOR2D pNextInner( cos( alpha ) * ( aRadius - width ),
867  sin( alpha ) * ( aRadius - width ) );
868 
869  DrawLine( pOuter, pNextOuter );
870  DrawLine( pInner, pNextInner );
871 
872  pOuter = pNextOuter;
873  pInner = pNextInner;
874  }
875 
876  // Draw the last missing part
877  if( alpha != aEndAngle )
878  {
879  VECTOR2D pLastOuter( cos( aEndAngle ) * ( aRadius + width ),
880  sin( aEndAngle ) * ( aRadius + width ) );
881  VECTOR2D pLastInner( cos( aEndAngle ) * ( aRadius - width ),
882  sin( aEndAngle ) * ( aRadius - width ) );
883 
884  DrawLine( pOuter, pLastOuter );
885  DrawLine( pInner, pLastInner );
886  }
887  }
888 
889  if( isFillEnabled )
890  {
892  SetLineWidth( aWidth );
893 
894  VECTOR2D p( cos( aStartAngle ) * aRadius, sin( aStartAngle ) * aRadius );
895  double alpha;
896 
897  for( alpha = aStartAngle + alphaIncrement; alpha <= aEndAngle; alpha += alphaIncrement )
898  {
899  VECTOR2D p_next( cos( alpha ) * aRadius, sin( alpha ) * aRadius );
900  DrawLine( p, p_next );
901 
902  p = p_next;
903  }
904 
905  // Draw the last missing part
906  if( alpha != aEndAngle )
907  {
908  VECTOR2D p_last( cos( aEndAngle ) * aRadius, sin( aEndAngle ) * aRadius );
909  DrawLine( p, p_last );
910  }
911  }
912 
913  Restore();
914 }
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:302
void Restore() override
Restore the context.
double g
Green component.
Definition: color4d.h:367
COLOR4D fillColor
The fill color.
virtual void SetLineWidth(float aLineWidth)
Set the line width.
double b
Blue component.
Definition: color4d.h:368
void Save() override
Save the context.
double a
Alpha component.
Definition: color4d.h:369
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:475
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 DrawLine(const VECTOR2D &aStartPoint, const VECTOR2D &aEndPoint) override
Draw a line.
Definition: opengl_gal.cpp:642
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:366
void DrawCircle(const VECTOR2D &aCenterPoint, double aRadius) override
Draw a circle using world coordinates.
Definition: opengl_gal.cpp:699

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

1107 {
1108  // We have to calculate the pixel size in users units to draw the image.
1109  // worldUnitLength is a factor used for converting IU to inches
1110  double scale = 1.0 / ( aBitmap.GetPPI() * worldUnitLength );
1111  double w = (double) aBitmap.GetSizePixels().x * scale;
1112  double h = (double) aBitmap.GetSizePixels().y * scale;
1113 
1114  auto xform = currentManager->GetTransformation();
1115 
1116  glm::vec4 v0 = xform * glm::vec4( -w/2, -h/2, 0.0, 0.0 );
1117  glm::vec4 v1 = xform * glm::vec4( w/2, h/2, 0.0, 0.0 );
1118  glm::vec4 trans = xform[3];
1119 
1120  auto texture_id = bitmapCache->RequestBitmap( &aBitmap );
1121 
1122  if( !glIsTexture( texture_id ) ) // ensure the bitmap texture is still valid
1123  return;
1124 
1125  auto oldTarget = GetTarget();
1126 
1127  glPushMatrix();
1128  glTranslated( trans.x, trans.y, trans.z );
1129 
1131  glEnable(GL_TEXTURE_2D);
1132  glActiveTexture( GL_TEXTURE0 );
1133  glBindTexture( GL_TEXTURE_2D, texture_id );
1134 
1135  glBegin( GL_QUADS );
1136  glColor4f( 1.0, 1.0, 1.0, 1.0 );
1137  glTexCoord2f( 0.0, 0.0 );
1138  glVertex3f( v0.x, v0.y, layerDepth );
1139  glColor4f( 1.0, 1.0, 1.0, 1.0 );
1140  glTexCoord2f( 1.0, 0.0 );
1141  glVertex3f( v1.x, v0.y, layerDepth );
1142  glColor4f( 1.0, 1.0, 1.0, 1.0 );
1143  glTexCoord2f( 1.0, 1.0 );
1144  glVertex3f( v1.x, v1.y, layerDepth );
1145  glColor4f( 1.0, 1.0, 1.0, 1.0 );
1146  glTexCoord2f( 0.0, 1.0 );
1147  glVertex3f( v0.x, v1.y, layerDepth );
1148  glEnd();
1149 
1150  SetTarget( oldTarget );
1151  glBindTexture( GL_TEXTURE_2D, 0 );
1152 
1153 #ifdef DISABLE_BITMAP_CACHE
1154  glDeleteTextures( 1, &texture_id );
1155 #endif
1156 
1157  glPopMatrix();
1158 }
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:302
const glm::mat4 & GetTransformation() const
double layerDepth
The actual layer depth.
std::unique_ptr< GL_BITMAP_CACHE > bitmapCache
Definition: opengl_gal.h:329
Auxiliary rendering target (noncached)
Definition: definitions.h:49
RENDER_TARGET GetTarget() const override
Gets the currently used target for rendering.
double worldUnitLength
The unit length of the world coordinates [inch].
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 1845 of file opengl_gal.cpp.

1846 {
1847  const float TEX_X = font_image.width;
1848  const float TEX_Y = font_image.height;
1849 
1850  // handle space
1851  if( aChar == ' ' )
1852  {
1853  const FONT_GLYPH_TYPE* g = LookupGlyph( 'x' );
1854  wxASSERT( g );
1855 
1856  if( !g ) // Should not happen.
1857  return 0;
1858 
1859  Translate( VECTOR2D( g->advance, 0 ) );
1860  return g->advance;
1861  }
1862 
1863  const FONT_GLYPH_TYPE* glyph = LookupGlyph( aChar );
1864 
1865  // If the glyph is not found (happens for many esotheric unicode chars)
1866  // shows a '?' instead.
1867  if( !glyph )
1868  glyph = LookupGlyph( '?' );
1869 
1870  if( !glyph ) // Should not happen.
1871  return 0;
1872 
1873  const float X = glyph->atlas_x + font_information.smooth_pixels;
1874  const float Y = glyph->atlas_y + font_information.smooth_pixels;
1875  const float XOFF = glyph->minx;
1876 
1877  // adjust for height rounding
1878  const float round_adjust = ( glyph->maxy - glyph->miny )
1879  - float( glyph->atlas_h - font_information.smooth_pixels * 2 );
1880  const float top_adjust = font_information.max_y - glyph->maxy;
1881  const float YOFF = round_adjust + top_adjust;
1882  const float W = glyph->atlas_w - font_information.smooth_pixels *2;
1883  const float H = glyph->atlas_h - font_information.smooth_pixels *2;
1884  const float B = 0;
1885 
1886  currentManager->Reserve( 6 );
1887  Translate( VECTOR2D( XOFF, YOFF ) );
1888  /* Glyph:
1889  * v0 v1
1890  * +--+
1891  * | /|
1892  * |/ |
1893  * +--+
1894  * v2 v3
1895  */
1896  currentManager->Shader( SHADER_FONT, X / TEX_X, ( Y + H ) / TEX_Y );
1897  currentManager->Vertex( -B, -B, 0 ); // v0
1898 
1899  currentManager->Shader( SHADER_FONT, ( X + W ) / TEX_X, ( Y + H ) / TEX_Y );
1900  currentManager->Vertex( W + B, -B, 0 ); // v1
1901 
1902  currentManager->Shader( SHADER_FONT, X / TEX_X, Y / TEX_Y );
1903  currentManager->Vertex( -B, H + B, 0 ); // v2
1904 
1905 
1906  currentManager->Shader( SHADER_FONT, ( X + W ) / TEX_X, ( Y + H ) / TEX_Y );
1907  currentManager->Vertex( W + B, -B, 0 ); // v1
1908 
1909  currentManager->Shader( SHADER_FONT, X / TEX_X, Y / TEX_Y );
1910  currentManager->Vertex( -B, H + B, 0 ); // v2
1911 
1912  currentManager->Shader( SHADER_FONT, ( X + W ) / TEX_X, Y / TEX_Y );
1913  currentManager->Vertex( W + B, H + B, 0 ); // v3
1914 
1915  Translate( VECTOR2D( -XOFF + glyph->advance, -YOFF ) );
1916 
1917  return glyph->advance;
1918 }
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:302
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 1921 of file opengl_gal.cpp.

1922 {
1923  // To draw an overbar, simply draw an overbar
1924  const FONT_GLYPH_TYPE* glyph = LookupGlyph( '_' );
1925  wxCHECK( glyph, /* void */ );
1926 
1927  const float H = glyph->maxy - glyph->miny;
1928 
1929  Save();
1930 
1931  Translate( VECTOR2D( -aLength, -aHeight-1.5*H ) );
1932 
1933  currentManager->Reserve( 6 );
1935 
1936  currentManager->Shader( 0 );
1937 
1938  currentManager->Vertex( 0, 0, 0 ); // v0
1939  currentManager->Vertex( aLength, 0, 0 ); // v1
1940  currentManager->Vertex( 0, H, 0 ); // v2
1941 
1942  currentManager->Vertex( aLength, 0, 0 ); // v1
1943  currentManager->Vertex( 0, H, 0 ); // v2
1944  currentManager->Vertex( aLength, H, 0 ); // v3
1945 
1946  Restore();
1947 }
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:302
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.
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:367
const FONT_GLYPH_TYPE * LookupGlyph(unsigned int aCodepoint)
double b
Blue component.
Definition: color4d.h:368
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:366

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

700 {
701  if( isFillEnabled )
702  {
703  currentManager->Reserve( 3 );
705 
706  /* Draw a triangle that contains the circle, then shade it leaving only the circle.
707  * Parameters given to Shader() are indices of the triangle's vertices
708  * (if you want to understand more, check the vertex shader source [shader.vert]).
709  * Shader uses this coordinates to determine if fragments are inside the circle or not.
710  * Does the calculations in the vertex shader now (pixel alignment)
711  * v2
712  * /\
713  * //\\
714  * v0 /_\/_\ v1
715  */
716  currentManager->Shader( SHADER_FILLED_CIRCLE, 1.0, aRadius );
717  currentManager->Vertex( aCenterPoint.x, aCenterPoint.y, layerDepth );
718 
719  currentManager->Shader( SHADER_FILLED_CIRCLE, 2.0, aRadius );
720  currentManager->Vertex( aCenterPoint.x, aCenterPoint.y, layerDepth );
721 
722  currentManager->Shader( SHADER_FILLED_CIRCLE, 3.0, aRadius );
723  currentManager->Vertex( aCenterPoint.x, aCenterPoint.y, layerDepth );
724  }
725  if( isStrokeEnabled )
726  {
727  currentManager->Reserve( 3 );
729 
730  /* Draw a triangle that contains the circle, then shade it leaving only the circle.
731  * Parameters given to Shader() are indices of the triangle's vertices
732  * (if you want to understand more, check the vertex shader source [shader.vert]).
733  * and the line width. Shader uses this coordinates to determine if fragments are
734  * inside the circle or not.
735  * v2
736  * /\
737  * //\\
738  * v0 /_\/_\ v1
739  */
741  currentManager->Vertex( aCenterPoint.x, // v0
742  aCenterPoint.y, layerDepth );
743 
745  currentManager->Vertex( aCenterPoint.x, // v1
746  aCenterPoint.y, layerDepth );
747 
749  currentManager->Vertex( aCenterPoint.x, aCenterPoint.y, // v2
750  layerDepth );
751  }
752 }
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:302
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:367
COLOR4D fillColor
The fill color.
double b
Blue component.
Definition: color4d.h:368
double a
Alpha component.
Definition: color4d.h:369
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:366

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

1656 {
1657  // Now we should only store the position of the mouse cursor
1658  // The real drawing routines are in blitCursor()
1659  //VECTOR2D screenCursor = worldScreenMatrix * aCursorPosition;
1660  //cursorPosition = screenWorldMatrix * VECTOR2D( screenCursor.x, screenCursor.y );
1661  cursorPosition = aCursorPosition;
1662 }
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 1087 of file opengl_gal.cpp.

1090 {
1091  std::vector<VECTOR2D> output;
1092  std::vector<VECTOR2D> pointCtrl;
1093 
1094  pointCtrl.push_back( aStartPoint );
1095  pointCtrl.push_back( aControlPointA );
1096  pointCtrl.push_back( aControlPointB );
1097  pointCtrl.push_back( aEndPoint );
1098 
1099  BEZIER_POLY converter( pointCtrl );
1100  converter.GetPoly( output, aFilterValue );
1101 
1102  DrawPolyline( &output[0], output.size() );
1103 }
void DrawPolyline(const std::deque< VECTOR2D > &aPointList) override
Draw a polyline.
Definition: opengl_gal.cpp:955
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 1726 of file opengl_gal.cpp.

1728 {
1729  Save();
1730 
1731  currentManager->Reserve( 3 );
1732  currentManager->Translate( aCenterPoint.x, aCenterPoint.y, 0.0f );
1733  currentManager->Rotate( aAngle, 0.0f, 0.0f, 1.0f );
1734 
1735  /* Draw a triangle that contains the semicircle, then shade it to leave only
1736  * the semicircle. Parameters given to Shader() are indices of the triangle's vertices
1737  * (if you want to understand more, check the vertex shader source [shader.vert]).
1738  * Shader uses these coordinates to determine if fragments are inside the semicircle or not.
1739  * v2
1740  * /\
1741  * /__\
1742  * v0 //__\\ v1
1743  */
1745  currentManager->Vertex( -aRadius * 3.0f / sqrt( 3.0f ), 0.0f, layerDepth ); // v0
1746 
1748  currentManager->Vertex( aRadius * 3.0f / sqrt( 3.0f ), 0.0f, layerDepth ); // v1
1749 
1751  currentManager->Vertex( 0.0f, aRadius * 2.0f, layerDepth ); // v2
1752 
1753  Restore();
1754 }
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:302
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.
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...
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 1277 of file opengl_gal.cpp.

1278 {
1281 
1283 
1284  // sub-pixel lines all render the same
1285  float minorLineWidth =
1286  std::fmax( 1.0f, gridLineWidth ) * getWorldPixelSize() / GetScaleFactor();
1287  float majorLineWidth = minorLineWidth * 2.0f;
1288 
1289  // Draw the axis and grid
1290  // For the drawing the start points, end points and increments have
1291  // to be calculated in world coordinates
1292  VECTOR2D worldStartPoint = screenWorldMatrix * VECTOR2D( 0.0, 0.0 );
1293  VECTOR2D worldEndPoint = screenWorldMatrix * VECTOR2D( screenSize );
1294 
1295  // Draw axes if desired
1296  if( axesEnabled )
1297  {
1298  SetLineWidth( minorLineWidth );
1300 
1301  DrawLine( VECTOR2D( worldStartPoint.x, 0 ), VECTOR2D( worldEndPoint.x, 0 ) );
1302  DrawLine( VECTOR2D( 0, worldStartPoint.y ), VECTOR2D( 0, worldEndPoint.y ) );
1303  }
1304 
1305  // force flush
1307 
1308  if( !gridVisibility || gridSize.x == 0 || gridSize.y == 0 )
1309  return;
1310 
1311  VECTOR2D gridScreenSize( gridSize );
1312 
1313  double gridThreshold = computeMinGridSpacing() / worldScale;
1314 
1316  gridThreshold *= 2.0;
1317 
1318  // If we cannot display the grid density, scale down by a tick size and
1319  // try again. Eventually, we get some representation of the grid
1320  while( std::min( gridScreenSize.x, gridScreenSize.y ) <= gridThreshold )
1321  {
1322  gridScreenSize = gridScreenSize * static_cast<double>( gridTick );
1323  }
1324 
1325  // Compute grid starting and ending indexes to draw grid points on the
1326  // visible screen area
1327  // Note: later any point coordinate will be offsetted by gridOrigin
1328  int gridStartX = KiROUND( ( worldStartPoint.x - gridOrigin.x ) / gridScreenSize.x );
1329  int gridEndX = KiROUND( ( worldEndPoint.x - gridOrigin.x ) / gridScreenSize.x );
1330  int gridStartY = KiROUND( ( worldStartPoint.y - gridOrigin.y ) / gridScreenSize.y );
1331  int gridEndY = KiROUND( ( worldEndPoint.y - gridOrigin.y ) / gridScreenSize.y );
1332 
1333  // Ensure start coordinate > end coordinate
1334  SWAP( gridStartX, >, gridEndX );
1335  SWAP( gridStartY, >, gridEndY );
1336 
1337  // Ensure the grid fills the screen
1338  --gridStartX; ++gridEndX;
1339  --gridStartY; ++gridEndY;
1340 
1341  glDisable( GL_DEPTH_TEST );
1342  glDisable( GL_TEXTURE_2D );
1343 
1344  if( gridStyle == GRID_STYLE::DOTS )
1345  {
1346  glEnable( GL_STENCIL_TEST );
1347  glStencilFunc( GL_ALWAYS, 1, 1 );
1348  glStencilOp( GL_KEEP, GL_KEEP, GL_INCR );
1349  glColor4d( 0.0, 0.0, 0.0, 0.0 );
1350  SetStrokeColor( COLOR4D( 0.0, 0.0, 0.0, 0.0 ) );
1351  }
1352  else
1353  {
1354  glColor4d( gridColor.r, gridColor.g, gridColor.b, gridColor.a );
1356  }
1357 
1359  {
1360 
1361  // Vertical positions
1362  for( int j = gridStartY; j <= gridEndY; j++ )
1363  {
1364  bool tickY = ( j % gridTick == 0 );
1365  const double posY = j * gridScreenSize.y + gridOrigin.y;
1366 
1367  // Horizontal positions
1368  for( int i = gridStartX; i <= gridEndX; i++ )
1369  {
1370  bool tickX = ( i % gridTick == 0 );
1371  SetLineWidth( ( ( tickX && tickY ) ? majorLineWidth : minorLineWidth ) );
1372  auto lineLen = 2.0 * GetLineWidth();
1373  auto posX = i * gridScreenSize.x + gridOrigin.x;
1374 
1375  DrawLine( VECTOR2D( posX - lineLen, posY ), VECTOR2D( posX + lineLen, posY ) );
1376  DrawLine( VECTOR2D( posX, posY - lineLen ), VECTOR2D( posX, posY + lineLen ) );
1377  }
1378  }
1379 
1381  }
1382  else
1383  {
1384  // Vertical lines
1385  for( int j = gridStartY; j <= gridEndY; j++ )
1386  {
1387  const double y = j * gridScreenSize.y + gridOrigin.y;
1388 
1389  // If axes are drawn, skip the lines that would cover them
1390  if( axesEnabled && y == 0.0 )
1391  continue;
1392 
1393  SetLineWidth( ( j % gridTick == 0 ) ? majorLineWidth : minorLineWidth );
1394  VECTOR2D a ( gridStartX * gridScreenSize.x + gridOrigin.x, y );
1395  VECTOR2D b ( gridEndX * gridScreenSize.x + gridOrigin.x, y );
1396 
1397  DrawLine( a, b );
1398  }
1399 
1401 
1402  if( gridStyle == GRID_STYLE::DOTS )
1403  {
1404  glStencilFunc( GL_NOTEQUAL, 0, 1 );
1405  glColor4d( gridColor.r, gridColor.g, gridColor.b, gridColor.a );
1407  }
1408 
1409  // Horizontal lines
1410  for( int i = gridStartX; i <= gridEndX; i++ )
1411  {
1412  const double x = i * gridScreenSize.x + gridOrigin.x;
1413 
1414  // If axes are drawn, skip the lines that would cover them
1415  if( axesEnabled && x == 0.0 )
1416  continue;
1417 
1418  SetLineWidth( ( i % gridTick == 0 ) ? majorLineWidth : minorLineWidth );
1419  VECTOR2D a ( x, gridStartY * gridScreenSize.y + gridOrigin.y );
1420  VECTOR2D b ( x, gridEndY * gridScreenSize.y + gridOrigin.y );
1421  DrawLine( a, b );
1422  }
1423 
1425 
1426  if( gridStyle == GRID_STYLE::DOTS )
1427  glDisable( GL_STENCIL_TEST );
1428  }
1429 
1430  glEnable( GL_DEPTH_TEST );
1431  glEnable( GL_TEXTURE_2D );
1432 }
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 GetScaleFactor() const
Get the current scale factor.
double g
Green component.
Definition: color4d.h:367
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:304
double b
Blue component.
Definition: color4d.h:368
Auxiliary rendering target (noncached)
Definition: definitions.h:49
double getWorldPixelSize() const
Definition: opengl_gal.cpp:392
double a
Alpha component.
Definition: color4d.h:369
OPENGL_COMPOSITOR * compositor
Handles multiple rendering targets.
Definition: opengl_gal.h:308
VECTOR2< double > VECTOR2D
Definition: vector2d.h:593
unsigned int mainBuffer
Main rendering target.
Definition: opengl_gal.h:309
COLOR4D axesColor
Color of the axes.
float gridLineWidth
Line width of the grid.
void DrawLine(const VECTOR2D &aStartPoint, const VECTOR2D &aEndPoint) override
Draw a line.
Definition: opengl_gal.cpp:642
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.
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.
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:68
#define SWAP(varA, condition, varB)
Swap the variables if a condition is met.
Definition: definitions.h:31
double r
Red component.
Definition: color4d.h:366
COLOR4D is the color representation with 4 components: red, green, blue, alpha.
Definition: color4d.h:99

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, KIGFX::GAL::GetLineWidth(), HIDPI_GL_CANVAS::GetScaleFactor(), 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 1542 of file opengl_gal.cpp.

1543 {
1544  if( groups[aGroupNumber] )
1545  cachedManager->DrawItem( *groups[aGroupNumber] );
1546 }
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:300
VERTEX_MANAGER * cachedManager
Container for storing cached VERTEX_ITEMs.
Definition: opengl_gal.h:303

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

643 {
645 
646  drawLineQuad( aStartPoint, aEndPoint );
647 }
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:302
void drawLineQuad(const VECTOR2D &aStartPoint, const VECTOR2D &aEndPoint)
Draw a quad for the line.
double g
Green component.
Definition: color4d.h:367
double b
Blue component.
Definition: color4d.h:368
double a
Alpha component.
Definition: color4d.h:369
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:366

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

1666 {
1667  /* Helper drawing: ____--- v3 ^
1668  * ____---- ... \ \
1669  * ____---- ... \ end \
1670  * v1 ____---- ... ____---- \ width
1671  * ---- ...___---- \ \
1672  * \ ___...-- \ v
1673  * \ ____----... ____---- v2
1674  * ---- ... ____----
1675  * start \ ... ____----
1676  * \... ____----
1677  * ----
1678  * v0
1679  * dots mark triangles' hypotenuses
1680  */
1681 
1682  auto v1 = currentManager->GetTransformation() * glm::vec4( aStartPoint.x, aStartPoint.y, 0.0, 0.0 );
1683  auto v2 = currentManager->GetTransformation() * glm::vec4( aEndPoint.x, aEndPoint.y, 0.0, 0.0 );
1684 
1685  VECTOR2D vs( v2.x - v1.x, v2.y - v1.y );
1686 
1687  currentManager->Reserve( 6 );
1688 
1689  // Line width is maintained by the vertex shader
1690  currentManager->Shader( SHADER_LINE_A, lineWidth, vs.x, vs.y );
1691  currentManager->Vertex( aStartPoint, layerDepth );
1692 
1693  currentManager->Shader( SHADER_LINE_B, lineWidth, vs.x, vs.y );
1694  currentManager->Vertex( aStartPoint, layerDepth );
1695 
1696  currentManager->Shader( SHADER_LINE_C, lineWidth, vs.x, vs.y );
1697  currentManager->Vertex( aEndPoint, layerDepth );
1698 
1699  currentManager->Shader( SHADER_LINE_D, lineWidth, vs.x, vs.y );
1700  currentManager->Vertex( aEndPoint, layerDepth );
1701 
1702  currentManager->Shader( SHADER_LINE_E, lineWidth, vs.x, vs.y );
1703  currentManager->Vertex( aEndPoint, layerDepth );
1704 
1705  currentManager->Shader( SHADER_LINE_F, lineWidth, vs.x, vs.y );
1706  currentManager->Vertex( aStartPoint, layerDepth );
1707 }
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:302
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 978 of file opengl_gal.cpp.

979 {
980  auto points = std::unique_ptr<GLdouble[]>( new GLdouble[3 * aPointList.size()] );
981  GLdouble* ptr = points.get();
982 
983  for( const VECTOR2D& p : aPointList )
984  {
985  *ptr++ = p.x;
986  *ptr++ = p.y;
987  *ptr++ = layerDepth;
988  }
989 
990  drawPolygon( points.get(), aPointList.size() );
991 }
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 994 of file opengl_gal.cpp.

995 {
996  auto points = std::unique_ptr<GLdouble[]>( new GLdouble[3 * aListSize] );
997  GLdouble* target = points.get();
998  const VECTOR2D* src = aPointList;
999 
1000  for( int i = 0; i < aListSize; ++i )
1001  {
1002  *target++ = src->x;
1003  *target++ = src->y;
1004  *target++ = layerDepth;
1005  ++src;
1006  }
1007 
1008  drawPolygon( points.get(), aListSize );
1009 }
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 1049 of file opengl_gal.cpp.

1050 {
1051  if ( aPolySet.IsTriangulationUpToDate() )
1052  {
1053  drawTriangulatedPolyset( aPolySet );
1054  return;
1055  }
1056 
1057  for( int j = 0; j < aPolySet.OutlineCount(); ++j )
1058  {
1059  const SHAPE_LINE_CHAIN& outline = aPolySet.COutline( j );
1060  DrawPolygon( outline );
1061  }
1062 }
int OutlineCount() const
Returns the number of outlines in the set
void DrawPolygon(const std::deque< VECTOR2D > &aPointList) override
Draw a polygon.
Definition: opengl_gal.cpp:978
bool IsTriangulationUpToDate() const
void drawTriangulatedPolyset(const SHAPE_POLY_SET &aPoly)
Draws a set of polygons with a cached triangulation.
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 1066 of file opengl_gal.cpp.

1067 {
1068  if( aPolygon.SegmentCount() == 0 )
1069  return;
1070 
1071  const int pointCount = aPolygon.SegmentCount() + 1;
1072  std::unique_ptr<GLdouble[]> points( new GLdouble[3 * pointCount] );
1073  GLdouble* ptr = points.get();
1074 
1075  for( int i = 0; i < pointCount; ++i )
1076  {
1077  const VECTOR2I& p = aPolygon.CPoint( i );
1078  *ptr++ = p.x;
1079  *ptr++ = p.y;
1080  *ptr++ = layerDepth;
1081  }
1082 
1083  drawPolygon( points.get(), pointCount );
1084 }
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 1791 of file opengl_gal.cpp.

1792 {
1793  if( isFillEnabled )
1794  {
1797 
1798  // Any non convex polygon needs to be tesselated
1799  // for this purpose the GLU standard functions are used
1800  TessParams params = { currentManager, tessIntersects };
1801  gluTessBeginPolygon( tesselator, &params );
1802  gluTessBeginContour( tesselator );
1803 
1804  GLdouble* point = aPoints;
1805 
1806  for( int i = 0; i < aPointCount; ++i )
1807  {
1808  gluTessVertex( tesselator, point, point );
1809  point += 3; // 3 coordinates
1810  }
1811 
1812  gluTessEndContour( tesselator );
1813  gluTessEndPolygon( tesselator );
1814 
1815  // Free allocated intersecting points
1816  tessIntersects.clear();
1817  }
1818 
1819  if( isStrokeEnabled )
1820  {
1821  drawPolyline( [&](int idx) { return VECTOR2D( aPoints[idx * 3], aPoints[idx * 3 + 1] ); },
1822  aPointCount );
1823  }
1824 }
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:302
double g
Green component.
Definition: color4d.h:367
COLOR4D fillColor
The fill color.
double b
Blue component.
Definition: color4d.h:368
double a
Alpha component.
Definition: color4d.h:369
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:352
bool isFillEnabled
Is filling of graphic objects enabled ?
std::deque< boost::shared_array< GLdouble > > tessIntersects
Storage for intersecting points.
Definition: opengl_gal.h:354
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:366

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

956 {
957  drawPolyline( [&](int idx) { return aPointList[idx]; }, aPointList.size() );
958 }
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 961 of file opengl_gal.cpp.

962 {
963  drawPolyline( [&](int idx) { return aPointList[idx]; }, aListSize );
964 }
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 967 of file opengl_gal.cpp.

968 {
969  auto numPoints = aLineChain.PointCount();
970 
971  if( aLineChain.IsClosed() )
972  numPoints += 1;
973 
974  drawPolyline( [&](int idx) { return aLineChain.CPoint(idx); }, numPoints );
975 }
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 1827 of file opengl_gal.cpp.

1828 {
1829  if( aPointCount < 2 )
1830  return;
1831 
1833  int i;
1834 
1835  for( i = 1; i < aPointCount; ++i )
1836  {
1837  auto start = aPointGetter( i - 1 );
1838  auto end = aPointGetter( i );
1839 
1840  drawLineQuad( start, end );
1841  }
1842 }
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:302
void drawLineQuad(const VECTOR2D &aStartPoint, const VECTOR2D &aEndPoint)
Draw a quad for the line.
double g
Green component.
Definition: color4d.h:367
double b
Blue component.
Definition: color4d.h:368
double a
Alpha component.
Definition: color4d.h:369
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:366

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

918 {
919  // Compute the diagonal points of the rectangle
920  VECTOR2D diagonalPointA( aEndPoint.x, aStartPoint.y );
921  VECTOR2D diagonalPointB( aStartPoint.x, aEndPoint.y );
922 
923  // Fill the rectangle
924  if( isFillEnabled )
925  {
926  currentManager->Reserve( 6 );
929 
930  currentManager->Vertex( aStartPoint.x, aStartPoint.y, layerDepth );
931  currentManager->Vertex( diagonalPointA.x, diagonalPointA.y, layerDepth );
932  currentManager->Vertex( aEndPoint.x, aEndPoint.y, layerDepth );
933 
934  currentManager->Vertex( aStartPoint.x, aStartPoint.y, layerDepth );
935  currentManager->Vertex( aEndPoint.x, aEndPoint.y, layerDepth );
936  currentManager->Vertex( diagonalPointB.x, diagonalPointB.y, layerDepth );
937  }
938 
939  // Stroke the outline
940  if( isStrokeEnabled )
941  {
943 
944  std::deque<VECTOR2D> pointList;
945  pointList.push_back( aStartPoint );
946  pointList.push_back( diagonalPointA );
947  pointList.push_back( aEndPoint );
948  pointList.push_back( diagonalPointB );
949  pointList.push_back( aStartPoint );
950  DrawPolyline( pointList );
951  }
952 }
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:302
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:367
COLOR4D fillColor
The fill color.
double b
Blue component.
Definition: color4d.h:368
double a
Alpha component.
Definition: color4d.h:369
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 ?
void DrawPolyline(const std::deque< VECTOR2D > &aPointList) override
Draw a polyline.
Definition: opengl_gal.cpp:955
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:366

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

652 {
653  VECTOR2D startEndVector = aEndPoint - aStartPoint;
654  double lineLength = startEndVector.EuclideanNorm();
655 
656  // segments having a length <= 1 are just a circle.
657  // Moreover trying to draw them as a segment does not work fine.
658  if( lineLength <= 1 )
659  {
660  DrawCircle( aStartPoint, aWidth/2 );
661  return;
662  }
663 
664  if( isFillEnabled || aWidth == 1.0 )
665  {
667 
668  SetLineWidth( aWidth );
669  drawLineQuad( aStartPoint, aEndPoint );
670  }
671  else
672  {
673  auto lineAngle = startEndVector.Angle();
674  // Outlined tracks
675 
676  SetLineWidth( 1.0 );
678 
679  Save();
680 
681  currentManager->Translate( aStartPoint.x, aStartPoint.y, 0.0 );
682  currentManager->Rotate( lineAngle, 0.0f, 0.0f, 1.0f );
683 
684  drawLineQuad( VECTOR2D( 0.0, aWidth / 2.0 ),
685  VECTOR2D( lineLength, aWidth / 2.0 ) );
686 
687  drawLineQuad( VECTOR2D( 0.0, -aWidth / 2.0 ),
688  VECTOR2D( lineLength, -aWidth / 2.0 ) );
689 
690  // Draw line caps
691  drawStrokedSemiCircle( VECTOR2D( 0.0, 0.0 ), aWidth / 2, M_PI / 2 );
692  drawStrokedSemiCircle( VECTOR2D( lineLength, 0.0 ), aWidth / 2, -M_PI / 2 );
693 
694  Restore();
695  }
696 }
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:302
void drawLineQuad(const VECTOR2D &aStartPoint, const VECTOR2D &aEndPoint)
Draw a quad for the line.
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:367
COLOR4D fillColor
The fill color.
virtual void SetLineWidth(float aLineWidth)
Set the line width.
double b
Blue component.
Definition: color4d.h:368
void Save() override
Save the context.
double a
Alpha component.
Definition: color4d.h:369
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 ?
T EuclideanNorm() const
Destructor.
Definition: vector2d.h:299
double r
Red component.
Definition: color4d.h:366
void DrawCircle(const VECTOR2D &aCenterPoint, double aRadius) override
Draw a circle using world coordinates.
Definition: opengl_gal.cpp:699

References KIGFX::COLOR4D::a, VECTOR2< T >::Angle(), KIGFX::COLOR4D::b, KIGFX::VERTEX_MANAGER::Color(), currentManager, DrawCircle(), drawLineQuad(), drawStrokedSemiCircle(), VECTOR2< T >::EuclideanNorm(), 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 1710 of file opengl_gal.cpp.

1711 {
1712  if( isFillEnabled )
1713  {
1715  drawFilledSemiCircle( aCenterPoint, aRadius, aAngle );
1716  }
1717 
1718  if( isStrokeEnabled )
1719  {
1721  drawStrokedSemiCircle( aCenterPoint, aRadius, aAngle );
1722  }
1723 }
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:302
double g
Green component.
Definition: color4d.h:367
COLOR4D fillColor
The fill color.
double b
Blue component.
Definition: color4d.h:368
double a
Alpha component.
Definition: color4d.h:369
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:366
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 1757 of file opengl_gal.cpp.

1759 {
1760  double outerRadius = aRadius + ( lineWidth / 2 );
1761 
1762  Save();
1763 
1764  currentManager->Reserve( 3 );
1765  currentManager->Translate( aCenterPoint.x, aCenterPoint.y, 0.0f );
1766  currentManager->Rotate( aAngle, 0.0f, 0.0f, 1.0f );
1767 
1768  /* Draw a triangle that contains the semicircle, then shade it to leave only
1769  * the semicircle. Parameters given to Shader() are indices of the triangle's vertices
1770  * (if you want to understand more, check the vertex shader source [shader.vert]), the
1771  * radius and the line width. Shader uses these coordinates to determine if fragments are
1772  * inside the semicircle or not.
1773  * v2
1774  * /\
1775  * /__\
1776  * v0 //__\\ v1
1777  */
1779  currentManager->Vertex( -outerRadius * 3.0f / sqrt( 3.0f ), 0.0f, layerDepth ); // v0
1780 
1782  currentManager->Vertex( outerRadius * 3.0f / sqrt( 3.0f ), 0.0f, layerDepth ); // v1
1783 
1785  currentManager->Vertex( 0.0f, outerRadius * 2.0f, layerDepth ); // v2
1786 
1787  Restore();
1788 }
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:302
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.
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...
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 1012 of file opengl_gal.cpp.

1013 {
1016 
1017  if( isFillEnabled )
1018  {
1019  for( unsigned int j = 0; j < aPolySet.TriangulatedPolyCount(); ++j )
1020  {
1021  auto triPoly = aPolySet.TriangulatedPolygon( j );
1022 
1023  for( size_t i = 0; i < triPoly->GetTriangleCount(); i++ )
1024  {
1025  VECTOR2I a, b, c;
1026  triPoly->GetTriangle( i, a, b, c );
1027  currentManager->Vertex( a.x, a.y, layerDepth );
1028  currentManager->Vertex( b.x, b.y, layerDepth );
1029  currentManager->Vertex( c.x, c.y, layerDepth );
1030  }
1031  }
1032  }
1033 
1034  if( isStrokeEnabled )
1035  {
1036  for( int j = 0; j < aPolySet.OutlineCount(); ++j )
1037  {
1038  const auto& poly = aPolySet.Polygon( j );
1039 
1040  for( const auto& lc : poly )
1041  {
1042  DrawPolyline( lc );
1043  }
1044  }
1045  }
1046 }
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:302
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:367
COLOR4D fillColor
The fill color.
double b
Blue component.
Definition: color4d.h:368
double a
Alpha component.
Definition: color4d.h:369
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 ?
void DrawPolyline(const std::deque< VECTOR2D > &aPointList) override
Draw a polyline.
Definition: opengl_gal.cpp:955
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:366

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

2183 {
2184  cachedManager->EnableDepthTest( aEnabled );
2185  nonCachedManager->EnableDepthTest( aEnabled );
2186  overlayManager->EnableDepthTest( aEnabled );
2187 }
VERTEX_MANAGER * overlayManager
Container for storing overlaid VERTEX_ITEMs.
Definition: opengl_gal.h:305
VERTEX_MANAGER * nonCachedManager
Container for storing non-cached VERTEX_ITEMs.
Definition: opengl_gal.h:304
VERTEX_MANAGER * cachedManager
Container for storing cached VERTEX_ITEMs.
Definition: opengl_gal.h:303
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 554 of file opengl_gal.cpp.

555 {
556  wxASSERT_MSG( isContextLocked, "What happened to the context lock?" );
557 
558 #ifdef __WXDEBUG__
559  PROF_COUNTER totalRealTime( "OPENGL_GAL::endDrawing()", true );
560 #endif /* __WXDEBUG__ */
561 
562  // Cached & non-cached containers are rendered to the same buffer
566 
567  // Overlay container is rendered to a different buffer
568  if( overlayBuffer )
571 
572  // Be sure that the framebuffer is not colorized (happens on specific GPU&drivers combinations)
573  glColor4d( 1.0, 1.0, 1.0, 1.0 );
574 
575  // Draw the remaining contents, blit the rendering targets to the screen, swap the buffers
577 
578  if( overlayBuffer )
580 
581  compositor->Present();
582  blitCursor();
583 
584  SwapBuffers();
585 
586 #ifdef __WXDEBUG__
587  totalRealTime.Stop();
588  wxLogTrace( "GAL_PROFILE", wxT( "OPENGL_GAL::endDrawing(): %.1f ms" ), totalRealTime.msecs() );
589 #endif /* __WXDEBUG__ */
590 }
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:310
VERTEX_MANAGER * overlayManager
Container for storing overlaid VERTEX_ITEMs.
Definition: opengl_gal.h:305
bool isContextLocked
Used for assertion checking.
Definition: opengl_gal.h:323
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:304
OPENGL_COMPOSITOR * compositor
Handles multiple rendering targets.
Definition: opengl_gal.h:308
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:309
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:303
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 1535 of file opengl_gal.cpp.

1536 {
1538  isGrouping = false;
1539 }
bool isGrouping
Was a group started?
Definition: opengl_gal.h:322
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:303

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

◆ endUpdate()

void OPENGL_GAL::endUpdate ( )
overrideprivatevirtual

Reimplemented from KIGFX::GAL.

Definition at line 633 of file opengl_gal.cpp.

634 {
635  if( !isInitialized )
636  return;
637 
638  cachedManager->Unmap();
639 }
void Unmap()
Function Unmap() unmaps vertex buffer.
VERTEX_MANAGER * cachedManager
Container for storing cached VERTEX_ITEMs.
Definition: opengl_gal.h:303
bool isInitialized
Basic initialization flag, has to be done when the window is visible.
Definition: opengl_gal.h:320

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

1460 {
1461  glFlush();
1462 }

◆ 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.

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

956  {
957  return gridLineWidth;
958  }
float gridLineWidth
Line width of the grid.

References KIGFX::GAL::gridLineWidth.

◆ GetGridOrigin()

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

Definition at line 880 of file graphics_abstraction_layer.h.

881  {
882  return gridOrigin;
883  }
VECTOR2D gridOrigin
The grid origin.

References KIGFX::GAL::gridOrigin.

Referenced by GRID_HELPER::GetOrigin().

◆ 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:68

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

908  {
909  return gridSize;
910  }
VECTOR2D gridSize
The grid size.

References KIGFX::GAL::gridSize.

Referenced by COMMON_TOOLS::CursorControl(), GRID_HELPER::GetGrid(), EDA_DRAW_FRAME::GetNearestGridPosition(), COMMON_TOOLS::PanControl(), and EDA_DRAW_PANEL_GAL::SwitchBackend().

◆ GetGridVisibility()

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

Definition at line 862 of file graphics_abstraction_layer.h.

862 { return gridVisibility; }
bool gridVisibility
Should the grid be shown.

References KIGFX::GAL::gridVisibility.

Referenced by EDA_DRAW_PANEL_GAL::SwitchBackend().

◆ GetHorizontalJustify()

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

Returns current text horizontal justification setting.

Definition at line 491 of file graphics_abstraction_layer.h.

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

692  {
693  return lookAtPoint;
694  }
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 760 of file graphics_abstraction_layer.h.

761  {
762  return depthRange.y;
763  }
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 752 of file graphics_abstraction_layer.h.

753  {
754  return depthRange.x;
755  }
VECTOR2D depthRange
Range of the depth.

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

◆ GetNativePixelSize()

wxSize HIDPI_GL_CANVAS::GetNativePixelSize ( ) const
virtualinherited

Definition at line 46 of file hidpi_gl_canvas.cpp.

47 {
48  wxSize size = wxGLCanvas::GetClientSize();
49 
50  const double scaleFactor = GetScaleFactor();
51  size.x *= scaleFactor;
52  size.y *= scaleFactor;
53 
54  return size;
55 }
double GetScaleFactor() const
Get the current scale factor.

References HIDPI_GL_CANVAS::GetScaleFactor().

Referenced by EDA_3D_CANVAS::DoRePaint(), EDA_3D_CANVAS::OnMouseMove(), 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 2032 of file opengl_gal.cpp.

2033 {
2034  wxASSERT_MSG( groups.size() < std::numeric_limits<unsigned int>::max(),
2035  wxT( "There are no free slots to store a group" ) );
2036 
2037  while( groups.find( groupCounter ) != groups.end() )
2038  {
2039  groupCounter++;
2040  }
2041 
2042  return groupCounter++;
2043 }
GROUPS_MAP groups
Stores informations about VBO objects (groups)
Definition: opengl_gal.h:300
unsigned int groupCounter
Counter used for generating keys for groups.
Definition: opengl_gal.h:301

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

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

732  {
733  return rotation;
734  }
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 64 of file hidpi_gl_canvas.cpp.

65 {
66  return m_scale_factor;
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(), ResizeScreen(), and updatedGalDisplayOptions().

◆ GetScreenPixelSize()

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

◆ getScreenPixelSize()

VECTOR2D OPENGL_GAL::getScreenPixelSize ( ) const
private

Definition at line 399 of file opengl_gal.cpp.

400 {
401  auto sf = GetScaleFactor();
402  return VECTOR2D( 2.0 / (double) ( screenSize.x * sf ), 2.0 / (double) ( screenSize.y * sf ) );
403 }
double GetScaleFactor() const
Get the current scale factor.
VECTOR2< double > VECTOR2D
Definition: vector2d.h:593
VECTOR2I screenSize
Screen size in screen coordinates.

References HIDPI_GL_CANVAS::GetScaleFactor(), 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 627 of file graphics_abstraction_layer.h.

628  {
629  return screenWorldMatrix;
630  }
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 1603 of file opengl_gal.cpp.

1604 {
1605  return currentTarget;
1606 }
RENDER_TARGET currentTarget
Current rendering target.
Definition: opengl_gal.h:311

References currentTarget.

Referenced by DrawBitmap().

◆ GetTextLineSize()

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

Compute the X and Y size of a given text.

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

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

Definition at line 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 );
178 }
STROKE_FONT strokeFont
Instance of object that stores information about how to draw texts.
VECTOR2D computeTextLineSize(const UTF8 &aText) const
Compute the X and Y size of a given text.

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

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

◆ GetVerticalJustify()

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

Returns current text vertical justification setting.

Definition at line 509 of file graphics_abstraction_layer.h.

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

393 {
394  auto matrix = GetScreenWorldMatrix();
395  return std::min( std::abs( matrix.GetScale().x ), std::abs( matrix.GetScale().y ) );
396 }
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 770 of file graphics_abstraction_layer.h.

771  {
772  return worldScale;
773  }
double worldScale
The scale factor world->screen.

References KIGFX::GAL::worldScale.

Referenced by GRID_HELPER::BestDragOrigin(), GRID_HELPER::BestSnapAnchor(), KIGFX::PCB_PAINTER::draw(), 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 617 of file graphics_abstraction_layer.h.

618  {
619  return worldScreenMatrix;
620  }
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 711 of file graphics_abstraction_layer.h.

712  {
713  return zoomFactor;
714  }
double zoomFactor
The zoom factor.

References KIGFX::GAL::zoomFactor.

Referenced by COMMON_TOOLS::doZoomInOut(), EDA_DRAW_FRAME::GetZoomLevelIndicator(), EDA_DRAW_FRAME::OnUpdateSelectZoom(), ZOOM_MENU::update(), and EDA_DRAW_FRAME::UpdateZoomSelectBox().

◆ HasTarget()

bool OPENGL_GAL::HasTarget ( RENDER_TARGET  aTarget)
overridevirtual

Returns true if the target exists.

Parameters
aTargetis the target to be checked.

Reimplemented from KIGFX::GAL.

Definition at line 1640 of file opengl_gal.cpp.

1641 {
1642  switch( aTarget )
1643  {
1644  default:
1645  case TARGET_CACHED:
1646  case TARGET_NONCACHED:
1647  return true;
1648 
1649  case TARGET_OVERLAY:
1650  return ( overlayBuffer != 0 );
1651  }
1652 }
unsigned int overlayBuffer
Auxiliary rendering target (for menus etc.)
Definition: opengl_gal.h:310
Auxiliary rendering target (noncached)
Definition: definitions.h:49
Items that may change while the view stays the same (noncached)
Definition: definitions.h:50
Main rendering target (cached)
Definition: definitions.h:48

References overlayBuffer, KIGFX::TARGET_CACHED, KIGFX::TARGET_NONCACHED, and KIGFX::TARGET_OVERLAY.

◆ init()

void OPENGL_GAL::init ( )
private

Basic OpenGL initialization and feature checks.

Exceptions
std::runtime_errorif any of the OpenGL feature checks failed

Definition at line 2046 of file opengl_gal.cpp.

2047 {
2048 
2049  wxASSERT( IsShownOnScreen() );
2050 
2051  wxASSERT_MSG( isContextLocked, "This should only be called from within a locked context." );
2052 
2053 // IsDisplayAttr() handles WX_GL_{MAJOR,MINOR}_VERSION correctly only in 3.0.4
2054 // starting with 3.1.0 one should use wxGLContext::IsOk() (done by GL_CONTEXT_MANAGER)
2055 #if wxCHECK_VERSION( 3, 0, 3 ) and !wxCHECK_VERSION( 3, 1, 0 )
2056  const int attr[] = { WX_GL_MAJOR_VERSION, 2, WX_GL_MINOR_VERSION, 1, 0 };
2057 
2058  if( !IsDisplaySupported( attr ) )
2059  throw std::runtime_error( "OpenGL 2.1 or higher is required!" );
2060 #endif /* wxCHECK_VERSION( 3, 0, 3 ) */
2061 
2062  // Check correct initialization from the constructor
2063  if( !glMainContext )
2064  throw std::runtime_error( "Could not create the main OpenGL context" );
2065 
2066  if( !glPrivContext )
2067  throw std::runtime_error( "Could not create a private OpenGL context" );
2068 
2069  if( tesselator == NULL )
2070  throw std::runtime_error( "Could not create the tesselator" );
2071  // End initialzation checks
2072 
2073  GLenum err = glewInit();
2074 
2075  if( GLEW_OK != err )
2076  throw std::runtime_error( (const char*) glewGetErrorString( err ) );
2077 
2078  // Check the OpenGL version (minimum 2.1 is required)
2079  if( !GLEW_VERSION_2_1 )
2080  throw std::runtime_error( "OpenGL 2.1 or higher is required!" );
2081 
2082 #if defined (__LINUX__) // calling enableGlDebug crashes opengl on some OS (OSX and some Windows)
2083 #ifdef DEBUG
2084  if( GLEW_ARB_debug_output )
2085  enableGlDebug( true );
2086 #endif
2087 #endif
2088 
2089  // Framebuffers have to be supported
2090  if( !GLEW_EXT_framebuffer_object )
2091  throw std::runtime_error( "Framebuffer objects are not supported!" );
2092 
2093  // Vertex buffer has to be supported
2094  if( !GLEW_ARB_vertex_buffer_object )
2095  throw std::runtime_error( "Vertex buffer objects are not supported!" );
2096 
2097  // Prepare shaders
2099  throw std::runtime_error( "Cannot compile vertex shader!" );
2100 
2102  throw std::runtime_error( "Cannot compile fragment shader!" );
2103 
2104  if( !shader->IsLinked() && !shader->Link() )
2105  throw std::runtime_error( "Cannot link the shaders!" );
2106 
2107  // Check if video card supports textures big enough to fit the font atlas
2108  int maxTextureSize;
2109  glGetIntegerv( GL_MAX_TEXTURE_SIZE, &maxTextureSize );
2110 
2111  if( maxTextureSize < (int) font_image.width || maxTextureSize < (int) font_image.height )
2112  {
2113  // TODO implement software texture scaling
2114  // for bitmap fonts and use a higher resolution texture?
2115  throw std::runtime_error( "Requested texture size is not supported" );
2116  }
2117 
2119 
2120  cachedManager = new VERTEX_MANAGER( true );
2121  nonCachedManager = new VERTEX_MANAGER( false );
2122  overlayManager = new VERTEX_MANAGER( false );
2123 
2124  // Make VBOs use shaders
2128 
2129  isInitialized = true;
2130 }
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
static wxGLContext * glMainContext
Parent OpenGL context.
Definition: opengl_gal.h:290
VERTEX_MANAGER * overlayManager
Container for storing overlaid VERTEX_ITEMs.
Definition: opengl_gal.h:305
bool isContextLocked
Used for assertion checking.
Definition: opengl_gal.h:323
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:314
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:304
#define NULL
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
GLUtesselator * tesselator
The tessellator.
Definition: opengl_gal.h:352
VERTEX_MANAGER * cachedManager
Container for storing cached VERTEX_ITEMs.
Definition: opengl_gal.h:303
bool isInitialized
Basic initialization flag, has to be done when the window is visible.
Definition: opengl_gal.h:320
wxGLContext * glPrivContext
Canvas-specific OpenGL context.
Definition: opengl_gal.h:291
static int SetSwapInterval(int aVal)
Attempts to set the OpenGL swap interval.
Definition: gl_utils.h:41

References cachedManager, enableGlDebug(), KIGFX::BUILTIN_FONT::font_image, glMainContext, glPrivContext, 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, NULL, overlayManager, KIGFX::VERTEX_MANAGER::SetShader(), GL_UTILS::SetSwapInterval(), shader, KIGFX::SHADER_TYPE_FRAGMENT, KIGFX::SHADER_TYPE_VERTEX, tesselator, and KIGFX::BUILTIN_FONT::FONT_IMAGE_TYPE::width.

Referenced by beginDrawing(), beginUpdate(), and CheckFeatures().

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

1009  {
1011  }
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 790 of file graphics_abstraction_layer.h.

791  {
792  return globalFlipX;
793  }
bool globalFlipX
Flag for X axis flipping.

References KIGFX::GAL::globalFlipX.

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

◆ IsFlippedY()

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

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

Definition at line 798 of file graphics_abstraction_layer.h.

799  {
800  return globalFlipY;
801  }
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 437 of file graphics_abstraction_layer.h.

438  {
439  return textProperties.m_bold;
440  }
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 455 of file graphics_abstraction_layer.h.

456  {
457  return textProperties.m_italic;
458  }
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()

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

Returns the initalization status for the canvas.

Reimplemented from KIGFX::GAL.

Definition at line 99 of file opengl_gal.h.

100  {
101  // is*Initialized flags, but it is enough for OpenGL to show up
102  return IsShownOnScreen() && !GetClientRect().IsEmpty();
103  }

◆ IsOpenGlEngine()

bool KIGFX::OPENGL_GAL::IsOpenGlEngine ( )
inlineoverridevirtual

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

Reimplemented from KIGFX::GAL.

Definition at line 96 of file opengl_gal.h.

96 { return true; }

◆ IsTextMirrored()

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

Returns true if text should displayed mirrored.

Definition at line 473 of file graphics_abstraction_layer.h.

474  {
475  return textProperties.m_mirrored;
476  }
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 106 of file opengl_gal.h.

107  {
108  return IsShownOnScreen() && !GetClientRect().IsEmpty();
109  }

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

594 {
595  wxASSERT_MSG( !isContextLocked, "Context already locked." );
596  isContextLocked = true;
597  lockClientCookie = aClientCookie;
598 
600 }
bool isContextLocked
Used for assertion checking.
Definition: opengl_gal.h:323
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:291

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

1987 {
1988  PostPaint( aEvent );
1989 }
void PostPaint(wxPaintEvent &aEvent)
Function PostPaint posts an event to m_paint_listener.
Definition: opengl_gal.cpp:355

References PostPaint().

Referenced by OPENGL_GAL().

◆ PopDepth()

void KIGFX::GAL::PopDepth ( )
inlineinherited

Restores previously stored drawing depth for the depth stack.

Definition at line 1050 of file graphics_abstraction_layer.h.

1051  {
1052  layerDepth = depthStack.top();
1053  depthStack.pop();
1054  }
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 OPENGL_GAL::PostPaint ( wxPaintEvent &  aEvent)

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, just by changing the PostPaint code.

Definition at line 355 of file opengl_gal.cpp.

356 {
357  // posts an event to m_paint_listener to ask for redraw the canvas.
358  if( paintListener )
359  {
360  wxPostEvent( paintListener, aEvent );
361  }
362 }
wxEvtHandler * paintListener
Definition: opengl_gal.h:294

References paintListener.

Referenced by onPaint().

◆ PushDepth()

void KIGFX::GAL::PushDepth ( )
inlineinherited

Stores current drawing depth on the depth stack.

Definition at line 1042 of file graphics_abstraction_layer.h.

1043  {
1044  depthStack.push( layerDepth );
1045  }
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 1435 of file opengl_gal.cpp.

1436 {
1437  screenSize = VECTOR2I( aWidth, aHeight );
1438 
1439  // Resize framebuffers
1440  const float scaleFactor = GetScaleFactor();
1441  compositor->Resize( aWidth * scaleFactor, aHeight * scaleFactor );
1442  isFramebufferInitialized = false;
1443 
1444  wxGLCanvas::SetSize( aWidth, aHeight );
1445 }
double GetScaleFactor() const
Get the current scale factor.
VECTOR2< int > VECTOR2I
Definition: vector2d.h:594
OPENGL_COMPOSITOR * compositor
Handles multiple rendering targets.
Definition: opengl_gal.h:308
bool isFramebufferInitialized
Are the framebuffers initialized?
Definition: opengl_gal.h:317
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...
VECTOR2I screenSize
Screen size in screen coordinates.

References compositor, HIDPI_GL_CANVAS::GetScaleFactor(), 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 1517 of file opengl_gal.cpp.

1518 {
1520 }
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:302
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 1493 of file opengl_gal.cpp.

1494 {
1495  currentManager->Rotate( aAngle, 0.0f, 0.0f, 1.0f );
1496 }
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:302
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 1511 of file opengl_gal.cpp.

1512 {
1514 }
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:302
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 1505 of file opengl_gal.cpp.

1506 {
1507  currentManager->Scale( aScale.x, aScale.y, 0.0f );
1508 }
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:302
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)