KiCad PCB EDA Suite
KIGFX::OPENGL_GAL Class Reference

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

#include <opengl_gal.h>

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

Classes

struct  TessParams
 

Public Member Functions

 OPENGL_GAL (GAL_DISPLAY_OPTIONS &aDisplayOptions, wxWindow *aParent, wxEvtHandler *aMouseListener=nullptr, wxEvtHandler *aPaintListener=nullptr, const wxString &aName=wxT("GLCanvas"))
 Constructor OPENGL_GAL. More...
 
virtual ~OPENGL_GAL ()
 
virtual bool IsInitialized () const override
 Returns the initalization status for the canvas. More...
 
bool IsVisible () const override
 > More...
 
virtual void BeginDrawing () override
 Begin the drawing, needs to be called for every new frame. More...
 
virtual void EndDrawing () override
 End the drawing, needs to be called for every new frame. More...
 
virtual void BeginUpdate () override
 Enables item update mode. More...
 
virtual void EndUpdate () override
 Disables item update mode. More...
 
virtual void DrawLine (const VECTOR2D &aStartPoint, const VECTOR2D &aEndPoint) override
 Draw a line. More...
 
virtual void DrawSegment (const VECTOR2D &aStartPoint, const VECTOR2D &aEndPoint, double aWidth) override
 Draw a rounded segment. More...
 
virtual void DrawCircle (const VECTOR2D &aCenterPoint, double aRadius) override
 Draw a circle using world coordinates. More...
 
virtual void DrawArc (const VECTOR2D &aCenterPoint, double aRadius, double aStartAngle, double aEndAngle) override
 Draw an arc. More...
 
virtual void DrawArcSegment (const VECTOR2D &aCenterPoint, double aRadius, double aStartAngle, double aEndAngle, double aWidth) override
 Draw an arc segment. More...
 
virtual void DrawRectangle (const VECTOR2D &aStartPoint, const VECTOR2D &aEndPoint) override
 Draw a rectangle. More...
 
virtual void DrawPolyline (const std::deque< VECTOR2D > &aPointList) override
 Draw a polyline. More...
 
virtual void DrawPolyline (const VECTOR2D aPointList[], int aListSize) override
 
virtual void DrawPolyline (const SHAPE_LINE_CHAIN &aLineChain) override
 
virtual void DrawPolygon (const std::deque< VECTOR2D > &aPointList) override
 Draw a polygon. More...
 
virtual void DrawPolygon (const VECTOR2D aPointList[], int aListSize) override
 
virtual void DrawPolygon (const SHAPE_POLY_SET &aPolySet) override
 
virtual void DrawCurve (const VECTOR2D &startPoint, const VECTOR2D &controlPointA, const VECTOR2D &controlPointB, const VECTOR2D &endPoint) override
 Draw a cubic bezier spline. More...
 
virtual void DrawBitmap (const BITMAP_BASE &aBitmap) override
 Draw a bitmap image. More...
 
virtual void BitmapText (const wxString &aText, const VECTOR2D &aPosition, double aRotationAngle) override
 Draws a text using a bitmap font. More...
 
virtual void DrawGrid () override
 > More...
 
virtual void ResizeScreen (int aWidth, int aHeight) override
 Resizes the canvas. More...
 
virtual bool Show (bool aShow) override
 Shows/hides the GAL canvas. More...
 
virtual void Flush () override
 Force all remaining objects to be drawn. More...
 
virtual void ClearScreen () override
 Clear the screen. More...
 
virtual void Transform (const MATRIX3x3D &aTransformation) override
 Transform the context. More...
 
virtual void Rotate (double aAngle) override
 Rotate the context. More...
 
virtual void Translate (const VECTOR2D &aTranslation) override
 Translate the context. More...
 
virtual void Scale (const VECTOR2D &aScale) override
 Scale the context. More...
 
virtual void Save () override
 Save the context. More...
 
virtual void Restore () override
 Restore the context. More...
 
virtual int BeginGroup () override
 Begin a group. More...
 
virtual void EndGroup () override
 End the group. More...
 
virtual void DrawGroup (int aGroupNumber) override
 Draw the stored group. More...
 
virtual void ChangeGroupColor (int aGroupNumber, const COLOR4D &aNewColor) override
 Changes the color used to draw the group. More...
 
virtual void ChangeGroupDepth (int aGroupNumber, int aDepth) override
 Changes the depth (Z-axis position) of the group. More...
 
virtual void DeleteGroup (int aGroupNumber) override
 Delete the group from the memory. More...
 
virtual void ClearCache () override
 Delete all data created during caching of graphic items. More...
 
virtual void SaveScreen () override
 Save the screen contents. More...
 
virtual void RestoreScreen () override
 Restore the screen contents. More...
 
virtual void SetTarget (RENDER_TARGET aTarget) override
 Sets the target for rendering. More...
 
virtual RENDER_TARGET GetTarget () const override
 Gets the currently used target for rendering. More...
 
virtual void ClearTarget (RENDER_TARGET aTarget) override
 Clears the target for rendering. More...
 
virtual void SetNegativeDrawMode (bool aSetting) override
 Sets negative draw mode in the renderer. More...
 
virtual void DrawCursor (const VECTOR2D &aCursorPosition) override
 Draw the cursor. More...
 
void PostPaint ()
 Function PostPaint posts an event to m_paint_listener. More...
 
void SetMouseListener (wxEvtHandler *aMouseListener)
 
void SetPaintListener (wxEvtHandler *aPaintListener)
 
virtual void EnableDepthTest (bool aEnabled=false) override
 Parameters passed to the GLU tesselator. More...
 
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 (double aLineWidth)
 Set the line width. More...
 
double 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...
 
virtual void ComputeWorldScreenMatrix ()
 Compute the world <-> screen transformation matrix. 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 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 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...
 
void SetGridVisibility (bool aVisibility)
 Sets the visibility setting of the grid. More...
 
void SetGridOrigin (const VECTOR2D &aGridOrigin)
 Set the origin point for the grid. More...
 
void SetGridSize (const VECTOR2D &aGridSize)
 Set the grid size. More...
 
const VECTOR2DGetGridSize () const
 Returns the grid size. More...
 
void SetGridColor (const COLOR4D &aGridColor)
 Set the grid color. More...
 
void SetAxesColor (const COLOR4D &aAxesColor)
 Set the axes color. More...
 
void SetAxesEnabled (bool aAxesEnabled)
 Enables drawing the axes. More...
 
void SetCoarseGrid (int aInterval)
 Draw every tick line wider. More...
 
double 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 GetClientSize () const
 
virtual float GetBackingScaleFactor () const
 

Static Public Attributes

static const double METRIC_UNIT_LENGTH = 1e9
 

Protected Member Functions

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

Protected Attributes

GAL_DISPLAY_OPTIONSoptions
 
UTIL::LINK observerLink
 
std::stack< double > depthStack
 Stored depth values. More...
 
VECTOR2I screenSize
 Screen size in screen coordinates. More...
 
double worldUnitLength
 The unit length of the world coordinates [inch]. More...
 
double screenDPI
 The dots per inch of the screen. More...
 
VECTOR2D lookAtPoint
 Point to be looked at in world space. More...
 
double zoomFactor
 The zoom factor. More...
 
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...
 
double 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...
 
double 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 () override
 
void unlockContext () override
 Update handler for OpenGL settings. More...
 
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
 
void init ()
 Basic OpenGL initialization. More...
 

Private Attributes

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

Static Private Attributes

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

Detailed Description

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

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

Definition at line 65 of file opengl_gal.h.

Member Typedef Documentation

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

Definition at line 307 of file opengl_gal.h.

typedef GAL KIGFX::OPENGL_GAL::super
private

Super class definition.

Definition at line 293 of file opengl_gal.h.

Constructor & Destructor Documentation

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

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

167  :
168  GAL( aDisplayOptions ),
169  HIDPI_GL_CANVAS( aParent, wxID_ANY, (int*) glAttributes, wxDefaultPosition, wxDefaultSize,
170  wxEXPAND, aName ),
171  mouseListener( aMouseListener ), paintListener( aPaintListener ), currentManager( nullptr ),
172  cachedManager( nullptr ), nonCachedManager( nullptr ), overlayManager( nullptr ), mainBuffer( 0 ), overlayBuffer( 0 )
173 {
174 // IsDisplayAttr() handles WX_GL_{MAJOR,MINOR}_VERSION correctly only in 3.0.4
175 // starting with 3.1.0 one should use wxGLContext::IsOk() (done by GL_CONTEXT_MANAGER)
176 #if wxCHECK_VERSION( 3, 0, 3 ) and !wxCHECK_VERSION( 3, 1, 0 )
177  const int attr[] = { WX_GL_MAJOR_VERSION, 2, WX_GL_MINOR_VERSION, 1, 0 };
178 
179  if( !IsDisplaySupported( attr ) )
180  throw std::runtime_error( "OpenGL 2.1 or higher is required!" );
181 #endif /* wxCHECK_VERSION( 3, 0, 3 ) */
182 
183  if( glMainContext == NULL )
184  {
186 
187  if( !glMainContext )
188  throw std::runtime_error( "Could not create the main OpenGL context" );
189 
191  shader = new SHADER();
192  }
193  else
194  {
196 
197  if( !glPrivContext )
198  throw std::runtime_error( "Could not create a private OpenGL context" );
199  }
200 
201  ++instanceCounter;
202 
203  bitmapCache.reset( new GL_BITMAP_CACHE );
204 
207 
208  // Initialize the flags
209  isFramebufferInitialized = false;
210  isBitmapFontInitialized = false;
211  isInitialized = false;
212  isGrouping = false;
213  groupCounter = 0;
214 
215  // Connecting the event handlers
216  Connect( wxEVT_PAINT, wxPaintEventHandler( OPENGL_GAL::onPaint ) );
217 
218  // Mouse events are skipped to the parent
219  Connect( wxEVT_MOTION, wxMouseEventHandler( OPENGL_GAL::skipMouseEvent ) );
220  Connect( wxEVT_LEFT_DOWN, wxMouseEventHandler( OPENGL_GAL::skipMouseEvent ) );
221  Connect( wxEVT_LEFT_UP, wxMouseEventHandler( OPENGL_GAL::skipMouseEvent ) );
222  Connect( wxEVT_LEFT_DCLICK, wxMouseEventHandler( OPENGL_GAL::skipMouseEvent ) );
223  Connect( wxEVT_MIDDLE_DOWN, wxMouseEventHandler( OPENGL_GAL::skipMouseEvent ) );
224  Connect( wxEVT_MIDDLE_UP, wxMouseEventHandler( OPENGL_GAL::skipMouseEvent ) );
225  Connect( wxEVT_MIDDLE_DCLICK, wxMouseEventHandler( OPENGL_GAL::skipMouseEvent ) );
226  Connect( wxEVT_RIGHT_DOWN, wxMouseEventHandler( OPENGL_GAL::skipMouseEvent ) );
227  Connect( wxEVT_RIGHT_UP, wxMouseEventHandler( OPENGL_GAL::skipMouseEvent ) );
228  Connect( wxEVT_RIGHT_DCLICK, wxMouseEventHandler( OPENGL_GAL::skipMouseEvent ) );
229  Connect( wxEVT_MOUSEWHEEL, wxMouseEventHandler( OPENGL_GAL::skipMouseEvent ) );
230 #if wxCHECK_VERSION( 3, 1, 0 ) || defined( USE_OSX_MAGNIFY_EVENT )
231  Connect( wxEVT_MAGNIFY, wxMouseEventHandler( OPENGL_GAL::skipMouseEvent ) );
232 #endif
233 #if defined _WIN32 || defined _WIN64
234  Connect( wxEVT_ENTER_WINDOW, wxMouseEventHandler( OPENGL_GAL::skipMouseEvent ) );
235 #endif
236 
237  SetSize( aParent->GetClientSize() );
238  screenSize = VECTOR2I( aParent->GetClientSize() );
239 
240  // Grid color settings are different in Cairo and OpenGL
241  SetGridColor( COLOR4D( 0.8, 0.8, 0.8, 0.1 ) );
242  SetAxesColor( COLOR4D( BLUE ) );
243 
244  // Tesselator initialization
245  tesselator = gluNewTess();
247 
248  if( tesselator == NULL )
249  throw std::runtime_error( "Could not create the tesselator" );
250 
251  gluTessProperty( tesselator, GLU_TESS_WINDING_RULE, GLU_TESS_WINDING_POSITIVE );
252 
254 }
Definition: colors.h:57
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:310
static SHADER * shader
There is only one shader used for different objects.
Definition: opengl_gal.h:322
static wxGLContext * glMainContext
Parent OpenGL context.
Definition: opengl_gal.h:298
unsigned int overlayBuffer
Auxiliary rendering target (for menus etc.)
Definition: opengl_gal.h:318
bool isBitmapFontInitialized
Is the shader set to use bitmap fonts?
Definition: opengl_gal.h:327
VERTEX_MANAGER * overlayManager
Container for storing overlaid VERTEX_ITEMs.
Definition: opengl_gal.h:313
GAL_DISPLAY_OPTIONS & options
std::unique_ptr< GL_BITMAP_CACHE > bitmapCache
Definition: opengl_gal.h:334
static void InitTesselatorCallbacks(GLUtesselator *aTesselator)
VECTOR2< int > VECTOR2I
Definition: vector2d.h:587
bool isGrouping
Was a group started?
Definition: opengl_gal.h:330
OPENGL_ANTIALIASING_MODE gl_antialiasing_mode
VERTEX_MANAGER * nonCachedManager
Container for storing non-cached VERTEX_ITEMs.
Definition: opengl_gal.h:312
Auxiliary rendering target (noncached)
Definition: definitions.h:42
static int instanceCounter
GL GAL instance counter.
Definition: opengl_gal.h:300
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:316
unsigned int mainBuffer
Main rendering target.
Definition: opengl_gal.h:317
wxEvtHandler * mouseListener
Definition: opengl_gal.h:301
void SetAxesColor(const COLOR4D &aAxesColor)
Set the axes color.
static const int glAttributes[]
Definition: opengl_gal.cpp:59
void onPaint(wxPaintEvent &aEvent)
This is the OnPaint event handler.
bool isFramebufferInitialized
Are the framebuffers initialized?
Definition: opengl_gal.h:325
Class SHADER provides the access to the OpenGL shaders.
Definition: shader.h:74
GLUtesselator * tesselator
The tessellator.
Definition: opengl_gal.h:345
VERTEX_MANAGER * cachedManager
Container for storing cached VERTEX_ITEMs.
Definition: opengl_gal.h:311
wxEvtHandler * paintListener
Definition: opengl_gal.h:302
virtual void SetTarget(RENDER_TARGET aTarget) override
Sets the target for rendering.
bool isInitialized
Basic initialization flag, has to be done when the window is visible.
Definition: opengl_gal.h:328
unsigned int groupCounter
Counter used for generating keys for groups.
Definition: opengl_gal.h:309
VECTOR2I screenSize
Screen size in screen coordinates.
wxGLContext * glPrivContext
Canvas-specific OpenGL context.
Definition: opengl_gal.h:299
wxGLContext * CreateCtx(wxGLCanvas *aCanvas, const wxGLContext *aOther=NULL)
Function CreateCtx creates a managed OpenGL context.
void skipMouseEvent(wxMouseEvent &aEvent)
Skip the mouse event to the parent.
Class COLOR4D is the color representation with 4 components: red, green, blue, alpha.
Definition: color4d.h:39
OPENGL_GAL::~OPENGL_GAL ( )
virtual

Definition at line 257 of file opengl_gal.cpp.

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

258 {
260 
261  --instanceCounter;
262  glFlush();
263  gluDeleteTess( tesselator );
264  ClearCache();
265 
266  delete compositor;
267 
268  if( isInitialized )
269  {
270  delete cachedManager;
271  delete nonCachedManager;
272  delete overlayManager;
273  }
274 
276 
277  // If it was the main context, then it will be deleted
278  // when the last OpenGL GAL instance is destroyed (a few lines below)
281 
282  // Are we destroying the last GAL instance?
283  if( instanceCounter == 0 )
284  {
286 
287  if( isBitmapFontLoaded )
288  {
289  glDeleteTextures( 1, &fontTexture );
290  isBitmapFontLoaded = false;
291  }
292 
293  delete shader;
294 
297  glMainContext = NULL;
298  }
299 }
static SHADER * shader
There is only one shader used for different objects.
Definition: opengl_gal.h:322
static wxGLContext * glMainContext
Parent OpenGL context.
Definition: opengl_gal.h:298
static GLuint fontTexture
Bitmap font texture handle (shared)
Definition: opengl_gal.h:304
VERTEX_MANAGER * overlayManager
Container for storing overlaid VERTEX_ITEMs.
Definition: opengl_gal.h:313
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:312
static int instanceCounter
GL GAL instance counter.
Definition: opengl_gal.h:300
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:316
virtual void ClearCache() override
Delete all data created during caching of graphic items.
GLUtesselator * tesselator
The tessellator.
Definition: opengl_gal.h:345
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:311
bool isInitialized
Basic initialization flag, has to be done when the window is visible.
Definition: opengl_gal.h:328
wxGLContext * glPrivContext
Canvas-specific OpenGL context.
Definition: opengl_gal.h:299
void DestroyCtx(wxGLContext *aContext)
Function DestroyCtx destroys a managed OpenGL context.
static bool isBitmapFontLoaded
Is the bitmap font texture loaded?
Definition: opengl_gal.h:326

