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

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

typedef GAL KIGFX::OPENGL_GAL::super
private

Super class definition.

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

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

69  :
70  GAL( aDisplayOptions ),
71  HIDPI_GL_CANVAS( aParent, wxID_ANY, (int*) glAttributes, wxDefaultPosition, wxDefaultSize,
72  wxEXPAND, aName ),
73  mouseListener( aMouseListener ), paintListener( aPaintListener ), currentManager( nullptr ),
74  cachedManager( nullptr ), nonCachedManager( nullptr ), overlayManager( nullptr ), mainBuffer( 0 ), overlayBuffer( 0 )
75 {
76  if( glMainContext == NULL )
77  {
80  shader = new SHADER();
81  }
82  else
83  {
85  }
86 
88 
91 
92  // Initialize the flags
95  isInitialized = false;
96  isGrouping = false;
97  groupCounter = 0;
98 
99  // Connecting the event handlers
100  Connect( wxEVT_PAINT, wxPaintEventHandler( OPENGL_GAL::onPaint ) );
101 
102  // Mouse events are skipped to the parent
103  Connect( wxEVT_MOTION, wxMouseEventHandler( OPENGL_GAL::skipMouseEvent ) );
104  Connect( wxEVT_LEFT_DOWN, wxMouseEventHandler( OPENGL_GAL::skipMouseEvent ) );
105  Connect( wxEVT_LEFT_UP, wxMouseEventHandler( OPENGL_GAL::skipMouseEvent ) );
106  Connect( wxEVT_LEFT_DCLICK, wxMouseEventHandler( OPENGL_GAL::skipMouseEvent ) );
107  Connect( wxEVT_MIDDLE_DOWN, wxMouseEventHandler( OPENGL_GAL::skipMouseEvent ) );
108  Connect( wxEVT_MIDDLE_UP, wxMouseEventHandler( OPENGL_GAL::skipMouseEvent ) );
109  Connect( wxEVT_MIDDLE_DCLICK, wxMouseEventHandler( OPENGL_GAL::skipMouseEvent ) );
110  Connect( wxEVT_RIGHT_DOWN, wxMouseEventHandler( OPENGL_GAL::skipMouseEvent ) );
111  Connect( wxEVT_RIGHT_UP, wxMouseEventHandler( OPENGL_GAL::skipMouseEvent ) );
112  Connect( wxEVT_RIGHT_DCLICK, wxMouseEventHandler( OPENGL_GAL::skipMouseEvent ) );
113  Connect( wxEVT_MOUSEWHEEL, wxMouseEventHandler( OPENGL_GAL::skipMouseEvent ) );
114 #if wxCHECK_VERSION( 3, 1, 0 ) || defined( USE_OSX_MAGNIFY_EVENT )
115  Connect( wxEVT_MAGNIFY, wxMouseEventHandler( OPENGL_GAL::skipMouseEvent ) );
116 #endif
117 #if defined _WIN32 || defined _WIN64
118  Connect( wxEVT_ENTER_WINDOW, wxMouseEventHandler( OPENGL_GAL::skipMouseEvent ) );
119 #endif
120 
121  SetSize( aParent->GetClientSize() );
122  screenSize = VECTOR2I( aParent->GetClientSize() );
123 
124  // Grid color settings are different in Cairo and OpenGL
125  SetGridColor( COLOR4D( 0.8, 0.8, 0.8, 0.1 ) );
126  SetAxesColor( COLOR4D( BLUE ) );
127 
128  // Tesselator initialization
129  tesselator = gluNewTess();
131 
132  if( tesselator == NULL )
133  throw std::runtime_error( "Could not create the tesselator" );
134 
135  gluTessProperty( tesselator, GLU_TESS_WINDING_RULE, GLU_TESS_WINDING_POSITIVE );
136 
138 }
Definition: colors.h:57
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:304
static SHADER * shader
There is only one shader used for different objects.
Definition: opengl_gal.h:316
static wxGLContext * glMainContext
Parent OpenGL context.
Definition: opengl_gal.h:292
unsigned int overlayBuffer
Auxiliary rendering target (for menus etc.)
Definition: opengl_gal.h:312
bool isBitmapFontInitialized
Is the shader set to use bitmap fonts?
Definition: opengl_gal.h:321
VERTEX_MANAGER * overlayManager
Container for storing overlaid VERTEX_ITEMs.
Definition: opengl_gal.h:307
GAL_DISPLAY_OPTIONS & options
static void InitTesselatorCallbacks(GLUtesselator *aTesselator)
VECTOR2< int > VECTOR2I
Definition: vector2d.h:589
bool isGrouping
Was a group started?
Definition: opengl_gal.h:324
OPENGL_ANTIALIASING_MODE gl_antialiasing_mode
VERTEX_MANAGER * nonCachedManager
Container for storing non-cached VERTEX_ITEMs.
Definition: opengl_gal.h:306
Auxiliary rendering target (noncached)
Definition: definitions.h:42
static int instanceCounter
GL GAL instance counter.
Definition: opengl_gal.h:294
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:310
unsigned int mainBuffer
Main rendering target.
Definition: opengl_gal.h:311
wxEvtHandler * mouseListener
Definition: opengl_gal.h:295
void SetAxesColor(const COLOR4D &aAxesColor)
Set the axes color.
static const int glAttributes[]
Definition: opengl_gal.cpp:58
void onPaint(wxPaintEvent &aEvent)
This is the OnPaint event handler.
bool isFramebufferInitialized
Are the framebuffers initialized?
Definition: opengl_gal.h:319
Class SHADER provides the access to the OpenGL shaders.
Definition: shader.h:74
GLUtesselator * tesselator
The tessellator.
Definition: opengl_gal.h:331
VERTEX_MANAGER * cachedManager
Container for storing cached VERTEX_ITEMs.
Definition: opengl_gal.h:305
wxEvtHandler * paintListener
Definition: opengl_gal.h:296
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:322
unsigned int groupCounter
Counter used for generating keys for groups.
Definition: opengl_gal.h:303
VECTOR2I screenSize
Screen size in screen coordinates.
wxGLContext * glPrivContext
Canvas-specific OpenGL context.
Definition: opengl_gal.h:293
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 141 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().

142 {
144 
145  --instanceCounter;
146  glFlush();
147  gluDeleteTess( tesselator );
148  ClearCache();
149 
150  delete compositor;
151 
152  if( isInitialized )
153  {
154  delete cachedManager;
155  delete nonCachedManager;
156  delete overlayManager;
157  }
158 
160 
161  // If it was the main context, then it will be deleted
162  // when the last OpenGL GAL instance is destroyed (a few lines below)
165 
166  // Are we destroying the last GAL instance?
167  if( instanceCounter == 0 )
168  {
170 
171  if( isBitmapFontLoaded )
172  {
173  glDeleteTextures( 1, &fontTexture );
174  isBitmapFontLoaded = false;
175  }
176 
177  delete shader;
178 
181  glMainContext = NULL;
182  }
183 }
static SHADER * shader
There is only one shader used for different objects.
Definition: opengl_gal.h:316
static wxGLContext * glMainContext
Parent OpenGL context.
Definition: opengl_gal.h:292
static GLuint fontTexture
Bitmap font texture handle (shared)
Definition: opengl_gal.h:298
VERTEX_MANAGER * overlayManager
Container for storing overlaid VERTEX_ITEMs.
Definition: opengl_gal.h:307
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:306
static int instanceCounter
GL GAL instance counter.
Definition: opengl_gal.h:294
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:310
virtual void ClearCache() override
Delete all data created during caching of graphic items.
GLUtesselator * tesselator
The tessellator.
Definition: opengl_gal.h:331
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:305
bool isInitialized
Basic initialization flag, has to be done when the window is visible.
Definition: opengl_gal.h:322
wxGLContext * glPrivContext
Canvas-specific OpenGL context.
Definition: opengl_gal.h:293
void DestroyCtx(wxGLContext *aContext)
Function DestroyCtx destroys a managed OpenGL context.
static bool isBitmapFontLoaded
Is the bitmap font texture loaded?
Definition: opengl_gal.h:320

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

References KIGFX::GAL::layerDepth.

964  {
965  layerDepth -= 0.05;
966  }
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 207 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, GL_CONTEXT_MANAGER::Get(), glPrivContext, KIGFX::BUILTIN_FONT::FONT_IMAGE_TYPE::height, init(), KIGFX::OPENGL_COMPOSITOR::Initialize(), isBitmapFontInitialized, isBitmapFontLoaded, isFramebufferInitialized, isInitialized, GL_CONTEXT_MANAGER::LockCtx(), 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, GL_CONTEXT_MANAGER::UnlockCtx(), KIGFX::SHADER::Use(), KIGFX::BUILTIN_FONT::FONT_IMAGE_TYPE::width, KIGFX::GAL::worldScreenMatrix, VECTOR2< T >::x, and VECTOR2< T >::y.

Referenced by IsVisible().

