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

Protected Member Functions

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

Protected Attributes

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

Static Protected Attributes

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

Private Types

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

Private Member Functions

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

Private Attributes

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

Static Private Attributes

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

Detailed Description

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

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

Definition at line 65 of file opengl_gal.h.

Member Typedef Documentation

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

Definition at line 295 of file opengl_gal.h.

typedef GAL KIGFX::OPENGL_GAL::super
private

Super class definition.

Definition at line 281 of file opengl_gal.h.

Constructor & Destructor Documentation

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

Constructor OPENGL_GAL.

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

Definition at line 165 of file opengl_gal.cpp.

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

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

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

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

References KIGFX::GAL::layerDepth.

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

1014  {
1015  layerDepth -= 0.05;
1016  }
double layerDepth
The actual layer depth.
void OPENGL_GAL::beginDrawing ( )
overrideprivatevirtual

Reimplemented from KIGFX::GAL.

Definition at line 336 of file opengl_gal.cpp.

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

337 {
338 #ifdef __WXDEBUG__
339  PROF_COUNTER totalRealTime( "OPENGL_GAL::beginDrawing()", true );
340 #endif /* __WXDEBUG__ */
341 
342  wxASSERT_MSG( isContextLocked, "GAL_DRAWING_CONTEXT RAII object should have locked context. "
343  "Calling GAL::beginDrawing() directly is not allowed." );
344 
345  wxASSERT_MSG( IsVisible(), "GAL::beginDrawing() must not be entered when GAL is not visible. "
346  "Other drawing routines will expect everything to be initialized "
347  "which will not be the case." );
348 
349  if( !isInitialized )
350  init();
351 
352  // Set up the view port
353  glMatrixMode( GL_PROJECTION );
354  glLoadIdentity();
355 
356  // Create the screen transformation (Do the RH-LH conversion here)
357  glOrtho( 0, (GLint) screenSize.x, (GLsizei) screenSize.y, 0, -depthRange.x, -depthRange.y );
358 
360  {
361  // Prepare rendering target buffers
365 
367  }
368 
369  compositor->Begin();
370 
371  // Disable 2D Textures
372  glDisable( GL_TEXTURE_2D );
373 
374  glShadeModel( GL_FLAT );
375 
376  // Enable the depth buffer
377  glEnable( GL_DEPTH_TEST );
378  glDepthFunc( GL_LESS );
379 
380  // Setup blending, required for transparent objects
381  glEnable( GL_BLEND );
382  glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
383 
384  glMatrixMode( GL_MODELVIEW );
385 
386  // Set up the world <-> screen transformation
388  GLdouble matrixData[16] = { 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1 };
389  matrixData[0] = worldScreenMatrix.m_data[0][0];
390  matrixData[1] = worldScreenMatrix.m_data[1][0];
391  matrixData[2] = worldScreenMatrix.m_data[2][0];
392  matrixData[4] = worldScreenMatrix.m_data[0][1];
393  matrixData[5] = worldScreenMatrix.m_data[1][1];
394  matrixData[6] = worldScreenMatrix.m_data[2][1];
395  matrixData[12] = worldScreenMatrix.m_data[0][2];
396  matrixData[13] = worldScreenMatrix.m_data[1][2];
397  matrixData[14] = worldScreenMatrix.m_data[2][2];
398  glLoadMatrixd( matrixData );
399 
400  // Set defaults
403 
404  // Remove all previously stored items
407 
411 
413  {
414  // Keep bitmap font texture always bound to the second texturing unit
415  const GLint FONT_TEXTURE_UNIT = 2;
416 
417  // Either load the font atlas to video memory, or simply bind it to a texture unit
418  if( !isBitmapFontLoaded )
419  {
420  glActiveTexture( GL_TEXTURE0 + FONT_TEXTURE_UNIT );
421  glGenTextures( 1, &fontTexture );
422  glBindTexture( GL_TEXTURE_2D, fontTexture );
423  glTexImage2D( GL_TEXTURE_2D, 0, GL_RGB8, font_image.width, font_image.height,
424  0, GL_RGB, GL_UNSIGNED_BYTE, font_image.pixels );
425  glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
426  glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
427  checkGlError( "loading bitmap font" );
428 
429  glActiveTexture( GL_TEXTURE0 );
430 
431  isBitmapFontLoaded = true;
432  }
433  else
434  {
435  glActiveTexture( GL_TEXTURE0 + FONT_TEXTURE_UNIT );
436  glBindTexture( GL_TEXTURE_2D, fontTexture );
437  glActiveTexture( GL_TEXTURE0 );
438  }
439 
440  // Set shader parameter
441  GLint ufm_fontTexture = shader->AddParameter( "fontTexture" );
442  GLint ufm_fontTextureWidth = shader->AddParameter( "fontTextureWidth" );
443  ufm_worldPixelSize = shader->AddParameter( "worldPixelSize" );
444 
445  shader->Use();
446  shader->SetParameter( ufm_fontTexture, (int) FONT_TEXTURE_UNIT );
447  shader->SetParameter( ufm_fontTextureWidth, (int) font_image.width );
448  shader->Deactivate();
449  checkGlError( "setting bitmap font sampler as shader parameter" );
450 
452  }
453 
454  shader->Use();
456  shader->Deactivate();
457 
458  // Something betreen BeginDrawing and EndDrawing seems to depend on
459  // this texture unit being active, but it does not assure it itself.
460  glActiveTexture( GL_TEXTURE0 );
461 
462  // Unbind buffers - set compositor for direct drawing
464 
465 #ifdef __WXDEBUG__
466  totalRealTime.Stop();
467  wxLogTrace( "GAL_PROFILE", wxT( "OPENGL_GAL::beginDrawing(): %.1f ms" ), totalRealTime.msecs() );
468 #endif /* __WXDEBUG__ */
469 }
virtual void SetFillColor(const COLOR4D &aColor)
Set the fill color.
double getWorldPixelSize() const
Definition: opengl_gal.cpp:330
static SHADER * shader
There is only one shader used for different objects.
Definition: opengl_gal.h:310
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:306
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:315
void Use()
Use the shader.
Definition: shader.h:130
void SetParameter(int aParameterNumber, float aValue) const
Set a parameter of the shader.
Definition: shader.cpp:138
static GLuint fontTexture
Bitmap font texture handle (shared)
Definition: opengl_gal.h:292
VERTEX_MANAGER * overlayManager
Container for storing overlaid VERTEX_ITEMs.
Definition: opengl_gal.h:301
bool isContextLocked
Used for assertion checking.
Definition: opengl_gal.h:319
COLOR4D fillColor
The fill color.
VECTOR2D depthRange
Range of the depth.
int checkGlError(const std::string &aInfo, bool aThrow)
Checks if one of recent OpenGL operations has failed.
Definition: utils.cpp:30
static const unsigned int DIRECT_RENDERING
virtual void ComputeWorldScreenMatrix()
Compute the world <-> screen transformation matrix.
The class PROF_COUNTER is a small class to help profiling.
Definition: profile.h:45
VERTEX_MANAGER * nonCachedManager
Container for storing non-cached VERTEX_ITEMs.
Definition: opengl_gal.h:300
T m_data[3][3]
Definition: matrix3x3.h:64
void init()
Basic OpenGL initialization.
OPENGL_COMPOSITOR * compositor
Handles multiple rendering targets.
Definition: opengl_gal.h:304
unsigned int mainBuffer
Main rendering target.
Definition: opengl_gal.h:305
COLOR4D strokeColor
The color of the outlines.
int AddParameter(const std::string &aParameterName)
Add a parameter to the parameter queue.
Definition: shader.cpp:125
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:313
FONT_IMAGE_TYPE font_image
Definition: gl_resources.cpp:4
unsigned char pixels[1024 *1024 *3]
Definition: gl_resources.h:38
MATRIX3x3D worldScreenMatrix
World transformation.
virtual void SetBuffer(unsigned int aBufferHandle) override
Function SetBuffer() sets the selected buffer as the rendering target.
void BeginDrawing() const
Function BeginDrawing() prepares buffers and items to start drawing.
VERTEX_MANAGER * cachedManager
Container for storing cached VERTEX_ITEMs.
Definition: opengl_gal.h:299
virtual void Initialize() override
Function Reset() performs primary initialiation, necessary to use the object.
GLint ufm_worldPixelSize
Definition: opengl_gal.h:321
virtual void SetStrokeColor(const COLOR4D &aColor)
Set the stroke color.
bool isInitialized
Basic initialization flag, has to be done when the window is visible.
Definition: opengl_gal.h:316
VECTOR2I screenSize
Screen size in screen coordinates.
virtual unsigned int CreateBuffer() override
Function CreateBuffer() prepares a new buffer that may be used as a rendering target.
bool IsVisible() const override
>
Definition: opengl_gal.h:97
static bool isBitmapFontLoaded
Is the bitmap font texture loaded?
Definition: opengl_gal.h:314
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 1445 of file opengl_gal.cpp.

References getNewGroupNumber(), groups, and isGrouping.

Referenced by IsVisible().

1446 {
1447  isGrouping = true;
1448 
1449  std::shared_ptr<VERTEX_ITEM> newItem = std::make_shared<VERTEX_ITEM>( *cachedManager );
1450  int groupNumber = getNewGroupNumber();
1451  groups.insert( std::make_pair( groupNumber, newItem ) );
1452 
1453  return groupNumber;
1454 }
bool isGrouping
Was a group started?
Definition: opengl_gal.h:318
GROUPS_MAP groups
Stores informations about VBO objects (groups)
Definition: opengl_gal.h:296
unsigned int getNewGroupNumber()
Returns a valid key that can be used as a new group number.
void OPENGL_GAL::beginUpdate ( )
overrideprivatevirtual

Reimplemented from KIGFX::GAL.

Definition at line 531 of file opengl_gal.cpp.

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

532 {
533  wxASSERT_MSG( isContextLocked, "GAL_UPDATE_CONTEXT RAII object should have locked context. "
534  "Calling this from anywhere else is not allowed." );
535 
536  wxASSERT_MSG( IsVisible(), "GAL::beginUpdate() must not be entered when GAL is not visible. "
537  "Other update routines will expect everything to be initialized "
538  "which will not be the case." );
539 
540  if( !isInitialized )
541  init();
542 
543  cachedManager->Map();
544 }
bool isContextLocked
Used for assertion checking.
Definition: opengl_gal.h:319
void init()
Basic OpenGL initialization.
void Map()
Function Map() maps vertex buffer.
VERTEX_MANAGER * cachedManager
Container for storing cached VERTEX_ITEMs.
Definition: opengl_gal.h:299
bool isInitialized
Basic initialization flag, has to be done when the window is visible.
Definition: opengl_gal.h:316
bool IsVisible() const override
>
Definition: opengl_gal.h:97
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 1075 of file opengl_gal.cpp.

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