Member Function Documentation

void KIGFX::GAL::AdvanceDepth ( )
inlineinherited

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

Definition at line 981 of file graphics_abstraction_layer.h.

References KIGFX::GAL::layerDepth.

Referenced by KIGFX::SCH_PAINTER::draw(), and KIGFX::VIEW_GROUP::ViewDraw().

982  {
983  layerDepth -= 0.05;
984  }
double layerDepth
The actual layer depth.
void OPENGL_GAL::BeginDrawing ( )
overridevirtual

Begin the drawing, needs to be called for every new frame.

Reimplemented from KIGFX::GAL.

Definition at line 328 of file opengl_gal.cpp.

References KIGFX::SHADER::AddParameter(), KIGFX::OPENGL_COMPOSITOR::Begin(), KIGFX::VERTEX_MANAGER::BeginDrawing(), cachedManager, checkGlError(), KIGFX::VERTEX_MANAGER::Clear(), compositor, KIGFX::GAL::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, getWorldPixelSize(), KIGFX::BUILTIN_FONT::FONT_IMAGE_TYPE::height, init(), KIGFX::OPENGL_COMPOSITOR::Initialize(), isBitmapFontInitialized, isBitmapFontLoaded, isContextLocked, isFramebufferInitialized, isInitialized, 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_worldPixelSize, KIGFX::SHADER::Use(), KIGFX::BUILTIN_FONT::FONT_IMAGE_TYPE::width, KIGFX::GAL::worldScreenMatrix, VECTOR2< T >::x, and VECTOR2< T >::y.

Referenced by IsVisible().

329 {
330  if( !IsShownOnScreen() || GetClientRect().IsEmpty() )
331  return;
332 
333 #ifdef __WXDEBUG__
334  PROF_COUNTER totalRealTime( "OPENGL_GAL::BeginDrawing()", true );
335 #endif /* __WXDEBUG__ */
336 
337  if( !isInitialized )
338  init();
339 
340  wxASSERT_MSG( isContextLocked, "You must create a local GAL_CONTEXT_LOCKER instance "
341  "before calling GAL::BeginDrawing()." );
342 
343  // Set up the view port
344  glMatrixMode( GL_PROJECTION );
345  glLoadIdentity();
346 
347  // Create the screen transformation (Do the RH-LH conversion here)
348  glOrtho( 0, (GLint) screenSize.x, (GLsizei) screenSize.y, 0, -depthRange.x, -depthRange.y );
349 
351  {
352  // Prepare rendering target buffers
356 
358  }
359 
360  compositor->Begin();
361 
362  // Disable 2D Textures
363  glDisable( GL_TEXTURE_2D );
364 
365  glShadeModel( GL_FLAT );
366 
367  // Enable the depth buffer
368  glEnable( GL_DEPTH_TEST );
369  glDepthFunc( GL_LESS );
370 
371  // Setup blending, required for transparent objects
372  glEnable( GL_BLEND );
373  glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
374 
375  glMatrixMode( GL_MODELVIEW );
376 
377  // Set up the world <-> screen transformation
379  GLdouble matrixData[16] = { 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1 };
380  matrixData[0] = worldScreenMatrix.m_data[0][0];
381  matrixData[1] = worldScreenMatrix.m_data[1][0];
382  matrixData[2] = worldScreenMatrix.m_data[2][0];
383  matrixData[4] = worldScreenMatrix.m_data[0][1];
384  matrixData[5] = worldScreenMatrix.m_data[1][1];
385  matrixData[6] = worldScreenMatrix.m_data[2][1];
386  matrixData[12] = worldScreenMatrix.m_data[0][2];
387  matrixData[13] = worldScreenMatrix.m_data[1][2];
388  matrixData[14] = worldScreenMatrix.m_data[2][2];
389  glLoadMatrixd( matrixData );
390 
391  // Set defaults
394 
395  // Remove all previously stored items
398 
402 
404  {
405  // Keep bitmap font texture always bound to the second texturing unit
406  const GLint FONT_TEXTURE_UNIT = 2;
407 
408  // Either load the font atlas to video memory, or simply bind it to a texture unit
409  if( !isBitmapFontLoaded )
410  {
411  glActiveTexture( GL_TEXTURE0 + FONT_TEXTURE_UNIT );
412  glGenTextures( 1, &fontTexture );
413  glBindTexture( GL_TEXTURE_2D, fontTexture );
414  glTexImage2D( GL_TEXTURE_2D, 0, GL_RGB8, font_image.width, font_image.height,
415  0, GL_RGB, GL_UNSIGNED_BYTE, font_image.pixels );
416  glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
417  glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
418  checkGlError( "loading bitmap font" );
419 
420  glActiveTexture( GL_TEXTURE0 );
421 
422  isBitmapFontLoaded = true;
423  }
424  else
425  {
426  glActiveTexture( GL_TEXTURE0 + FONT_TEXTURE_UNIT );
427  glBindTexture( GL_TEXTURE_2D, fontTexture );
428  glActiveTexture( GL_TEXTURE0 );
429  }
430 
431  // Set shader parameter
432  GLint ufm_fontTexture = shader->AddParameter( "fontTexture" );
433  GLint ufm_fontTextureWidth = shader->AddParameter( "fontTextureWidth" );
434  ufm_worldPixelSize = shader->AddParameter( "worldPixelSize" );
435 
436  shader->Use();
437  shader->SetParameter( ufm_fontTexture, (int) FONT_TEXTURE_UNIT );
438  shader->SetParameter( ufm_fontTextureWidth, (int) font_image.width );
439  shader->Deactivate();
440  checkGlError( "setting bitmap font sampler as shader parameter" );
441 
443  }
444 
445  shader->Use();
447  shader->Deactivate();
448 
449  // Something betreen BeginDrawing and EndDrawing seems to depend on
450  // this texture unit being active, but it does not assure it itself.
451  glActiveTexture( GL_TEXTURE0 );
452 
453  // Unbind buffers - set compositor for direct drawing
455 
456 #ifdef __WXDEBUG__
457  totalRealTime.Stop();
458  wxLogTrace( "GAL_PROFILE",
459  wxT( "OPENGL_GAL::BeginDrawing(): %.1f ms" ), totalRealTime.msecs() );
460 #endif /* __WXDEBUG__ */
461 }
virtual void SetFillColor(const COLOR4D &aColor)
Set the fill color.
double getWorldPixelSize() const
Definition: opengl_gal.cpp:322
static SHADER * shader
There is only one shader used for different objects.
Definition: opengl_gal.h:322
void Clear() const
Function Clear() removes all the stored vertices from the container.
unsigned int overlayBuffer
Auxiliary rendering target (for menus etc.)
Definition: opengl_gal.h:318
virtual void Begin() override
Function Begin() Call this at the beginning of each frame.
bool isBitmapFontInitialized
Is the shader set to use bitmap fonts?
Definition: opengl_gal.h:327
void Use()
Use the shader.
Definition: shader.h:130
void SetParameter(int aParameterNumber, float aValue) const
Set a parameter of the shader.
Definition: shader.cpp:138
static GLuint fontTexture
Bitmap font texture handle (shared)
Definition: opengl_gal.h:304
VERTEX_MANAGER * overlayManager
Container for storing overlaid VERTEX_ITEMs.
Definition: opengl_gal.h:313
bool isContextLocked
Used for assertion checking.
Definition: opengl_gal.h:331
COLOR4D fillColor
The fill color.
VECTOR2D depthRange
Range of the depth.
int checkGlError(const std::string &aInfo, bool aThrow)
Checks if one of recent OpenGL operations has failed.
Definition: utils.cpp:30
static const unsigned int DIRECT_RENDERING
virtual void ComputeWorldScreenMatrix()
Compute the world <-> screen transformation matrix.
The class PROF_COUNTER is a small class to help profiling.
Definition: profile.h:45
VERTEX_MANAGER * nonCachedManager
Container for storing non-cached VERTEX_ITEMs.
Definition: opengl_gal.h:312
T m_data[3][3]
Definition: matrix3x3.h:64
void init()
Basic OpenGL initialization.
OPENGL_COMPOSITOR * compositor
Handles multiple rendering targets.
Definition: opengl_gal.h:316
unsigned int mainBuffer
Main rendering target.
Definition: opengl_gal.h:317
COLOR4D strokeColor
The color of the outlines.
int AddParameter(const std::string &aParameterName)
Add a parameter to the parameter queue.
Definition: shader.cpp:125
void Deactivate()
Deactivate the shader and use the default OpenGL program.
Definition: shader.h:139
bool isFramebufferInitialized
Are the framebuffers initialized?
Definition: opengl_gal.h:325
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.
void BeginDrawing() const
Function BeginDrawing() prepares buffers and items to start drawing.
VERTEX_MANAGER * cachedManager
Container for storing cached VERTEX_ITEMs.
Definition: opengl_gal.h:311
virtual void Initialize() override
Function Reset() performs primary initialiation, necessary to use the object.
GLint ufm_worldPixelSize
Definition: opengl_gal.h:332
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:328
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.
static bool isBitmapFontLoaded
Is the bitmap font texture loaded?
Definition: opengl_gal.h:326
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 1425 of file opengl_gal.cpp.

References getNewGroupNumber(), groups, and isGrouping.

Referenced by IsVisible().

1426 {
1427  isGrouping = true;
1428 
1429  std::shared_ptr<VERTEX_ITEM> newItem = std::make_shared<VERTEX_ITEM>( *cachedManager );
1430  int groupNumber = getNewGroupNumber();
1431  groups.insert( std::make_pair( groupNumber, newItem ) );
1432 
1433  return groupNumber;
1434 }
bool isGrouping
Was a group started?
Definition: opengl_gal.h:330
GROUPS_MAP groups
Stores informations about VBO objects (groups)
Definition: opengl_gal.h:308
unsigned int getNewGroupNumber()
Returns a valid key that can be used as a new group number.
void OPENGL_GAL::BeginUpdate ( )
overridevirtual

Enables item update mode.

Reimplemented from KIGFX::GAL.

Definition at line 513 of file opengl_gal.cpp.

References cachedManager, GL_CONTEXT_MANAGER::Get(), glPrivContext, init(), isInitialized, GL_CONTEXT_MANAGER::LockCtx(), and KIGFX::VERTEX_MANAGER::Map().

Referenced by IsVisible().

514 {
515  if( !IsShownOnScreen() || GetClientRect().IsEmpty() )
516  return;
517 
518  if( !isInitialized )
519  init();
520 
522  cachedManager->Map();
523 }
static GL_CONTEXT_MANAGER & Get()
Function Get returns the GL_CONTEXT_MANAGER instance (singleton).
void init()
Basic OpenGL initialization.
void Map()
Function Map() maps vertex buffer.
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:311
bool isInitialized
Basic initialization flag, has to be done when the window is visible.
Definition: opengl_gal.h:328
wxGLContext * glPrivContext
Canvas-specific OpenGL context.
Definition: opengl_gal.h:299
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 1055 of file opengl_gal.cpp.

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

Referenced by IsVisible().

1057 {
1058  wxASSERT_MSG( !IsTextMirrored(), "No support for mirrored text using bitmap fonts." );
1059 
1060  auto processedText = ProcessOverbars( aText );
1061  const auto& text = processedText.first;
1062  const auto& overbars = processedText.second;
1063 
1064  // Compute text size, so it can be properly justified
1065  VECTOR2D textSize;
1066  float commonOffset;
1067  std::tie( textSize, commonOffset ) = computeBitmapTextSize( text );
1068 
1069  const double SCALE = 1.4 * GetGlyphSize().y / textSize.y;
1070  bool overbar = false;
1071 
1072  int overbarLength = 0;
1073  double overbarHeight = textSize.y;
1074 
1075  Save();
1076 
1078  currentManager->Translate( aPosition.x, aPosition.y, layerDepth );
1079  currentManager->Rotate( aRotationAngle, 0.0f, 0.0f, -1.0f );
1080 
1081  double sx = SCALE * ( globalFlipX ? -1.0 : 1.0 );
1082  double sy = SCALE * ( globalFlipY ? -1.0 : 1.0 );
1083 
1084  currentManager->Scale( sx, sy, 0 );
1085  currentManager->Translate( 0, -commonOffset, 0 );
1086 
1087  switch( GetHorizontalJustify() )
1088  {
1090  Translate( VECTOR2D( -textSize.x / 2.0, 0 ) );
1091  break;
1092 
1094  //if( !IsTextMirrored() )
1095  Translate( VECTOR2D( -textSize.x, 0 ) );
1096  break;
1097 
1098  case GR_TEXT_HJUSTIFY_LEFT:
1099  //if( IsTextMirrored() )
1100  //Translate( VECTOR2D( -textSize.x, 0 ) );
1101  break;
1102  }
1103 
1104  switch( GetVerticalJustify() )
1105  {
1106  case GR_TEXT_VJUSTIFY_TOP:
1107  Translate( VECTOR2D( 0, -textSize.y ) );
1108  overbarHeight = -textSize.y / 2.0;
1109  break;
1110 
1112  Translate( VECTOR2D( 0, -textSize.y / 2.0 ) );
1113  overbarHeight = 0;
1114  break;
1115 
1117  break;
1118  }
1119 
1120  int i = 0;
1121 
1122  for( UTF8::uni_iter chIt = text.ubegin(), end = text.uend(); chIt < end; ++chIt )
1123  {
1124  unsigned int c = *chIt;
1125  wxASSERT_MSG( c != '\n' && c != '\r', wxT( "No support for multiline bitmap text yet" ) );
1126 
1127  // Handle overbar
1128  if( overbars[i] && !overbar )
1129  {
1130  overbar = true; // beginning of an overbar
1131  }
1132  else if( overbar && !overbars[i] )
1133  {
1134  overbar = false; // end of an overbar
1135  drawBitmapOverbar( overbarLength, overbarHeight );
1136  overbarLength = 0;
1137  }
1138 
1139  if( overbar )
1140  overbarLength += drawBitmapChar( c );
1141  else
1142  drawBitmapChar( c );
1143 
1144  ++i;
1145  }
1146 
1147  // Handle the case when overbar is active till the end of the drawn text
1148  currentManager->Translate( 0, commonOffset, 0 );
1149 
1150  if( overbar && overbarLength > 0 )
1151  drawBitmapOverbar( overbarLength, overbarHeight );
1152 
1153  Restore();
1154 }
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:310
EDA_TEXT_HJUSTIFY_T GetHorizontalJustify() const
Returns current text horizontal justification setting.
EDA_TEXT_VJUSTIFY_T GetVerticalJustify() const
Returns current text vertical justification setting.
std::pair< UTF8, std::vector< bool > > ProcessOverbars(const UTF8 &aText)
Processes a text to extract the raw text and overbar flags.
Definition: text_utils.cpp:27
double layerDepth
The actual layer depth.
virtual void Translate(const VECTOR2D &aTranslation) override
Translate the context.
virtual void Restore() override
Restore the context.
void Rotate(GLfloat aAngle, GLfloat aX, GLfloat aY, GLfloat aZ)
Function Rotate() multiplies the current matrix by a rotation matrix, so the newly vertices will be r...
double g
Green component.
Definition: color4d.h:292
bool globalFlipX
Flag for X axis flipping.
double b
Blue component.
Definition: color4d.h:293
virtual void Save() override
Save the context.
double a
Alpha component.
Definition: color4d.h:294
VECTOR2< double > VECTOR2D
Definition: vector2d.h:586
std::pair< VECTOR2D, float > computeBitmapTextSize(const UTF8 &aText) const
Computes a size of text drawn using bitmap font with current text setting applied.
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...
const VECTOR2D & GetGlyphSize() const
void Color(const COLOR4D &aColor)
Function Color() changes currently used color that will be applied to newly added vertices...
class uni_iter is a non-mutating iterator that walks through unicode code points in the UTF8 encoded ...
Definition: utf8.h:207
bool globalFlipY
Flag for Y axis flipping.
int drawBitmapChar(unsigned long aChar)
Draws a single character using bitmap font.
size_t i
Definition: json11.cpp:597
void Scale(GLfloat aX, GLfloat aY, GLfloat aZ)
Function Scale() multiplies the current matrix by a scaling matrix, so the newly vertices will be sca...
double r
Red component.
Definition: color4d.h:291
bool IsTextMirrored() const
Returns true if text should displayed mirrored.
void drawBitmapOverbar(double aLength, double aHeight)
Draws an overbar over the currently drawn text.
void OPENGL_GAL::blitCursor ( )
private