208 {
209  if( !IsShownOnScreen() )
210  return;
211 
212 #ifdef __WXDEBUG__
213  PROF_COUNTER totalRealTime( "OPENGL_GAL::BeginDrawing()", true );
214 #endif /* __WXDEBUG__ */
215 
216  if( !isInitialized )
217  init();
218 
220 
221  // Set up the view port
222  glMatrixMode( GL_PROJECTION );
223  glLoadIdentity();
224 
225  // Create the screen transformation (Do the RH-LH conversion here)
226  glOrtho( 0, (GLint) screenSize.x, (GLsizei) screenSize.y, 0, -depthRange.x, -depthRange.y );
227 
229  {
230  try
231  {
232  // Prepare rendering target buffers
236  }
237  catch( std::runtime_error& )
238  {
240  throw; // DRAW_PANEL_GAL will handle it
241  }
242 
244  }
245 
246  compositor->Begin();
247 
248  // Disable 2D Textures
249  glDisable( GL_TEXTURE_2D );
250 
251  glShadeModel( GL_FLAT );
252 
253  // Enable the depth buffer
254  glEnable( GL_DEPTH_TEST );
255  glDepthFunc( GL_LESS );
256 
257  // Setup blending, required for transparent objects
258  glEnable( GL_BLEND );
259  glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
260 
261  glMatrixMode( GL_MODELVIEW );
262 
263  // Set up the world <-> screen transformation
265  GLdouble matrixData[16] = { 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1 };
266  matrixData[0] = worldScreenMatrix.m_data[0][0];
267  matrixData[1] = worldScreenMatrix.m_data[1][0];
268  matrixData[2] = worldScreenMatrix.m_data[2][0];
269  matrixData[4] = worldScreenMatrix.m_data[0][1];
270  matrixData[5] = worldScreenMatrix.m_data[1][1];
271  matrixData[6] = worldScreenMatrix.m_data[2][1];
272  matrixData[12] = worldScreenMatrix.m_data[0][2];
273  matrixData[13] = worldScreenMatrix.m_data[1][2];
274  matrixData[14] = worldScreenMatrix.m_data[2][2];
275  glLoadMatrixd( matrixData );
276 
277  // Set defaults
280 
281  // Remove all previously stored items
284 
288 
290  {
291  // Keep bitmap font texture always bound to the second texturing unit
292  const GLint FONT_TEXTURE_UNIT = 2;
293 
294  // Either load the font atlas to video memory, or simply bind it to a texture unit
295  if( !isBitmapFontLoaded )
296  {
297  glActiveTexture( GL_TEXTURE0 + FONT_TEXTURE_UNIT );
298  glGenTextures( 1, &fontTexture );
299  glBindTexture( GL_TEXTURE_2D, fontTexture );
300  glTexImage2D( GL_TEXTURE_2D, 0, GL_RGB8, font_image.width, font_image.height,
301  0, GL_RGB, GL_UNSIGNED_BYTE, font_image.pixels );
302  glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
303  glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
304  checkGlError( "loading bitmap font" );
305 
306  glActiveTexture( GL_TEXTURE0 );
307 
308  isBitmapFontLoaded = true;
309  }
310  else
311  {
312  glActiveTexture( GL_TEXTURE0 + FONT_TEXTURE_UNIT );
313  glBindTexture( GL_TEXTURE_2D, fontTexture );
314  glActiveTexture( GL_TEXTURE0 );
315  }
316 
317  // Set shader parameter
318  GLint ufm_fontTexture = shader->AddParameter( "fontTexture" );
319  GLint ufm_fontTextureWidth = shader->AddParameter( "fontTextureWidth" );
320  shader->Use();
321  shader->SetParameter( ufm_fontTexture, (int) FONT_TEXTURE_UNIT );
322  shader->SetParameter( ufm_fontTextureWidth, (int) font_image.width );
323  shader->Deactivate();
324  checkGlError( "setting bitmap font sampler as shader parameter" );
325 
327  }
328 
329  // Something betreen BeginDrawing and EndDrawing seems to depend on
330  // this texture unit being active, but it does not assure it itself.
331  glActiveTexture( GL_TEXTURE0 );
332 
333  // Unbind buffers - set compositor for direct drawing
335 
336 #ifdef __WXDEBUG__
337  totalRealTime.Stop();
338  wxLogTrace( "GAL_PROFILE",
339  wxT( "OPENGL_GAL::BeginDrawing(): %.1f ms" ), totalRealTime.msecs() );
340 #endif /* __WXDEBUG__ */
341 }
virtual void SetFillColor(const COLOR4D &aColor)
Set the fill color.
static SHADER * shader
There is only one shader used for different objects.
Definition: opengl_gal.h:316
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:312
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:321
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:137
static GLuint fontTexture
Bitmap font texture handle (shared)
Definition: opengl_gal.h:298
VERTEX_MANAGER * overlayManager
Container for storing overlaid VERTEX_ITEMs.
Definition: opengl_gal.h:307
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
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:306
T m_data[3][3]
Definition: matrix3x3.h:64
static GL_CONTEXT_MANAGER & Get()
Function Get returns the GL_CONTEXT_MANAGER instance (singleton).
void init()
Basic OpenGL initialization.
OPENGL_COMPOSITOR * compositor
Handles multiple rendering targets.
Definition: opengl_gal.h:310
unsigned int mainBuffer
Main rendering target.
Definition: opengl_gal.h:311
COLOR4D strokeColor
The color of the outlines.
int AddParameter(const std::string &aParameterName)
Add a parameter to the parameter queue.
Definition: shader.cpp:124
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:319
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.
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:305
virtual void Initialize() override
Function Reset() performs primary initialiation, necessary to use the object.
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:322
VECTOR2I screenSize
Screen size in screen coordinates.
wxGLContext * glPrivContext
Canvas-specific OpenGL context.
Definition: opengl_gal.h:293
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:320
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 1244 of file opengl_gal.cpp.

References getNewGroupNumber(), groups, and isGrouping.

Referenced by IsVisible().

1245 {
1246  isGrouping = true;
1247 
1248  std::shared_ptr<VERTEX_ITEM> newItem = std::make_shared<VERTEX_ITEM>( *cachedManager );
1249  int groupNumber = getNewGroupNumber();
1250  groups.insert( std::make_pair( groupNumber, newItem ) );
1251 
1252  return groupNumber;
1253 }
bool isGrouping
Was a group started?
Definition: opengl_gal.h:324
GROUPS_MAP groups
Stores informations about VBO objects (groups)
Definition: opengl_gal.h:302
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 378 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().

379 {
380  if( !IsShownOnScreen() )
381  return;
382 
383  if( !isInitialized )
384  init();
385 
387  cachedManager->Map();
388 }
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:305
bool isInitialized
Basic initialization flag, has to be done when the window is visible.
Definition: opengl_gal.h:322
wxGLContext * glPrivContext
Canvas-specific OpenGL context.
Definition: opengl_gal.h:293
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 876 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, KIGFX::GAL::IsTextMirrored(), KIGFX::GAL::layerDepth, ProcessOverbars(), KIGFX::COLOR4D::r, Restore(), KIGFX::VERTEX_MANAGER::Rotate(), Save(), KIGFX::VERTEX_MANAGER::Scale(), KIGFX::GAL::strokeColor, KIGFX::VERTEX_MANAGER::Translate(), Translate(), VECTOR2< T >::x, and VECTOR2< T >::y.

Referenced by IsVisible().

878 {
879  wxASSERT_MSG( !IsTextMirrored(), "No support for mirrored text using bitmap fonts." );
880 
881  auto processedText = ProcessOverbars( aText );
882  const auto& text = processedText.first;
883  const auto& overbars = processedText.second;
884 
885  // Compute text size, so it can be properly justified
886  VECTOR2D textSize;
887  float commonOffset;
888  std::tie( textSize, commonOffset ) = computeBitmapTextSize( text );
889 
890  const double SCALE = 1.4 * GetGlyphSize().y / textSize.y;
891  bool overbar = false;
892 
893  int overbarLength = 0;
894  double overbarHeight = textSize.y;
895 
896  Save();
897 
899  currentManager->Translate( aPosition.x, aPosition.y, layerDepth );
900  currentManager->Rotate( aRotationAngle, 0.0f, 0.0f, -1.0f );
901 
902  double sx = SCALE * ( globalFlipX ? -1.0 : 1.0 );
903  double sy = SCALE * ( globalFlipY ? -1.0 : 1.0 );
904 
905  currentManager->Scale( sx, sy, 0 );
906  currentManager->Translate( 0, -commonOffset, 0 );
907 
908  switch( GetHorizontalJustify() )
909  {
911  Translate( VECTOR2D( -textSize.x / 2.0, 0 ) );
912  break;
913 
915  //if( !IsTextMirrored() )
916  Translate( VECTOR2D( -textSize.x, 0 ) );
917  break;
918 
920  //if( IsTextMirrored() )
921  //Translate( VECTOR2D( -textSize.x, 0 ) );
922  break;
923  }
924 
925  switch( GetVerticalJustify() )
926  {
928  Translate( VECTOR2D( 0, -textSize.y ) );
929  overbarHeight = -textSize.y / 2.0;
930  break;
931 
933  Translate( VECTOR2D( 0, -textSize.y / 2.0 ) );
934  overbarHeight = 0;
935  break;
936 
938  break;
939  }
940 
941  int i = 0;
942 
943  for( UTF8::uni_iter chIt = text.ubegin(), end = text.uend(); chIt < end; ++chIt )
944  {
945  unsigned int c = *chIt;
946  wxASSERT_MSG( c != '\n' && c != '\r', wxT( "No support for multiline bitmap text yet" ) );
947 
948  // Handle overbar
949  if( overbars[i] && !overbar )
950  {
951  overbar = true; // beginning of an overbar
952  }
953  else if( overbar && !overbars[i] )
954  {
955  overbar = false; // end of an overbar
956  drawBitmapOverbar( overbarLength, overbarHeight );
957  overbarLength = 0;
958  }
959 
960  if( overbar )
961  overbarLength += drawBitmapChar( c );
962  else
963  drawBitmapChar( c );
964 
965  ++i;
966  }
967 
968  // Handle the case when overbar is active till the end of the drawn text
969  currentManager->Translate( 0, commonOffset, 0 );
970 
971  if( overbar && overbarLength > 0 )
972  drawBitmapOverbar( overbarLength, overbarHeight );
973 
974  Restore();
975 }
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:304
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:588
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.
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 1721 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().

1722 {
1723  if( !IsCursorEnabled() )
1724  return;
1725 
1727 
1728  const int cursorSize = fullscreenCursor ? 8000 : 80;
1729 
1730  VECTOR2D cursorBegin = cursorPosition - cursorSize / ( 2 * worldScale );
1731  VECTOR2D cursorEnd = cursorPosition + cursorSize / ( 2 * worldScale );
1732  VECTOR2D cursorCenter = ( cursorBegin + cursorEnd ) / 2;
1733 
1734  const COLOR4D cColor = getCursorColor();
1735  const COLOR4D color( cColor.r * cColor.a, cColor.g * cColor.a,
1736  cColor.b * cColor.a, 1.0 );
1737 
1738  glActiveTexture( GL_TEXTURE0 );
1739  glDisable( GL_TEXTURE_2D );
1740  glLineWidth( 1.0 );
1741  glColor4d( color.r, color.g, color.b, color.a );
1742 
1743  glBegin( GL_LINES );
1744  glVertex2d( cursorCenter.x, cursorBegin.y );
1745  glVertex2d( cursorCenter.x, cursorEnd.y );
1746 
1747  glVertex2d( cursorBegin.x, cursorCenter.y );
1748  glVertex2d( cursorEnd.x, cursorCenter.y );
1749  glEnd();
1750 }
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:310
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 454 of file opengl_gal.h.

References init(), and min.

Referenced by DrawArc(), and DrawArcSegment().

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

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

Referenced by IsVisible().

1270 {
1271  cachedManager->ChangeItemColor( *groups[aGroupNumber], aNewColor );
1272 }
GROUPS_MAP groups
Stores informations about VBO objects (groups)
Definition: opengl_gal.h:302
VERTEX_MANAGER * cachedManager
Container for storing cached VERTEX_ITEMs.
Definition: opengl_gal.h:305
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 1275 of file opengl_gal.cpp.

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

Referenced by IsVisible().

1276 {
1277  cachedManager->ChangeItemDepth( *groups[aGroupNumber], aDepth );
1278 }
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:302
VERTEX_MANAGER * cachedManager
Container for storing cached VERTEX_ITEMs.
Definition: opengl_gal.h:305
void OPENGL_GAL::ClearCache ( )
overridevirtual

Delete all data created during caching of graphic items.

Reimplemented from KIGFX::GAL.

Definition at line 1288 of file opengl_gal.cpp.

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

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

1289 {
1290  groups.clear();
1291 
1292  if( isInitialized )
1293  cachedManager->Clear();
1294 }
void Clear() const
Function Clear() removes all the stored vertices from the container.
GROUPS_MAP groups
Stores informations about VBO objects (groups)
Definition: opengl_gal.h:302
VERTEX_MANAGER * cachedManager
Container for storing cached VERTEX_ITEMs.
Definition: opengl_gal.h:305
bool isInitialized
Basic initialization flag, has to be done when the window is visible.
Definition: opengl_gal.h:322
void OPENGL_GAL::ClearScreen ( )
overridevirtual

Clear the screen.

Parameters
aColoris the color used for clearing.

Reimplemented from KIGFX::GAL.

Definition at line 1186 of file opengl_gal.cpp.

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

Referenced by IsVisible().

1187 {
1188  // Clear screen
1190  // NOTE: Black used here instead of m_clearColor; it will be composited later
1191  glClearColor( 0, 0, 0, 1 );
1192  glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT );
1193 }
static const unsigned int DIRECT_RENDERING
OPENGL_COMPOSITOR * compositor
Handles multiple rendering targets.
Definition: opengl_gal.h:310
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 1337 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().