Referenced by IsVisible().

1077 {
1078  wxASSERT_MSG( !IsTextMirrored(), "No support for mirrored text using bitmap fonts." );
1079 
1080  auto processedText = ProcessOverbars( aText );
1081  const auto& text = processedText.first;
1082  const auto& overbars = processedText.second;
1083 
1084  // Compute text size, so it can be properly justified
1085  VECTOR2D textSize;
1086  float commonOffset;
1087  std::tie( textSize, commonOffset ) = computeBitmapTextSize( text );
1088 
1089  const double SCALE = 1.4 * GetGlyphSize().y / textSize.y;
1090  bool overbar = false;
1091 
1092  int overbarLength = 0;
1093  double overbarHeight = textSize.y;
1094 
1095  Save();
1096 
1098  currentManager->Translate( aPosition.x, aPosition.y, layerDepth );
1099  currentManager->Rotate( aRotationAngle, 0.0f, 0.0f, -1.0f );
1100 
1101  double sx = SCALE * ( globalFlipX ? -1.0 : 1.0 );
1102  double sy = SCALE * ( globalFlipY ? -1.0 : 1.0 );
1103 
1104  currentManager->Scale( sx, sy, 0 );
1105  currentManager->Translate( 0, -commonOffset, 0 );
1106 
1107  switch( GetHorizontalJustify() )
1108  {
1110  Translate( VECTOR2D( -textSize.x / 2.0, 0 ) );
1111  break;
1112 
1114  //if( !IsTextMirrored() )
1115  Translate( VECTOR2D( -textSize.x, 0 ) );
1116  break;
1117 
1118  case GR_TEXT_HJUSTIFY_LEFT:
1119  //if( IsTextMirrored() )
1120  //Translate( VECTOR2D( -textSize.x, 0 ) );
1121  break;
1122  }
1123 
1124  switch( GetVerticalJustify() )
1125  {
1126  case GR_TEXT_VJUSTIFY_TOP:
1127  Translate( VECTOR2D( 0, -textSize.y ) );
1128  overbarHeight = -textSize.y / 2.0;
1129  break;
1130 
1132  Translate( VECTOR2D( 0, -textSize.y / 2.0 ) );
1133  overbarHeight = 0;
1134  break;
1135 
1137  break;
1138  }
1139 
1140  int i = 0;
1141 
1142  for( UTF8::uni_iter chIt = text.ubegin(), end = text.uend(); chIt < end; ++chIt )
1143  {
1144  unsigned int c = *chIt;
1145  wxASSERT_MSG( c != '\n' && c != '\r', wxT( "No support for multiline bitmap text yet" ) );
1146 
1147  // Handle overbar
1148  if( overbars[i] && !overbar )
1149  {
1150  overbar = true; // beginning of an overbar
1151  }
1152  else if( overbar && !overbars[i] )
1153  {
1154  overbar = false; // end of an overbar
1155  drawBitmapOverbar( overbarLength, overbarHeight );
1156  overbarLength = 0;
1157  }
1158 
1159  if( overbar )
1160  overbarLength += drawBitmapChar( c );
1161  else
1162  drawBitmapChar( c );
1163 
1164  ++i;
1165  }
1166 
1167  // Handle the case when overbar is active till the end of the drawn text
1168  currentManager->Translate( 0, commonOffset, 0 );
1169 
1170  if( overbar && overbarLength > 0 )
1171  drawBitmapOverbar( overbarLength, overbarHeight );
1172 
1173  Restore();
1174 }
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:298
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:288
bool globalFlipX
Flag for X axis flipping.
double b
Blue component.
Definition: color4d.h:289
virtual void Save() override
Save the context.
double a
Alpha component.
Definition: color4d.h:290
VECTOR2< double > VECTOR2D
Definition: vector2d.h:586
std::pair< VECTOR2D, float > computeBitmapTextSize(const UTF8 &aText) const
Computes a size of text drawn using bitmap font with current text setting applied.
COLOR4D strokeColor
The color of the outlines.
void Translate(GLfloat aX, GLfloat aY, GLfloat aZ)
Function Translate() multiplies the current matrix by a translation matrix, so newly vertices will be...
const VECTOR2D & GetGlyphSize() const
void Color(const COLOR4D &aColor)
Function Color() changes currently used color that will be applied to newly added vertices...
class uni_iter is a non-mutating iterator that walks through unicode code points in the UTF8 encoded ...
Definition: utf8.h:207
bool globalFlipY
Flag for Y axis flipping.
int drawBitmapChar(unsigned long aChar)
Draws a single character using bitmap font.
size_t i
Definition: json11.cpp:597
void Scale(GLfloat aX, GLfloat aY, GLfloat aZ)
Function Scale() multiplies the current matrix by a scaling matrix, so the newly vertices will be sca...
double r
Red component.
Definition: color4d.h:287
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 1942 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().

1943 {
1944  if( !IsCursorEnabled() )
1945  return;
1946 
1948 
1949  const int cursorSize = fullscreenCursor ? 8000 : 80;
1950 
1951  VECTOR2D cursorBegin = cursorPosition - cursorSize / ( 2 * worldScale );
1952  VECTOR2D cursorEnd = cursorPosition + cursorSize / ( 2 * worldScale );
1953  VECTOR2D cursorCenter = ( cursorBegin + cursorEnd ) / 2;
1954 
1955  const COLOR4D cColor = getCursorColor();
1956  const COLOR4D color( cColor.r * cColor.a, cColor.g * cColor.a,
1957  cColor.b * cColor.a, 1.0 );
1958 
1959  glActiveTexture( GL_TEXTURE0 );
1960  glDisable( GL_TEXTURE_2D );
1961  glLineWidth( 1.0 );
1962  glColor4d( color.r, color.g, color.b, color.a );
1963 
1964  glBegin( GL_LINES );
1965  glVertex2d( cursorCenter.x, cursorBegin.y );
1966  glVertex2d( cursorCenter.x, cursorEnd.y );
1967 
1968  glVertex2d( cursorBegin.x, cursorCenter.y );
1969  glVertex2d( cursorEnd.x, cursorCenter.y );
1970  glEnd();
1971 }
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:288
static const unsigned int DIRECT_RENDERING
double b
Blue component.
Definition: color4d.h:289
double a
Alpha component.
Definition: color4d.h:290
OPENGL_COMPOSITOR * compositor
Handles multiple rendering targets.
Definition: opengl_gal.h:304
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:287
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 469 of file opengl_gal.h.

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

Referenced by DrawArc(), and DrawArcSegment().

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

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

Referenced by IsVisible().

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

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

Referenced by IsVisible().

1479 {
1480  if( groups[aGroupNumber] )
1481  cachedManager->ChangeItemDepth( *groups[aGroupNumber], aDepth );
1482 }
void ChangeItemDepth(const VERTEX_ITEM &aItem, GLfloat aDepth) const
Function ChangeItemDepth() changes the depth of all vertices owned by an item.
GROUPS_MAP groups
Stores informations about VBO objects (groups)
Definition: opengl_gal.h:296
VERTEX_MANAGER * cachedManager
Container for storing cached VERTEX_ITEMs.
Definition: opengl_gal.h:299
void OPENGL_GAL::ClearCache ( )
overridevirtual

Delete all data created during caching of graphic items.

Reimplemented from KIGFX::GAL.

Definition at line 1492 of file opengl_gal.cpp.

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

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

1493 {
1494  bitmapCache.reset( new GL_BITMAP_CACHE );
1495 
1496  groups.clear();
1497 
1498  if( isInitialized )
1499  cachedManager->Clear();
1500 }
void Clear() const
Function Clear() removes all the stored vertices from the container.
std::unique_ptr< GL_BITMAP_CACHE > bitmapCache
Definition: opengl_gal.h:323
GROUPS_MAP groups
Stores informations about VBO objects (groups)
Definition: opengl_gal.h:296
VERTEX_MANAGER * cachedManager
Container for storing cached VERTEX_ITEMs.
Definition: opengl_gal.h:299
bool isInitialized
Basic initialization flag, has to be done when the window is visible.
Definition: opengl_gal.h:316
void OPENGL_GAL::ClearScreen ( )
overridevirtual

Clear the screen.

Parameters
aColoris the color used for clearing.

Reimplemented from KIGFX::GAL.

Definition at line 1387 of file opengl_gal.cpp.

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

Referenced by IsVisible().

1388 {
1389  // Clear screen
1391  // NOTE: Black used here instead of m_clearColor; it will be composited later
1392  glClearColor( 0, 0, 0, 1 );
1393  glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT );
1394 }
static const unsigned int DIRECT_RENDERING
OPENGL_COMPOSITOR * compositor
Handles multiple rendering targets.
Definition: opengl_gal.h:304
virtual void SetBuffer(unsigned int aBufferHandle) override
Function SetBuffer() sets the selected buffer as the rendering target.
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 1543 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().

1544 {
1545  // Save the current state
1546  unsigned int oldTarget = compositor->GetBuffer();
1547 
1548  switch( aTarget )
1549  {
1550  // Cached and noncached items are rendered to the same buffer
1551  default:
1552  case TARGET_CACHED:
1553  case TARGET_NONCACHED:
1555  break;
1556 
1557  case TARGET_OVERLAY:
1559  break;
1560  }
1561 
1562 
1563  if( aTarget != TARGET_OVERLAY )
1565  else
1567 
1568  // Restore the previous state
1569  compositor->SetBuffer( oldTarget );
1570 }
unsigned int overlayBuffer
Auxiliary rendering target (for menus etc.)
Definition: opengl_gal.h:306
static const COLOR4D BLACK
Definition: color4d.h:297
Auxiliary rendering target (noncached)
Definition: definitions.h:42
OPENGL_COMPOSITOR * compositor
Handles multiple rendering targets.
Definition: opengl_gal.h:304
unsigned int mainBuffer
Main rendering target.
Definition: opengl_gal.h:305
virtual void ClearBuffer(const COLOR4D &aColor) override
Function ClearBuffer() clears the selected buffer (set by the SetBuffer() function).
Items that may change while the view stays the same (noncached)
Definition: definitions.h: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 1892 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().

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

References KIGFX::GAL::gridMinSpacing.

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

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

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

Definition at line 1115 of file graphics_abstraction_layer.h.

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

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

1116  {
1118  }
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.

Reimplemented in KIGFX::CAIRO_PRINT_GAL.

Definition at line 179 of file graphics_abstraction_layer.cpp.

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

Referenced by beginDrawing(), KIGFX::GAL::ClearCache(), KIGFX::CAIRO_GAL_BASE::resetContext(), KIGFX::VIEW::SetCenter(), and KIGFX::VIEW::SetScale().

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

Delete the group from the memory.

Parameters
aGroupNumberis the group number.

Reimplemented from KIGFX::GAL.

Definition at line 1485 of file opengl_gal.cpp.

References groups.