Blits cursor into the current screen.

Definition at line 1916 of file opengl_gal.cpp.

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().

1917 {
1918  if( !IsCursorEnabled() )
1919  return;
1920 
1922 
1923  const int cursorSize = fullscreenCursor ? 8000 : 80;
1924 
1925  VECTOR2D cursorBegin = cursorPosition - cursorSize / ( 2 * worldScale );
1926  VECTOR2D cursorEnd = cursorPosition + cursorSize / ( 2 * worldScale );
1927  VECTOR2D cursorCenter = ( cursorBegin + cursorEnd ) / 2;
1928 
1929  const COLOR4D cColor = getCursorColor();
1930  const COLOR4D color( cColor.r * cColor.a, cColor.g * cColor.a,
1931  cColor.b * cColor.a, 1.0 );
1932 
1933  glActiveTexture( GL_TEXTURE0 );
1934  glDisable( GL_TEXTURE_2D );
1935  glLineWidth( 1.0 );
1936  glColor4d( color.r, color.g, color.b, color.a );
1937 
1938  glBegin( GL_LINES );
1939  glVertex2d( cursorCenter.x, cursorBegin.y );
1940  glVertex2d( cursorCenter.x, cursorEnd.y );
1941 
1942  glVertex2d( cursorBegin.x, cursorCenter.y );
1943  glVertex2d( cursorEnd.x, cursorCenter.y );
1944  glEnd();
1945 }
bool IsCursorEnabled() const
Returns information about cursor visibility.
VECTOR2D cursorPosition
Current cursor position (world coordinates)
int color
Definition: DXF_plotter.cpp:62
double g
Green component.
Definition: color4d.h:292
static const unsigned int DIRECT_RENDERING
double b
Blue component.
Definition: color4d.h:293
double a
Alpha component.
Definition: color4d.h:294
OPENGL_COMPOSITOR * compositor
Handles multiple rendering targets.
Definition: opengl_gal.h:316
bool fullscreenCursor
Shape of the cursor (fullscreen or small cross)
COLOR4D getCursorColor() const
Gets the actual cursor color to draw.
virtual void SetBuffer(unsigned int aBufferHandle) override
Function SetBuffer() sets the selected buffer as the rendering target.
double worldScale
The scale factor world->screen.
double r
Red component.
Definition: color4d.h:291
Class COLOR4D is the color representation with 4 components: red, green, blue, alpha.
Definition: color4d.h:39
double KIGFX::OPENGL_GAL::calcAngleStep ( double  aRadius) const
inlineprivate

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

Definition at line 468 of file opengl_gal.h.

References getWorldPixelSize(), init(), and min.

Referenced by DrawArc(), and DrawArcSegment().

469  {
470  // Bigger arcs need smaller alpha increment to make them look smooth
471  return std::min( 1e6 / aRadius, 2.0 * M_PI / CIRCLE_POINTS );
472  }
CIRCLE_POINTS
#define min(a, b)
Definition: auxiliary.h:85
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 1451 of file opengl_gal.cpp.

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

Referenced by IsVisible().

1452 {
1453  if( groups[aGroupNumber] )
1454  cachedManager->ChangeItemColor( *groups[aGroupNumber], aNewColor );
1455 }
GROUPS_MAP groups
Stores informations about VBO objects (groups)
Definition: opengl_gal.h:308
VERTEX_MANAGER * cachedManager
Container for storing cached VERTEX_ITEMs.
Definition: opengl_gal.h:311
void ChangeItemColor(const VERTEX_ITEM &aItem, const COLOR4D &aColor) const
Function ChangeItemColor() changes the color of all vertices owned by an item.
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 1458 of file opengl_gal.cpp.

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

Referenced by IsVisible().

1459 {
1460  if( groups[aGroupNumber] )
1461  cachedManager->ChangeItemDepth( *groups[aGroupNumber], aDepth );
1462 }
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:308
VERTEX_MANAGER * cachedManager
Container for storing cached VERTEX_ITEMs.
Definition: opengl_gal.h:311
void OPENGL_GAL::ClearCache ( )
overridevirtual

Delete all data created during caching of graphic items.

Reimplemented from KIGFX::GAL.

Definition at line 1472 of file opengl_gal.cpp.

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

Referenced by IsVisible(), and ~OPENGL_GAL().

1473 {
1474  bitmapCache.reset( new GL_BITMAP_CACHE );
1475 
1476  groups.clear();
1477 
1478  if( isInitialized )
1479  cachedManager->Clear();
1480 }
void Clear() const
Function Clear() removes all the stored vertices from the container.
std::unique_ptr< GL_BITMAP_CACHE > bitmapCache
Definition: opengl_gal.h:334
GROUPS_MAP groups
Stores informations about VBO objects (groups)
Definition: opengl_gal.h:308
VERTEX_MANAGER * cachedManager
Container for storing cached VERTEX_ITEMs.
Definition: opengl_gal.h:311
bool isInitialized
Basic initialization flag, has to be done when the window is visible.
Definition: opengl_gal.h:328
void OPENGL_GAL::ClearScreen ( )
overridevirtual

Clear the screen.

Parameters
aColoris the color used for clearing.

Reimplemented from KIGFX::GAL.

Definition at line 1367 of file opengl_gal.cpp.

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

Referenced by IsVisible().

1368 {
1369  // Clear screen
1371  // NOTE: Black used here instead of m_clearColor; it will be composited later
1372  glClearColor( 0, 0, 0, 1 );
1373  glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT );
1374 }
static const unsigned int DIRECT_RENDERING
OPENGL_COMPOSITOR * compositor
Handles multiple rendering targets.
Definition: opengl_gal.h:316
virtual void SetBuffer(unsigned int aBufferHandle) override
Function SetBuffer() sets the selected buffer as the rendering target.
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 1523 of file opengl_gal.cpp.

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.

Referenced by IsVisible().

1524 {
1525  // Save the current state
1526  unsigned int oldTarget = compositor->GetBuffer();
1527 
1528  switch( aTarget )
1529  {
1530  // Cached and noncached items are rendered to the same buffer
1531  default:
1532  case TARGET_CACHED:
1533  case TARGET_NONCACHED:
1535  break;
1536 
1537  case TARGET_OVERLAY:
1539  break;
1540  }
1541 
1542 
1543  if( aTarget != TARGET_OVERLAY )
1545  else
1547 
1548  // Restore the previous state
1549  compositor->SetBuffer( oldTarget );
1550 }
unsigned int overlayBuffer
Auxiliary rendering target (for menus etc.)
Definition: opengl_gal.h:318
static const COLOR4D BLACK
Definition: color4d.h:301
Auxiliary rendering target (noncached)
Definition: definitions.h:42
OPENGL_COMPOSITOR * compositor
Handles multiple rendering targets.
Definition: opengl_gal.h:316
unsigned int mainBuffer
Main rendering target.
Definition: opengl_gal.h:317
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:43
virtual void SetBuffer(unsigned int aBufferHandle) override
Function SetBuffer() sets the selected buffer as the rendering target.
Main rendering target (cached)
Definition: definitions.h:41
virtual unsigned int GetBuffer() const override
Function GetBuffer() returns currently used buffer handle.
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 1868 of file opengl_gal.cpp.

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

Referenced by BitmapText().

1869 {
1870  VECTOR2D textSize( 0, 0 );
1871  float commonOffset = std::numeric_limits<float>::max();
1872  static const auto defaultGlyph = LookupGlyph( '(' ); // for strange chars
1873 
1874  for( UTF8::uni_iter chIt = aText.ubegin(), end = aText.uend(); chIt < end; ++chIt )
1875  {
1876  unsigned int c = *chIt;
1877 
1878  const FONT_GLYPH_TYPE* glyph = LookupGlyph( c );
1879  // Debug: show not coded char in the atlas
1880  wxASSERT_MSG( glyph, wxString::Format( "missing char in font: code 0x%x <%c>", c, c ) );
1881 
1882  if( !glyph || // Not coded in font
1883  c == '-' || c == '_' ) // Strange size of these 2 chars
1884  {
1885  glyph = defaultGlyph;
1886  }
1887 
1888  if( glyph )
1889  {
1890  textSize.x += glyph->advance;
1891  }
1892  }
1893 
1894  textSize.y = std::max<float>( textSize.y, font_information.max_y - defaultGlyph->miny );
1895  commonOffset = std::min<float>( font_information.max_y - defaultGlyph->maxy, commonOffset );
1896  textSize.y -= commonOffset;
1897 
1898  return std::make_pair( textSize, commonOffset );
1899 }
const FONT_GLYPH_TYPE * LookupGlyph(unsigned int aCodepoint)
uni_iter ubegin() const
Function ubegin returns a uni_iter initialized to the start of "this" UTF8 byte sequence.
Definition: utf8.h:285
FONT_INFO_TYPE font_information
Definition: gl_resources.cpp:3
class uni_iter is a non-mutating iterator that walks through unicode code points in the UTF8 encoded ...
Definition: utf8.h:207
uni_iter uend() const
Function uend returns a uni_iter initialized to the end of "this" UTF8 byte sequence.
Definition: utf8.h:294
void Format(OUTPUTFORMATTER *out, int aNestLevel, int aCtl, CPTREE &aTree)
Function Format outputs a PTREE into s-expression format via an OUTPUTFORMATTER derivative.
Definition: ptree.cpp:205
#define max(a, b)
Definition: auxiliary.h:86
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 205 of file graphics_abstraction_layer.cpp.

References KIGFX::GAL::gridMinSpacing.

Referenced by KIGFX::GAL::computeWorldScale(), DrawGrid(), and KIGFX::GAL::DrawGrid().

206 {
207  // just return the current value. This could be cleverer and take
208  // into account other settings in future
209  return gridMinSpacing;
210 }
int gridMinSpacing
Minimum screen size of the grid (pixels) below which the grid is not drawn.
void KIGFX::GAL::computeWorldScale ( )
inlineprotectedinherited

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

Definition at line 1068 of file graphics_abstraction_layer.h.

References KIGFX::GAL::computeMinGridSpacing(), and KIGFX::GAL::zoomFactor.

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

1069  {
1071  }
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.
void GAL::ComputeWorldScreenMatrix ( )
virtualinherited

Compute the world <-> screen transformation matrix.

Definition at line 177 of file graphics_abstraction_layer.cpp.

References KIGFX::GAL::computeWorldScale(), KIGFX::GAL::globalFlipX, KIGFX::GAL::globalFlipY, MATRIX3x3< T >::Inverse(), KIGFX::GAL::lookAtPoint, scale, KIGFX::GAL::screenSize, KIGFX::GAL::screenWorldMatrix, MATRIX3x3< T >::SetIdentity(), MATRIX3x3< T >::SetScale(), MATRIX3x3< T >::SetTranslation(), KIGFX::GAL::worldScale, and KIGFX::GAL::worldScreenMatrix.

Referenced by BeginDrawing(), KIGFX::GAL::ClearCache(), KIGFX::CAIRO_GAL::initSurface(), KIGFX::VIEW::SetCenter(), and KIGFX::VIEW::SetScale().

178 {
180 
182 
183  MATRIX3x3D translation;
184  translation.SetIdentity();
185  translation.SetTranslation( 0.5 * VECTOR2D( screenSize ) );
186 
188  scale.SetIdentity();
189  scale.SetScale( VECTOR2D( worldScale, worldScale ) );
190 
191  MATRIX3x3D flip;
192 
193  flip.SetIdentity();
194  flip.SetScale( VECTOR2D( globalFlipX ? -1.0 : 1.0, globalFlipY ? -1.0 : 1.0 ) );
195 
196  MATRIX3x3D lookat;
197  lookat.SetIdentity();
198  lookat.SetTranslation( -lookAtPoint );
199 
200  worldScreenMatrix = translation * flip * scale * lookat * worldScreenMatrix;
201  screenWorldMatrix = worldScreenMatrix.Inverse();
202 }
MATRIX3x3 Inverse() const
Determine the inverse of the matrix.
Definition: matrix3x3.h:343
MATRIX3x3D screenWorldMatrix
Screen transformation.
bool globalFlipX
Flag for X axis flipping.
void SetIdentity()
Set the matrix to the identity matrix.
Definition: matrix3x3.h:214
VECTOR2D lookAtPoint
Point to be looked at in world space.
VECTOR2< double > VECTOR2D
Definition: vector2d.h:586
MATRIX3x3D worldScreenMatrix
World transformation.
void computeWorldScale()
Compute the scaling factor for the world->screen matrix.
const int scale
void SetScale(VECTOR2< T > aScale)
Set the scale components of the matrix.
Definition: matrix3x3.h:261
bool globalFlipY
Flag for Y axis flipping.
double worldScale
The scale factor world->screen.
VECTOR2I screenSize
Screen size in screen coordinates.
void SetTranslation(VECTOR2< T > aTranslation)
Set the translation components of the matrix.
Definition: matrix3x3.h:230
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 1465 of file opengl_gal.cpp.

References groups.

Referenced by IsVisible().

1466 {
1467  // Frees memory in the container as well
1468  groups.erase( aGroupNumber );
1469 }
GROUPS_MAP groups
Stores informations about VBO objects (groups)
Definition: opengl_gal.h:308
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 643 of file opengl_gal.cpp.

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

Referenced by IsVisible().

645 {
646  if( aRadius <= 0 )
647  return;
648 
649  // Swap the angles, if start angle is greater than end angle
650  SWAP( aStartAngle, >, aEndAngle );
651 
652  const double alphaIncrement = calcAngleStep( aRadius );
653 
654  Save();
655  currentManager->Translate( aCenterPoint.x, aCenterPoint.y, 0.0 );
656 
657  if( isFillEnabled )
658  {
659  double alpha;
662 
663  // Triangle fan
664  for( alpha = aStartAngle; ( alpha + alphaIncrement ) < aEndAngle; )
665  {
666  currentManager->Reserve( 3 );
667  currentManager->Vertex( 0.0, 0.0, 0.0 );
668  currentManager->Vertex( cos( alpha ) * aRadius, sin( alpha ) * aRadius, 0.0 );
669  alpha += alphaIncrement;
670  currentManager->Vertex( cos( alpha ) * aRadius, sin( alpha ) * aRadius, 0.0 );
671  }
672 
673  // The last missing triangle
674  const VECTOR2D endPoint( cos( aEndAngle ) * aRadius, sin( aEndAngle ) * aRadius );
675 
676  currentManager->Reserve( 3 );
677  currentManager->Vertex( 0.0, 0.0, 0.0 );
678  currentManager->Vertex( cos( alpha ) * aRadius, sin( alpha ) * aRadius, 0.0 );
679  currentManager->Vertex( endPoint.x, endPoint.y, 0.0 );
680  }
681 
682  if( isStrokeEnabled )
683  {
685 
686  VECTOR2D p( cos( aStartAngle ) * aRadius, sin( aStartAngle ) * aRadius );
687  double alpha;
688 
689  for( alpha = aStartAngle + alphaIncrement; alpha <= aEndAngle; alpha += alphaIncrement )
690  {
691  VECTOR2D p_next( cos( alpha ) * aRadius, sin( alpha ) * aRadius );
692  DrawLine( p, p_next );
693 
694  p = p_next;
695  }
696 
697  // Draw the last missing part
698  if( alpha != aEndAngle )
699  {
700  VECTOR2D p_last( cos( aEndAngle ) * aRadius, sin( aEndAngle ) * aRadius );
701  DrawLine( p, p_last );
702  }
703  }
704 
705  Restore();
706 }
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:310
double calcAngleStep(double aRadius) const
Compute the angle step when drawing arcs/circles approximated with lines.
Definition: opengl_gal.h:468
bool Reserve(unsigned int aSize)
Function Reserve() allocates space for vertices, so it will be used with subsequent Vertex() calls...
virtual void Restore() override
Restore the context.
bool Vertex(const VERTEX &aVertex)
Function Vertex() adds a vertex with the given coordinates to the currently set item.
double g
Green component.
Definition: color4d.h:292
COLOR4D fillColor
The fill color.
double b
Blue component.
Definition: color4d.h:293
virtual void Save() override
Save the context.
double a
Alpha component.
Definition: color4d.h:294
bool isStrokeEnabled
Are the outlines stroked ?
COLOR4D strokeColor
The color of the outlines.
void Translate(GLfloat aX, GLfloat aY, GLfloat aZ)
Function Translate() multiplies the current matrix by a translation matrix, so newly vertices will be...
virtual void DrawLine(const VECTOR2D &aStartPoint, const VECTOR2D &aEndPoint) override
Draw a line.
Definition: opengl_gal.cpp:536
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:291
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.

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

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.

Referenced by IsVisible().