1338 {
1339  // Save the current state
1340  unsigned int oldTarget = compositor->GetBuffer();
1341 
1342  switch( aTarget )
1343  {
1344  // Cached and noncached items are rendered to the same buffer
1345  default:
1346  case TARGET_CACHED:
1347  case TARGET_NONCACHED:
1349  break;
1350 
1351  case TARGET_OVERLAY:
1353  break;
1354  }
1355 
1356 
1357  if( aTarget != TARGET_OVERLAY )
1359  else
1361 
1362  // Restore the previous state
1363  compositor->SetBuffer( oldTarget );
1364 }
unsigned int overlayBuffer
Auxiliary rendering target (for menus etc.)
Definition: opengl_gal.h:312
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:310
unsigned int mainBuffer
Main rendering target.
Definition: opengl_gal.h:311
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 1673 of file opengl_gal.cpp.

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

Referenced by BitmapText().

1674 {
1675  VECTOR2D textSize( 0, 0 );
1676  float commonOffset = std::numeric_limits<float>::max();
1677  static const auto defaultGlyph = LookupGlyph( '(' ); // for strange chars
1678 
1679  for( UTF8::uni_iter chIt = aText.ubegin(), end = aText.uend(); chIt < end; ++chIt )
1680  {
1681  unsigned int c = *chIt;
1682 
1683  const FONT_GLYPH_TYPE* glyph = LookupGlyph( c );
1684  wxASSERT( c == ' ' || glyph ); // space is not in the atlas
1685 
1686  // a few chars
1687  if( !glyph || // Not coded in font
1688  c == '-' || c == '_' ) // Strange size of these 2 chars
1689  {
1690  glyph = defaultGlyph;
1691  }
1692 
1693  if( glyph )
1694  {
1695  textSize.x += glyph->advance;
1696  }
1697  }
1698 
1699  textSize.y = std::max<float>( textSize.y, font_information.max_y - defaultGlyph->miny );
1700  commonOffset = std::min<float>( font_information.max_y - defaultGlyph->maxy, commonOffset );
1701  textSize.y -= commonOffset;
1702 
1703  return std::make_pair( textSize, commonOffset );
1704 }
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
#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 1044 of file graphics_abstraction_layer.h.

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

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

1045  {
1047  }
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:588
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 1281 of file opengl_gal.cpp.

References groups.

Referenced by IsVisible().

1282 {
1283  // Frees memory in the container as well
1284  groups.erase( aGroupNumber );
1285 }
GROUPS_MAP groups
Stores informations about VBO objects (groups)
Definition: opengl_gal.h:302
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 524 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().

526 {
527  if( aRadius <= 0 )
528  return;
529 
530  // Swap the angles, if start angle is greater than end angle
531  SWAP( aStartAngle, >, aEndAngle );
532 
533  const double alphaIncrement = calcAngleStep( aRadius );
534 
535  Save();
536  currentManager->Translate( aCenterPoint.x, aCenterPoint.y, 0.0 );
537 
538  if( isStrokeEnabled )
539  {
541 
542  VECTOR2D p( cos( aStartAngle ) * aRadius, sin( aStartAngle ) * aRadius );
543  double alpha;
544 
545  for( alpha = aStartAngle + alphaIncrement; alpha <= aEndAngle; alpha += alphaIncrement )
546  {
547  VECTOR2D p_next( cos( alpha ) * aRadius, sin( alpha ) * aRadius );
548  DrawLine( p, p_next );
549 
550  p = p_next;
551  }
552 
553  // Draw the last missing part
554  if( alpha != aEndAngle )
555  {
556  VECTOR2D p_last( cos( aEndAngle ) * aRadius, sin( aEndAngle ) * aRadius );
557  DrawLine( p, p_last );
558  }
559  }
560 
561  if( isFillEnabled )
562  {
563  double alpha;
566 
567  // Triangle fan
568  for( alpha = aStartAngle; ( alpha + alphaIncrement ) < aEndAngle; )
569  {
570  currentManager->Reserve( 3 );
571  currentManager->Vertex( 0.0, 0.0, 0.0 );
572  currentManager->Vertex( cos( alpha ) * aRadius, sin( alpha ) * aRadius, 0.0 );
573  alpha += alphaIncrement;
574  currentManager->Vertex( cos( alpha ) * aRadius, sin( alpha ) * aRadius, 0.0 );
575  }
576 
577  // The last missing triangle
578  const VECTOR2D endPoint( cos( aEndAngle ) * aRadius, sin( aEndAngle ) * aRadius );
579 
580  currentManager->Reserve( 3 );
581  currentManager->Vertex( 0.0, 0.0, 0.0 );
582  currentManager->Vertex( cos( alpha ) * aRadius, sin( alpha ) * aRadius, 0.0 );
583  currentManager->Vertex( endPoint.x, endPoint.y, 0.0 );
584  }
585 
586  Restore();
587 }
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:304
double calcAngleStep(double aRadius) const
Compute the angle step when drawing arcs/circles approximated with lines.
Definition: opengl_gal.h:454
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:401
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 590 of file opengl_gal.cpp.

References KIGFX::COLOR4D::a, KIGFX::COLOR4D::b, calcAngleStep(), KIGFX::VERTEX_MANAGER::Color(), currentManager, 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().

592 {
593  if( aRadius <= 0 )
594  return;
595 
596  // Swap the angles, if start angle is greater than end angle
597  SWAP( aStartAngle, >, aEndAngle );
598 
599  const double alphaIncrement = calcAngleStep( aRadius );
600 
601  Save();
602  currentManager->Translate( aCenterPoint.x, aCenterPoint.y, 0.0 );
603 
604  if( isStrokeEnabled )
605  {
607 
608  double width = aWidth / 2.0;
609  VECTOR2D startPoint( cos( aStartAngle ) * aRadius,
610  sin( aStartAngle ) * aRadius );
611  VECTOR2D endPoint( cos( aEndAngle ) * aRadius,
612  sin( aEndAngle ) * aRadius );
613 
614  drawStrokedSemiCircle( startPoint, width, aStartAngle + M_PI );
615  drawStrokedSemiCircle( endPoint, width, aEndAngle );
616 
617  VECTOR2D pOuter( cos( aStartAngle ) * ( aRadius + width ),
618  sin( aStartAngle ) * ( aRadius + width ) );
619 
620  VECTOR2D pInner( cos( aStartAngle ) * ( aRadius - width ),
621  sin( aStartAngle ) * ( aRadius - width ) );
622 
623  double alpha;
624 
625  for( alpha = aStartAngle + alphaIncrement; alpha <= aEndAngle; alpha += alphaIncrement )
626  {
627  VECTOR2D pNextOuter( cos( alpha ) * ( aRadius + width ),
628  sin( alpha ) * ( aRadius + width ) );
629  VECTOR2D pNextInner( cos( alpha ) * ( aRadius - width ),
630  sin( alpha ) * ( aRadius - width ) );
631 
632  DrawLine( pOuter, pNextOuter );
633  DrawLine( pInner, pNextInner );
634 
635  pOuter = pNextOuter;
636  pInner = pNextInner;
637  }
638 
639  // Draw the last missing part
640  if( alpha != aEndAngle )
641  {
642  VECTOR2D pLastOuter( cos( aEndAngle ) * ( aRadius + width ),
643  sin( aEndAngle ) * ( aRadius + width ) );
644  VECTOR2D pLastInner( cos( aEndAngle ) * ( aRadius - width ),
645  sin( aEndAngle ) * ( aRadius - width ) );
646 
647  DrawLine( pOuter, pLastOuter );
648  DrawLine( pInner, pLastInner );
649  }
650  }
651 
652  if( isFillEnabled )
653  {
655  SetLineWidth( aWidth );
656 
657  VECTOR2D p( cos( aStartAngle ) * aRadius, sin( aStartAngle ) * aRadius );
658  double alpha;
659 
660  for( alpha = aStartAngle + alphaIncrement; alpha <= aEndAngle; alpha += alphaIncrement )
661  {
662  VECTOR2D p_next( cos( alpha ) * aRadius, sin( alpha ) * aRadius );
663  DrawLine( p, p_next );
664 
665  p = p_next;
666  }
667 
668  // Draw the last missing part
669  if( alpha != aEndAngle )
670  {
671  VECTOR2D p_last( cos( aEndAngle ) * aRadius, sin( aEndAngle ) * aRadius );
672  DrawLine( p, p_last );
673  }
674  }
675 
676  Restore();
677 }
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:304
double calcAngleStep(double aRadius) const
Compute the angle step when drawing arcs/circles approximated with lines.
Definition: opengl_gal.h:454
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:401
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
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 1576 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().

1577 {
1578  const float TEX_X = font_image.width;
1579  const float TEX_Y = font_image.height;
1580 
1581  // handle space
1582  if( aChar == ' ' )
1583  {
1584  const FONT_GLYPH_TYPE* g = LookupGlyph( 'x' );
1585  wxASSERT( g );
1586  Translate( VECTOR2D( g->advance, 0 ) );
1587  return g->advance;
1588  }
1589 
1590  const FONT_GLYPH_TYPE* glyph = LookupGlyph( aChar );
1591  wxASSERT( glyph );
1592 
1593  if( !glyph )
1594  return 0;
1595 
1596  const float X = glyph->atlas_x + font_information.smooth_pixels;
1597  const float Y = glyph->atlas_y + font_information.smooth_pixels;
1598  const float XOFF = glyph->minx;
1599 
1600  // adjust for height rounding
1601  const float round_adjust = ( glyph->maxy - glyph->miny )
1602  - float( glyph->atlas_h - font_information.smooth_pixels * 2 );
1603  const float top_adjust = font_information.max_y - glyph->maxy;
1604  const float YOFF = round_adjust + top_adjust;
1605  const float W = glyph->atlas_w - font_information.smooth_pixels *2;
1606  const float H = glyph->atlas_h - font_information.smooth_pixels *2;
1607  const float B = 0;
1608 
1609  currentManager->Reserve( 6 );
1610  Translate( VECTOR2D( XOFF, YOFF ) );
1611  /* Glyph:
1612  * v0 v1
1613  * +--+
1614  * | /|
1615  * |/ |
1616  * +--+
1617  * v2 v3
1618  */
1619  currentManager->Shader( SHADER_FONT, X / TEX_X, ( Y + H ) / TEX_Y );
1620  currentManager->Vertex( -B, -B, 0 ); // v0
1621 
1622  currentManager->Shader( SHADER_FONT, ( X + W ) / TEX_X, ( Y + H ) / TEX_Y );
1623  currentManager->Vertex( W + B, -B, 0 ); // v1
1624 
1625  currentManager->Shader( SHADER_FONT, X / TEX_X, Y / TEX_Y );
1626  currentManager->Vertex( -B, H + B, 0 ); // v2
1627 
1628 
1629  currentManager->Shader( SHADER_FONT, ( X + W ) / TEX_X, ( Y + H ) / TEX_Y );
1630  currentManager->Vertex( W + B, -B, 0 ); // v1
1631 
1632  currentManager->Shader( SHADER_FONT, X / TEX_X, Y / TEX_Y );
1633  currentManager->Vertex( -B, H + B, 0 ); // v2
1634 
1635  currentManager->Shader( SHADER_FONT, ( X + W ) / TEX_X, Y / TEX_Y );
1636  currentManager->Vertex( W + B, H + B, 0 ); // v3
1637 
1638  Translate( VECTOR2D( -XOFF + glyph->advance, -YOFF ) );
1639 
1640  return glyph->advance;
1641 }
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:304
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:588
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 1644 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().