Referenced by IsVisible().

1486 {
1487  // Frees memory in the container as well
1488  groups.erase( aGroupNumber );
1489 }
GROUPS_MAP groups
Stores informations about VBO objects (groups)
Definition: opengl_gal.h:296
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 669 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::GAL::layerDepth, KIGFX::COLOR4D::r, KIGFX::VERTEX_MANAGER::Reserve(), Restore(), Save(), KIGFX::VERTEX_MANAGER::Shader(), KIGFX::SHADER_NONE, KIGFX::GAL::strokeColor, SWAP, KIGFX::VERTEX_MANAGER::Translate(), KIGFX::VERTEX_MANAGER::Vertex(), VECTOR2< T >::x, and VECTOR2< T >::y.

Referenced by IsVisible().

671 {
672  if( aRadius <= 0 )
673  return;
674 
675  // Swap the angles, if start angle is greater than end angle
676  SWAP( aStartAngle, >, aEndAngle );
677 
678  const double alphaIncrement = calcAngleStep( aRadius );
679 
680  Save();
681  currentManager->Translate( aCenterPoint.x, aCenterPoint.y, 0.0 );
682 
683  if( isFillEnabled )
684  {
685  double alpha;
688 
689  // Triangle fan
690  for( alpha = aStartAngle; ( alpha + alphaIncrement ) < aEndAngle; )
691  {
692  currentManager->Reserve( 3 );
693  currentManager->Vertex( 0.0, 0.0, layerDepth );
694  currentManager->Vertex( cos( alpha ) * aRadius, sin( alpha ) * aRadius, layerDepth );
695  alpha += alphaIncrement;
696  currentManager->Vertex( cos( alpha ) * aRadius, sin( alpha ) * aRadius, layerDepth );
697  }
698 
699  // The last missing triangle
700  const VECTOR2D endPoint( cos( aEndAngle ) * aRadius, sin( aEndAngle ) * aRadius );
701 
702  currentManager->Reserve( 3 );
703  currentManager->Vertex( 0.0, 0.0, layerDepth );
704  currentManager->Vertex( cos( alpha ) * aRadius, sin( alpha ) * aRadius, layerDepth );
705  currentManager->Vertex( endPoint.x, endPoint.y, layerDepth );
706  }
707 
708  if( isStrokeEnabled )
709  {
711 
712  VECTOR2D p( cos( aStartAngle ) * aRadius, sin( aStartAngle ) * aRadius );
713  double alpha;
714 
715  for( alpha = aStartAngle + alphaIncrement; alpha <= aEndAngle; alpha += alphaIncrement )
716  {
717  VECTOR2D p_next( cos( alpha ) * aRadius, sin( alpha ) * aRadius );
718  DrawLine( p, p_next );
719 
720  p = p_next;
721  }
722 
723  // Draw the last missing part
724  if( alpha != aEndAngle )
725  {
726  VECTOR2D p_last( cos( aEndAngle ) * aRadius, sin( aEndAngle ) * aRadius );
727  DrawLine( p, p_last );
728  }
729  }
730 
731  Restore();
732 }
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:298
double calcAngleStep(double aRadius) const
Compute the angle step when drawing arcs/circles approximated with lines.
Definition: opengl_gal.h:469
double layerDepth
The actual layer depth.
bool Reserve(unsigned int aSize)
Function Reserve() allocates space for vertices, so it will be used with subsequent Vertex() calls...
virtual void Restore() override
Restore the context.
bool Vertex(const VERTEX &aVertex)
Function Vertex() adds a vertex with the given coordinates to the currently set item.
double g
Green component.
Definition: color4d.h:288
COLOR4D fillColor
The fill color.
double b
Blue component.
Definition: color4d.h:289
virtual void Save() override
Save the context.
double a
Alpha component.
Definition: color4d.h:290
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:556
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:287
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 735 of file opengl_gal.cpp.

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

Referenced by IsVisible().

737 {
738  if( aRadius <= 0 )
739  {
740  // Arcs of zero radius are a circle of aWidth diameter
741  if( aWidth > 0 )
742  DrawCircle( aCenterPoint, aWidth / 2.0 );
743 
744  return;
745  }
746 
747  // Swap the angles, if start angle is greater than end angle
748  SWAP( aStartAngle, >, aEndAngle );
749 
750  const double alphaIncrement = calcAngleStep( aRadius );
751 
752  Save();
753  currentManager->Translate( aCenterPoint.x, aCenterPoint.y, 0.0 );
754 
755  if( isStrokeEnabled )
756  {
758 
759  double width = aWidth / 2.0;
760  VECTOR2D startPoint( cos( aStartAngle ) * aRadius,
761  sin( aStartAngle ) * aRadius );
762  VECTOR2D endPoint( cos( aEndAngle ) * aRadius,
763  sin( aEndAngle ) * aRadius );
764 
765  drawStrokedSemiCircle( startPoint, width, aStartAngle + M_PI );
766  drawStrokedSemiCircle( endPoint, width, aEndAngle );
767 
768  VECTOR2D pOuter( cos( aStartAngle ) * ( aRadius + width ),
769  sin( aStartAngle ) * ( aRadius + width ) );
770 
771  VECTOR2D pInner( cos( aStartAngle ) * ( aRadius - width ),
772  sin( aStartAngle ) * ( aRadius - width ) );
773 
774  double alpha;
775 
776  for( alpha = aStartAngle + alphaIncrement; alpha <= aEndAngle; alpha += alphaIncrement )
777  {
778  VECTOR2D pNextOuter( cos( alpha ) * ( aRadius + width ),
779  sin( alpha ) * ( aRadius + width ) );
780  VECTOR2D pNextInner( cos( alpha ) * ( aRadius - width ),
781  sin( alpha ) * ( aRadius - width ) );
782 
783  DrawLine( pOuter, pNextOuter );
784  DrawLine( pInner, pNextInner );
785 
786  pOuter = pNextOuter;
787  pInner = pNextInner;
788  }
789 
790  // Draw the last missing part
791  if( alpha != aEndAngle )
792  {
793  VECTOR2D pLastOuter( cos( aEndAngle ) * ( aRadius + width ),
794  sin( aEndAngle ) * ( aRadius + width ) );
795  VECTOR2D pLastInner( cos( aEndAngle ) * ( aRadius - width ),
796  sin( aEndAngle ) * ( aRadius - width ) );
797 
798  DrawLine( pOuter, pLastOuter );
799  DrawLine( pInner, pLastInner );
800  }
801  }
802 
803  if( isFillEnabled )
804  {
806  SetLineWidth( aWidth );
807 
808  VECTOR2D p( cos( aStartAngle ) * aRadius, sin( aStartAngle ) * aRadius );
809  double alpha;
810 
811  for( alpha = aStartAngle + alphaIncrement; alpha <= aEndAngle; alpha += alphaIncrement )
812  {
813  VECTOR2D p_next( cos( alpha ) * aRadius, sin( alpha ) * aRadius );
814  DrawLine( p, p_next );
815 
816  p = p_next;
817  }
818 
819  // Draw the last missing part
820  if( alpha != aEndAngle )
821  {
822  VECTOR2D p_last( cos( aEndAngle ) * aRadius, sin( aEndAngle ) * aRadius );
823  DrawLine( p, p_last );
824  }
825  }
826 
827  Restore();
828 }
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:298
double calcAngleStep(double aRadius) const
Compute the angle step when drawing arcs/circles approximated with lines.
Definition: opengl_gal.h:469
virtual void Restore() override
Restore the context.
double g
Green component.
Definition: color4d.h:288
COLOR4D fillColor
The fill color.
virtual void SetLineWidth(float aLineWidth)
Set the line width.
double b
Blue component.
Definition: color4d.h:289
virtual void Save() override
Save the context.
double a
Alpha component.
Definition: color4d.h:290
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:556
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:287
virtual void DrawCircle(const VECTOR2D &aCenterPoint, double aRadius) override
Draw a circle using world coordinates.
Definition: opengl_gal.cpp:609
void OPENGL_GAL::DrawBitmap ( const BITMAP_BASE aBitmap)
overridevirtual

Draw a bitmap image.

Reimplemented from KIGFX::GAL.

Definition at line 1027 of file opengl_gal.cpp.

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

Referenced by IsVisible().

1028 {
1029  // We have to calculate the pixel size in users units to draw the image.
1030  // worldUnitLength is a factor used for converting IU to inches
1031  double scale = 1.0 / ( aBitmap.GetPPI() * worldUnitLength );
1032  double w = (double) aBitmap.GetSizePixels().x * scale;
1033  double h = (double) aBitmap.GetSizePixels().y * scale;
1034 
1035  auto xform = currentManager->GetTransformation();
1036 
1037  glm::vec4 v0 = xform * glm::vec4( -w/2, -h/2, 0.0, 0.0 );
1038  glm::vec4 v1 = xform * glm::vec4( w/2, h/2, 0.0, 0.0 );
1039  glm::vec4 trans = xform[3];
1040 
1041  auto id = bitmapCache->RequestBitmap( &aBitmap );
1042 
1043  auto oldTarget = GetTarget();
1044 
1045  glPushMatrix();
1046  glTranslated( trans.x, trans.y, trans.z );
1047 
1049  glEnable(GL_TEXTURE_2D);
1050  glActiveTexture( GL_TEXTURE0 );
1051  glBindTexture( GL_TEXTURE_2D, id );
1052 
1053  glBegin( GL_QUADS );
1054  glColor4f( 1.0, 1.0, 1.0, 1.0 );
1055  glTexCoord2f( 0.0, 0.0 );
1056  glVertex3f( v0.x, v0.y, layerDepth );
1057  glColor4f( 1.0, 1.0, 1.0, 1.0 );
1058  glTexCoord2f( 1.0, 0.0 );
1059  glVertex3f( v1.x, v0.y, layerDepth );
1060  glColor4f( 1.0, 1.0, 1.0, 1.0 );
1061  glTexCoord2f( 1.0, 1.0 );
1062  glVertex3f( v1.x, v1.y, layerDepth );
1063  glColor4f( 1.0, 1.0, 1.0, 1.0 );
1064  glTexCoord2f( 0.0, 1.0 );
1065  glVertex3f( v0.x, v1.y, layerDepth );
1066  glEnd();
1067 
1068  SetTarget( oldTarget );
1069  glBindTexture( GL_TEXTURE_2D, 0 );
1070 
1071  glPopMatrix();
1072 }
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:298
double layerDepth
The actual layer depth.
std::unique_ptr< GL_BITMAP_CACHE > bitmapCache
Definition: opengl_gal.h:323
Auxiliary rendering target (noncached)
Definition: definitions.h:42
virtual RENDER_TARGET GetTarget() const override
Gets the currently used target for rendering.
double worldUnitLength
The unit length of the world coordinates [inch].
wxSize GetSizePixels() const
Function GetSizePixels.
Definition: bitmap_base.h:133
virtual void SetTarget(RENDER_TARGET aTarget) override
Sets the target for rendering.
const int scale
int GetPPI() const
Definition: bitmap_base.h:145
const glm::mat4 & GetTransformation() const
int OPENGL_GAL::drawBitmapChar ( unsigned long  aChar)
private