711 {
712  if( aRadius <= 0 )
713  {
714  // Arcs of zero radius are a circle of aWidth diameter
715  if( aWidth > 0 )
716  DrawCircle( aCenterPoint, aWidth / 2.0 );
717 
718  return;
719  }
720 
721  // Swap the angles, if start angle is greater than end angle
722  SWAP( aStartAngle, >, aEndAngle );
723 
724  const double alphaIncrement = calcAngleStep( aRadius );
725 
726  Save();
727  currentManager->Translate( aCenterPoint.x, aCenterPoint.y, 0.0 );
728 
729  if( isStrokeEnabled )
730  {
732 
733  double width = aWidth / 2.0;
734  VECTOR2D startPoint( cos( aStartAngle ) * aRadius,
735  sin( aStartAngle ) * aRadius );
736  VECTOR2D endPoint( cos( aEndAngle ) * aRadius,
737  sin( aEndAngle ) * aRadius );
738 
739  drawStrokedSemiCircle( startPoint, width, aStartAngle + M_PI );
740  drawStrokedSemiCircle( endPoint, width, aEndAngle );
741 
742  VECTOR2D pOuter( cos( aStartAngle ) * ( aRadius + width ),
743  sin( aStartAngle ) * ( aRadius + width ) );
744 
745  VECTOR2D pInner( cos( aStartAngle ) * ( aRadius - width ),
746  sin( aStartAngle ) * ( aRadius - width ) );
747 
748  double alpha;
749 
750  for( alpha = aStartAngle + alphaIncrement; alpha <= aEndAngle; alpha += alphaIncrement )
751  {
752  VECTOR2D pNextOuter( cos( alpha ) * ( aRadius + width ),
753  sin( alpha ) * ( aRadius + width ) );
754  VECTOR2D pNextInner( cos( alpha ) * ( aRadius - width ),
755  sin( alpha ) * ( aRadius - width ) );
756 
757  DrawLine( pOuter, pNextOuter );
758  DrawLine( pInner, pNextInner );
759 
760  pOuter = pNextOuter;
761  pInner = pNextInner;
762  }
763 
764  // Draw the last missing part
765  if( alpha != aEndAngle )
766  {
767  VECTOR2D pLastOuter( cos( aEndAngle ) * ( aRadius + width ),
768  sin( aEndAngle ) * ( aRadius + width ) );
769  VECTOR2D pLastInner( cos( aEndAngle ) * ( aRadius - width ),
770  sin( aEndAngle ) * ( aRadius - width ) );
771 
772  DrawLine( pOuter, pLastOuter );
773  DrawLine( pInner, pLastInner );
774  }
775  }
776 
777  if( isFillEnabled )
778  {
780  SetLineWidth( aWidth );
781 
782  VECTOR2D p( cos( aStartAngle ) * aRadius, sin( aStartAngle ) * aRadius );
783  double alpha;
784 
785  for( alpha = aStartAngle + alphaIncrement; alpha <= aEndAngle; alpha += alphaIncrement )
786  {
787  VECTOR2D p_next( cos( alpha ) * aRadius, sin( alpha ) * aRadius );
788  DrawLine( p, p_next );
789 
790  p = p_next;
791  }
792 
793  // Draw the last missing part
794  if( alpha != aEndAngle )
795  {
796  VECTOR2D p_last( cos( aEndAngle ) * aRadius, sin( aEndAngle ) * aRadius );
797  DrawLine( p, p_last );
798  }
799  }
800 
801  Restore();
802 }
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:310
double calcAngleStep(double aRadius) const
Compute the angle step when drawing arcs/circles approximated with lines.
Definition: opengl_gal.h:468
virtual void Restore() override
Restore the context.
double g
Green component.
Definition: color4d.h:292
COLOR4D fillColor
The fill color.
double b
Blue component.
Definition: color4d.h:293
virtual void Save() override
Save the context.
double a
Alpha component.
Definition: color4d.h:294
virtual void SetLineWidth(double aLineWidth)
Set the line width.
bool isStrokeEnabled
Are the outlines stroked ?
COLOR4D strokeColor
The color of the outlines.
void Translate(GLfloat aX, GLfloat aY, GLfloat aZ)
Function Translate() multiplies the current matrix by a translation matrix, so newly vertices will be...
virtual void DrawLine(const VECTOR2D &aStartPoint, const VECTOR2D &aEndPoint) override
Draw a line.
Definition: opengl_gal.cpp:536
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:291
virtual void DrawCircle(const VECTOR2D &aCenterPoint, double aRadius) override
Draw a circle using world coordinates.
Definition: opengl_gal.cpp:583
void OPENGL_GAL::DrawBitmap ( const BITMAP_BASE aBitmap)
overridevirtual

Draw a bitmap image.

Reimplemented from KIGFX::GAL.

Definition at line 1001 of file opengl_gal.cpp.

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

Referenced by IsVisible().

1002 {
1003  int ppi = aBitmap.GetPPI();
1004 
1005  // We have to calculate the pixel size in users units to draw the image.
1006  // worldUnitLength is the user unit in GAL unit value
1007  // (GAL unit = 2.54/1e9 in meter).
1008  // worldUnitLength * 1000 / 2.54 is the user unit in mm
1009  double worldIU_per_mm = 1.0 / ( worldUnitLength / 0.00254 );
1010  double pix_size_iu = worldIU_per_mm * ( 25.4 / ppi );
1011 
1012  double w = (double) aBitmap.GetSizePixels().x * pix_size_iu;
1013  double h = (double) aBitmap.GetSizePixels().y * pix_size_iu;
1014 
1015  auto xform = currentManager->GetTransformation();
1016 
1017  glm::vec4 v0 = xform * glm::vec4( -w/2, -h/2, 0.0, 0.0 );
1018  glm::vec4 v1 = xform * glm::vec4( w/2, h/2, 0.0, 0.0 );
1019  glm::vec4 trans = xform[3];
1020 
1021  auto id = bitmapCache->RequestBitmap( &aBitmap );
1022 
1023  auto oldTarget = GetTarget();
1024 
1025  glPushMatrix();
1026  glTranslated( trans.x, trans.y, trans.z );
1027 
1029  glEnable(GL_TEXTURE_2D);
1030  glActiveTexture( GL_TEXTURE0 );
1031  glBindTexture( GL_TEXTURE_2D, id );
1032 
1033  glBegin( GL_QUADS );
1034  glColor4f(1.0, 1.0, 1.0, 1.0);
1035  glTexCoord2f(0.0, 0.0);
1036  glVertex3f( v0.x, v0.y, layerDepth );
1037  glColor4f(1.0, 1.0, 1.0, 1.0);
1038  glTexCoord2f(1.0, 0.0);
1039  glVertex3f( v1.x, v0.y, layerDepth );
1040  glColor4f(1.0, 1.0, 1.0, 1.0);
1041  glTexCoord2f(1.0, 1.0);
1042  glVertex3f( v1.x, v1.y, layerDepth );
1043  glColor4f(1.0, 1.0, 1.0, 1.0);
1044  glTexCoord2f(0.0, 1.0);
1045  glVertex3f( v0.x, v1.y, layerDepth );
1046  glEnd();
1047 
1048  SetTarget( oldTarget );
1049  glBindTexture( GL_TEXTURE_2D, 0 );
1050 
1051  glPopMatrix();
1052 }
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:310
double layerDepth
The actual layer depth.
std::unique_ptr< GL_BITMAP_CACHE > bitmapCache
Definition: opengl_gal.h:334
Auxiliary rendering target (noncached)
Definition: definitions.h:42
virtual RENDER_TARGET GetTarget() const override
Gets the currently used target for rendering.
double worldUnitLength
The unit length of the world coordinates [inch].
wxSize GetSizePixels() const
Function GetSizePixels.
Definition: bitmap_base.h:133
virtual void SetTarget(RENDER_TARGET aTarget) override
Sets the target for rendering.
int GetPPI() const
Definition: bitmap_base.h:145
const glm::mat4 & GetTransformation() const
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 1771 of file opengl_gal.cpp.

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().

1772 {
1773  const float TEX_X = font_image.width;
1774  const float TEX_Y = font_image.height;
1775 
1776  // handle space
1777  if( aChar == ' ' )
1778  {
1779  const FONT_GLYPH_TYPE* g = LookupGlyph( 'x' );
1780  wxASSERT( g );
1781  Translate( VECTOR2D( g->advance, 0 ) );
1782  return g->advance;
1783  }
1784 
1785  const FONT_GLYPH_TYPE* glyph = LookupGlyph( aChar );
1786  wxASSERT( glyph );
1787 
1788  if( !glyph )
1789  return 0;
1790 
1791  const float X = glyph->atlas_x + font_information.smooth_pixels;
1792  const float Y = glyph->atlas_y + font_information.smooth_pixels;
1793  const float XOFF = glyph->minx;
1794 
1795  // adjust for height rounding
1796  const float round_adjust = ( glyph->maxy - glyph->miny )
1797  - float( glyph->atlas_h - font_information.smooth_pixels * 2 );
1798  const float top_adjust = font_information.max_y - glyph->maxy;
1799  const float YOFF = round_adjust + top_adjust;
1800  const float W = glyph->atlas_w - font_information.smooth_pixels *2;
1801  const float H = glyph->atlas_h - font_information.smooth_pixels *2;
1802  const float B = 0;
1803 
1804  currentManager->Reserve( 6 );
1805  Translate( VECTOR2D( XOFF, YOFF ) );
1806  /* Glyph:
1807  * v0 v1
1808  * +--+
1809  * | /|
1810  * |/ |
1811  * +--+
1812  * v2 v3
1813  */
1814  currentManager->Shader( SHADER_FONT, X / TEX_X, ( Y + H ) / TEX_Y );
1815  currentManager->Vertex( -B, -B, 0 ); // v0
1816 
1817  currentManager->Shader( SHADER_FONT, ( X + W ) / TEX_X, ( Y + H ) / TEX_Y );
1818  currentManager->Vertex( W + B, -B, 0 ); // v1
1819 
1820  currentManager->Shader( SHADER_FONT, X / TEX_X, Y / TEX_Y );
1821  currentManager->Vertex( -B, H + B, 0 ); // v2
1822 
1823 
1824  currentManager->Shader( SHADER_FONT, ( X + W ) / TEX_X, ( Y + H ) / TEX_Y );
1825  currentManager->Vertex( W + B, -B, 0 ); // v1
1826 
1827  currentManager->Shader( SHADER_FONT, X / TEX_X, Y / TEX_Y );
1828  currentManager->Vertex( -B, H + B, 0 ); // v2
1829 
1830  currentManager->Shader( SHADER_FONT, ( X + W ) / TEX_X, Y / TEX_Y );
1831  currentManager->Vertex( W + B, H + B, 0 ); // v3
1832 
1833  Translate( VECTOR2D( -XOFF + glyph->advance, -YOFF ) );
1834 
1835  return glyph->advance;
1836 }
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:310
virtual void Translate(const VECTOR2D &aTranslation) override
Translate the context.
bool Reserve(unsigned int aSize)
Function Reserve() allocates space for vertices, so it will be used with subsequent Vertex() calls...
bool Vertex(const VERTEX &aVertex)
Function Vertex() adds a vertex with the given coordinates to the currently set item.
const FONT_GLYPH_TYPE * LookupGlyph(unsigned int aCodepoint)
VECTOR2< double > VECTOR2D
Definition: vector2d.h:586
FONT_IMAGE_TYPE font_image
Definition: gl_resources.cpp:4
FONT_INFO_TYPE font_information
Definition: gl_resources.cpp:3
#define H(x, y, z)
Definition: md5_hash.cpp:17
void Shader(GLfloat aShaderType, GLfloat aParam1=0.0f, GLfloat aParam2=0.0f, GLfloat aParam3=0.0f)
Function Shader() changes currently used shader and its parameters that will be applied to newly adde...
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 1839 of file opengl_gal.cpp.

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().

1840 {
1841  // To draw an overbar, simply draw an overbar
1842  const FONT_GLYPH_TYPE* glyph = LookupGlyph( '_' );
1843  wxCHECK( glyph, /* void */ );
1844 
1845  const float H = glyph->maxy - glyph->miny;
1846 
1847  Save();
1848 
1849  Translate( VECTOR2D( -aLength, -aHeight-1.5*H ) );
1850 
1851  currentManager->Reserve( 6 );
1853 
1854  currentManager->Shader( 0 );
1855 
1856  currentManager->Vertex( 0, 0, 0 ); // v0
1857  currentManager->Vertex( aLength, 0, 0 ); // v1
1858  currentManager->Vertex( 0, H, 0 ); // v2
1859 
1860  currentManager->Vertex( aLength, 0, 0 ); // v1
1861  currentManager->Vertex( 0, H, 0 ); // v2
1862  currentManager->Vertex( aLength, H, 0 ); // v3
1863 
1864  Restore();
1865 }
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:310
virtual void Translate(const VECTOR2D &aTranslation) override
Translate the context.
bool Reserve(unsigned int aSize)
Function Reserve() allocates space for vertices, so it will be used with subsequent Vertex() calls...
virtual void Restore() override
Restore the context.
bool Vertex(const VERTEX &aVertex)
Function Vertex() adds a vertex with the given coordinates to the currently set item.
double g
Green component.
Definition: color4d.h:292
const FONT_GLYPH_TYPE * LookupGlyph(unsigned int aCodepoint)
double b
Blue component.
Definition: color4d.h:293
virtual void Save() override
Save the context.
VECTOR2< double > VECTOR2D
Definition: vector2d.h:586
COLOR4D strokeColor
The color of the outlines.
void Color(const COLOR4D &aColor)
Function Color() changes currently used color that will be applied to newly added vertices...
#define H(x, y, z)
Definition: md5_hash.cpp:17
void Shader(GLfloat aShaderType, GLfloat aParam1=0.0f, GLfloat aParam2=0.0f, GLfloat aParam3=0.0f)
Function Shader() changes currently used shader and its parameters that will be applied to newly adde...
double r
Red component.
Definition: color4d.h:291
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 583 of file opengl_gal.cpp.

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 IsVisible().

584 {
585  if( isFillEnabled )
586  {
587  currentManager->Reserve( 3 );
589 
590  /* Draw a triangle that contains the circle, then shade it leaving only the circle.
591  * Parameters given to Shader() are indices of the triangle's vertices
592  * (if you want to understand more, check the vertex shader source [shader.vert]).
593  * Shader uses this coordinates to determine if fragments are inside the circle or not.
594  * v2
595  * /\
596  * //\\
597  * v0 /_\/_\ v1
598  */
600  currentManager->Vertex( aCenterPoint.x - aRadius * sqrt( 3.0f ), // v0
601  aCenterPoint.y - aRadius, layerDepth );
602 
604  currentManager->Vertex( aCenterPoint.x + aRadius * sqrt( 3.0f), // v1
605  aCenterPoint.y - aRadius, layerDepth );
606 
608  currentManager->Vertex( aCenterPoint.x, aCenterPoint.y + aRadius * 2.0f, // v2
609  layerDepth );
610  }
611 
612  if( isStrokeEnabled )
613  {
614  currentManager->Reserve( 3 );
616 
617  /* Draw a triangle that contains the circle, then shade it leaving only the circle.
618  * Parameters given to Shader() are indices of the triangle's vertices
619  * (if you want to understand more, check the vertex shader source [shader.vert]).
620  * and the line width. Shader uses this coordinates to determine if fragments are
621  * inside the circle or not.
622  * v2
623  * /\
624  * //\\
625  * v0 /_\/_\ v1
626  */
627  double outerRadius = aRadius + ( lineWidth / 2 );
629  currentManager->Vertex( aCenterPoint.x - outerRadius * sqrt( 3.0f ), // v0
630  aCenterPoint.y - outerRadius, layerDepth );
631 
633  currentManager->Vertex( aCenterPoint.x + outerRadius * sqrt( 3.0f ), // v1
634  aCenterPoint.y - outerRadius, layerDepth );
635 
637  currentManager->Vertex( aCenterPoint.x, aCenterPoint.y + outerRadius * 2.0f, // v2
638  layerDepth );
639  }
640 }
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:310
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:292
COLOR4D fillColor
The fill color.
double b
Blue component.
Definition: color4d.h:293
double lineWidth
The line width.
double a
Alpha component.
Definition: color4d.h:294
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 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:291
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 1553 of file opengl_gal.cpp.

References KIGFX::GAL::cursorPosition.

Referenced by SetNegativeDrawMode().

1554 {
1555  // Now we should only store the position of the mouse cursor
1556  // The real drawing routines are in blitCursor()
1557  //VECTOR2D screenCursor = worldScreenMatrix * aCursorPosition;
1558  //cursorPosition = screenWorldMatrix * VECTOR2D( screenCursor.x, screenCursor.y );
1559  cursorPosition = aCursorPosition;
1560 }
VECTOR2D cursorPosition
Current cursor position (world coordinates)
void OPENGL_GAL::DrawCurve ( const VECTOR2D startPoint,
const VECTOR2D controlPointA,
const VECTOR2D controlPointB,
const VECTOR2D endPoint 
)
overridevirtual