1645 {
1646  // To draw an overbar, simply draw an overbar
1647  const FONT_GLYPH_TYPE* glyph = LookupGlyph( '_' );
1648  wxCHECK( glyph, /* void */ );
1649 
1650  const float H = glyph->maxy - glyph->miny;
1651 
1652  Save();
1653 
1654  Translate( VECTOR2D( -aLength, -aHeight-1.5*H ) );
1655 
1656  currentManager->Reserve( 6 );
1658 
1659  currentManager->Shader( 0 );
1660 
1661  currentManager->Vertex( 0, 0, 0 ); // v0
1662  currentManager->Vertex( aLength, 0, 0 ); // v1
1663  currentManager->Vertex( 0, H, 0 ); // v2
1664 
1665  currentManager->Vertex( aLength, 0, 0 ); // v1
1666  currentManager->Vertex( 0, H, 0 ); // v2
1667  currentManager->Vertex( aLength, H, 0 ); // v3
1668 
1669  Restore();
1670 }
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:304
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:588
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 464 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 IsVisible().

465 {
466  if( isFillEnabled )
467  {
468  currentManager->Reserve( 3 );
470 
471  /* Draw a triangle that contains the circle, then shade it leaving only the circle.
472  * Parameters given to Shader() are indices of the triangle's vertices
473  * (if you want to understand more, check the vertex shader source [shader.vert]).
474  * Shader uses this coordinates to determine if fragments are inside the circle or not.
475  * v2
476  * /\
477  * //\\
478  * v0 /_\/_\ v1
479  */
481  currentManager->Vertex( aCenterPoint.x - aRadius * sqrt( 3.0f ), // v0
482  aCenterPoint.y - aRadius, layerDepth );
483 
485  currentManager->Vertex( aCenterPoint.x + aRadius * sqrt( 3.0f), // v1
486  aCenterPoint.y - aRadius, layerDepth );
487 
489  currentManager->Vertex( aCenterPoint.x, aCenterPoint.y + aRadius * 2.0f, // v2
490  layerDepth );
491  }
492 
493  if( isStrokeEnabled )
494  {
495  currentManager->Reserve( 3 );
497 
498  /* Draw a triangle that contains the circle, then shade it leaving only the circle.
499  * Parameters given to Shader() are indices of the triangle's vertices
500  * (if you want to understand more, check the vertex shader source [shader.vert]).
501  * and the line width. Shader uses this coordinates to determine if fragments are
502  * inside the circle or not.
503  * v2
504  * /\
505  * //\\
506  * v0 /_\/_\ v1
507  */
508  double outerRadius = aRadius + ( lineWidth / 2 );
510  currentManager->Vertex( aCenterPoint.x - outerRadius * sqrt( 3.0f ), // v0
511  aCenterPoint.y - outerRadius, layerDepth );
512 
514  currentManager->Vertex( aCenterPoint.x + outerRadius * sqrt( 3.0f ), // v1
515  aCenterPoint.y - outerRadius, layerDepth );
516 
518  currentManager->Vertex( aCenterPoint.x, aCenterPoint.y + outerRadius * 2.0f, // v2
519  layerDepth );
520  }
521 }
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:304
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 1367 of file opengl_gal.cpp.

References KIGFX::GAL::cursorPosition.

Referenced by SetNegativeDrawMode().

1368 {
1369  // Now we should only store the position of the mouse cursor
1370  // The real drawing routines are in blitCursor()
1371  //VECTOR2D screenCursor = worldScreenMatrix * aCursorPosition;
1372  //cursorPosition = screenWorldMatrix * VECTOR2D( screenCursor.x, screenCursor.y );
1373  cursorPosition = aCursorPosition;
1374 }
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 844 of file opengl_gal.cpp.

References CURVE_POINTS, and DrawPolyline().

Referenced by IsVisible().

846 {
847  // FIXME The drawing quality needs to be improved
848  // FIXME Perhaps choose a quad/triangle strip instead?
849  // FIXME Brute force method, use a better (recursive?) algorithm
850 
851  std::deque<VECTOR2D> pointList;
852 
853  double t = 0.0;
854  double dt = 1.0 / (double) CURVE_POINTS;
855 
856  for( int i = 0; i <= CURVE_POINTS; i++ )
857  {
858  double omt = 1.0 - t;
859  double omt2 = omt * omt;
860  double omt3 = omt * omt2;
861  double t2 = t * t;
862  double t3 = t * t2;
863 
864  VECTOR2D vertex = omt3 * aStartPoint + 3.0 * t * omt2 * aControlPointA
865  + 3.0 * t2 * omt * aControlPointB + t3 * aEndPoint;
866 
867  pointList.push_back( vertex );
868 
869  t += dt;
870  }
871 
872  DrawPolyline( pointList );
873 }
static const int CURVE_POINTS
The number of points for curve approximation.
Definition: opengl_gal.h:290
virtual void DrawPolyline(const std::deque< VECTOR2D > &aPointList) override
Draw a polyline.
Definition: opengl_gal.cpp:718
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 1445 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 DrawLine(), drawPolyline(), DrawSegment(), and drawSemiCircle().

1447 {
1448  Save();
1449 
1450  currentManager->Reserve( 3 );
1451  currentManager->Translate( aCenterPoint.x, aCenterPoint.y, 0.0f );
1452  currentManager->Rotate( aAngle, 0.0f, 0.0f, 1.0f );
1453 
1454  /* Draw a triangle that contains the semicircle, then shade it to leave only
1455  * the semicircle. Parameters given to Shader() are indices of the triangle's vertices
1456  * (if you want to understand more, check the vertex shader source [shader.vert]).
1457  * Shader uses these coordinates to determine if fragments are inside the semicircle or not.
1458  * v2
1459  * /\
1460  * /__\
1461  * v0 //__\\ v1
1462  */
1464  currentManager->Vertex( -aRadius * 3.0f / sqrt( 3.0f ), 0.0f, layerDepth ); // v0
1465 
1467  currentManager->Vertex( aRadius * 3.0f / sqrt( 3.0f ), 0.0f, layerDepth ); // v1
1468 
1470  currentManager->Vertex( 0.0f, aRadius * 2.0f, layerDepth ); // v2
1471 
1472  Restore();
1473 }
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:304
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 978 of file opengl_gal.cpp.

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

Referenced by IsVisible().

979 {
982 
983  // sub-pixel lines all render the same
984  double minorLineWidth = std::max( 1.0, gridLineWidth );
985  double majorLineWidth = minorLineWidth * 2.0;
986 
987  // Draw the axis and grid
988  // For the drawing the start points, end points and increments have
989  // to be calculated in world coordinates
990  VECTOR2D worldStartPoint = screenWorldMatrix * VECTOR2D( 0.0, 0.0 );
991  VECTOR2D worldEndPoint = screenWorldMatrix * VECTOR2D( screenSize );
992 
993  // Draw axes if desired
994  if( axesEnabled )
995  {
996  glLineWidth( minorLineWidth );
997  glColor4d( axesColor.r, axesColor.g, axesColor.b, 1.0 );
998 
999  glBegin( GL_LINES );
1000  glVertex2d( worldStartPoint.x, 0 );
1001  glVertex2d( worldEndPoint.x, 0 );
1002  glEnd();
1003 
1004  glBegin( GL_LINES );
1005  glVertex2d( 0, worldStartPoint.y );
1006  glVertex2d( 0, worldEndPoint.y );
1007  glEnd();
1008  }
1009 
1010  if( !gridVisibility )
1011  return;
1012 
1013  int gridScreenSizeDense = KiROUND( gridSize.x * worldScale );
1014  int gridScreenSizeCoarse = KiROUND( gridSize.x * static_cast<double>( gridTick ) * worldScale );
1015 
1016  const double gridThreshold = computeMinGridSpacing();
1017 
1018  // Check if the grid would not be too dense
1019  if( std::max( gridScreenSizeDense, gridScreenSizeCoarse ) < gridThreshold )
1020  return;
1021 
1022  // Compute grid staring and ending indexes to draw grid points on the
1023  // visible screen area
1024  // Note: later any point coordinate will be offsetted by gridOrigin
1025  int gridStartX = KiROUND( ( worldStartPoint.x - gridOrigin.x ) / gridSize.x );
1026  int gridEndX = KiROUND( ( worldEndPoint.x - gridOrigin.x ) / gridSize.x );
1027  int gridStartY = KiROUND( ( worldStartPoint.y - gridOrigin.y ) / gridSize.y );
1028  int gridEndY = KiROUND( ( worldEndPoint.y - gridOrigin.y ) / gridSize.y );
1029 
1030  // Ensure start coordinate > end coordinate
1031  if( gridStartX > gridEndX )
1032  std::swap( gridStartX, gridEndX );
1033 
1034  if( gridStartY > gridEndY )
1035  std::swap( gridStartY, gridEndY );
1036 
1037  // Ensure the grid fills the screen
1038  --gridStartX; ++gridEndX;
1039  --gridStartY; ++gridEndY;
1040 
1041  glDisable( GL_DEPTH_TEST );
1042  glDisable( GL_TEXTURE_2D );
1043 
1044  if( gridStyle == GRID_STYLE::DOTS )
1045  {
1046  glEnable( GL_STENCIL_TEST );
1047  glStencilFunc( GL_ALWAYS, 1, 1 );
1048  glStencilOp( GL_KEEP, GL_KEEP, GL_INCR );
1049  glColor4d( 0.0, 0.0, 0.0, 0.0 );
1050  }
1051  else
1052  {
1053  glColor4d( gridColor.r, gridColor.g, gridColor.b, 1.0 );
1054  }
1055 
1057  {
1058  glLineWidth( minorLineWidth );
1059 
1060  // calculate a line len = 2 minorLineWidth, in internal unit value
1061  // (in fact the size of cross is lineLen*2)
1062  int lineLen = KiROUND( minorLineWidth / worldScale * 2 );
1063 
1064  // Vertical positions
1065  for( int j = gridStartY; j <= gridEndY; j++ )
1066  {
1067  if( ( j % gridTick == 0 && gridScreenSizeCoarse > gridThreshold )
1068  || gridScreenSizeDense > gridThreshold )
1069  {
1070  int posY = j * gridSize.y + gridOrigin.y;
1071 
1072  // Horizontal positions
1073  for( int i = gridStartX; i <= gridEndX; i++ )
1074  {
1075  if( ( i % gridTick == 0 && gridScreenSizeCoarse > gridThreshold )
1076  || gridScreenSizeDense > gridThreshold )
1077  {
1078  int posX = i * gridSize.x + gridOrigin.x;
1079 
1080  glBegin( GL_LINES );
1081  glVertex2d( posX -lineLen, posY );
1082  glVertex2d( posX + lineLen, posY );
1083  glVertex2d( posX, posY - lineLen );
1084  glVertex2d( posX, posY + lineLen );
1085  glEnd();
1086  }
1087  }
1088  }
1089  }
1090  }
1091  else
1092  {
1093  // Vertical lines
1094  for( int j = gridStartY; j <= gridEndY; j++ )
1095  {
1096  const double y = j * gridSize.y + gridOrigin.y;
1097 
1098  // If axes are drawn, skip the lines that would cover them
1099  if( axesEnabled && y == 0 )
1100  continue;
1101 
1102  if( j % gridTick == 0 && gridScreenSizeDense > gridThreshold )
1103  glLineWidth( majorLineWidth );
1104  else
1105  glLineWidth( minorLineWidth );
1106 
1107  if( ( j % gridTick == 0 && gridScreenSizeCoarse > gridThreshold )
1108  || gridScreenSizeDense > gridThreshold )
1109  {
1110  glBegin( GL_LINES );
1111  glVertex2d( gridStartX * gridSize.x + gridOrigin.x, y );
1112  glVertex2d( gridEndX * gridSize.x + gridOrigin.x, y );
1113  glEnd();
1114  }
1115  }
1116 
1117  if( gridStyle == GRID_STYLE::DOTS )
1118  {
1119  glStencilFunc( GL_NOTEQUAL, 0, 1 );
1120  glColor4d( gridColor.r, gridColor.g, gridColor.b, 1.0 );
1121  }
1122 
1123  // Horizontal lines
1124  for( int i = gridStartX; i <= gridEndX; i++ )
1125  {
1126  const double x = i * gridSize.x + gridOrigin.x;
1127 
1128  // If axes are drawn, skip the lines that would cover them
1129  if( axesEnabled && x == 0 )
1130  continue;
1131 
1132  if( i % gridTick == 0 && gridScreenSizeDense > gridThreshold )
1133  glLineWidth( majorLineWidth );
1134  else
1135  glLineWidth( minorLineWidth );
1136 
1137  if( ( i % gridTick == 0 && gridScreenSizeCoarse > gridThreshold )
1138  || gridScreenSizeDense > gridThreshold )
1139  {
1140  glBegin( GL_LINES );
1141  glVertex2d( x, gridStartY * gridSize.y + gridOrigin.y );
1142  glVertex2d( x, gridEndY * gridSize.y + gridOrigin.y );
1143  glEnd();
1144  }
1145  }
1146 
1147  if( gridStyle == GRID_STYLE::DOTS )
1148  glDisable( GL_STENCIL_TEST );
1149  }
1150 
1151  glEnable( GL_DEPTH_TEST );
1152  glEnable( GL_TEXTURE_2D );
1153 }
double computeMinGridSpacing() const
compute minimum grid spacing from the grid settings
int gridTick
Every tick line gets the double width.
bool axesEnabled
Should the axes be drawn.
static int KiROUND(double v)
KiROUND rounds a floating point number to an int using "round halfway cases away from zero"...
Definition: common.h:107
GRID_STYLE gridStyle
Grid display style.
double g
Green component.
Definition: color4d.h:292
MATRIX3x3D screenWorldMatrix
Screen transformation.
double b
Blue component.
Definition: color4d.h:293
Auxiliary rendering target (noncached)
Definition: definitions.h:42
OPENGL_COMPOSITOR * compositor
Handles multiple rendering targets.
Definition: opengl_gal.h:310
VECTOR2< double > VECTOR2D
Definition: vector2d.h:588
unsigned int mainBuffer
Main rendering target.
Definition: opengl_gal.h:311
COLOR4D axesColor
Color of the axes.
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.
COLOR4D gridColor
Color of the grid.
bool gridVisibility
Should the grid be shown.
#define max(a, b)
Definition: auxiliary.h:86
double worldScale
The scale factor world->screen.
VECTOR2D gridSize
The grid size.
VECTOR2I screenSize
Screen size in screen coordinates.
double r
Red component.
Definition: color4d.h:291
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 1062 of file graphics_abstraction_layer.h.

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

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