Draws a single character using bitmap font.

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

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

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

1792 {
1793  const float TEX_X = font_image.width;
1794  const float TEX_Y = font_image.height;
1795 
1796  // handle space
1797  if( aChar == ' ' )
1798  {
1799  const FONT_GLYPH_TYPE* g = LookupGlyph( 'x' );
1800  wxASSERT( g );
1801  Translate( VECTOR2D( g->advance, 0 ) );
1802  return g->advance;
1803  }
1804 
1805  const FONT_GLYPH_TYPE* glyph = LookupGlyph( aChar );
1806 
1807  // If the glyph is not found (happens for many esotheric unicode chars)
1808  // shows a '?' instead.
1809  if( !glyph )
1810  glyph = LookupGlyph( '?' );
1811 
1812  if( !glyph ) // Should not happen.
1813  return 0;
1814 
1815  const float X = glyph->atlas_x + font_information.smooth_pixels;
1816  const float Y = glyph->atlas_y + font_information.smooth_pixels;
1817  const float XOFF = glyph->minx;
1818 
1819  // adjust for height rounding
1820  const float round_adjust = ( glyph->maxy - glyph->miny )
1821  - float( glyph->atlas_h - font_information.smooth_pixels * 2 );
1822  const float top_adjust = font_information.max_y - glyph->maxy;
1823  const float YOFF = round_adjust + top_adjust;
1824  const float W = glyph->atlas_w - font_information.smooth_pixels *2;
1825  const float H = glyph->atlas_h - font_information.smooth_pixels *2;
1826  const float B = 0;
1827 
1828  currentManager->Reserve( 6 );
1829  Translate( VECTOR2D( XOFF, YOFF ) );
1830  /* Glyph:
1831  * v0 v1
1832  * +--+
1833  * | /|
1834  * |/ |
1835  * +--+
1836  * v2 v3
1837  */
1838  currentManager->Shader( SHADER_FONT, X / TEX_X, ( Y + H ) / TEX_Y );
1839  currentManager->Vertex( -B, -B, 0 ); // v0
1840 
1841  currentManager->Shader( SHADER_FONT, ( X + W ) / TEX_X, ( Y + H ) / TEX_Y );
1842  currentManager->Vertex( W + B, -B, 0 ); // v1
1843 
1844  currentManager->Shader( SHADER_FONT, X / TEX_X, Y / TEX_Y );
1845  currentManager->Vertex( -B, H + B, 0 ); // v2
1846 
1847 
1848  currentManager->Shader( SHADER_FONT, ( X + W ) / TEX_X, ( Y + H ) / TEX_Y );
1849  currentManager->Vertex( W + B, -B, 0 ); // v1
1850 
1851  currentManager->Shader( SHADER_FONT, X / TEX_X, Y / TEX_Y );
1852  currentManager->Vertex( -B, H + B, 0 ); // v2
1853 
1854  currentManager->Shader( SHADER_FONT, ( X + W ) / TEX_X, Y / TEX_Y );
1855  currentManager->Vertex( W + B, H + B, 0 ); // v3
1856 
1857  Translate( VECTOR2D( -XOFF + glyph->advance, -YOFF ) );
1858 
1859  return glyph->advance;
1860 }
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:298
virtual void Translate(const VECTOR2D &aTranslation) override
Translate the context.
bool Reserve(unsigned int aSize)
Function Reserve() allocates space for vertices, so it will be used with subsequent Vertex() calls...
bool Vertex(const VERTEX &aVertex)
Function Vertex() adds a vertex with the given coordinates to the currently set item.
const FONT_GLYPH_TYPE * LookupGlyph(unsigned int aCodepoint)
VECTOR2< double > VECTOR2D
Definition: vector2d.h:586
FONT_IMAGE_TYPE font_image
Definition: gl_resources.cpp:4
FONT_INFO_TYPE font_information
Definition: gl_resources.cpp:3
#define H(x, y, z)
Definition: md5_hash.cpp:17
void Shader(GLfloat aShaderType, GLfloat aParam1=0.0f, GLfloat aParam2=0.0f, GLfloat aParam3=0.0f)
Function Shader() changes currently used shader and its parameters that will be applied to newly adde...
void OPENGL_GAL::drawBitmapOverbar ( double  aLength,
double  aHeight 
)
private

Draws an overbar over the currently drawn text.

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

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

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

1864 {
1865  // To draw an overbar, simply draw an overbar
1866  const FONT_GLYPH_TYPE* glyph = LookupGlyph( '_' );
1867  wxCHECK( glyph, /* void */ );
1868 
1869  const float H = glyph->maxy - glyph->miny;
1870 
1871  Save();
1872 
1873  Translate( VECTOR2D( -aLength, -aHeight-1.5*H ) );
1874 
1875  currentManager->Reserve( 6 );
1877 
1878  currentManager->Shader( 0 );
1879 
1880  currentManager->Vertex( 0, 0, 0 ); // v0
1881  currentManager->Vertex( aLength, 0, 0 ); // v1
1882  currentManager->Vertex( 0, H, 0 ); // v2
1883 
1884  currentManager->Vertex( aLength, 0, 0 ); // v1
1885  currentManager->Vertex( 0, H, 0 ); // v2
1886  currentManager->Vertex( aLength, H, 0 ); // v3
1887 
1888  Restore();
1889 }
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:298
virtual void Translate(const VECTOR2D &aTranslation) override
Translate the context.
bool Reserve(unsigned int aSize)
Function Reserve() allocates space for vertices, so it will be used with subsequent Vertex() calls...
virtual void Restore() override
Restore the context.
bool Vertex(const VERTEX &aVertex)
Function Vertex() adds a vertex with the given coordinates to the currently set item.
double g
Green component.
Definition: color4d.h:288
const FONT_GLYPH_TYPE * LookupGlyph(unsigned int aCodepoint)
double b
Blue component.
Definition: color4d.h:289
virtual void Save() override
Save the context.
VECTOR2< double > VECTOR2D
Definition: vector2d.h:586
COLOR4D strokeColor
The color of the outlines.
void Color(const COLOR4D &aColor)
Function Color() changes currently used color that will be applied to newly added vertices...
#define H(x, y, z)
Definition: md5_hash.cpp:17
void Shader(GLfloat aShaderType, GLfloat aParam1=0.0f, GLfloat aParam2=0.0f, GLfloat aParam3=0.0f)
Function Shader() changes currently used shader and its parameters that will be applied to newly adde...
double r
Red component.
Definition: color4d.h:287
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 609 of file opengl_gal.cpp.

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

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

610 {
611  if( isFillEnabled )
612  {
613  currentManager->Reserve( 3 );
615 
616  /* Draw a triangle that contains the circle, then shade it leaving only the circle.
617  * Parameters given to Shader() are indices of the triangle's vertices
618  * (if you want to understand more, check the vertex shader source [shader.vert]).
619  * Shader uses this coordinates to determine if fragments are inside the circle or not.
620  * v2
621  * /\
622  * //\\
623  * v0 /_\/_\ v1
624  */
626  currentManager->Vertex( aCenterPoint.x - aRadius * sqrt( 3.0f ), // v0
627  aCenterPoint.y - aRadius, layerDepth );
628 
630  currentManager->Vertex( aCenterPoint.x + aRadius * sqrt( 3.0f), // v1
631  aCenterPoint.y - aRadius, layerDepth );
632 
634  currentManager->Vertex( aCenterPoint.x, aCenterPoint.y + aRadius * 2.0f, // v2
635  layerDepth );
636  }
637 
638  if( isStrokeEnabled )
639  {
640  currentManager->Reserve( 3 );
642 
643  /* Draw a triangle that contains the circle, then shade it leaving only the circle.
644  * Parameters given to Shader() are indices of the triangle's vertices
645  * (if you want to understand more, check the vertex shader source [shader.vert]).
646  * and the line width. Shader uses this coordinates to determine if fragments are
647  * inside the circle or not.
648  * v2
649  * /\
650  * //\\
651  * v0 /_\/_\ v1
652  */
653  double outerRadius = aRadius + ( lineWidth / 2 );
655  currentManager->Vertex( aCenterPoint.x - outerRadius * sqrt( 3.0f ), // v0
656  aCenterPoint.y - outerRadius, layerDepth );
657 
659  currentManager->Vertex( aCenterPoint.x + outerRadius * sqrt( 3.0f ), // v1
660  aCenterPoint.y - outerRadius, layerDepth );
661 
663  currentManager->Vertex( aCenterPoint.x, aCenterPoint.y + outerRadius * 2.0f, // v2
664  layerDepth );
665  }
666 }
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:298
double layerDepth
The actual layer depth.
bool Reserve(unsigned int aSize)
Function Reserve() allocates space for vertices, so it will be used with subsequent Vertex() calls...
bool Vertex(const VERTEX &aVertex)
Function Vertex() adds a vertex with the given coordinates to the currently set item.
double g
Green component.
Definition: color4d.h:288
COLOR4D fillColor
The fill color.
double b
Blue component.
Definition: color4d.h:289
double a
Alpha component.
Definition: color4d.h:290
bool isStrokeEnabled
Are the outlines stroked ?
COLOR4D strokeColor
The color of the outlines.
void Color(const COLOR4D &aColor)
Function Color() changes currently used color that will be applied to newly added vertices...
float lineWidth
The line width.
bool isFillEnabled
Is filling of graphic objects enabled ?
void Shader(GLfloat aShaderType, GLfloat aParam1=0.0f, GLfloat aParam2=0.0f, GLfloat aParam3=0.0f)
Function Shader() changes currently used shader and its parameters that will be applied to newly adde...
double r
Red component.
Definition: color4d.h:287
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 1573 of file opengl_gal.cpp.

References KIGFX::GAL::cursorPosition.

Referenced by SetNegativeDrawMode().

1574 {
1575  // Now we should only store the position of the mouse cursor
1576  // The real drawing routines are in blitCursor()
1577  //VECTOR2D screenCursor = worldScreenMatrix * aCursorPosition;
1578  //cursorPosition = screenWorldMatrix * VECTOR2D( screenCursor.x, screenCursor.y );
1579  cursorPosition = aCursorPosition;
1580 }
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 995 of file opengl_gal.cpp.

References CURVE_POINTS, DrawPolyline(), and i.

Referenced by IsVisible().