Draw a cubic bezier spline.

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

Reimplemented from KIGFX::GAL.

Definition at line 969 of file opengl_gal.cpp.

References CURVE_POINTS, DrawPolyline(), and i.

Referenced by IsVisible().

971 {
972  // FIXME The drawing quality needs to be improved
973  // FIXME Perhaps choose a quad/triangle strip instead?
974  // FIXME Brute force method, use a better (recursive?) algorithm
975 
976  std::deque<VECTOR2D> pointList;
977 
978  double t = 0.0;
979  double dt = 1.0 / (double) CURVE_POINTS;
980 
981  for( int i = 0; i <= CURVE_POINTS; i++ )
982  {
983  double omt = 1.0 - t;
984  double omt2 = omt * omt;
985  double omt3 = omt * omt2;
986  double t2 = t * t;
987  double t3 = t * t2;
988 
989  VECTOR2D vertex = omt3 * aStartPoint + 3.0 * t * omt2 * aControlPointA
990  + 3.0 * t2 * omt * aControlPointB + t3 * aEndPoint;
991 
992  pointList.push_back( vertex );
993 
994  t += dt;
995  }
996 
997  DrawPolyline( pointList );
998 }
static const int CURVE_POINTS
The number of points for curve approximation.
Definition: opengl_gal.h:296
virtual void DrawPolyline(const std::deque< VECTOR2D > &aPointList) override
Draw a polyline.
Definition: opengl_gal.cpp:843
size_t i
Definition: json11.cpp:597
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 1640 of file opengl_gal.cpp.

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 drawPolyline(), and drawSemiCircle().

1642 {
1643  Save();
1644 
1645  currentManager->Reserve( 3 );
1646  currentManager->Translate( aCenterPoint.x, aCenterPoint.y, 0.0f );
1647  currentManager->Rotate( aAngle, 0.0f, 0.0f, 1.0f );
1648 
1649  /* Draw a triangle that contains the semicircle, then shade it to leave only
1650  * the semicircle. Parameters given to Shader() are indices of the triangle's vertices
1651  * (if you want to understand more, check the vertex shader source [shader.vert]).
1652  * Shader uses these coordinates to determine if fragments are inside the semicircle or not.
1653  * v2
1654  * /\
1655  * /__\
1656  * v0 //__\\ v1
1657  */
1659  currentManager->Vertex( -aRadius * 3.0f / sqrt( 3.0f ), 0.0f, layerDepth ); // v0
1660 
1662  currentManager->Vertex( aRadius * 3.0f / sqrt( 3.0f ), 0.0f, layerDepth ); // v1
1663 
1665  currentManager->Vertex( 0.0f, aRadius * 2.0f, layerDepth ); // v2
1666 
1667  Restore();
1668 }
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:310
double layerDepth
The actual layer depth.
bool Reserve(unsigned int aSize)
Function Reserve() allocates space for vertices, so it will be used with subsequent Vertex() calls...
virtual void Restore() override
Restore the context.
bool Vertex(const VERTEX &aVertex)
Function Vertex() adds a vertex with the given coordinates to the currently set item.
void Rotate(GLfloat aAngle, GLfloat aX, GLfloat aY, GLfloat aZ)
Function Rotate() multiplies the current matrix by a rotation matrix, so the newly vertices will be r...
virtual void Save() override
Save the context.
void Translate(GLfloat aX, GLfloat aY, GLfloat aZ)
Function Translate() multiplies the current matrix by a translation matrix, so newly vertices will be...
void Shader(GLfloat aShaderType, GLfloat aParam1=0.0f, GLfloat aParam2=0.0f, GLfloat aParam3=0.0f)
Function Shader() changes currently used shader and its parameters that will be applied to newly adde...
void OPENGL_GAL::DrawGrid ( )
overridevirtual

>

Draw the grid

Reimplemented from KIGFX::GAL.

Definition at line 1157 of file opengl_gal.cpp.

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

Referenced by IsVisible().

1158 {
1161 
1163 
1164  // sub-pixel lines all render the same
1165  double minorLineWidth = std::max( 1.0, gridLineWidth ) * getWorldPixelSize();
1166  double majorLineWidth = minorLineWidth * 2.0;
1167 
1168  // Draw the axis and grid
1169  // For the drawing the start points, end points and increments have
1170  // to be calculated in world coordinates
1171  VECTOR2D worldStartPoint = screenWorldMatrix * VECTOR2D( 0.0, 0.0 );
1172  VECTOR2D worldEndPoint = screenWorldMatrix * VECTOR2D( screenSize );
1173 
1174  // Draw axes if desired
1175  if( axesEnabled )
1176  {
1177  SetLineWidth( minorLineWidth );
1179 
1180  DrawLine( VECTOR2D( worldStartPoint.x, 0 ), VECTOR2D( worldEndPoint.x, 0 ) );
1181  DrawLine( VECTOR2D( 0, worldStartPoint.y ), VECTOR2D( 0, worldEndPoint.y ) );
1182  }
1183 
1184  // force flush
1186 
1187  if( !gridVisibility )
1188  return;
1189 
1190  int gridScreenSizeDense = KiROUND( gridSize.x * worldScale );
1191  int gridScreenSizeCoarse = KiROUND( gridSize.x * static_cast<double>( gridTick ) * worldScale );
1192 
1193  const double gridThreshold = computeMinGridSpacing();
1194 
1195  // Check if the grid would not be too dense
1196  if( std::max( gridScreenSizeDense, gridScreenSizeCoarse ) < gridThreshold )
1197  return;
1198 
1199  // Compute grid staring and ending indexes to draw grid points on the
1200  // visible screen area
1201  // Note: later any point coordinate will be offsetted by gridOrigin
1202  int gridStartX = KiROUND( ( worldStartPoint.x - gridOrigin.x ) / gridSize.x );
1203  int gridEndX = KiROUND( ( worldEndPoint.x - gridOrigin.x ) / gridSize.x );
1204  int gridStartY = KiROUND( ( worldStartPoint.y - gridOrigin.y ) / gridSize.y );
1205  int gridEndY = KiROUND( ( worldEndPoint.y - gridOrigin.y ) / gridSize.y );
1206 
1207  // Ensure start coordinate > end coordinate
1208  if( gridStartX > gridEndX )
1209  std::swap( gridStartX, gridEndX );
1210 
1211  if( gridStartY > gridEndY )
1212  std::swap( gridStartY, gridEndY );
1213 
1214  // Ensure the grid fills the screen
1215  --gridStartX; ++gridEndX;
1216  --gridStartY; ++gridEndY;
1217 
1218  glDisable( GL_DEPTH_TEST );
1219  glDisable( GL_TEXTURE_2D );
1220 
1221  if( gridStyle == GRID_STYLE::DOTS )
1222  {
1223  glEnable( GL_STENCIL_TEST );
1224  glStencilFunc( GL_ALWAYS, 1, 1 );
1225  glStencilOp( GL_KEEP, GL_KEEP, GL_INCR );
1226  glColor4d( 0.0, 0.0, 0.0, 0.0 );
1227  SetStrokeColor( COLOR4D( 0.0, 0.0, 0.0, 0.0 ) );
1228  }
1229  else
1230  {
1231  glColor4d( gridColor.r, gridColor.g, gridColor.b, gridColor.a );
1233  }
1234 
1236  {
1237  SetLineWidth( minorLineWidth );
1238 
1239  // calculate a line len = 2 minorLineWidth, in internal unit value
1240  // (in fact the size of cross is lineLen*2)
1241  int lineLen = KiROUND( minorLineWidth * 2.0 );
1242 
1243  // Vertical positions
1244  for( int j = gridStartY; j <= gridEndY; j++ )
1245  {
1246  if( ( j % gridTick == 0 && gridScreenSizeCoarse > gridThreshold )
1247  || gridScreenSizeDense > gridThreshold )
1248  {
1249  int posY = j * gridSize.y + gridOrigin.y;
1250 
1251  // Horizontal positions
1252  for( int i = gridStartX; i <= gridEndX; i++ )
1253  {
1254  if( ( i % gridTick == 0 && gridScreenSizeCoarse > gridThreshold )
1255  || gridScreenSizeDense > gridThreshold )
1256  {
1257  int posX = i * gridSize.x + gridOrigin.x;
1258 
1259  DrawLine( VECTOR2D( posX - lineLen, posY ), VECTOR2D( posX + lineLen, posY ) );
1260  DrawLine( VECTOR2D( posX, posY - lineLen ), VECTOR2D( posX, posY + lineLen ) );
1261  }
1262  }
1263  }
1264  }
1265 
1267  }
1268  else
1269  {
1270  // Vertical lines
1271  for( int j = gridStartY; j <= gridEndY; j++ )
1272  {
1273  const double y = j * gridSize.y + gridOrigin.y;
1274 
1275  // If axes are drawn, skip the lines that would cover them
1276  if( axesEnabled && y == 0 )
1277  continue;
1278 
1279  if( j % gridTick == 0 && gridScreenSizeDense > gridThreshold )
1280  SetLineWidth( majorLineWidth );
1281  else
1282  SetLineWidth( minorLineWidth );
1283 
1284  if( ( j % gridTick == 0 && gridScreenSizeCoarse > gridThreshold )
1285  || gridScreenSizeDense > gridThreshold )
1286  {
1287  VECTOR2D a ( gridStartX * gridSize.x + gridOrigin.x, y );
1288  VECTOR2D b ( gridEndX * gridSize.x + gridOrigin.x, y );
1289 
1290  DrawLine( a, b );
1291  }
1292  }
1293 
1295 
1296  if( gridStyle == GRID_STYLE::DOTS )
1297  {
1298  glStencilFunc( GL_NOTEQUAL, 0, 1 );
1299  glColor4d( gridColor.r, gridColor.g, gridColor.b, gridColor.a );
1301  }
1302 
1303  // Horizontal lines
1304  for( int i = gridStartX; i <= gridEndX; i++ )
1305  {
1306  const double x = i * gridSize.x + gridOrigin.x;
1307 
1308  // If axes are drawn, skip the lines that would cover them
1309  if( axesEnabled && x == 0 )
1310  continue;
1311 
1312  if( i % gridTick == 0 && gridScreenSizeDense > gridThreshold )
1313  SetLineWidth( majorLineWidth );
1314  else
1315  SetLineWidth( minorLineWidth );
1316 
1317  if( ( i % gridTick == 0 && gridScreenSizeCoarse > gridThreshold )
1318  || gridScreenSizeDense > gridThreshold )
1319  {
1320  VECTOR2D a ( x, gridStartY * gridSize.y + gridOrigin.y );
1321  VECTOR2D b ( x, gridEndY * gridSize.y + gridOrigin.y );
1322  DrawLine( a, b );
1323  }
1324  }
1325 
1327 
1328  if( gridStyle == GRID_STYLE::DOTS )
1329  glDisable( GL_STENCIL_TEST );
1330  }
1331 
1332  glEnable( GL_DEPTH_TEST );
1333  glEnable( GL_TEXTURE_2D );
1334 }
double computeMinGridSpacing() const
compute minimum grid spacing from the grid settings
int gridTick
Every tick line gets the double width.
double getWorldPixelSize() const
Definition: opengl_gal.cpp:322
bool axesEnabled
Should the axes be drawn.
static int KiROUND(double v)
Round a floating point number to an integer using "round halfway cases away from zero".
Definition: common.h:120
GRID_STYLE gridStyle
Grid display style.
double g
Green component.
Definition: color4d.h:292
MATRIX3x3D screenWorldMatrix
Screen transformation.
VERTEX_MANAGER * nonCachedManager
Container for storing non-cached VERTEX_ITEMs.
Definition: opengl_gal.h:312
double b
Blue component.
Definition: color4d.h:293
Auxiliary rendering target (noncached)
Definition: definitions.h:42
double a
Alpha component.
Definition: color4d.h:294
virtual void SetLineWidth(double aLineWidth)
Set the line width.
OPENGL_COMPOSITOR * compositor
Handles multiple rendering targets.
Definition: opengl_gal.h:316
VECTOR2< double > VECTOR2D
Definition: vector2d.h:586
unsigned int mainBuffer
Main rendering target.
Definition: opengl_gal.h:317
COLOR4D axesColor
Color of the axes.
void EndDrawing() const
Function EndDrawing() finishes drawing operations.
virtual void DrawLine(const VECTOR2D &aStartPoint, const VECTOR2D &aEndPoint) override
Draw a line.
Definition: opengl_gal.cpp:536
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.
virtual void SetTarget(RENDER_TARGET aTarget) override
Sets the target for rendering.
virtual void SetStrokeColor(const COLOR4D &aColor)
Set the stroke color.
COLOR4D gridColor
Color of the grid.
bool gridVisibility
Should the grid be shown.
void EnableDepthTest(bool aEnabled)
Function EnableDepthTest() Enables/disables Z buffer depth test.
#define max(a, b)
Definition: auxiliary.h:86
double worldScale
The scale factor world->screen.
VECTOR2D gridSize
The grid size.
size_t i
Definition: json11.cpp:597
VECTOR2I screenSize
Screen size in screen coordinates.
double r
Red component.
Definition: color4d.h:291
Class COLOR4D is the color representation with 4 components: red, green, blue, alpha.
Definition: color4d.h:39
double gridLineWidth
Line width of the grid.
virtual void KIGFX::GAL::drawGridLine ( const VECTOR2D aStartPoint,
const VECTOR2D aEndPoint 
)
inlineprotectedvirtualinherited

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

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

Reimplemented in KIGFX::CAIRO_GAL.

Definition at line 1086 of file graphics_abstraction_layer.h.

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

1086 {};
void OPENGL_GAL::DrawGroup ( int  aGroupNumber)
overridevirtual

Draw the stored group.

Parameters
aGroupNumberis the group number.

Reimplemented from KIGFX::GAL.

Definition at line 1444 of file opengl_gal.cpp.

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

Referenced by IsVisible().

1445 {
1446  if( groups[aGroupNumber] )
1447  cachedManager->DrawItem( *groups[aGroupNumber] );
1448 }
GROUPS_MAP groups
Stores informations about VBO objects (groups)
Definition: opengl_gal.h:308
VERTEX_MANAGER * cachedManager
Container for storing cached VERTEX_ITEMs.
Definition: opengl_gal.h:311
void DrawItem(const VERTEX_ITEM &aItem) const
Function DrawItem() draws an item to the buffer.
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 536 of file opengl_gal.cpp.

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(), DrawGrid(), and IsVisible().

537 {
539 
540  drawLineQuad( aStartPoint, aEndPoint );
541 }
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:310
void drawLineQuad(const VECTOR2D &aStartPoint, const VECTOR2D &aEndPoint)
Draw a quad for the line.
double g
Green component.
Definition: color4d.h:292
double b
Blue component.
Definition: color4d.h:293
double a
Alpha component.
Definition: color4d.h:294
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:291
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 1563 of file opengl_gal.cpp.

References currentManager, VECTOR2< T >::EuclideanNorm(), KIGFX::VERTEX_MANAGER::GetTransformation(), KIGFX::GAL::layerDepth, KIGFX::GAL::lineWidth, KIGFX::VERTEX_MANAGER::Reserve(), VECTOR2< T >::Resize(), 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().

1564 {
1565  /* Helper drawing: ____--- v3 ^
1566  * ____---- ... \ \
1567  * ____---- ... \ end \
1568  * v1 ____---- ... ____---- \ width
1569  * ---- ...___---- \ \
1570  * \ ___...-- \ v
1571  * \ ____----... ____---- v2
1572  * ---- ... ____----
1573  * start \ ... ____----
1574  * \... ____----
1575  * ----
1576  * v0
1577  * dots mark triangles' hypotenuses
1578  */
1579 
1580  auto v1 = currentManager->GetTransformation() * glm::vec4( aStartPoint.x, aStartPoint.y, 0.0, 0.0 );
1581  auto v2 = currentManager->GetTransformation() * glm::vec4( aEndPoint.x, aEndPoint.y, 0.0, 0.0 );
1582 
1583  VECTOR2D startEndVector( v2.x - v1.x, v2.y - v1.y );
1584 
1585  double lineLength = startEndVector.EuclideanNorm();
1586 
1587  VECTOR2D vs ( startEndVector );
1588  float aspect;
1589 
1590  if ( lineWidth == 0.0 ) // pixel-width line
1591  {
1592  vs = vs.Resize( 0.5 );
1593  aspect = ( lineLength + 1.0 );
1594  }
1595  else
1596  {
1597  vs = vs.Resize( 0.5 * lineWidth );
1598  aspect = ( lineLength + lineWidth ) / lineWidth;
1599  }
1600 
1601  currentManager->Reserve( 6 );
1602 
1603  // Line width is maintained by the vertex shader
1604  currentManager->Shader( SHADER_LINE_A, aspect, vs.x, vs.y );
1605  currentManager->Vertex( aStartPoint, layerDepth );
1606 
1607  currentManager->Shader( SHADER_LINE_B, aspect, vs.x, vs.y );
1608  currentManager->Vertex( aStartPoint, layerDepth );
1609 
1610  currentManager->Shader( SHADER_LINE_C, aspect, vs.x, vs.y );
1611  currentManager->Vertex( aEndPoint, layerDepth );
1612 
1613  currentManager->Shader( SHADER_LINE_D, aspect, vs.x, vs.y );
1614  currentManager->Vertex( aEndPoint, layerDepth );
1615 
1616  currentManager->Shader( SHADER_LINE_E, aspect, vs.x, vs.y );
1617  currentManager->Vertex( aEndPoint, layerDepth );
1618 
1619  currentManager->Shader( SHADER_LINE_F, aspect, vs.x, vs.y );
1620  currentManager->Vertex( aStartPoint, layerDepth );
1621 }
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:310
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 lineWidth
The line width.
const glm::mat4 & GetTransformation() const
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...
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 866 of file opengl_gal.cpp.

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