Draw the stored group.

Parameters
aGroupNumberis the group number.

Reimplemented from KIGFX::GAL.

Definition at line 1263 of file opengl_gal.cpp.

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

Referenced by IsVisible().

1264 {
1265  cachedManager->DrawItem( *groups[aGroupNumber] );
1266 }
GROUPS_MAP groups
Stores informations about VBO objects (groups)
Definition: opengl_gal.h:302
VERTEX_MANAGER * cachedManager
Container for storing cached VERTEX_ITEMs.
Definition: opengl_gal.h:305
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 401 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, KIGFX::GAL::lineWidth, KIGFX::COLOR4D::r, and KIGFX::GAL::strokeColor.

Referenced by DrawArc(), DrawArcSegment(), and IsVisible().

402 {
403  const VECTOR2D startEndVector = aEndPoint - aStartPoint;
404  double lineAngle = startEndVector.Angle();
405 
407 
408  drawLineQuad( aStartPoint, aEndPoint );
409 
410  // Line caps
411  if( lineWidth > 1.0 )
412  {
413  drawFilledSemiCircle( aStartPoint, lineWidth / 2, lineAngle + M_PI / 2 );
414  drawFilledSemiCircle( aEndPoint, lineWidth / 2, lineAngle - M_PI / 2 );
415  }
416 }
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:304
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:308
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 drawFilledSemiCircle(const VECTOR2D &aCenterPoint, double aRadius, double aAngle)
Draw a filled semicircle.
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 1377 of file opengl_gal.cpp.

References currentManager, VECTOR2< T >::EuclideanNorm(), KIGFX::VERTEX_MANAGER::GetTransformation(), KIGFX::GAL::layerDepth, KIGFX::GAL::lineWidth, KIGFX::VERTEX_MANAGER::Reserve(), scale, KIGFX::VERTEX_MANAGER::Shader(), KIGFX::SHADER_LINE, KIGFX::VERTEX_MANAGER::Vertex(), VECTOR2< T >::x, and VECTOR2< T >::y.

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

1378 {
1379  /* Helper drawing: ____--- v3 ^
1380  * ____---- ... \ \
1381  * ____---- ... \ end \
1382  * v1 ____---- ... ____---- \ width
1383  * ---- ...___---- \ \
1384  * \ ___...-- \ v
1385  * \ ____----... ____---- v2
1386  * ---- ... ____----
1387  * start \ ... ____----
1388  * \... ____----
1389  * ----
1390  * v0
1391  * dots mark triangles' hypotenuses
1392  */
1393 
1394  VECTOR2D startEndVector = aEndPoint - aStartPoint;
1395  double lineLength = startEndVector.EuclideanNorm();
1396 
1397  if( lineLength <= 0.0 )
1398  return;
1399 
1400  double scale = 0.5 * lineWidth / lineLength;
1401 
1402  // The perpendicular vector also needs transformations
1403  glm::vec4 vector = currentManager->GetTransformation() *
1404  glm::vec4( -startEndVector.y * scale, startEndVector.x * scale, 0.0, 0.0 );
1405 
1406  currentManager->Reserve( 6 );
1407 
1408  // Line width is maintained by the vertex shader
1409  currentManager->Shader( SHADER_LINE, vector.x, vector.y, lineWidth );
1410  currentManager->Vertex( aStartPoint.x, aStartPoint.y, layerDepth ); // v0
1411 
1412  currentManager->Shader( SHADER_LINE, -vector.x, -vector.y, lineWidth );
1413  currentManager->Vertex( aStartPoint.x, aStartPoint.y, layerDepth ); // v1
1414 
1415  currentManager->Shader( SHADER_LINE, -vector.x, -vector.y, lineWidth );
1416  currentManager->Vertex( aEndPoint.x, aEndPoint.y, layerDepth ); // v3
1417 
1418  currentManager->Shader( SHADER_LINE, vector.x, vector.y, lineWidth );
1419  currentManager->Vertex( aStartPoint.x, aStartPoint.y, layerDepth ); // v0
1420 
1421  currentManager->Shader( SHADER_LINE, -vector.x, -vector.y, lineWidth );
1422  currentManager->Vertex( aEndPoint.x, aEndPoint.y, layerDepth ); // v3
1423 
1424  currentManager->Shader( SHADER_LINE, vector.x, vector.y, lineWidth );
1425  currentManager->Vertex( aEndPoint.x, aEndPoint.y, layerDepth ); // v2
1426 }
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:304
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.
T EuclideanNorm() const
Destructor.
Definition: vector2d.h:294
const int scale
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 741 of file opengl_gal.cpp.

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

Referenced by IsVisible().

742 {
743  auto points = std::unique_ptr<GLdouble[]>( new GLdouble[3 * aPointList.size()] );
744  GLdouble* ptr = points.get();
745 
746  for( const VECTOR2D& p : aPointList )
747  {
748  *ptr++ = p.x;
749  *ptr++ = p.y;
750  *ptr++ = layerDepth;
751  }
752 
753  drawPolygon( points.get(), aPointList.size() );
754 }
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 757 of file opengl_gal.cpp.

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

758 {
759  auto points = std::unique_ptr<GLdouble[]>( new GLdouble[3 * aListSize] );
760  GLdouble* target = points.get();
761  const VECTOR2D* src = aPointList;
762 
763  for( int i = 0; i < aListSize; ++i )
764  {
765  *target++ = src->x;
766  *target++ = src->y;
767  *target++ = layerDepth;
768  ++src;
769  }
770 
771  drawPolygon( points.get(), aListSize );
772 }
double layerDepth
The actual layer depth.
void drawPolygon(GLdouble *aPoints, int aPointCount)
Draws a filled polygon.
void OPENGL_GAL::DrawPolygon ( const SHAPE_POLY_SET aPolySet)
overridevirtual

Reimplemented from KIGFX::GAL.

Definition at line 812 of file opengl_gal.cpp.

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

813 {
814  if ( aPolySet.IsTriangulationUpToDate() )
815  {
816  drawTriangulatedPolyset( aPolySet );
817  return;
818  }
819 
820  for( int j = 0; j < aPolySet.OutlineCount(); ++j )
821  {
822  const SHAPE_LINE_CHAIN& outline = aPolySet.COutline( j );
823 
824  if( outline.SegmentCount() == 0 )
825  continue;
826 
827  const int pointCount = outline.SegmentCount() + 1;
828  std::unique_ptr<GLdouble[]> points( new GLdouble[3 * pointCount] );
829  GLdouble* ptr = points.get();
830 
831  for( int i = 0; i < pointCount; ++i )
832  {
833  const VECTOR2I& p = outline.CPoint( i );
834  *ptr++ = p.x;
835  *ptr++ = p.y;
836  *ptr++ = layerDepth;
837  }
838 
839  drawPolygon( points.get(), pointCount );
840  }
841 }
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:774
Class SHAPE_LINE_CHAIN.
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 1510 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::COLOR4D::r, KIGFX::VERTEX_MANAGER::Shader(), KIGFX::SHADER_NONE, tesselator, and tessIntersects.

Referenced by DrawPolygon().

1511 {
1512  if( isFillEnabled )
1513  {
1516 
1517  // Any non convex polygon needs to be tesselated
1518  // for this purpose the GLU standard functions are used
1519  TessParams params = { currentManager, tessIntersects };
1520  gluTessBeginPolygon( tesselator, &params );
1521  gluTessBeginContour( tesselator );
1522 
1523  GLdouble* point = aPoints;
1524 
1525  for( int i = 0; i < aPointCount; ++i )
1526  {
1527  gluTessVertex( tesselator, point, point );
1528  point += 3; // 3 coordinates
1529  }
1530 
1531  gluTessEndContour( tesselator );
1532  gluTessEndPolygon( tesselator );
1533 
1534  // Free allocated intersecting points
1535  tessIntersects.clear();
1536  }
1537 
1538  if( isStrokeEnabled )
1539  {
1540  drawPolyline( [&](int idx) { return VECTOR2D( aPoints[idx * 3], aPoints[idx * 3 + 1] ); },
1541  aPointCount );
1542  }
1543 }
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:304
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:588
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:331
bool isFillEnabled
Is filling of graphic objects enabled ?
std::deque< boost::shared_array< GLdouble > > tessIntersects
Storage for intersecting points.
Definition: opengl_gal.h:333
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 718 of file opengl_gal.cpp.

References drawPolyline().

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

719 {
720  drawPolyline( [&](int idx) { return aPointList[idx]; }, aPointList.size() );
721 }
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 724 of file opengl_gal.cpp.

References drawPolyline().

725 {
726  drawPolyline( [&](int idx) { return aPointList[idx]; }, aListSize );
727 }
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 730 of file opengl_gal.cpp.

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