997 {
998  // FIXME The drawing quality needs to be improved
999  // FIXME Perhaps choose a quad/triangle strip instead?
1000  // FIXME Brute force method, use a better (recursive?) algorithm
1001 
1002  std::deque<VECTOR2D> pointList;
1003 
1004  double t = 0.0;
1005  double dt = 1.0 / (double) CURVE_POINTS;
1006 
1007  for( int i = 0; i <= CURVE_POINTS; i++ )
1008  {
1009  double omt = 1.0 - t;
1010  double omt2 = omt * omt;
1011  double omt3 = omt * omt2;
1012  double t2 = t * t;
1013  double t3 = t * t2;
1014 
1015  VECTOR2D vertex = omt3 * aStartPoint + 3.0 * t * omt2 * aControlPointA
1016  + 3.0 * t2 * omt * aControlPointB + t3 * aEndPoint;
1017 
1018  pointList.push_back( vertex );
1019 
1020  t += dt;
1021  }
1022 
1023  DrawPolyline( pointList );
1024 }
static const int CURVE_POINTS
The number of points for curve approximation.
Definition: opengl_gal.h:284
virtual void DrawPolyline(const std::deque< VECTOR2D > &aPointList) override
Draw a polyline.
Definition: opengl_gal.cpp:869
size_t i
Definition: json11.cpp:597
void OPENGL_GAL::drawFilledSemiCircle ( const VECTOR2D aCenterPoint,
double  aRadius,
double  aAngle 
)
private

Draw a filled semicircle.

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

Definition at line 1660 of file opengl_gal.cpp.

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

Referenced by drawPolyline(), and drawSemiCircle().

1662 {
1663  Save();
1664 
1665  currentManager->Reserve( 3 );
1666  currentManager->Translate( aCenterPoint.x, aCenterPoint.y, 0.0f );
1667  currentManager->Rotate( aAngle, 0.0f, 0.0f, 1.0f );
1668 
1669  /* Draw a triangle that contains the semicircle, then shade it to leave only
1670  * the semicircle. Parameters given to Shader() are indices of the triangle's vertices
1671  * (if you want to understand more, check the vertex shader source [shader.vert]).
1672  * Shader uses these coordinates to determine if fragments are inside the semicircle or not.
1673  * v2
1674  * /\
1675  * /__\
1676  * v0 //__\\ v1
1677  */
1679  currentManager->Vertex( -aRadius * 3.0f / sqrt( 3.0f ), 0.0f, layerDepth ); // v0
1680 
1682  currentManager->Vertex( aRadius * 3.0f / sqrt( 3.0f ), 0.0f, layerDepth ); // v1
1683 
1685  currentManager->Vertex( 0.0f, aRadius * 2.0f, layerDepth ); // v2
1686 
1687  Restore();
1688 }
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:298
double layerDepth
The actual layer depth.
bool Reserve(unsigned int aSize)
Function Reserve() allocates space for vertices, so it will be used with subsequent Vertex() calls...
virtual void Restore() override
Restore the context.
bool Vertex(const VERTEX &aVertex)
Function Vertex() adds a vertex with the given coordinates to the currently set item.
void Rotate(GLfloat aAngle, GLfloat aX, GLfloat aY, GLfloat aZ)
Function Rotate() multiplies the current matrix by a rotation matrix, so the newly vertices will be r...
virtual void Save() override
Save the context.
void Translate(GLfloat aX, GLfloat aY, GLfloat aZ)
Function Translate() multiplies the current matrix by a translation matrix, so newly vertices will be...
void Shader(GLfloat aShaderType, GLfloat aParam1=0.0f, GLfloat aParam2=0.0f, GLfloat aParam3=0.0f)
Function Shader() changes currently used shader and its parameters that will be applied to newly adde...
void OPENGL_GAL::DrawGrid ( )
overridevirtual

>

Draw the grid

Reimplemented from KIGFX::GAL.

Definition at line 1177 of file opengl_gal.cpp.

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

Referenced by IsVisible().

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

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

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

Reimplemented in KIGFX::CAIRO_GAL_BASE.

Definition at line 1133 of file graphics_abstraction_layer.h.

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

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

Draw the stored group.

Parameters
aGroupNumberis the group number.

Reimplemented from KIGFX::GAL.

Definition at line 1464 of file opengl_gal.cpp.

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

Referenced by IsVisible().

1465 {
1466  if( groups[aGroupNumber] )
1467  cachedManager->DrawItem( *groups[aGroupNumber] );
1468 }
GROUPS_MAP groups
Stores informations about VBO objects (groups)
Definition: opengl_gal.h:296
VERTEX_MANAGER * cachedManager
Container for storing cached VERTEX_ITEMs.
Definition: opengl_gal.h:299
void 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 556 of file opengl_gal.cpp.

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

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

557 {
559 
560  drawLineQuad( aStartPoint, aEndPoint );
561 }
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:298
void drawLineQuad(const VECTOR2D &aStartPoint, const VECTOR2D &aEndPoint)
Draw a quad for the line.
double g
Green component.
Definition: color4d.h:288
double b
Blue component.
Definition: color4d.h:289
double a
Alpha component.
Definition: color4d.h:290
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:287
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 1583 of file opengl_gal.cpp.

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

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

1584 {
1585  /* Helper drawing: ____--- v3 ^
1586  * ____---- ... \ \
1587  * ____---- ... \ end \
1588  * v1 ____---- ... ____---- \ width
1589  * ---- ...___---- \ \
1590  * \ ___...-- \ v
1591  * \ ____----... ____---- v2
1592  * ---- ... ____----
1593  * start \ ... ____----
1594  * \... ____----
1595  * ----
1596  * v0
1597  * dots mark triangles' hypotenuses
1598  */
1599 
1600  auto v1 = currentManager->GetTransformation() * glm::vec4( aStartPoint.x, aStartPoint.y, 0.0, 0.0 );
1601  auto v2 = currentManager->GetTransformation() * glm::vec4( aEndPoint.x, aEndPoint.y, 0.0, 0.0 );
1602 
1603  VECTOR2D startEndVector( v2.x - v1.x, v2.y - v1.y );
1604 
1605  double lineLength = startEndVector.EuclideanNorm();
1606 
1607  VECTOR2D vs ( startEndVector );
1608  float aspect;
1609 
1610  if ( lineWidth == 0.0 ) // pixel-width line
1611  {
1612  vs = vs.Resize( 0.5 );
1613  aspect = ( lineLength + 1.0 );
1614  }
1615  else
1616  {
1617  vs = vs.Resize( 0.5 * lineWidth );
1618  aspect = ( lineLength + lineWidth ) / lineWidth;
1619  }
1620 
1621  currentManager->Reserve( 6 );
1622 
1623  // Line width is maintained by the vertex shader
1624  currentManager->Shader( SHADER_LINE_A, aspect, vs.x, vs.y );
1625  currentManager->Vertex( aStartPoint, layerDepth );
1626 
1627  currentManager->Shader( SHADER_LINE_B, aspect, vs.x, vs.y );
1628  currentManager->Vertex( aStartPoint, layerDepth );
1629 
1630  currentManager->Shader( SHADER_LINE_C, aspect, vs.x, vs.y );
1631  currentManager->Vertex( aEndPoint, layerDepth );
1632 
1633  currentManager->Shader( SHADER_LINE_D, aspect, vs.x, vs.y );
1634  currentManager->Vertex( aEndPoint, layerDepth );
1635 
1636  currentManager->Shader( SHADER_LINE_E, aspect, vs.x, vs.y );
1637  currentManager->Vertex( aEndPoint, layerDepth );
1638 
1639  currentManager->Shader( SHADER_LINE_F, aspect, vs.x, vs.y );
1640  currentManager->Vertex( aStartPoint, layerDepth );
1641 }
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:298
double layerDepth
The actual layer depth.
bool Reserve(unsigned int aSize)
Function Reserve() allocates space for vertices, so it will be used with subsequent Vertex() calls...
bool Vertex(const VERTEX &aVertex)
Function Vertex() adds a vertex with the given coordinates to the currently set item.
float lineWidth
The line width.
const glm::mat4 & GetTransformation() const
void Shader(GLfloat aShaderType, GLfloat aParam1=0.0f, GLfloat aParam2=0.0f, GLfloat aParam3=0.0f)
Function Shader() changes currently used shader and its parameters that will be applied to newly adde...
void OPENGL_GAL::DrawPolygon ( const std::deque< VECTOR2D > &  aPointList)
overridevirtual

Draw a polygon.

Parameters
aPointListis the list of the polygon points.

Reimplemented from KIGFX::GAL.

Definition at line 892 of file opengl_gal.cpp.

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

Referenced by IsVisible().

893 {
894  auto points = std::unique_ptr<GLdouble[]>( new GLdouble[3 * aPointList.size()] );
895  GLdouble* ptr = points.get();
896 
897  for( const VECTOR2D& p : aPointList )
898  {
899  *ptr++ = p.x;
900  *ptr++ = p.y;
901  *ptr++ = layerDepth;
902  }
903 
904  drawPolygon( points.get(), aPointList.size() );
905 }
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 908 of file opengl_gal.cpp.

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

909 {
910  auto points = std::unique_ptr<GLdouble[]>( new GLdouble[3 * aListSize] );
911  GLdouble* target = points.get();
912  const VECTOR2D* src = aPointList;
913 
914  for( int i = 0; i < aListSize; ++i )
915  {
916  *target++ = src->x;
917  *target++ = src->y;
918  *target++ = layerDepth;
919  ++src;
920  }
921 
922  drawPolygon( points.get(), aListSize );
923 }
double layerDepth
The actual layer depth.
void drawPolygon(GLdouble *aPoints, int aPointCount)
Draws a filled polygon.
size_t i
Definition: json11.cpp:597
void OPENGL_GAL::DrawPolygon ( const SHAPE_POLY_SET aPolySet)
overridevirtual

Reimplemented from KIGFX::GAL.

Definition at line 963 of file opengl_gal.cpp.

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

964 {
965  if ( aPolySet.IsTriangulationUpToDate() )
966  {
967  drawTriangulatedPolyset( aPolySet );
968  return;
969  }
970 
971  for( int j = 0; j < aPolySet.OutlineCount(); ++j )
972  {
973  const SHAPE_LINE_CHAIN& outline = aPolySet.COutline( j );
974 
975  if( outline.SegmentCount() == 0 )
976  continue;
977 
978  const int pointCount = outline.SegmentCount() + 1;
979  std::unique_ptr<GLdouble[]> points( new GLdouble[3 * pointCount] );
980  GLdouble* ptr = points.get();
981 
982  for( int i = 0; i < pointCount; ++i )
983  {
984  const VECTOR2I& p = outline.CPoint( i );
985  *ptr++ = p.x;
986  *ptr++ = p.y;
987  *ptr++ = layerDepth;
988  }
989 
990  drawPolygon( points.get(), pointCount );
991  }
992 }
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:926
Class SHAPE_LINE_CHAIN.
size_t i
Definition: json11.cpp:597
const VECTOR2I & CPoint(int aIndex) const
Function CPoint()
int SegmentCount() const
Function SegmentCount()
void OPENGL_GAL::drawPolygon ( GLdouble *  aPoints,
int  aPointCount 
)
private