Referenced by IsVisible().

867 {
868  auto points = std::unique_ptr<GLdouble[]>( new GLdouble[3 * aPointList.size()] );
869  GLdouble* ptr = points.get();
870 
871  for( const VECTOR2D& p : aPointList )
872  {
873  *ptr++ = p.x;
874  *ptr++ = p.y;
875  *ptr++ = layerDepth;
876  }
877 
878  drawPolygon( points.get(), aPointList.size() );
879 }
double layerDepth
The actual layer depth.
void drawPolygon(GLdouble *aPoints, int aPointCount)
Draws a filled polygon.
void OPENGL_GAL::DrawPolygon ( const VECTOR2D  aPointList[],
int  aListSize 
)
overridevirtual

Reimplemented from KIGFX::GAL.

Definition at line 882 of file opengl_gal.cpp.

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

883 {
884  auto points = std::unique_ptr<GLdouble[]>( new GLdouble[3 * aListSize] );
885  GLdouble* target = points.get();
886  const VECTOR2D* src = aPointList;
887 
888  for( int i = 0; i < aListSize; ++i )
889  {
890  *target++ = src->x;
891  *target++ = src->y;
892  *target++ = layerDepth;
893  ++src;
894  }
895 
896  drawPolygon( points.get(), aListSize );
897 }
double layerDepth
The actual layer depth.
void drawPolygon(GLdouble *aPoints, int aPointCount)
Draws a filled polygon.
size_t i
Definition: json11.cpp:597
void OPENGL_GAL::DrawPolygon ( const SHAPE_POLY_SET aPolySet)
overridevirtual

Reimplemented from KIGFX::GAL.

Definition at line 937 of file opengl_gal.cpp.

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

938 {
939  if ( aPolySet.IsTriangulationUpToDate() )
940  {
941  drawTriangulatedPolyset( aPolySet );
942  return;
943  }
944 
945  for( int j = 0; j < aPolySet.OutlineCount(); ++j )
946  {
947  const SHAPE_LINE_CHAIN& outline = aPolySet.COutline( j );
948 
949  if( outline.SegmentCount() == 0 )
950  continue;
951 
952  const int pointCount = outline.SegmentCount() + 1;
953  std::unique_ptr<GLdouble[]> points( new GLdouble[3 * pointCount] );
954  GLdouble* ptr = points.get();
955 
956  for( int i = 0; i < pointCount; ++i )
957  {
958  const VECTOR2I& p = outline.CPoint( i );
959  *ptr++ = p.x;
960  *ptr++ = p.y;
961  *ptr++ = layerDepth;
962  }
963 
964  drawPolygon( points.get(), pointCount );
965  }
966 }
double layerDepth
The actual layer depth.
void drawPolygon(GLdouble *aPoints, int aPointCount)
Draws a filled polygon.
bool IsTriangulationUpToDate() const
int OutlineCount() const
Returns the number of outlines in the set
const SHAPE_LINE_CHAIN & COutline(int aIndex) const
void drawTriangulatedPolyset(const SHAPE_POLY_SET &aPoly)
Draws a set of polygons with a cached triangulation.
Definition: opengl_gal.cpp:900
Class SHAPE_LINE_CHAIN.
size_t i
Definition: json11.cpp:597
const VECTOR2I & CPoint(int aIndex) const
Function CPoint()
int SegmentCount() const
Function SegmentCount()
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 1705 of file opengl_gal.cpp.

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

Referenced by DrawPolygon().

1706 {
1707  if( isFillEnabled )
1708  {
1711 
1712  // Any non convex polygon needs to be tesselated
1713  // for this purpose the GLU standard functions are used
1714  TessParams params = { currentManager, tessIntersects };
1715  gluTessBeginPolygon( tesselator, &params );
1716  gluTessBeginContour( tesselator );
1717 
1718  GLdouble* point = aPoints;
1719 
1720  for( int i = 0; i < aPointCount; ++i )
1721  {
1722  gluTessVertex( tesselator, point, point );
1723  point += 3; // 3 coordinates
1724  }
1725 
1726  gluTessEndContour( tesselator );
1727  gluTessEndPolygon( tesselator );
1728 
1729  // Free allocated intersecting points
1730  tessIntersects.clear();
1731  }
1732 
1733  if( isStrokeEnabled )
1734  {
1735  drawPolyline( [&](int idx) { return VECTOR2D( aPoints[idx * 3], aPoints[idx * 3 + 1] ); },
1736  aPointCount );
1737  }
1738 }
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:310
double g
Green component.
Definition: color4d.h:292
COLOR4D fillColor
The fill color.
double b
Blue component.
Definition: color4d.h:293
double a
Alpha component.
Definition: color4d.h:294
bool isStrokeEnabled
Are the outlines stroked ?
VECTOR2< double > VECTOR2D
Definition: vector2d.h:586
void Color(const COLOR4D &aColor)
Function Color() changes currently used color that will be applied to newly added vertices...
GLUtesselator * tesselator
The tessellator.
Definition: opengl_gal.h:345
bool isFillEnabled
Is filling of graphic objects enabled ?
std::deque< boost::shared_array< GLdouble > > tessIntersects
Storage for intersecting points.
Definition: opengl_gal.h:347
size_t i
Definition: json11.cpp:597
void drawPolyline(const std::function< VECTOR2D(int)> &aPointGetter, int aPointCount)
Generic way of drawing a polyline stored in different containers.
void Shader(GLfloat aShaderType, GLfloat aParam1=0.0f, GLfloat aParam2=0.0f, GLfloat aParam3=0.0f)
Function Shader() changes currently used shader and its parameters that will be applied to newly adde...
double r
Red component.
Definition: color4d.h:291
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 843 of file opengl_gal.cpp.

References drawPolyline().

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

844 {
845  drawPolyline( [&](int idx) { return aPointList[idx]; }, aPointList.size() );
846 }
void drawPolyline(const std::function< VECTOR2D(int)> &aPointGetter, int aPointCount)
Generic way of drawing a polyline stored in different containers.
void OPENGL_GAL::DrawPolyline ( const VECTOR2D  aPointList[],
int  aListSize 
)
overridevirtual

Reimplemented from KIGFX::GAL.

Definition at line 849 of file opengl_gal.cpp.

References drawPolyline().

850 {
851  drawPolyline( [&](int idx) { return aPointList[idx]; }, aListSize );
852 }
void drawPolyline(const std::function< VECTOR2D(int)> &aPointGetter, int aPointCount)
Generic way of drawing a polyline stored in different containers.
void OPENGL_GAL::DrawPolyline ( const SHAPE_LINE_CHAIN aLineChain)
overridevirtual

Reimplemented from KIGFX::GAL.

Definition at line 855 of file opengl_gal.cpp.

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

856 {
857  auto numPoints = aLineChain.PointCount();
858 
859  if( aLineChain.IsClosed() )
860  numPoints += 1;
861 
862  drawPolyline( [&](int idx) { return aLineChain.CPoint(idx); }, numPoints );
863 }
int PointCount() const
Function PointCount()
bool IsClosed() const
Function IsClosed()
void drawPolyline(const std::function< VECTOR2D(int)> &aPointGetter, int aPointCount)
Generic way of drawing a polyline stored in different containers.
const VECTOR2I & CPoint(int aIndex) const
Function CPoint()
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 1741 of file opengl_gal.cpp.

References KIGFX::COLOR4D::a, VECTOR2< T >::Angle(), KIGFX::COLOR4D::b, KIGFX::VERTEX_MANAGER::Color(), currentManager, drawFilledSemiCircle(), drawLineQuad(), KIGFX::COLOR4D::g, i, KIGFX::GAL::lineWidth, KIGFX::COLOR4D::r, and KIGFX::GAL::strokeColor.

Referenced by drawPolygon(), and DrawPolyline().

1742 {
1743  if( aPointCount < 2 )
1744  return;
1745 
1747  int i;
1748 
1749  for( i = 1; i < aPointCount; ++i )
1750  {
1751  auto start = aPointGetter( i - 1 );
1752  auto end = aPointGetter( i );
1753  const VECTOR2D startEndVector = ( end - start );
1754  double lineAngle = startEndVector.Angle();
1755 
1756  drawLineQuad( start, end );
1757 
1758  // There is no need to draw line caps on both ends of polyline's segments
1759  drawFilledSemiCircle( start, lineWidth / 2, lineAngle + M_PI / 2 );
1760  }
1761 
1762  // ..and now - draw the ending cap
1763  auto start = aPointGetter( i - 2 );
1764  auto end = aPointGetter( i - 1 );
1765  const VECTOR2D startEndVector = ( end - start );
1766  double lineAngle = startEndVector.Angle();
1767  drawFilledSemiCircle( end, lineWidth / 2, lineAngle - M_PI / 2 );
1768 }
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:310
void drawLineQuad(const VECTOR2D &aStartPoint, const VECTOR2D &aEndPoint)
Draw a quad for the line.
double g
Green component.
Definition: color4d.h:292
double b
Blue component.
Definition: color4d.h:293
double lineWidth
The line width.
double Angle() const
Function Angle computes the angle of the vector.
Definition: vector2d.h:306
double a
Alpha component.
Definition: color4d.h:294
COLOR4D strokeColor
The color of the outlines.
void Color(const COLOR4D &aColor)
Function Color() changes currently used color that will be applied to newly added vertices...
size_t i
Definition: json11.cpp:597
double r
Red component.
Definition: color4d.h:291
void drawFilledSemiCircle(const VECTOR2D &aCenterPoint, double aRadius, double aAngle)
Draw a filled semicircle.
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 805 of file opengl_gal.cpp.

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.

Referenced by IsVisible().

806 {
807  // Compute the diagonal points of the rectangle
808  VECTOR2D diagonalPointA( aEndPoint.x, aStartPoint.y );
809  VECTOR2D diagonalPointB( aStartPoint.x, aEndPoint.y );
810 
811  // Fill the rectangle
812  if( isFillEnabled )
813  {
814  currentManager->Reserve( 6 );
817 
818  currentManager->Vertex( aStartPoint.x, aStartPoint.y, layerDepth );
819  currentManager->Vertex( diagonalPointA.x, diagonalPointA.y, layerDepth );
820  currentManager->Vertex( aEndPoint.x, aEndPoint.y, layerDepth );
821 
822  currentManager->Vertex( aStartPoint.x, aStartPoint.y, layerDepth );
823  currentManager->Vertex( aEndPoint.x, aEndPoint.y, layerDepth );
824  currentManager->Vertex( diagonalPointB.x, diagonalPointB.y, layerDepth );
825  }
826 
827  // Stroke the outline
828  if( isStrokeEnabled )
829  {
831 
832  std::deque<VECTOR2D> pointList;
833  pointList.push_back( aStartPoint );
834  pointList.push_back( diagonalPointA );
835  pointList.push_back( aEndPoint );
836  pointList.push_back( diagonalPointB );
837  pointList.push_back( aStartPoint );
838  DrawPolyline( pointList );
839  }
840 }
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:310
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:292
COLOR4D fillColor
The fill color.
double b
Blue component.
Definition: color4d.h:293
double a
Alpha component.
Definition: color4d.h:294
bool isStrokeEnabled
Are the outlines stroked ?
COLOR4D strokeColor
The color of the outlines.
void Color(const COLOR4D &aColor)
Function Color() changes currently used color that will be applied to newly added vertices...
bool isFillEnabled
Is filling of graphic objects enabled ?
virtual void DrawPolyline(const std::deque< VECTOR2D > &aPointList) override
Draw a polyline.
Definition: opengl_gal.cpp:843
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:291
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 544 of file opengl_gal.cpp.

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

Referenced by IsVisible().

546 {
547  if( isFillEnabled || aWidth == 1.0 )
548  {
550 
551  SetLineWidth( aWidth );
552  drawLineQuad( aStartPoint, aEndPoint );
553  }
554  else
555  {
556  auto startEndVector = aEndPoint - aStartPoint;
557  auto lineAngle = startEndVector.Angle();
558  // Outlined tracks
559  double lineLength = startEndVector.EuclideanNorm();
560 
562 
563  Save();
564 
565  currentManager->Translate( aStartPoint.x, aStartPoint.y, 0.0 );
566  currentManager->Rotate( lineAngle, 0.0f, 0.0f, 1.0f );
567 
568  drawLineQuad( VECTOR2D( 0.0, aWidth / 2.0 ),
569  VECTOR2D( lineLength, aWidth / 2.0 ) );
570 
571  drawLineQuad( VECTOR2D( 0.0, -aWidth / 2.0 ),
572  VECTOR2D( lineLength, -aWidth / 2.0 ) );
573 
574  // Draw line caps
575  drawStrokedSemiCircle( VECTOR2D( 0.0, 0.0 ), aWidth / 2, M_PI / 2 );
576  drawStrokedSemiCircle( VECTOR2D( lineLength, 0.0 ), aWidth / 2, -M_PI / 2 );
577 
578  Restore();
579  }
580 }
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:310
void drawLineQuad(const VECTOR2D &aStartPoint, const VECTOR2D &aEndPoint)
Draw a quad for the line.
virtual void Restore() override
Restore the context.
void Rotate(GLfloat aAngle, GLfloat aX, GLfloat aY, GLfloat aZ)
Function Rotate() multiplies the current matrix by a rotation matrix, so the newly vertices will be r...
double g
Green component.
Definition: color4d.h:292
COLOR4D fillColor
The fill color.
double b
Blue component.
Definition: color4d.h:293
double Angle() const
Function Angle computes the angle of the vector.
Definition: vector2d.h:306
virtual void Save() override
Save the context.
double a
Alpha component.
Definition: color4d.h:294
virtual void SetLineWidth(double aLineWidth)
Set the line width.
VECTOR2< double > VECTOR2D
Definition: vector2d.h:586
COLOR4D strokeColor
The color of the outlines.
void Translate(GLfloat aX, GLfloat aY, GLfloat aZ)
Function Translate() multiplies the current matrix by a translation matrix, so newly vertices will be...
void Color(const COLOR4D &aColor)
Function Color() changes currently used color that will be applied to newly added vertices...
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:291
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 1624 of file opengl_gal.cpp.

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.

1625 {
1626  if( isFillEnabled )
1627  {
1629  drawFilledSemiCircle( aCenterPoint, aRadius, aAngle );
1630  }
1631 
1632  if( isStrokeEnabled )
1633  {
1635  drawStrokedSemiCircle( aCenterPoint, aRadius, aAngle );
1636  }
1637 }
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:310
double g
Green component.
Definition: color4d.h:292
COLOR4D fillColor
The fill color.
double b
Blue component.
Definition: color4d.h:293
double a
Alpha component.
Definition: color4d.h:294
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:291
void drawFilledSemiCircle(const VECTOR2D &aCenterPoint, double aRadius, double aAngle)
Draw a filled semicircle.
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 1671 of file opengl_gal.cpp.

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().