731 {
732  auto numPoints = aLineChain.PointCount();
733 
734  if( aLineChain.IsClosed() )
735  numPoints += 1;
736 
737  drawPolyline( [&](int idx) { return aLineChain.CPoint(idx); }, numPoints );
738 }
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 1546 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, KIGFX::GAL::lineWidth, KIGFX::COLOR4D::r, and KIGFX::GAL::strokeColor.

Referenced by drawPolygon(), and DrawPolyline().

1547 {
1548  if( aPointCount < 2 )
1549  return;
1550 
1552  int i;
1553 
1554  for( i = 1; i < aPointCount; ++i )
1555  {
1556  auto start = aPointGetter( i - 1 );
1557  auto end = aPointGetter( i );
1558  const VECTOR2D startEndVector = ( end - start );
1559  double lineAngle = startEndVector.Angle();
1560 
1561  drawLineQuad( start, end );
1562 
1563  // There is no need to draw line caps on both ends of polyline's segments
1564  drawFilledSemiCircle( start, lineWidth / 2, lineAngle + M_PI / 2 );
1565  }
1566 
1567  // ..and now - draw the ending cap
1568  auto start = aPointGetter( i - 2 );
1569  auto end = aPointGetter( i - 1 );
1570  const VECTOR2D startEndVector = ( end - start );
1571  double lineAngle = startEndVector.Angle();
1572  drawFilledSemiCircle( end, lineWidth / 2, lineAngle - M_PI / 2 );
1573 }
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:304
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:308
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 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 680 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().

681 {
682  // Compute the diagonal points of the rectangle
683  VECTOR2D diagonalPointA( aEndPoint.x, aStartPoint.y );
684  VECTOR2D diagonalPointB( aStartPoint.x, aEndPoint.y );
685 
686  // Stroke the outline
687  if( isStrokeEnabled )
688  {
690 
691  std::deque<VECTOR2D> pointList;
692  pointList.push_back( aStartPoint );
693  pointList.push_back( diagonalPointA );
694  pointList.push_back( aEndPoint );
695  pointList.push_back( diagonalPointB );
696  pointList.push_back( aStartPoint );
697  DrawPolyline( pointList );
698  }
699 
700  // Fill the rectangle
701  if( isFillEnabled )
702  {
703  currentManager->Reserve( 6 );
706 
707  currentManager->Vertex( aStartPoint.x, aStartPoint.y, layerDepth );
708  currentManager->Vertex( diagonalPointA.x, diagonalPointA.y, layerDepth );
709  currentManager->Vertex( aEndPoint.x, aEndPoint.y, layerDepth );
710 
711  currentManager->Vertex( aStartPoint.x, aStartPoint.y, layerDepth );
712  currentManager->Vertex( aEndPoint.x, aEndPoint.y, layerDepth );
713  currentManager->Vertex( diagonalPointB.x, diagonalPointB.y, layerDepth );
714  }
715 }
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:304
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:718
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 419 of file opengl_gal.cpp.

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

Referenced by IsVisible().

421 {
422  VECTOR2D startEndVector = aEndPoint - aStartPoint;
423  double lineAngle = startEndVector.Angle();
424 
425  if( isFillEnabled )
426  {
427  // Filled tracks
429 
430  SetLineWidth( aWidth );
431  drawLineQuad( aStartPoint, aEndPoint );
432 
433  // Draw line caps
434  drawFilledSemiCircle( aStartPoint, aWidth / 2, lineAngle + M_PI / 2 );
435  drawFilledSemiCircle( aEndPoint, aWidth / 2, lineAngle - M_PI / 2 );
436  }
437  else
438  {
439  // Outlined tracks
440  double lineLength = startEndVector.EuclideanNorm();
441 
443 
444  Save();
445 
446  currentManager->Translate( aStartPoint.x, aStartPoint.y, 0.0 );
447  currentManager->Rotate( lineAngle, 0.0f, 0.0f, 1.0f );
448 
449  drawLineQuad( VECTOR2D( 0.0, aWidth / 2.0 ),
450  VECTOR2D( lineLength, aWidth / 2.0 ) );
451 
452  drawLineQuad( VECTOR2D( 0.0, -aWidth / 2.0 ),
453  VECTOR2D( lineLength, -aWidth / 2.0 ) );
454 
455  // Draw line caps
456  drawStrokedSemiCircle( VECTOR2D( 0.0, 0.0 ), aWidth / 2, M_PI / 2 );
457  drawStrokedSemiCircle( VECTOR2D( lineLength, 0.0 ), aWidth / 2, -M_PI / 2 );
458 
459  Restore();
460  }
461 }
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:304
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:308
virtual void Save() override
Save the context.
double a
Alpha component.
Definition: color4d.h:294
virtual void SetLineWidth(double aLineWidth)
Set the line width.
T EuclideanNorm() const
Destructor.
Definition: vector2d.h:294
VECTOR2< double > VECTOR2D
Definition: vector2d.h:588
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 drawFilledSemiCircle(const VECTOR2D &aCenterPoint, double aRadius, double aAngle)
Draw a filled semicircle.
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 1429 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.

1430 {
1431  if( isFillEnabled )
1432  {
1434  drawFilledSemiCircle( aCenterPoint, aRadius, aAngle );
1435  }
1436 
1437  if( isStrokeEnabled )
1438  {
1440  drawStrokedSemiCircle( aCenterPoint, aRadius, aAngle );
1441  }
1442 }
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:304
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 1476 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().

1478 {
1479  double outerRadius = aRadius + ( lineWidth / 2 );
1480 
1481  Save();
1482 
1483  currentManager->Reserve( 3 );
1484  currentManager->Translate( aCenterPoint.x, aCenterPoint.y, 0.0f );
1485  currentManager->Rotate( aAngle, 0.0f, 0.0f, 1.0f );
1486 
1487  /* Draw a triangle that contains the semicircle, then shade it to leave only
1488  * the semicircle. Parameters given to Shader() are indices of the triangle's vertices
1489  * (if you want to understand more, check the vertex shader source [shader.vert]), the
1490  * radius and the line width. Shader uses these coordinates to determine if fragments are
1491  * inside the semicircle or not.
1492  * v2
1493  * /\
1494  * /__\
1495  * v0 //__\\ v1
1496  */
1498  currentManager->Vertex( -outerRadius * 3.0f / sqrt( 3.0f ), 0.0f, layerDepth ); // v0
1499 
1501  currentManager->Vertex( outerRadius * 3.0f / sqrt( 3.0f ), 0.0f, layerDepth ); // v1
1502 
1504  currentManager->Vertex( 0.0f, outerRadius * 2.0f, layerDepth ); // v2
1505 
1506  Restore();
1507 }
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:304
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 774 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, SHAPE_POLY_SET::OutlineCount(), SHAPE_POLY_SET::Polygon(), KIGFX::COLOR4D::r, KIGFX::VERTEX_MANAGER::Shader(), KIGFX::SHADER_NONE, SHAPE_POLY_SET::TriangulatedPolygon(), KIGFX::VERTEX_MANAGER::Vertex(), VECTOR2< T >::x, and VECTOR2< T >::y.

Referenced by DrawPolygon().

775 {
778 
779 
780  if ( isFillEnabled )
781  {
782  for( int j = 0; j < aPolySet.OutlineCount(); ++j )
783  {
784  auto triPoly = aPolySet.TriangulatedPolygon( j );
785 
786  for( int i = 0; i < triPoly->GetTriangleCount(); i++ )
787  {
788  VECTOR2I a, b, c;
789  triPoly->GetTriangle( i ,a,b,c);
790  currentManager->Vertex( a.x, a.y, layerDepth );
791  currentManager->Vertex( b.x, b.y, layerDepth );
792  currentManager->Vertex( c.x, c.y, layerDepth );
793  }
794  }
795  }
796 
797  if( isStrokeEnabled )
798  {
799  for( int j = 0; j < aPolySet.OutlineCount(); ++j )
800  {
801  const auto& poly = aPolySet.Polygon( j );
802 
803  for( const auto& lc : poly )
804  {
805  DrawPolyline( lc );
806  }
807  }
808  }
809 }
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:304
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:718
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::EndDrawing ( )
overridevirtual

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

Reimplemented from KIGFX::GAL.

Definition at line 344 of file opengl_gal.cpp.

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

Referenced by IsVisible().

345 {
346 #ifdef __WXDEBUG__
347  PROF_COUNTER totalRealTime( "OPENGL_GAL::EndDrawing()", true );
348 #endif /* __WXDEBUG__ */
349 
350  // Cached & non-cached containers are rendered to the same buffer
354 
355  // Overlay container is rendered to a different buffer
358 
359  // Be sure that the framebuffer is not colorized (happens on specific GPU&drivers combinations)
360  glColor4d( 1.0, 1.0, 1.0, 1.0 );
361 
362  // Draw the remaining contents, blit the rendering targets to the screen, swap the buffers
365  compositor->Present();
366  blitCursor();
367 
368  SwapBuffers();
370 
371 #ifdef __WXDEBUG__
372  totalRealTime.Stop();
373  wxLogTrace( "GAL_PROFILE", wxT( "OPENGL_GAL::EndDrawing(): %.1f ms" ), totalRealTime.msecs() );
374 #endif /* __WXDEBUG__ */
375 }
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:312
VERTEX_MANAGER * overlayManager
Container for storing overlaid VERTEX_ITEMs.
Definition: opengl_gal.h:307
The class PROF_COUNTER is a small class to help profiling.
Definition: profile.h:45
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:306
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:310
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:311
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:305
wxGLContext * glPrivContext
Canvas-specific OpenGL context.
Definition: opengl_gal.h:293
void OPENGL_GAL::EndGroup ( )
overridevirtual

End the group.

Reimplemented from KIGFX::GAL.

Definition at line 1256 of file opengl_gal.cpp.

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

Referenced by IsVisible().

1257 {
1259  isGrouping = false;
1260 }
bool isGrouping
Was a group started?
Definition: opengl_gal.h:324
VERTEX_MANAGER * cachedManager
Container for storing cached VERTEX_ITEMs.
Definition: opengl_gal.h:305
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 391 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().

392 {
393  if( !isInitialized )
394  return;
395 
396  cachedManager->Unmap();
398 }
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:305
bool isInitialized
Basic initialization flag, has to be done when the window is visible.
Definition: opengl_gal.h:322
wxGLContext * glPrivContext
Canvas-specific OpenGL context.
Definition: opengl_gal.h:293
void OPENGL_GAL::Flush ( )
overridevirtual

Force all remaining objects to be drawn.

Reimplemented from KIGFX::GAL.

Definition at line 1180 of file opengl_gal.cpp.

Referenced by IsVisible().

1181 {
1182  glFlush();
1183 }
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 206 of file graphics_abstraction_layer.h.

References KIGFX::GAL::m_clearColor.

207  {
208  return m_clearColor;
209  }
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.
double KIGFX::GAL::GetGridLineWidth ( ) const
inlineinherited

Get the grid line width.

Returns
the grid line width

Definition at line 884 of file graphics_abstraction_layer.h.

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

885  {
886  return gridLineWidth;
887  }
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(), and KIGFX::WX_VIEW_CONTROLS::GetRawCursorPosition().

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)
KiROUND rounds a floating point number to an int using "round halfway cases away from zero"...
Definition: common.h:107
VECTOR2< double > VECTOR2D
Definition: vector2d.h:588
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 836 of file graphics_abstraction_layer.h.

References KIGFX::GAL::gridSize.

837  {
838  return gridSize;
839  }
VECTOR2D gridSize
The grid size.
EDA_TEXT_HJUSTIFY_T KIGFX::GAL::GetHorizontalJustify ( ) const
inlineinherited