Draws a filled polygon.

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

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

Definition at line 1725 of file opengl_gal.cpp.

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

Referenced by DrawPolygon().

1726 {
1727  if( isFillEnabled )
1728  {
1731 
1732  // Any non convex polygon needs to be tesselated
1733  // for this purpose the GLU standard functions are used
1734  TessParams params = { currentManager, tessIntersects };
1735  gluTessBeginPolygon( tesselator, &params );
1736  gluTessBeginContour( tesselator );
1737 
1738  GLdouble* point = aPoints;
1739 
1740  for( int i = 0; i < aPointCount; ++i )
1741  {
1742  gluTessVertex( tesselator, point, point );
1743  point += 3; // 3 coordinates
1744  }
1745 
1746  gluTessEndContour( tesselator );
1747  gluTessEndPolygon( tesselator );
1748 
1749  // Free allocated intersecting points
1750  tessIntersects.clear();
1751  }
1752 
1753  if( isStrokeEnabled )
1754  {
1755  drawPolyline( [&](int idx) { return VECTOR2D( aPoints[idx * 3], aPoints[idx * 3 + 1] ); },
1756  aPointCount );
1757  }
1758 }
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:298
double g
Green component.
Definition: color4d.h:288
COLOR4D fillColor
The fill color.
double b
Blue component.
Definition: color4d.h:289
double a
Alpha component.
Definition: color4d.h:290
bool isStrokeEnabled
Are the outlines stroked ?
VECTOR2< double > VECTOR2D
Definition: vector2d.h:586
void Color(const COLOR4D &aColor)
Function Color() changes currently used color that will be applied to newly added vertices...
GLUtesselator * tesselator
The tessellator.
Definition: opengl_gal.h:346
bool isFillEnabled
Is filling of graphic objects enabled ?
std::deque< boost::shared_array< GLdouble > > tessIntersects
Storage for intersecting points.
Definition: opengl_gal.h:348
size_t i
Definition: json11.cpp:597
void drawPolyline(const std::function< VECTOR2D(int)> &aPointGetter, int aPointCount)
Generic way of drawing a polyline stored in different containers.
void Shader(GLfloat aShaderType, GLfloat aParam1=0.0f, GLfloat aParam2=0.0f, GLfloat aParam3=0.0f)
Function Shader() changes currently used shader and its parameters that will be applied to newly adde...
double r
Red component.
Definition: color4d.h:287
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 869 of file opengl_gal.cpp.

References drawPolyline().

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

870 {
871  drawPolyline( [&](int idx) { return aPointList[idx]; }, aPointList.size() );
872 }
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 875 of file opengl_gal.cpp.

References drawPolyline().

876 {
877  drawPolyline( [&](int idx) { return aPointList[idx]; }, aListSize );
878 }
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 881 of file opengl_gal.cpp.

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

882 {
883  auto numPoints = aLineChain.PointCount();
884 
885  if( aLineChain.IsClosed() )
886  numPoints += 1;
887 
888  drawPolyline( [&](int idx) { return aLineChain.CPoint(idx); }, numPoints );
889 }
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 1761 of file opengl_gal.cpp.

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

Referenced by drawPolygon(), and DrawPolyline().

1762 {
1763  if( aPointCount < 2 )
1764  return;
1765 
1767  int i;
1768 
1769  for( i = 1; i < aPointCount; ++i )
1770  {
1771  auto start = aPointGetter( i - 1 );
1772  auto end = aPointGetter( i );
1773  const VECTOR2D startEndVector = ( end - start );
1774  double lineAngle = startEndVector.Angle();
1775 
1776  drawLineQuad( start, end );
1777 
1778  // There is no need to draw line caps on both ends of polyline's segments
1779  drawFilledSemiCircle( start, lineWidth / 2, lineAngle + M_PI / 2 );
1780  }
1781 
1782  // ..and now - draw the ending cap
1783  auto start = aPointGetter( i - 2 );
1784  auto end = aPointGetter( i - 1 );
1785  const VECTOR2D startEndVector = ( end - start );
1786  double lineAngle = startEndVector.Angle();
1787  drawFilledSemiCircle( end, lineWidth / 2, lineAngle - M_PI / 2 );
1788 }
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:298
void drawLineQuad(const VECTOR2D &aStartPoint, const VECTOR2D &aEndPoint)
Draw a quad for the line.
double g
Green component.
Definition: color4d.h:288
double b
Blue component.
Definition: color4d.h:289
double Angle() const
Function Angle computes the angle of the vector.
Definition: vector2d.h:306
double a
Alpha component.
Definition: color4d.h:290
COLOR4D strokeColor
The color of the outlines.
void Color(const COLOR4D &aColor)
Function Color() changes currently used color that will be applied to newly added vertices...
float lineWidth
The line width.
size_t i
Definition: json11.cpp:597
double r
Red component.
Definition: color4d.h:287
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 831 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().

832 {
833  // Compute the diagonal points of the rectangle
834  VECTOR2D diagonalPointA( aEndPoint.x, aStartPoint.y );
835  VECTOR2D diagonalPointB( aStartPoint.x, aEndPoint.y );
836 
837  // Fill the rectangle
838  if( isFillEnabled )
839  {
840  currentManager->Reserve( 6 );
843 
844  currentManager->Vertex( aStartPoint.x, aStartPoint.y, layerDepth );
845  currentManager->Vertex( diagonalPointA.x, diagonalPointA.y, layerDepth );
846  currentManager->Vertex( aEndPoint.x, aEndPoint.y, layerDepth );
847 
848  currentManager->Vertex( aStartPoint.x, aStartPoint.y, layerDepth );
849  currentManager->Vertex( aEndPoint.x, aEndPoint.y, layerDepth );
850  currentManager->Vertex( diagonalPointB.x, diagonalPointB.y, layerDepth );
851  }
852 
853  // Stroke the outline
854  if( isStrokeEnabled )
855  {
857 
858  std::deque<VECTOR2D> pointList;
859  pointList.push_back( aStartPoint );
860  pointList.push_back( diagonalPointA );
861  pointList.push_back( aEndPoint );
862  pointList.push_back( diagonalPointB );
863  pointList.push_back( aStartPoint );
864  DrawPolyline( pointList );
865  }
866 }
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:298
double layerDepth
The actual layer depth.
bool Reserve(unsigned int aSize)
Function Reserve() allocates space for vertices, so it will be used with subsequent Vertex() calls...
bool Vertex(const VERTEX &aVertex)
Function Vertex() adds a vertex with the given coordinates to the currently set item.
double g
Green component.
Definition: color4d.h:288
COLOR4D fillColor
The fill color.
double b
Blue component.
Definition: color4d.h:289
double a
Alpha component.
Definition: color4d.h:290
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:869
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:287
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 564 of file opengl_gal.cpp.

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

Referenced by IsVisible().

566 {
567  if( aStartPoint == aEndPoint ) // 0 length segments are just a circle.
568  {
569  DrawCircle( aStartPoint, aWidth/2 );
570  return;
571  }
572 
573  if( isFillEnabled || aWidth == 1.0 )
574  {
576 
577  SetLineWidth( aWidth );
578  drawLineQuad( aStartPoint, aEndPoint );
579  }
580  else
581  {
582  auto startEndVector = aEndPoint - aStartPoint;
583  auto lineAngle = startEndVector.Angle();
584  // Outlined tracks
585  double lineLength = startEndVector.EuclideanNorm();
586 
588 
589  Save();
590 
591  currentManager->Translate( aStartPoint.x, aStartPoint.y, 0.0 );
592  currentManager->Rotate( lineAngle, 0.0f, 0.0f, 1.0f );
593 
594  drawLineQuad( VECTOR2D( 0.0, aWidth / 2.0 ),
595  VECTOR2D( lineLength, aWidth / 2.0 ) );
596 
597  drawLineQuad( VECTOR2D( 0.0, -aWidth / 2.0 ),
598  VECTOR2D( lineLength, -aWidth / 2.0 ) );
599 
600  // Draw line caps
601  drawStrokedSemiCircle( VECTOR2D( 0.0, 0.0 ), aWidth / 2, M_PI / 2 );
602  drawStrokedSemiCircle( VECTOR2D( lineLength, 0.0 ), aWidth / 2, -M_PI / 2 );
603 
604  Restore();
605  }
606 }
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:298
void drawLineQuad(const VECTOR2D &aStartPoint, const VECTOR2D &aEndPoint)
Draw a quad for the line.
virtual void Restore() override
Restore the context.
void Rotate(GLfloat aAngle, GLfloat aX, GLfloat aY, GLfloat aZ)
Function Rotate() multiplies the current matrix by a rotation matrix, so the newly vertices will be r...
double g
Green component.
Definition: color4d.h:288
COLOR4D fillColor
The fill color.
virtual void SetLineWidth(float aLineWidth)
Set the line width.
double b
Blue component.
Definition: color4d.h:289
double Angle() const
Function Angle computes the angle of the vector.
Definition: vector2d.h:306
virtual void Save() override
Save the context.
double a
Alpha component.
Definition: color4d.h:290
VECTOR2< double > VECTOR2D
Definition: vector2d.h:586
COLOR4D strokeColor
The color of the outlines.
void Translate(GLfloat aX, GLfloat aY, GLfloat aZ)
Function Translate() multiplies the current matrix by a translation matrix, so newly vertices will be...
void Color(const COLOR4D &aColor)
Function Color() changes currently used color that will be applied to newly added vertices...
void drawStrokedSemiCircle(const VECTOR2D &aCenterPoint, double aRadius, double aAngle)
Draw a stroked semicircle.
bool isFillEnabled
Is filling of graphic objects enabled ?
double r
Red component.
Definition: color4d.h:287
virtual void DrawCircle(const VECTOR2D &aCenterPoint, double aRadius) override
Draw a circle using world coordinates.
Definition: opengl_gal.cpp:609
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 1644 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.

1645 {
1646  if( isFillEnabled )
1647  {
1649  drawFilledSemiCircle( aCenterPoint, aRadius, aAngle );
1650  }
1651 
1652  if( isStrokeEnabled )
1653  {
1655  drawStrokedSemiCircle( aCenterPoint, aRadius, aAngle );
1656  }
1657 }
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:298
double g
Green component.
Definition: color4d.h:288
COLOR4D fillColor
The fill color.
double b
Blue component.
Definition: color4d.h:289
double a
Alpha component.
Definition: color4d.h:290
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:287
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 1691 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().