1673 {
1674  double outerRadius = aRadius + ( lineWidth / 2 );
1675 
1676  Save();
1677 
1678  currentManager->Reserve( 3 );
1679  currentManager->Translate( aCenterPoint.x, aCenterPoint.y, 0.0f );
1680  currentManager->Rotate( aAngle, 0.0f, 0.0f, 1.0f );
1681 
1682  /* Draw a triangle that contains the semicircle, then shade it to leave only
1683  * the semicircle. Parameters given to Shader() are indices of the triangle's vertices
1684  * (if you want to understand more, check the vertex shader source [shader.vert]), the
1685  * radius and the line width. Shader uses these coordinates to determine if fragments are
1686  * inside the semicircle or not.
1687  * v2
1688  * /\
1689  * /__\
1690  * v0 //__\\ v1
1691  */
1693  currentManager->Vertex( -outerRadius * 3.0f / sqrt( 3.0f ), 0.0f, layerDepth ); // v0
1694 
1696  currentManager->Vertex( outerRadius * 3.0f / sqrt( 3.0f ), 0.0f, layerDepth ); // v1
1697 
1699  currentManager->Vertex( 0.0f, outerRadius * 2.0f, layerDepth ); // v2
1700 
1701  Restore();
1702 }
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:310
double layerDepth
The actual layer depth.
bool Reserve(unsigned int aSize)
Function Reserve() allocates space for vertices, so it will be used with subsequent Vertex() calls...
virtual void Restore() override
Restore the context.
bool Vertex(const VERTEX &aVertex)
Function Vertex() adds a vertex with the given coordinates to the currently set item.
void Rotate(GLfloat aAngle, GLfloat aX, GLfloat aY, GLfloat aZ)
Function Rotate() multiplies the current matrix by a rotation matrix, so the newly vertices will be r...
double lineWidth
The line width.
virtual void Save() override
Save the context.
void Translate(GLfloat aX, GLfloat aY, GLfloat aZ)
Function Translate() multiplies the current matrix by a translation matrix, so newly vertices will be...
void Shader(GLfloat aShaderType, GLfloat aParam1=0.0f, GLfloat aParam2=0.0f, GLfloat aParam3=0.0f)
Function Shader() changes currently used shader and its parameters that will be applied to newly adde...
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 900 of file opengl_gal.cpp.

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

Referenced by DrawPolygon().

901 {
904 
905  if( isFillEnabled )
906  {
907  for( unsigned int j = 0; j < aPolySet.TriangulatedPolyCount(); ++j )
908  {
909  auto triPoly = aPolySet.TriangulatedPolygon( j );
910 
911  for( size_t i = 0; i < triPoly->GetTriangleCount(); i++ )
912  {
913  VECTOR2I a, b, c;
914  triPoly->GetTriangle( i, a, b, c );
915  currentManager->Vertex( a.x, a.y, layerDepth );
916  currentManager->Vertex( b.x, b.y, layerDepth );
917  currentManager->Vertex( c.x, c.y, layerDepth );
918  }
919  }
920  }
921 
922  if( isStrokeEnabled )
923  {
924  for( int j = 0; j < aPolySet.OutlineCount(); ++j )
925  {
926  const auto& poly = aPolySet.Polygon( j );
927 
928  for( const auto& lc : poly )
929  {
930  DrawPolyline( lc );
931  }
932  }
933  }
934 }
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:310
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:292
COLOR4D fillColor
The fill color.
double b
Blue component.
Definition: color4d.h:293
double a
Alpha component.
Definition: color4d.h:294
bool isStrokeEnabled
Are the outlines stroked ?
void Color(const COLOR4D &aColor)
Function Color() changes currently used color that will be applied to newly added vertices...
bool isFillEnabled
Is filling of graphic objects enabled ?
virtual void DrawPolyline(const std::deque< VECTOR2D > &aPointList) override
Draw a polyline.
Definition: opengl_gal.cpp:843
size_t i
Definition: json11.cpp:597
void Shader(GLfloat aShaderType, GLfloat aParam1=0.0f, GLfloat aParam2=0.0f, GLfloat aParam3=0.0f)
Function Shader() changes currently used shader and its parameters that will be applied to newly adde...
double r
Red component.
Definition: color4d.h:291
void OPENGL_GAL::EnableDepthTest ( bool  aEnabled = false)
overridevirtual

Parameters passed to the GLU tesselator.

Reimplemented from KIGFX::GAL.

Definition at line 2075 of file opengl_gal.cpp.

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

Referenced by SetPaintListener().

2076 {
2077  cachedManager->EnableDepthTest( aEnabled );
2078  nonCachedManager->EnableDepthTest( aEnabled );
2079  overlayManager->EnableDepthTest( aEnabled );
2080 }
VERTEX_MANAGER * overlayManager
Container for storing overlaid VERTEX_ITEMs.
Definition: opengl_gal.h:313
VERTEX_MANAGER * nonCachedManager
Container for storing non-cached VERTEX_ITEMs.
Definition: opengl_gal.h:312
VERTEX_MANAGER * cachedManager
Container for storing cached VERTEX_ITEMs.
Definition: opengl_gal.h:311
void EnableDepthTest(bool aEnabled)
Function EnableDepthTest() Enables/disables Z buffer depth test.
void OPENGL_GAL::EndDrawing ( )
overridevirtual

End the drawing, needs to be called for every new frame.

Reimplemented from KIGFX::GAL.

Definition at line 464 of file opengl_gal.cpp.

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().

Referenced by IsVisible().

465 {
466  wxASSERT_MSG( isContextLocked, "What happened to the context lock?" );
467 
468 #ifdef __WXDEBUG__
469  PROF_COUNTER totalRealTime( "OPENGL_GAL::EndDrawing()", true );
470 #endif /* __WXDEBUG__ */
471 
472  // Cached & non-cached containers are rendered to the same buffer
476 
477  // Overlay container is rendered to a different buffer
480 
481  // Be sure that the framebuffer is not colorized (happens on specific GPU&drivers combinations)
482  glColor4d( 1.0, 1.0, 1.0, 1.0 );
483 
484  // Draw the remaining contents, blit the rendering targets to the screen, swap the buffers
487  compositor->Present();
488  blitCursor();
489 
490  SwapBuffers();
491 
492 #ifdef __WXDEBUG__
493  totalRealTime.Stop();
494  wxLogTrace( "GAL_PROFILE", wxT( "OPENGL_GAL::EndDrawing(): %.1f ms" ), totalRealTime.msecs() );
495 #endif /* __WXDEBUG__ */
496 }
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:318
VERTEX_MANAGER * overlayManager
Container for storing overlaid VERTEX_ITEMs.
Definition: opengl_gal.h:313
bool isContextLocked
Used for assertion checking.
Definition: opengl_gal.h:331
The class PROF_COUNTER is a small class to help profiling.
Definition: profile.h:45
VERTEX_MANAGER * nonCachedManager
Container for storing non-cached VERTEX_ITEMs.
Definition: opengl_gal.h:312
OPENGL_COMPOSITOR * compositor
Handles multiple rendering targets.
Definition: opengl_gal.h:316
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:317
void EndDrawing() const
Function EndDrawing() finishes drawing operations.
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:311
void OPENGL_GAL::EndGroup ( )
overridevirtual

End the group.

Reimplemented from KIGFX::GAL.

Definition at line 1437 of file opengl_gal.cpp.

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

Referenced by IsVisible().

1438 {
1440  isGrouping = false;
1441 }
bool isGrouping
Was a group started?
Definition: opengl_gal.h:330
VERTEX_MANAGER * cachedManager
Container for storing cached VERTEX_ITEMs.
Definition: opengl_gal.h:311
void FinishItem() const
Function FinishItem() does the cleaning after adding an item.
void OPENGL_GAL::EndUpdate ( )
overridevirtual

Disables item update mode.

Reimplemented from KIGFX::GAL.

Definition at line 526 of file opengl_gal.cpp.

References cachedManager, GL_CONTEXT_MANAGER::Get(), glPrivContext, isInitialized, GL_CONTEXT_MANAGER::UnlockCtx(), and KIGFX::VERTEX_MANAGER::Unmap().

Referenced by IsVisible().

527 {
528  if( !isInitialized )
529  return;
530 
531  cachedManager->Unmap();
533 }
void UnlockCtx(wxGLContext *aContext)
Function UnlockCtx allows other canvases to bind an OpenGL context.
static GL_CONTEXT_MANAGER & Get()
Function Get returns the GL_CONTEXT_MANAGER instance (singleton).
void Unmap()
Function Unmap() unmaps vertex buffer.
VERTEX_MANAGER * cachedManager
Container for storing cached VERTEX_ITEMs.
Definition: opengl_gal.h:311
bool isInitialized
Basic initialization flag, has to be done when the window is visible.
Definition: opengl_gal.h:328
wxGLContext * glPrivContext
Canvas-specific OpenGL context.
Definition: opengl_gal.h:299
void OPENGL_GAL::Flush ( )
overridevirtual

Force all remaining objects to be drawn.

Reimplemented from KIGFX::GAL.

Definition at line 1361 of file opengl_gal.cpp.

Referenced by IsVisible().

1362 {
1363  glFlush();
1364 }
float HIDPI_GL_CANVAS::GetBackingScaleFactor ( ) const
virtualinherited

Definition at line 59 of file hidpi_gl_canvas.cpp.

Referenced by HIDPI_GL_CANVAS::GetClientSize(), and ResizeScreen().

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

Definition at line 214 of file graphics_abstraction_layer.h.

References KIGFX::GAL::m_clearColor.

215  {
216  return m_clearColor;
217  }
wxSize HIDPI_GL_CANVAS::GetClientSize ( ) const
virtualinherited

Definition at line 46 of file hidpi_gl_canvas.cpp.

References HIDPI_GL_CANVAS::GetBackingScaleFactor().

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

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

Gets the actual cursor color to draw.

Definition at line 421 of file graphics_abstraction_layer.cpp.

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

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

422 {
423  auto color = cursorColor;
424 
425  // dim the cursor if it's only on because it was forced
426  // (this helps to provide a hint for active tools)
427  if( !isCursorEnabled )
428  {
429  color.a = color.a * 0.5;
430  }
431 
432  return color;
433 }
bool isCursorEnabled
Is the cursor enabled?
int color
Definition: DXF_plotter.cpp:62
COLOR4D cursorColor
Cursor color.
const COLOR4D& KIGFX::GAL::GetFillColor ( ) const
inlineinherited

Get the fill color.

Returns
the color for filling a outline.

Definition at line 264 of file graphics_abstraction_layer.h.

References KIGFX::GAL::fillColor.

Referenced by KIGFX::CAIRO_GAL::DrawArc().

265  {
266  return fillColor;
267  }
COLOR4D fillColor
The fill color.
double KIGFX::GAL::GetGridLineWidth ( ) const
inlineinherited

Get the grid line width.

Returns
the grid line width

Definition at line 902 of file graphics_abstraction_layer.h.

References KIGFX::GAL::DrawGrid(), KIGFX::GAL::GetGridPoint(), and KIGFX::GAL::gridLineWidth.

903  {
904  return gridLineWidth;
905  }
double gridLineWidth
Line width of the grid.
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 399 of file graphics_abstraction_layer.cpp.

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

Referenced by EDIT_POINTS_FACTORY::buildForPolyOutline(), KIGFX::GAL::GetGridLineWidth(), KIGFX::WX_VIEW_CONTROLS::GetRawCursorPosition(), and SCH_BASE_FRAME::HandleBlockBegin().

400 {
401 #if 0
402  // This old code expects a non zero grid size, which can be wrong here.
403  return VECTOR2D( KiROUND( ( aPoint.x - gridOffset.x ) / gridSize.x ) * gridSize.x + gridOffset.x,
404  KiROUND( ( aPoint.y - gridOffset.y ) / gridSize.y ) * gridSize.y + gridOffset.y );
405 #else
406  // if grid size == 0.0 there is no grid, so use aPoint as grid reference position
407  double cx = gridSize.x > 0.0 ? KiROUND( ( aPoint.x - gridOffset.x ) / gridSize.x ) * gridSize.x + gridOffset.x
408  : aPoint.x;
409  double cy = gridSize.y > 0.0 ? KiROUND( ( aPoint.y - gridOffset.y ) / gridSize.y ) * gridSize.y + gridOffset.y
410  : aPoint.y;
411 
412  return VECTOR2D( cx, cy );
413 #endif
414 }
VECTOR2D gridOffset
The grid offset to compensate cursor position.
static int KiROUND(double v)
Round a floating point number to an integer using "round halfway cases away from zero".
Definition: common.h:120
VECTOR2< double > VECTOR2D
Definition: vector2d.h:586
VECTOR2D gridSize
The grid size.
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 854 of file graphics_abstraction_layer.h.

References KIGFX::GAL::gridSize.

Referenced by SCH_DRAW_PANEL::SwitchBackend(), and SCH_BASE_FRAME::SyncView().

855  {
856  return gridSize;
857  }
VECTOR2D gridSize
The grid size.
EDA_TEXT_HJUSTIFY_T KIGFX::GAL::GetHorizontalJustify ( ) const
inlineinherited

Returns current text horizontal justification setting.

Definition at line 486 of file graphics_abstraction_layer.h.

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

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

487  {
489  }
struct KIGFX::GAL::TEXT_PROPERTIES textProperties
EDA_TEXT_HJUSTIFY_T m_horizontalJustify
Horizontal justification.
double KIGFX::GAL::GetLineWidth ( ) const
inlineinherited
const VECTOR2D& KIGFX::GAL::GetLookAtPoint ( ) const
inlineinherited

Get the look at point.

Returns
the look at point.

Definition at line 681 of file graphics_abstraction_layer.h.

References KIGFX::GAL::lookAtPoint.

682  {
683  return lookAtPoint;
684  }
VECTOR2D lookAtPoint
Point to be looked at in world space.
double KIGFX::GAL::GetMaxDepth ( ) const
inlineinherited

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

Definition at line 730 of file graphics_abstraction_layer.h.

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

731  {
732  return depthRange.y;
733  }
VECTOR2D depthRange
Range of the depth.
double KIGFX::GAL::GetMinDepth ( ) const
inlineinherited

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

Definition at line 722 of file graphics_abstraction_layer.h.

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

723  {
724  return depthRange.x;
725  }
VECTOR2D depthRange
Range of the depth.
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 1948 of file opengl_gal.cpp.

References groupCounter, groups, and max.

Referenced by BeginGroup().

1949 {
1950  wxASSERT_MSG( groups.size() < std::numeric_limits<unsigned int>::max(),
1951  wxT( "There are no free slots to store a group" ) );
1952 
1953  while( groups.find( groupCounter ) != groups.end() )
1954  {
1955  groupCounter++;
1956  }
1957 
1958  return groupCounter++;
1959 }
GROUPS_MAP groups
Stores informations about VBO objects (groups)
Definition: opengl_gal.h:308
#define max(a, b)
Definition: auxiliary.h:86
unsigned int groupCounter
Counter used for generating keys for groups.
Definition: opengl_gal.h:309
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 381 of file graphics_abstraction_layer.h.

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

382  {
384  }
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.
const VECTOR2I& KIGFX::GAL::GetScreenPixelSize ( ) const
inlineinherited
const MATRIX3x3D& KIGFX::GAL::GetScreenWorldMatrix ( ) const
inlineinherited

Get the screen <-> world transformation matrix.

Returns
the transformation matrix.

Definition at line 622 of file graphics_abstraction_layer.h.

References KIGFX::GAL::screenWorldMatrix.

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

623  {
624  return screenWorldMatrix;
625  }
MATRIX3x3D screenWorldMatrix
Screen transformation.
const COLOR4D& KIGFX::GAL::GetStrokeColor ( ) const
inlineinherited

Get the stroke color.

Returns
the color for stroking the outline.

Definition at line 284 of file graphics_abstraction_layer.h.

References KIGFX::GAL::strokeColor.

Referenced by KIGFX::CAIRO_GAL::DrawArc().

285  {
286  return strokeColor;
287  }
COLOR4D strokeColor
The color of the outlines.
const STROKE_FONT& KIGFX::GAL::GetStrokeFont ( ) const
inlineinherited

Definition at line 326 of file graphics_abstraction_layer.h.

References KIGFX::GAL::strokeFont.

Referenced by EDA_TEXT::GetTextBox().

327  {
328  return strokeFont;
329  }
STROKE_FONT strokeFont
Instance of object that stores information about how to draw texts.
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 1517 of file opengl_gal.cpp.

References currentTarget.

Referenced by DrawBitmap(), and IsVisible().

1518 {
1519  return currentTarget;
1520 }
RENDER_TARGET currentTarget
Current rendering target.
Definition: opengl_gal.h:319
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 168 of file graphics_abstraction_layer.cpp.

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

Referenced by KIGFX::GAL::BitmapText(), GraphicTextWidth(), and EDA_TEXT::LenSize().

169 {
170  // Compute the X and Y size of a given text.
171  // Because computeTextLineSize expects a one line text,
172  // aText is expected to be only one line text.
173  return strokeFont.computeTextLineSize( aText );
174 }
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.
EDA_TEXT_VJUSTIFY_T KIGFX::GAL::GetVerticalJustify ( ) const
inlineinherited

Returns current text vertical justification setting.

Definition at line 504 of file graphics_abstraction_layer.h.

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

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

505  {
507  }
EDA_TEXT_VJUSTIFY_T m_verticalJustify
Vertical justification.
struct KIGFX::GAL::TEXT_PROPERTIES textProperties
double OPENGL_GAL::getWorldPixelSize ( ) const
private

Definition at line 322 of file opengl_gal.cpp.

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

Referenced by BeginDrawing(), calcAngleStep(), and DrawGrid().