Returns current text horizontal justification setting.

Definition at line 468 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().

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

Get the look at point.

Returns
the look at point.

Definition at line 663 of file graphics_abstraction_layer.h.

References KIGFX::GAL::lookAtPoint.

664  {
665  return lookAtPoint;
666  }
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 712 of file graphics_abstraction_layer.h.

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

713  {
714  return depthRange.y;
715  }
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 704 of file graphics_abstraction_layer.h.

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

705  {
706  return depthRange.x;
707  }
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 1753 of file opengl_gal.cpp.

References groupCounter, groups, and max.

Referenced by BeginGroup().

1754 {
1755  wxASSERT_MSG( groups.size() < std::numeric_limits<unsigned int>::max(),
1756  wxT( "There are no free slots to store a group" ) );
1757 
1758  while( groups.find( groupCounter ) != groups.end() )
1759  {
1760  groupCounter++;
1761  }
1762 
1763  return groupCounter++;
1764 }
GROUPS_MAP groups
Stores informations about VBO objects (groups)
Definition: opengl_gal.h:302
#define max(a, b)
Definition: auxiliary.h:86
unsigned int groupCounter
Counter used for generating keys for groups.
Definition: opengl_gal.h:303
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 363 of file graphics_abstraction_layer.h.

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

364  {
366  }
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 604 of file graphics_abstraction_layer.h.

References KIGFX::GAL::screenWorldMatrix.

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

605  {
606  return screenWorldMatrix;
607  }
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 266 of file graphics_abstraction_layer.h.

References KIGFX::GAL::strokeColor.

267  {
268  return strokeColor;
269  }
COLOR4D strokeColor
The color of the outlines.
const STROKE_FONT& KIGFX::GAL::GetStrokeFont ( ) const
inlineinherited

Definition at line 308 of file graphics_abstraction_layer.h.

References KIGFX::GAL::strokeFont.

Referenced by EDA_TEXT::GetTextBox().

309  {
310  return strokeFont;
311  }
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 1331 of file opengl_gal.cpp.

References currentTarget.

Referenced by IsVisible().

1332 {
1333  return currentTarget;
1334 }
RENDER_TARGET currentTarget
Current rendering target.
Definition: opengl_gal.h:313
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 486 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().

487  {
489  }
EDA_TEXT_VJUSTIFY_T m_verticalJustify
Vertical justification.
struct KIGFX::GAL::TEXT_PROPERTIES textProperties
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 594 of file graphics_abstraction_layer.h.

References KIGFX::GAL::worldScreenMatrix.

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

595  {
596  return worldScreenMatrix;
597  }
MATRIX3x3D worldScreenMatrix
World transformation.
double KIGFX::GAL::GetZoomFactor ( ) const
inlineinherited

Get the zoom factor.

Returns
the zoom factor.

Definition at line 683 of file graphics_abstraction_layer.h.

References KIGFX::GAL::zoomFactor.

Referenced by EDA_DRAW_PANEL_GAL::GetLegacyZoom(), EDA_DRAW_FRAME::GetZoomLevelIndicator(), EDA_DRAW_FRAME::UseGalCanvas(), and COMMON_TOOLS::ZoomPreset().

684  {
685  return zoomFactor;
686  }
double zoomFactor
The zoom factor.
void OPENGL_GAL::init ( )
private

Basic OpenGL initialization.

Definition at line 1767 of file opengl_gal.cpp.

References cachedManager, enableGlDebug(), KIGFX::BUILTIN_FONT::font_image, GL_CONTEXT_MANAGER::Get(), glPrivContext, 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(), GL_CONTEXT_MANAGER::LockCtx(), nonCachedManager, overlayManager, KIGFX::VERTEX_MANAGER::SetShader(), shader, KIGFX::SHADER_TYPE_FRAGMENT, KIGFX::SHADER_TYPE_VERTEX, GL_CONTEXT_MANAGER::UnlockCtx(), and KIGFX::BUILTIN_FONT::FONT_IMAGE_TYPE::width.

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

1768 {
1769  wxASSERT( IsShownOnScreen() );
1770 
1772 
1773  GLenum err = glewInit();
1774 
1775  try
1776  {
1777  if( GLEW_OK != err )
1778  throw std::runtime_error( (const char*) glewGetErrorString( err ) );
1779 
1780  // Check the OpenGL version (minimum 2.1 is required)
1781  if( !GLEW_VERSION_2_1 )
1782  throw std::runtime_error( "OpenGL 2.1 or higher is required!" );
1783 
1784 #if defined (__LINUX__) // calling enableGlDebug crashes opengl on some OS (OSX and some Windows)
1785 #ifdef DEBUG
1786  if( GLEW_ARB_debug_output )
1787  enableGlDebug( true );
1788 #endif
1789 #endif
1790 
1791  // Framebuffers have to be supported
1792  if( !GLEW_EXT_framebuffer_object )
1793  throw std::runtime_error( "Framebuffer objects are not supported!" );
1794 
1795  // Vertex buffer has to be supported
1796  if( !GLEW_ARB_vertex_buffer_object )
1797  throw std::runtime_error( "Vertex buffer objects are not supported!" );
1798 
1799  // Prepare shaders
1801  throw std::runtime_error( "Cannot compile vertex shader!" );
1802 
1804  throw std::runtime_error( "Cannot compile fragment shader!" );
1805 
1806  if( !shader->IsLinked() && !shader->Link() )
1807  throw std::runtime_error( "Cannot link the shaders!" );
1808 
1809  // Check if video card supports textures big enough to fit the font atlas
1810  int maxTextureSize;
1811  glGetIntegerv( GL_MAX_TEXTURE_SIZE, &maxTextureSize );
1812 
1813  if( maxTextureSize < (int) font_image.width || maxTextureSize < (int)font_image.height )
1814  {
1815  // TODO implement software texture scaling
1816  // for bitmap fonts and use a higher resolution texture?
1817  throw std::runtime_error( "Requested texture size is not supported" );
1818  }
1819  }
1820  catch( std::runtime_error& )
1821  {
1823  throw;
1824  }
1825 
1826  cachedManager = new VERTEX_MANAGER( true );
1827  nonCachedManager = new VERTEX_MANAGER( false );
1828  overlayManager = new VERTEX_MANAGER( false );
1829 
1830  // Make VBOs use shaders
1834 
1836  isInitialized = true;
1837 }
static SHADER * shader
There is only one shader used for different objects.
Definition: opengl_gal.h:316
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:307
Fragment shader.
Definition: shader.h:45
bool Link()
Link the shaders.
Definition: shader.cpp:96
void UnlockCtx(wxGLContext *aContext)
Function UnlockCtx allows other canvases to bind an OpenGL context.
void enableGlDebug(bool aEnable)
Enables/disables OpenGL driver messages output.
Definition: utils.cpp:103
VERTEX_MANAGER * nonCachedManager
Container for storing non-cached VERTEX_ITEMs.
Definition: opengl_gal.h:306
static GL_CONTEXT_MANAGER & Get()
Function Get returns the GL_CONTEXT_MANAGER instance (singleton).
FONT_IMAGE_TYPE font_image
Definition: gl_resources.cpp:4
Vertex shader.
Definition: shader.h:44
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:305
bool isInitialized
Basic initialization flag, has to be done when the window is visible.
Definition: opengl_gal.h:322
wxGLContext * glPrivContext
Canvas-specific OpenGL context.
Definition: opengl_gal.h:293
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 937 of file graphics_abstraction_layer.h.

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

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

938  {
940  }
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 414 of file graphics_abstraction_layer.h.

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

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

415  {
416  return textProperties.m_bold;
417  }
struct KIGFX::GAL::TEXT_PROPERTIES textProperties
bool KIGFX::GAL::IsFontItalic ( ) const
inlineinherited

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

Definition at line 432 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().

433  {
434  return textProperties.m_italic;
435  }
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 89 of file opengl_gal.h.

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

Returns true if text should displayed mirrored.

Definition at line 450 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().

451  {
452  return textProperties.m_mirrored;
453  }
struct KIGFX::GAL::TEXT_PROPERTIES textProperties
bool KIGFX::OPENGL_GAL::IsVisible ( ) const
inlineoverridevirtual
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 1707 of file opengl_gal.cpp.

References PostPaint().

Referenced by OPENGL_GAL().

1708 {
1709  PostPaint();
1710 }
void PostPaint()
Function PostPaint posts an event to m_paint_listener.
Definition: opengl_gal.h:256
void KIGFX::GAL::PopDepth ( )
inlineinherited

Restores previously stored drawing depth for the depth stack.

Definition at line 979 of file graphics_abstraction_layer.h.

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

980  {
981  layerDepth = depthStack.top();
982  depthStack.pop();
983  }
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 256 of file opengl_gal.h.

References paintListener.

Referenced by onPaint().

257  {
258  if( paintListener )
259  {
260  wxPaintEvent redrawEvent;
261  wxPostEvent( paintListener, redrawEvent );
262  }
263  }
wxEvtHandler * paintListener
Definition: opengl_gal.h:296
void KIGFX::GAL::PushDepth ( )
inlineinherited

Stores current drawing depth on the depth stack.

Definition at line 971 of file graphics_abstraction_layer.h.

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

972  {
973  depthStack.push( layerDepth );
974  }
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 1156 of file opengl_gal.cpp.

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

Referenced by IsVisible().

1157 {
1158  screenSize = VECTOR2I( aWidth, aHeight );
1159 
1160  // Resize framebuffers
1161  const float scaleFactor = GetBackingScaleFactor();
1162  compositor->Resize( aWidth * scaleFactor, aHeight * scaleFactor );
1163  isFramebufferInitialized = false;
1164 
1165  wxGLCanvas::SetSize( aWidth, aHeight );
1166 }
VECTOR2< int > VECTOR2I
Definition: vector2d.h:589
OPENGL_COMPOSITOR * compositor
Handles multiple rendering targets.
Definition: opengl_gal.h:310
bool isFramebufferInitialized
Are the framebuffers initialized?
Definition: opengl_gal.h:319
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 1238 of file opengl_gal.cpp.

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

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

1239 {
1241 }
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:304
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 1303 of file opengl_gal.cpp.

Referenced by IsVisible().

1304 {
1305  wxASSERT_MSG( false, wxT( "Not implemented yet" ) );
1306 }
void OPENGL_GAL::Rotate ( double  aAngle)
overridevirtual

Rotate the context.

Parameters
aAngleis the rotation angle in radians.

Reimplemented from KIGFX::GAL.

Definition at line 1214 of file opengl_gal.cpp.

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

Referenced by IsVisible().

1215 {
1216  currentManager->Rotate( aAngle, 0.0f, 0.0f, 1.0f );
1217 }
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:304
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 1232 of file opengl_gal.cpp.

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

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

1233 {
1235 }
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:304
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 1297 of file opengl_gal.cpp.

Referenced by IsVisible().

1298 {
1299  wxASSERT_MSG( false, wxT( "Not implemented yet" ) );
1300 }
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 1226 of file opengl_gal.cpp.

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

Referenced by IsVisible().

1227 {
1228  currentManager->Scale( aScale.x, aScale.y, 0.0f );
1229 }
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:304
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 856 of file graphics_abstraction_layer.h.

References KIGFX::GAL::axesColor.

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

857  {
858  axesColor = aAxesColor;
859  }
COLOR4D axesColor
Color of the axes.
void KIGFX::GAL::SetAxesEnabled ( bool  aAxesEnabled)
inlineinherited

Enables drawing the axes.

Definition at line 864 of file graphics_abstraction_layer.h.