1693 {
1694  double outerRadius = aRadius + ( lineWidth / 2 );
1695 
1696  Save();
1697 
1698  currentManager->Reserve( 3 );
1699  currentManager->Translate( aCenterPoint.x, aCenterPoint.y, 0.0f );
1700  currentManager->Rotate( aAngle, 0.0f, 0.0f, 1.0f );
1701 
1702  /* Draw a triangle that contains the semicircle, then shade it to leave only
1703  * the semicircle. Parameters given to Shader() are indices of the triangle's vertices
1704  * (if you want to understand more, check the vertex shader source [shader.vert]), the
1705  * radius and the line width. Shader uses these coordinates to determine if fragments are
1706  * inside the semicircle or not.
1707  * v2
1708  * /\
1709  * /__\
1710  * v0 //__\\ v1
1711  */
1713  currentManager->Vertex( -outerRadius * 3.0f / sqrt( 3.0f ), 0.0f, layerDepth ); // v0
1714 
1716  currentManager->Vertex( outerRadius * 3.0f / sqrt( 3.0f ), 0.0f, layerDepth ); // v1
1717 
1719  currentManager->Vertex( 0.0f, outerRadius * 2.0f, layerDepth ); // v2
1720 
1721  Restore();
1722 }
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:298
double layerDepth
The actual layer depth.
bool Reserve(unsigned int aSize)
Function Reserve() allocates space for vertices, so it will be used with subsequent Vertex() calls...
virtual void Restore() override
Restore the context.
bool Vertex(const VERTEX &aVertex)
Function Vertex() adds a vertex with the given coordinates to the currently set item.
void Rotate(GLfloat aAngle, GLfloat aX, GLfloat aY, GLfloat aZ)
Function Rotate() multiplies the current matrix by a rotation matrix, so the newly vertices will be r...
virtual void Save() override
Save the context.
void Translate(GLfloat aX, GLfloat aY, GLfloat aZ)
Function Translate() multiplies the current matrix by a translation matrix, so newly vertices will be...
float lineWidth
The line width.
void Shader(GLfloat aShaderType, GLfloat aParam1=0.0f, GLfloat aParam2=0.0f, GLfloat aParam3=0.0f)
Function Shader() changes currently used shader and its parameters that will be applied to newly adde...
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 926 of file opengl_gal.cpp.

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

Referenced by DrawPolygon().

927 {
930 
931  if( isFillEnabled )
932  {
933  for( unsigned int j = 0; j < aPolySet.TriangulatedPolyCount(); ++j )
934  {
935  auto triPoly = aPolySet.TriangulatedPolygon( j );
936 
937  for( size_t i = 0; i < triPoly->GetTriangleCount(); i++ )
938  {
939  VECTOR2I a, b, c;
940  triPoly->GetTriangle( i, a, b, c );
941  currentManager->Vertex( a.x, a.y, layerDepth );
942  currentManager->Vertex( b.x, b.y, layerDepth );
943  currentManager->Vertex( c.x, c.y, layerDepth );
944  }
945  }
946  }
947 
948  if( isStrokeEnabled )
949  {
950  for( int j = 0; j < aPolySet.OutlineCount(); ++j )
951  {
952  const auto& poly = aPolySet.Polygon( j );
953 
954  for( const auto& lc : poly )
955  {
956  DrawPolyline( lc );
957  }
958  }
959  }
960 }
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:298
double layerDepth
The actual layer depth.
bool Vertex(const VERTEX &aVertex)
Function Vertex() adds a vertex with the given coordinates to the currently set item.
double g
Green component.
Definition: color4d.h:288
COLOR4D fillColor
The fill color.
double b
Blue component.
Definition: color4d.h:289
double a
Alpha component.
Definition: color4d.h:290
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:869
size_t i
Definition: json11.cpp:597
void Shader(GLfloat aShaderType, GLfloat aParam1=0.0f, GLfloat aParam2=0.0f, GLfloat aParam3=0.0f)
Function Shader() changes currently used shader and its parameters that will be applied to newly adde...
double r
Red component.
Definition: color4d.h:287
void OPENGL_GAL::EnableDepthTest ( bool  aEnabled = false)
overridevirtual

Parameters passed to the GLU tesselator.

Reimplemented from KIGFX::GAL.

Definition at line 2101 of file opengl_gal.cpp.

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

Referenced by SetPaintListener().

2102 {
2103  cachedManager->EnableDepthTest( aEnabled );
2104  nonCachedManager->EnableDepthTest( aEnabled );
2105  overlayManager->EnableDepthTest( aEnabled );
2106 }
VERTEX_MANAGER * overlayManager
Container for storing overlaid VERTEX_ITEMs.
Definition: opengl_gal.h:301
VERTEX_MANAGER * nonCachedManager
Container for storing non-cached VERTEX_ITEMs.
Definition: opengl_gal.h:300
VERTEX_MANAGER * cachedManager
Container for storing cached VERTEX_ITEMs.
Definition: opengl_gal.h:299
void EnableDepthTest(bool aEnabled)
Function EnableDepthTest() Enables/disables Z buffer depth test.
void OPENGL_GAL::endDrawing ( )
overrideprivatevirtual

Update handler for OpenGL settings

Reimplemented from KIGFX::GAL.

Definition at line 472 of file opengl_gal.cpp.

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

473 {
474  wxASSERT_MSG( isContextLocked, "What happened to the context lock?" );
475 
476 #ifdef __WXDEBUG__
477  PROF_COUNTER totalRealTime( "OPENGL_GAL::endDrawing()", true );
478 #endif /* __WXDEBUG__ */
479 
480  // Cached & non-cached containers are rendered to the same buffer
484 
485  // Overlay container is rendered to a different buffer
488 
489  // Be sure that the framebuffer is not colorized (happens on specific GPU&drivers combinations)
490  glColor4d( 1.0, 1.0, 1.0, 1.0 );
491 
492  // Draw the remaining contents, blit the rendering targets to the screen, swap the buffers
495  compositor->Present();
496  blitCursor();
497 
498  SwapBuffers();
499 
500 #ifdef __WXDEBUG__
501  totalRealTime.Stop();
502  wxLogTrace( "GAL_PROFILE", wxT( "OPENGL_GAL::endDrawing(): %.1f ms" ), totalRealTime.msecs() );
503 #endif /* __WXDEBUG__ */
504 }
virtual void DrawBuffer(unsigned int aBufferHandle) override
Function DrawBuffer() draws the selected buffer to the output buffer.
unsigned int overlayBuffer
Auxiliary rendering target (for menus etc.)
Definition: opengl_gal.h:306
VERTEX_MANAGER * overlayManager
Container for storing overlaid VERTEX_ITEMs.
Definition: opengl_gal.h:301
bool isContextLocked
Used for assertion checking.
Definition: opengl_gal.h:319
The class PROF_COUNTER is a small class to help profiling.
Definition: profile.h:45
VERTEX_MANAGER * nonCachedManager
Container for storing non-cached VERTEX_ITEMs.
Definition: opengl_gal.h:300
OPENGL_COMPOSITOR * compositor
Handles multiple rendering targets.
Definition: opengl_gal.h:304
virtual void Present() override
Function Present() Call this to present the output buffer to the screen.
unsigned int mainBuffer
Main rendering target.
Definition: opengl_gal.h:305
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:299
void OPENGL_GAL::EndGroup ( )
overridevirtual

End the group.

Reimplemented from KIGFX::GAL.

Definition at line 1457 of file opengl_gal.cpp.

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

Referenced by IsVisible().

1458 {
1460  isGrouping = false;
1461 }
bool isGrouping
Was a group started?
Definition: opengl_gal.h:318
VERTEX_MANAGER * cachedManager
Container for storing cached VERTEX_ITEMs.
Definition: opengl_gal.h:299
void FinishItem() const
Function FinishItem() does the cleaning after adding an item.
void OPENGL_GAL::endUpdate ( )
overrideprivatevirtual

Reimplemented from KIGFX::GAL.

Definition at line 547 of file opengl_gal.cpp.

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

548 {
549  if( !isInitialized )
550  return;
551 
552  cachedManager->Unmap();
553 }
void Unmap()
Function Unmap() unmaps vertex buffer.
VERTEX_MANAGER * cachedManager
Container for storing cached VERTEX_ITEMs.
Definition: opengl_gal.h:299
bool isInitialized
Basic initialization flag, has to be done when the window is visible.
Definition: opengl_gal.h:316
void OPENGL_GAL::Flush ( )
overridevirtual

Force all remaining objects to be drawn.

Reimplemented from KIGFX::GAL.

Definition at line 1381 of file opengl_gal.cpp.

Referenced by IsVisible().

1382 {
1383  glFlush();
1384 }
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 424 of file graphics_abstraction_layer.cpp.

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

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

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

Get the fill color.

Returns
the color for filling a outline.

Definition at line 256 of file graphics_abstraction_layer.h.

References KIGFX::GAL::fillColor.

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

257  {
258  return fillColor;
259  }
COLOR4D fillColor
The fill color.
float KIGFX::GAL::GetGridLineWidth ( ) const
inlineinherited

Get the grid line width.

Returns
the grid line width

Definition at line 934 of file graphics_abstraction_layer.h.

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

935  {
936  return gridLineWidth;
937  }
float 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 402 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().

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

Returns the grid size.

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

Definition at line 886 of file graphics_abstraction_layer.h.

References KIGFX::GAL::gridSize.

Referenced by SCH_BASE_FRAME::SyncView().

887  {
888  return gridSize;
889  }
VECTOR2D gridSize
The grid size.
EDA_TEXT_HJUSTIFY_T KIGFX::GAL::GetHorizontalJustify ( ) const
inlineinherited

Returns current text horizontal justification setting.

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

479  {
481  }
struct KIGFX::GAL::TEXT_PROPERTIES textProperties
EDA_TEXT_HJUSTIFY_T m_horizontalJustify
Horizontal justification.
float KIGFX::GAL::GetLineWidth ( ) const
inlineinherited
const VECTOR2D& KIGFX::GAL::GetLookAtPoint ( ) const
inlineinherited

Get the look at point.

Returns
the look at point.

Definition at line 678 of file graphics_abstraction_layer.h.

References KIGFX::GAL::lookAtPoint.

679  {
680  return lookAtPoint;
681  }
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 747 of file graphics_abstraction_layer.h.

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

748  {
749  return depthRange.y;
750  }
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 739 of file graphics_abstraction_layer.h.

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

740  {
741  return depthRange.x;
742  }
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 1974 of file opengl_gal.cpp.

References groupCounter, groups, and max.

Referenced by BeginGroup().

1975 {
1976  wxASSERT_MSG( groups.size() < std::numeric_limits<unsigned int>::max(),
1977  wxT( "There are no free slots to store a group" ) );
1978 
1979  while( groups.find( groupCounter ) != groups.end() )
1980  {
1981  groupCounter++;
1982  }
1983 
1984  return groupCounter++;
1985 }
GROUPS_MAP groups
Stores informations about VBO objects (groups)
Definition: opengl_gal.h:296
#define max(a, b)
Definition: auxiliary.h:86
unsigned int groupCounter
Counter used for generating keys for groups.
Definition: opengl_gal.h:297
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 373 of file graphics_abstraction_layer.h.

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