323 {
324  auto matrix = GetScreenWorldMatrix();
325  return std::min( std::abs( matrix.GetScale().x ), std::abs( matrix.GetScale().y ) );
326 }
const MATRIX3x3D & GetScreenWorldMatrix() const
Get the screen <-> world transformation matrix.
#define abs(a)
Definition: auxiliary.h:84
#define min(a, b)
Definition: auxiliary.h:85
double KIGFX::GAL::GetWorldScale ( ) const
inlineinherited
const MATRIX3x3D& KIGFX::GAL::GetWorldScreenMatrix ( ) const
inlineinherited

Get the world <-> screen transformation matrix.

Returns
the transformation matrix.

Definition at line 612 of file graphics_abstraction_layer.h.

References KIGFX::GAL::worldScreenMatrix.

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

613  {
614  return worldScreenMatrix;
615  }
MATRIX3x3D worldScreenMatrix
World transformation.
double KIGFX::GAL::GetZoomFactor ( ) const
inlineinherited
void OPENGL_GAL::init ( )
private

Basic OpenGL initialization.

Definition at line 1962 of file opengl_gal.cpp.

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

Referenced by BeginDrawing(), BeginUpdate(), and calcAngleStep().

1963 {
1964  wxASSERT( IsShownOnScreen() );
1965 
1966  GAL_CONTEXT_LOCKER locker( this );
1967 
1968  GLenum err = glewInit();
1969 
1970  if( GLEW_OK != err )
1971  throw std::runtime_error( (const char*) glewGetErrorString( err ) );
1972 
1973  // Check the OpenGL version (minimum 2.1 is required)
1974  if( !GLEW_VERSION_2_1 )
1975  throw std::runtime_error( "OpenGL 2.1 or higher is required!" );
1976 
1977 #if defined (__LINUX__) // calling enableGlDebug crashes opengl on some OS (OSX and some Windows)
1978 #ifdef DEBUG
1979  if( GLEW_ARB_debug_output )
1980  enableGlDebug( true );
1981 #endif
1982 #endif
1983 
1984  // Framebuffers have to be supported
1985  if( !GLEW_EXT_framebuffer_object )
1986  throw std::runtime_error( "Framebuffer objects are not supported!" );
1987 
1988  // Vertex buffer has to be supported
1989  if( !GLEW_ARB_vertex_buffer_object )
1990  throw std::runtime_error( "Vertex buffer objects are not supported!" );
1991 
1992  // Prepare shaders
1994  throw std::runtime_error( "Cannot compile vertex shader!" );
1995 
1997  throw std::runtime_error( "Cannot compile fragment shader!" );
1998 
1999  if( !shader->IsLinked() && !shader->Link() )
2000  throw std::runtime_error( "Cannot link the shaders!" );
2001 
2002  // Check if video card supports textures big enough to fit the font atlas
2003  int maxTextureSize;
2004  glGetIntegerv( GL_MAX_TEXTURE_SIZE, &maxTextureSize );
2005 
2006  if( maxTextureSize < (int) font_image.width || maxTextureSize < (int)font_image.height )
2007  {
2008  // TODO implement software texture scaling
2009  // for bitmap fonts and use a higher resolution texture?
2010  throw std::runtime_error( "Requested texture size is not supported" );
2011  }
2012 
2013  cachedManager = new VERTEX_MANAGER( true );
2014  nonCachedManager = new VERTEX_MANAGER( false );
2015  overlayManager = new VERTEX_MANAGER( false );
2016 
2017  // Make VBOs use shaders
2021 
2022  isInitialized = true;
2023 }
static SHADER * shader
There is only one shader used for different objects.
Definition: opengl_gal.h:322
bool IsLinked() const
Returns true if shaders are linked correctly.
Definition: shader.h:122
bool LoadShaderFromStrings(SHADER_TYPE aShaderType, Args &&...aArgs)
Add a shader and compile the shader sources.
Definition: shader.h:97
VERTEX_MANAGER * overlayManager
Container for storing overlaid VERTEX_ITEMs.
Definition: opengl_gal.h:313
Fragment shader.
Definition: shader.h:45
bool Link()
Link the shaders.
Definition: shader.cpp:97
void enableGlDebug(bool aEnable)
Enables/disables OpenGL driver messages output.
Definition: utils.cpp:140
VERTEX_MANAGER * nonCachedManager
Container for storing non-cached VERTEX_ITEMs.
Definition: opengl_gal.h:312
FONT_IMAGE_TYPE font_image
Definition: gl_resources.cpp:4
Vertex shader.
Definition: shader.h:44
string & err
Definition: json11.cpp:598
VERTEX_MANAGER * cachedManager
Container for storing cached VERTEX_ITEMs.
Definition: opengl_gal.h:311
bool isInitialized
Basic initialization flag, has to be done when the window is visible.
Definition: opengl_gal.h:328
void SetShader(SHADER &aShader) const
Function SetShader() sets a shader program that is going to be used during rendering.
bool KIGFX::GAL::IsCursorEnabled ( ) const
inlineinherited

Returns information about cursor visibility.

Returns
True if cursor is visible.

Definition at line 955 of file graphics_abstraction_layer.h.

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

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

956  {
958  }
bool isCursorEnabled
Is the cursor enabled?
bool forceDisplayCursor
Always show cursor.
bool KIGFX::GAL::IsFontBold ( ) const
inlineinherited

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

Definition at line 432 of file graphics_abstraction_layer.h.

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

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

433  {
434  return textProperties.m_bold;
435  }
struct KIGFX::GAL::TEXT_PROPERTIES textProperties
bool KIGFX::GAL::IsFontItalic ( ) const
inlineinherited

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

Definition at line 450 of file graphics_abstraction_layer.h.

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

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

451  {
452  return textProperties.m_italic;
453  }
struct KIGFX::GAL::TEXT_PROPERTIES textProperties
virtual bool KIGFX::OPENGL_GAL::IsInitialized ( ) const
inlineoverridevirtual

Returns the initalization status for the canvas.

Reimplemented from KIGFX::GAL.

Definition at line 90 of file opengl_gal.h.

91  {
92  // is*Initialized flags, but it is enough for OpenGL to show up
93  return IsShownOnScreen() && !GetClientRect().IsEmpty();
94  }
bool KIGFX::GAL::IsTextMirrored ( ) const
inlineinherited

Returns true if text should displayed mirrored.

Definition at line 468 of file graphics_abstraction_layer.h.

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

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

469  {
470  return textProperties.m_mirrored;
471  }
struct KIGFX::GAL::TEXT_PROPERTIES textProperties
bool KIGFX::OPENGL_GAL::IsVisible ( ) const
inlineoverridevirtual
void OPENGL_GAL::lockContext ( )
overrideprivatevirtual

Reimplemented from KIGFX::GAL.

Definition at line 499 of file opengl_gal.cpp.

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

500 {
502  isContextLocked = true;
503 }
bool isContextLocked
Used for assertion checking.
Definition: opengl_gal.h:331
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:299
void GAL::OnGalDisplayOptionsChanged ( const GAL_DISPLAY_OPTIONS aOptions)
overrideprotectedvirtualinherited

Handler for observer settings changes.

Implements KIGFX::GAL_DISPLAY_OPTIONS_OBSERVER.

Definition at line 88 of file graphics_abstraction_layer.cpp.

References KIGFX::GAL::updatedGalDisplayOptions().

89 {
90  // defer to the child class first
91  updatedGalDisplayOptions( aOptions );
92 
93  // there is no refresh to do at this level
94 }
virtual bool updatedGalDisplayOptions(const GAL_DISPLAY_OPTIONS &aOptions)
Function updatedGalDisplayOptions.
void OPENGL_GAL::onPaint ( wxPaintEvent &  aEvent)
private

This is the OnPaint event handler.

Parameters
aEventis the OnPaint event.

Definition at line 1902 of file opengl_gal.cpp.

References PostPaint().

Referenced by OPENGL_GAL().

1903 {
1904  PostPaint();
1905 }
void PostPaint()
Function PostPaint posts an event to m_paint_listener.
Definition: opengl_gal.h:260
void KIGFX::GAL::PopDepth ( )
inlineinherited

Restores previously stored drawing depth for the depth stack.

Definition at line 997 of file graphics_abstraction_layer.h.

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

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

998  {
999  layerDepth = depthStack.top();
1000  depthStack.pop();
1001  }
double layerDepth
The actual layer depth.
std::stack< double > depthStack
Stored depth values.
void KIGFX::OPENGL_GAL::PostPaint ( )
inline

Function PostPaint posts an event to m_paint_listener.

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

Definition at line 260 of file opengl_gal.h.

References paintListener.

Referenced by onPaint().

261  {
262  if( paintListener )
263  {
264  wxPaintEvent redrawEvent;
265  wxPostEvent( paintListener, redrawEvent );
266  }
267  }
wxEvtHandler * paintListener
Definition: opengl_gal.h:302
void KIGFX::GAL::PushDepth ( )
inlineinherited

Stores current drawing depth on the depth stack.

Definition at line 989 of file graphics_abstraction_layer.h.

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

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

990  {
991  depthStack.push( layerDepth );
992  }
double layerDepth
The actual layer depth.
std::stack< double > depthStack
Stored depth values.
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 153 of file graphics_abstraction_layer.cpp.

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::GAL::GetOverbarVerticalPosition().

154 {
155  // Tiny but non-zero - this will always need setting
156  // there is no built-in default
157  SetGlyphSize( { 1.0, 1.0 } );
158 
161 
162  SetFontBold( false );
163  SetFontItalic( false );
164  SetTextMirrored( false );
165 }
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.
void OPENGL_GAL::ResizeScreen ( int  aWidth,
int  aHeight 
)
overridevirtual

Resizes the canvas.

Reimplemented from KIGFX::GAL.

Definition at line 1337 of file opengl_gal.cpp.

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

Referenced by IsVisible().

1338 {
1339  screenSize = VECTOR2I( aWidth, aHeight );
1340 
1341  // Resize framebuffers
1342  const float scaleFactor = GetBackingScaleFactor();
1343  compositor->Resize( aWidth * scaleFactor, aHeight * scaleFactor );
1344  isFramebufferInitialized = false;
1345 
1346  wxGLCanvas::SetSize( aWidth, aHeight );
1347 }
VECTOR2< int > VECTOR2I
Definition: vector2d.h:587
OPENGL_COMPOSITOR * compositor
Handles multiple rendering targets.
Definition: opengl_gal.h:316
bool isFramebufferInitialized
Are the framebuffers initialized?
Definition: opengl_gal.h:325
virtual void Resize(unsigned int aWidth, unsigned int aHeight) override
Function Resize() clears the state of COMPOSITOR, so it has to be reinitialized again with the new di...
virtual float GetBackingScaleFactor() const
VECTOR2I screenSize
Screen size in screen coordinates.
void OPENGL_GAL::Restore ( )
overridevirtual

Restore the context.

Reimplemented from KIGFX::GAL.

Definition at line 1419 of file opengl_gal.cpp.

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

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

1420 {
1422 }
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:310
void PopMatrix()
Function PopMatrix() pops the current transformation matrix stack.
void OPENGL_GAL::RestoreScreen ( )
overridevirtual

Restore the screen contents.

Reimplemented from KIGFX::GAL.

Definition at line 1489 of file opengl_gal.cpp.

Referenced by IsVisible().

1490 {
1491  wxASSERT_MSG( false, wxT( "Not implemented yet" ) );
1492 }
void OPENGL_GAL::Rotate ( double  aAngle)
overridevirtual

Rotate the context.

Parameters
aAngleis the rotation angle in radians.

Reimplemented from KIGFX::GAL.

Definition at line 1395 of file opengl_gal.cpp.

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

Referenced by IsVisible().

1396 {
1397  currentManager->Rotate( aAngle, 0.0f, 0.0f, 1.0f );
1398 }
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:310
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 OPENGL_GAL::Save ( )
overridevirtual

Save the context.

Reimplemented from KIGFX::GAL.

Definition at line 1413 of file opengl_gal.cpp.

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

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

1414 {
1416 }
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:310
void PushMatrix()
Function PushMatrix() pushes the current transformation matrix stack.
void OPENGL_GAL::SaveScreen ( )
overridevirtual

Save the screen contents.

Reimplemented from KIGFX::GAL.

Definition at line 1483 of file opengl_gal.cpp.

Referenced by IsVisible().

1484 {
1485  wxASSERT_MSG( false, wxT( "Not implemented yet" ) );
1486 }
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 1407 of file opengl_gal.cpp.

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

Referenced by IsVisible().

1408 {
1409  currentManager->Scale( aScale.x, aScale.y, 0.0f );
1410 }
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:310
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...
void KIGFX::GAL::SetAxesColor ( const COLOR4D aAxesColor)
inlineinherited

Set the axes color.

Parameters
aAxesColoris the color to draw the axes if enabled.

Definition at line 874 of file graphics_abstraction_layer.h.

References KIGFX::GAL::axesColor.

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

875  {
876  axesColor = aAxesColor;
877  }
COLOR4D axesColor
Color of the axes.
void KIGFX::GAL::SetAxesEnabled ( bool  aAxesEnabled)
inlineinherited

Enables drawing the axes.

Definition at line 882 of file graphics_abstraction_layer.h.

References KIGFX::GAL::axesEnabled.

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

883  {
884  axesEnabled = aAxesEnabled;
885  }
bool axesEnabled
Should the axes be drawn.
void KIGFX::GAL::SetClearColor ( const COLOR4D aColor)
inlineinherited

Definition at line 209 of file graphics_abstraction_layer.h.

References KIGFX::GAL::m_clearColor.

Referenced by EDA_DRAW_PANEL_GAL::onPaint().

210  {
211  m_clearColor = aColor;
212  }
void KIGFX::GAL::SetCoarseGrid ( int  aInterval)
inlineinherited

Draw every tick line wider.

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

Definition at line 892 of file graphics_abstraction_layer.h.

References KIGFX::GAL::gridTick.

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

893  {
894  gridTick = aInterval;
895  }
int gridTick
Every tick line gets the double width.
void KIGFX::GAL::SetCursorColor ( const COLOR4D aCursorColor)
inlineinherited

Set the cursor color.

Parameters
aCursorColoris the color of the cursor.

Definition at line 965 of file graphics_abstraction_layer.h.

References KIGFX::GAL::cursorColor.

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

966  {
967  cursorColor = aCursorColor;
968  }
COLOR4D cursorColor
Cursor color.
void KIGFX::GAL::SetCursorEnabled ( bool  aCursorEnabled)
inlineinherited

Enable/disable cursor.

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

Definition at line 946 of file graphics_abstraction_layer.h.

References KIGFX::GAL::isCursorEnabled.

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

947  {
948  isCursorEnabled = aCursorEnabled;
949  }
bool isCursorEnabled
Is the cursor enabled?
void KIGFX::GAL::SetDepthRange ( const VECTOR2D aDepthRange)
inlineinherited

Set the range of the layer depth.

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

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

Definition at line 714 of file graphics_abstraction_layer.h.

References KIGFX::GAL::depthRange.

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

715  {
716  depthRange = aDepthRange;
717  }
VECTOR2D depthRange
Range of the depth.
virtual void KIGFX::GAL::SetFillColor ( const COLOR4D aColor)
inlinevirtualinherited
void KIGFX::GAL::SetFlip ( bool  xAxis,
bool  yAxis 
)
inlineinherited

Sets flipping of the screen.

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

Definition at line 751 of file graphics_abstraction_layer.h.

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

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

752  {
753  globalFlipX = xAxis;
754  globalFlipY = yAxis;
755  }
bool globalFlipX
Flag for X axis flipping.
bool globalFlipY
Flag for Y axis flipping.
void KIGFX::GAL::SetFontBold ( const bool  aBold)
inlineinherited

Set bold property of current font.

Parameters
aBoldtells if the font should be bold or not.

Definition at line 424 of file graphics_abstraction_layer.h.

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

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

425  {
426  textProperties.m_bold = aBold;
427  }
struct KIGFX::GAL::TEXT_PROPERTIES textProperties
void KIGFX::GAL::SetFontItalic ( const bool  aItalic)
inlineinherited

Set italic property of current font.

Parameters
aItalictells if the font should be italic or not.

Definition at line 442 of file graphics_abstraction_layer.h.

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

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

443  {
444  textProperties.m_italic = aItalic;
445  }
struct KIGFX::GAL::TEXT_PROPERTIES textProperties
void KIGFX::GAL::SetGlyphSize ( const VECTOR2D  aGlyphSize)
inlineinherited

Set the font glyph size.

Parameters
aGlyphSizeis the new font glyph size.

Definition at line 406 of file graphics_abstraction_layer.h.

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

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

407  {
408  textProperties.m_glyphSize = aGlyphSize;
409  }
struct KIGFX::GAL::TEXT_PROPERTIES textProperties
VECTOR2D m_glyphSize
Size of the glyphs.
void KIGFX::GAL::SetGridColor ( const COLOR4D aGridColor)
inlineinherited

Set the grid color.

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

Definition at line 864 of file graphics_abstraction_layer.h.

References KIGFX::GAL::gridColor.

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

865  {
866  gridColor = aGridColor;