References KIGFX::GAL::axesEnabled.

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

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

Definition at line 201 of file graphics_abstraction_layer.h.

References KIGFX::GAL::m_clearColor.

Referenced by EDA_DRAW_PANEL_GAL::onPaint().

202  {
203  m_clearColor = aColor;
204  }
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 874 of file graphics_abstraction_layer.h.

References KIGFX::GAL::gridTick.

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

875  {
876  gridTick = aInterval;
877  }
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 947 of file graphics_abstraction_layer.h.

References KIGFX::GAL::cursorColor.

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

948  {
949  cursorColor = aCursorColor;
950  }
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 928 of file graphics_abstraction_layer.h.

References KIGFX::GAL::isCursorEnabled.

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

929  {
930  isCursorEnabled = aCursorEnabled;
931  }
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 696 of file graphics_abstraction_layer.h.

References KIGFX::GAL::depthRange.

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

697  {
698  depthRange = aDepthRange;
699  }
VECTOR2D depthRange
Range of the depth.
virtual void KIGFX::GAL::SetFillColor ( const COLOR4D aColor)
inlinevirtualinherited

Set the fill color.

Parameters
aColoris the color for filling.

Reimplemented in KIGFX::CAIRO_GAL.

Definition at line 246 of file graphics_abstraction_layer.h.

References KIGFX::GAL::fillColor.

Referenced by BeginDrawing(), KIGFX::WORKSHEET_VIEWITEM::draw(), KIGFX::GERBVIEW_PAINTER::draw(), KIGFX::PCB_PAINTER::draw(), KIGFX::GAL::DrawGrid(), KIGFX::GAL::GAL(), KIGFX::PREVIEW::SIMPLE_OVERLAY_ITEM::setupGal(), and EDIT_POINTS::ViewDraw().

247  {
248  fillColor = aColor;
249  }
COLOR4D fillColor
The fill color.
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 733 of file graphics_abstraction_layer.h.

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

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

734  {
735  globalFlipX = xAxis;
736  globalFlipY = yAxis;
737  }
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 406 of file graphics_abstraction_layer.h.

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

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

407  {
408  textProperties.m_bold = aBold;
409  }
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 424 of file graphics_abstraction_layer.h.

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

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

425  {
426  textProperties.m_italic = aItalic;
427  }
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 388 of file graphics_abstraction_layer.h.

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

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

389  {
390  textProperties.m_glyphSize = aGlyphSize;
391  }
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 846 of file graphics_abstraction_layer.h.

References KIGFX::GAL::gridColor.

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

847  {
848  gridColor = aGridColor;
849  }
COLOR4D gridColor
Color of the grid.
void KIGFX::GAL::SetGridOrigin ( const VECTOR2D aGridOrigin)
inlineinherited

Set the origin point for the grid.

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

Definition at line 807 of file graphics_abstraction_layer.h.

References KIGFX::GAL::gridOffset, KIGFX::GAL::gridOrigin, KIGFX::GAL::gridSize, VECTOR2< T >::x, and VECTOR2< T >::y.

Referenced by PCBNEW_CONTROL::DoSetGridOrigin(), PCB_BASE_EDIT_FRAME::SetBoard(), and EDA_DRAW_FRAME::UseGalCanvas().

808  {
809  gridOrigin = aGridOrigin;
810 
811  if( gridSize.x == 0.0 || gridSize.y == 0.0 )
812  gridOffset = VECTOR2D(0.0, 0.0);
813  else
814  gridOffset = VECTOR2D( (long) gridOrigin.x % (long) gridSize.x,
815  (long) gridOrigin.y % (long) gridSize.y );
816  }
VECTOR2D gridOffset
The grid offset to compensate cursor position.
VECTOR2< double > VECTOR2D
Definition: vector2d.h:588
VECTOR2D gridOrigin
The grid origin.
VECTOR2D gridSize
The grid size.
void KIGFX::GAL::SetGridSize ( const VECTOR2D aGridSize)
inlineinherited

Set the grid size.

Parameters
aGridSizeis a vector containing the grid size in x and y direction.

Definition at line 823 of file graphics_abstraction_layer.h.

References KIGFX::GAL::gridOffset, KIGFX::GAL::gridOrigin, KIGFX::GAL::gridSize, VECTOR2< T >::x, and VECTOR2< T >::y.

Referenced by DIALOG_PAD_PROPERTIES::prepareCanvas(), COMMON_TOOLS::updateGrid(), PCBNEW_CONTROL::updateGrid(), and EDA_DRAW_FRAME::UseGalCanvas().

824  {
825  gridSize = aGridSize;
826 
827  gridOffset = VECTOR2D( (long) gridOrigin.x % (long) gridSize.x,
828  (long) gridOrigin.y % (long) gridSize.y );
829  }
VECTOR2D gridOffset
The grid offset to compensate cursor position.
VECTOR2< double > VECTOR2D
Definition: vector2d.h:588
VECTOR2D gridOrigin
The grid origin.
VECTOR2D gridSize
The grid size.
void KIGFX::GAL::SetGridVisibility ( bool  aVisibility)
inlineinherited

Sets the visibility setting of the grid.

Parameters
aVisibilityis the new visibility setting of the grid.

Definition at line 797 of file graphics_abstraction_layer.h.

References KIGFX::GAL::gridVisibility.

Referenced by KIGFX::GAL::GAL(), GERBER_LAYER_WIDGET::OnRenderEnable(), PCB_LAYER_WIDGET::OnRenderEnable(), EDA_DRAW_FRAME::OnToggleGridState(), and EDA_DRAW_FRAME::UseGalCanvas().

798  {
799  gridVisibility = aVisibility;
800  }
bool gridVisibility
Should the grid be shown.
void KIGFX::GAL::SetHorizontalJustify ( const EDA_TEXT_HJUSTIFY_T  aHorizontalJustify)
inlineinherited

Set the horizontal justify for text drawing.

Parameters
aHorizontalJustifyis the horizontal justify value.

Definition at line 460 of file graphics_abstraction_layer.h.

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

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

461  {
462  textProperties.m_horizontalJustify = aHorizontalJustify;
463  }
struct KIGFX::GAL::TEXT_PROPERTIES textProperties
EDA_TEXT_HJUSTIFY_T m_horizontalJustify
Horizontal justification.
virtual void KIGFX::GAL::SetIsFill ( bool  aIsFillEnabled)
inlinevirtualinherited

Enable/disable fill.

Parameters
aIsFillEnabledis true, when the graphics objects should be filled, else false.

Reimplemented in KIGFX::CAIRO_GAL.

Definition at line 226 of file graphics_abstraction_layer.h.

References KIGFX::GAL::isFillEnabled.

Referenced by KIGFX::WORKSHEET_VIEWITEM::draw(), KIGFX::GERBVIEW_PAINTER::draw(), KIGFX::PCB_PAINTER::draw(), KIGFX::WORKSHEET_VIEWITEM::drawBorder(), KIGFX::GERBVIEW_PAINTER::drawFlashedShape(), DrawGraphicText(), KIGFX::GAL::DrawGrid(), KIGFX::GAL::GAL(), and KIGFX::PREVIEW::SIMPLE_OVERLAY_ITEM::setupGal().

227  {
228  isFillEnabled = aIsFillEnabled;
229  }
bool isFillEnabled
Is filling of graphic objects enabled ?
virtual void KIGFX::GAL::SetIsStroke ( bool  aIsStrokeEnabled)
inlinevirtualinherited
virtual void KIGFX::GAL::SetLayerDepth ( double  aLayerDepth)
inlinevirtualinherited

Set the depth of the layer (position on the z-axis)

Parameters
aLayerDepththe layer depth for the objects.

Reimplemented in KIGFX::CAIRO_GAL.

Definition at line 296 of file graphics_abstraction_layer.h.

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

Referenced by KIGFX::VIEW::draw(), KIGFX::GAL::DrawGrid(), KIGFX::GAL::GAL(), KIGFX::VIEW::redrawRect(), KIGFX::CAIRO_GAL::SetLayerDepth(), KIGFX::VIEW::updateItemGeometry(), and ROUTER_PREVIEW_ITEM::ViewDraw().

297  {
298  assert( aLayerDepth <= depthRange.y );
299  assert( aLayerDepth >= depthRange.x );
300 
301  layerDepth = aLayerDepth;
302  }
double layerDepth
The actual layer depth.
VECTOR2D depthRange
Range of the depth.
void KIGFX::GAL::SetLookAtPoint ( const VECTOR2D aPoint)
inlineinherited

Set the Point in world space to look at.

This point corresponds with the center of the actual drawing area.

Parameters
aPointis the look at point (center of the actual drawing area).

Definition at line 653 of file graphics_abstraction_layer.h.

References KIGFX::GAL::lookAtPoint.

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

654  {
655  lookAtPoint = aPoint;
656  }
VECTOR2D lookAtPoint
Point to be looked at in world space.
void KIGFX::OPENGL_GAL::SetMouseListener ( wxEvtHandler *  aMouseListener)
inline

Definition at line 265 of file opengl_gal.h.

References mouseListener.

266  {
267  mouseListener = aMouseListener;
268  }
wxEvtHandler * mouseListener
Definition: opengl_gal.h:295
virtual void KIGFX::OPENGL_GAL::SetNegativeDrawMode ( bool  aSetting)
inlineoverridevirtual

Sets negative draw mode in the renderer.

When negative mode is enabled, drawn items will subtract from previously drawn items. This is mainly needed for Gerber negative item support in Cairo, since unlike in OpenGL, objects drawn with zero opacity on top of other objects would not normally mask objects in Cairo. This method is a no-op in OpenGL.

Parameters
aSettingis true if negative mode should be enabled

Reimplemented from KIGFX::GAL.

Definition at line 242 of file opengl_gal.h.

References DrawCursor().

242 {}
void KIGFX::OPENGL_GAL::SetPaintListener ( wxEvtHandler *  aPaintListener)
inline

Parameters passed to the GLU tesselator.

Definition at line 270 of file opengl_gal.h.

References paintListener.

void KIGFX::GAL::SetScreenDPI ( double  aScreenDPI)
inlineinherited

Set the dots per inch of the screen.

This value depends on the user screen, it should be configurable by the application. For instance a typical notebook with HD+ resolution (1600x900) has 106 DPI.

Parameters
aScreenDPIare the screen DPI.

Definition at line 641 of file graphics_abstraction_layer.h.

References KIGFX::GAL::screenDPI.

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

642  {
643  screenDPI = aScreenDPI;
644  }
double screenDPI
The dots per inch of the screen.
virtual void KIGFX::GAL::SetStrokeColor ( const COLOR4D aColor)
inlinevirtualinherited

Set the stroke color.

Parameters
aColoris the color for stroking the outline.

Reimplemented in KIGFX::CAIRO_GAL.

Definition at line 256 of file graphics_abstraction_layer.h.

References KIGFX::GAL::strokeColor.

Referenced by BeginDrawing(), KIGFX::WORKSHEET_VIEWITEM::draw(), KIGFX::GERBVIEW_PAINTER::draw(), KIGFX::PCB_PAINTER::draw(), KIGFX::WORKSHEET_VIEWITEM::drawBorder(), KIGFX::GAL::DrawGrid(), KIGFX::GAL::GAL(), and KIGFX::PREVIEW::SIMPLE_OVERLAY_ITEM::setupGal().

257  {
258  strokeColor = aColor;
259  }
COLOR4D strokeColor
The color of the outlines.
void OPENGL_GAL::SetTarget ( RENDER_TARGET  aTarget)
overridevirtual

Sets the target for rendering.