374  {
376  }
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.
double KIGFX::GAL::GetRotation ( ) const
inlineinherited

Get the rotation angle.

Returns
The rotation angle (radians).

Definition at line 718 of file graphics_abstraction_layer.h.

References KIGFX::GAL::rotation.

719  {
720  return rotation;
721  }
double rotation
Rotation transformation (radians)
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 614 of file graphics_abstraction_layer.h.

References KIGFX::GAL::screenWorldMatrix.

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

615  {
616  return screenWorldMatrix;
617  }
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 276 of file graphics_abstraction_layer.h.

References KIGFX::GAL::strokeColor.

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

277  {
278  return strokeColor;
279  }
COLOR4D strokeColor
The color of the outlines.
const STROKE_FONT& KIGFX::GAL::GetStrokeFont ( ) const
inlineinherited

Definition at line 318 of file graphics_abstraction_layer.h.

References KIGFX::GAL::strokeFont.

Referenced by EDA_TEXT::GetTextBox().

319  {
320  return strokeFont;
321  }
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 1537 of file opengl_gal.cpp.

References currentTarget.

Referenced by DrawBitmap(), and IsVisible().

1538 {
1539  return currentTarget;
1540 }
RENDER_TARGET currentTarget
Current rendering target.
Definition: opengl_gal.h:307
VECTOR2D GAL::GetTextLineSize ( const UTF8 aText) const
inherited

Compute the X and Y size of a given text.

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

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

Definition at line 170 of file graphics_abstraction_layer.cpp.

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

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

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

Returns current text vertical justification setting.

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

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

Definition at line 330 of file opengl_gal.cpp.

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

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

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

Get the world scale.

Returns
the actual world scale factor.

Definition at line 757 of file graphics_abstraction_layer.h.

References KIGFX::GAL::worldScale.

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

758  {
759  return worldScale;
760  }
double worldScale
The scale factor world->screen.
const MATRIX3x3D& KIGFX::GAL::GetWorldScreenMatrix ( ) const
inlineinherited

Get the world <-> screen transformation matrix.

Returns
the transformation matrix.

Definition at line 604 of file graphics_abstraction_layer.h.

References KIGFX::GAL::worldScreenMatrix.

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

605  {
606  return worldScreenMatrix;
607  }
MATRIX3x3D worldScreenMatrix
World transformation.
double KIGFX::GAL::GetZoomFactor ( ) const
inlineinherited

Get the zoom factor.

Returns
the zoom factor.

Definition at line 698 of file graphics_abstraction_layer.h.

References KIGFX::GAL::zoomFactor.

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

699  {
700  return zoomFactor;
701  }
double zoomFactor
The zoom factor.
void OPENGL_GAL::init ( )
private

Basic OpenGL initialization.

Definition at line 1988 of file opengl_gal.cpp.

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

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

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

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

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

988  {
990  }
bool isCursorEnabled
Is the cursor enabled?
bool forceDisplayCursor
Always show cursor.
bool KIGFX::GAL::IsFlippedX ( ) const
inlineinherited

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

Definition at line 777 of file graphics_abstraction_layer.h.

References KIGFX::GAL::globalFlipX.

778  {
779  return globalFlipX;
780  }
bool globalFlipX
Flag for X axis flipping.
bool KIGFX::GAL::IsFlippedY ( ) const
inlineinherited

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

Definition at line 785 of file graphics_abstraction_layer.h.

References KIGFX::GAL::globalFlipY.

786  {
787  return globalFlipY;
788  }
bool globalFlipY
Flag for Y axis flipping.
bool KIGFX::GAL::IsFontBold ( ) const
inlineinherited

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

Definition at line 424 of file graphics_abstraction_layer.h.

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

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

425  {
426  return textProperties.m_bold;
427  }
struct KIGFX::GAL::TEXT_PROPERTIES textProperties
bool KIGFX::GAL::IsFontItalic ( ) const
inlineinherited

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

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

443  {
444  return textProperties.m_italic;
445  }
struct KIGFX::GAL::TEXT_PROPERTIES textProperties
virtual bool KIGFX::OPENGL_GAL::IsInitialized ( ) const
inlineoverridevirtual

Returns the initalization status for the canvas.

Reimplemented from KIGFX::GAL.

Definition at line 90 of file opengl_gal.h.

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

Returns true if text should displayed mirrored.

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

461  {
462  return textProperties.m_mirrored;
463  }
struct KIGFX::GAL::TEXT_PROPERTIES textProperties
bool KIGFX::OPENGL_GAL::IsVisible ( ) const
inlineoverridevirtual
void OPENGL_GAL::lockContext ( int  aClientCookie)
overrideprivatevirtual

Private: use GAL_CONTEXT_LOCKER RAII object.

Reimplemented from KIGFX::GAL.

Definition at line 507 of file opengl_gal.cpp.

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

508 {
509  wxASSERT_MSG( !isContextLocked, "Context already locked." );
510  isContextLocked = true;
511  lockClientCookie = aClientCookie;
512 
514 }
bool isContextLocked
Used for assertion checking.
Definition: opengl_gal.h:319
static GL_CONTEXT_MANAGER & Get()
Function Get returns the GL_CONTEXT_MANAGER instance (singleton).
void LockCtx(wxGLContext *aContext, wxGLCanvas *aCanvas)
Function LockCtx sets a context as current and prevents other canvases from switching it...
wxGLContext * glPrivContext
Canvas-specific OpenGL context.
Definition: opengl_gal.h:287
void GAL::OnGalDisplayOptionsChanged ( const GAL_DISPLAY_OPTIONS aOptions)
overrideprotectedvirtualinherited

Handler for observer settings changes.

Implements KIGFX::GAL_DISPLAY_OPTIONS_OBSERVER.

Definition at line 90 of file graphics_abstraction_layer.cpp.

References KIGFX::GAL::updatedGalDisplayOptions().

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

This is the OnPaint event handler.

Parameters
aEventis the OnPaint event.

Definition at line 1928 of file opengl_gal.cpp.

References PostPaint().

Referenced by OPENGL_GAL().

1929 {
1930  PostPaint();
1931 }
void PostPaint()
Function PostPaint posts an event to m_paint_listener.
Definition: opengl_gal.h:248
void KIGFX::GAL::PopDepth ( )
inlineinherited

Restores previously stored drawing depth for the depth stack.

Definition at line 1029 of file graphics_abstraction_layer.h.

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

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

1030  {
1031  layerDepth = depthStack.top();
1032  depthStack.pop();
1033  }
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 248 of file opengl_gal.h.

References paintListener.

Referenced by onPaint().

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

Stores current drawing depth on the depth stack.

Definition at line 1021 of file graphics_abstraction_layer.h.

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

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

1022  {
1023  depthStack.push( layerDepth );
1024  }
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 155 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().

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

Resizes the canvas.

Reimplemented from KIGFX::GAL.

Definition at line 1357 of file opengl_gal.cpp.

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

Referenced by IsVisible().

1358 {
1359  screenSize = VECTOR2I( aWidth, aHeight );
1360 
1361  // Resize framebuffers
1362  const float scaleFactor = GetBackingScaleFactor();
1363  compositor->Resize( aWidth * scaleFactor, aHeight * scaleFactor );
1364  isFramebufferInitialized = false;
1365 
1366  wxGLCanvas::SetSize( aWidth, aHeight );
1367 }
VECTOR2< int > VECTOR2I
Definition: vector2d.h:587
OPENGL_COMPOSITOR * compositor
Handles multiple rendering targets.
Definition: opengl_gal.h:304
bool isFramebufferInitialized
Are the framebuffers initialized?
Definition: opengl_gal.h:313
virtual void Resize(unsigned int aWidth, unsigned int aHeight) override
Function Resize() clears the state of COMPOSITOR, so it has to be reinitialized again with the new di...
virtual float GetBackingScaleFactor() const
VECTOR2I screenSize
Screen size in screen coordinates.
void OPENGL_GAL::Restore ( )
overridevirtual

Restore the context.

Reimplemented from KIGFX::GAL.

Definition at line 1439 of file opengl_gal.cpp.

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

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

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

Restore the screen contents.

Reimplemented from KIGFX::GAL.

Definition at line 1509 of file opengl_gal.cpp.

Referenced by IsVisible().

1510 {
1511  wxASSERT_MSG( false, wxT( "Not implemented yet" ) );
1512 }
void OPENGL_GAL::Rotate ( double  aAngle)
overridevirtual

Rotate the context.

Parameters
aAngleis the rotation angle in radians.

Reimplemented from KIGFX::GAL.

Definition at line 1415 of file opengl_gal.cpp.

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

Referenced by IsVisible().

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

Save the context.

Reimplemented from KIGFX::GAL.

Definition at line 1433 of file opengl_gal.cpp.

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

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

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

Save the screen contents.

Reimplemented from KIGFX::GAL.

Definition at line 1503 of file opengl_gal.cpp.

Referenced by IsVisible().

1504 {
1505  wxASSERT_MSG( false, wxT( "Not implemented yet" ) );
1506 }
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 1427 of file opengl_gal.cpp.

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

Referenced by IsVisible().

1428 {
1429  currentManager->Scale( aScale.x, aScale.y, 0.0f );
1430 }
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:298
void Scale(GLfloat aX, GLfloat aY, GLfloat aZ)
Function Scale() multiplies the current matrix by a scaling matrix, so the newly vertices will be sca...
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 906 of file graphics_abstraction_layer.h.

References KIGFX::GAL::axesColor.

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

907  {
908  axesColor = aAxesColor;
909  }
COLOR4D axesColor
Color of the axes.
void KIGFX::GAL::SetAxesEnabled ( bool  aAxesEnabled)
inlineinherited

Enables drawing the axes.

Definition at line 914 of file graphics_abstraction_layer.h.

References KIGFX::GAL::axesEnabled.

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

915  {
916  axesEnabled = aAxesEnabled;
917  }
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 924 of file graphics_abstraction_layer.h.

References KIGFX::GAL::gridTick.

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

925  {
926  gridTick = aInterval;
927  }
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 997 of file graphics_abstraction_layer.h.

References KIGFX::GAL::cursorColor.

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

998  {
999  cursorColor = aCursorColor;
1000  }
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 978 of file graphics_abstraction_layer.h.

References KIGFX::GAL::isCursorEnabled.

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

979  {
980  isCursorEnabled = aCursorEnabled;
981  }
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 731 of file graphics_abstraction_layer.h.

References KIGFX::GAL::depthRange.

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

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

Sets flipping of the screen.

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

Definition at line 768 of file graphics_abstraction_layer.h.

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

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

769  {
770  globalFlipX = xAxis;
771  globalFlipY = yAxis;
772  }
bool globalFlipX
Flag for X axis flipping.