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 KIGFX::GAL_DISPLAY_OPTIONS_OBSERVER

Classes

struct  TessParams
 

Public Member Functions

 OPENGL_GAL (GAL_DISPLAY_OPTIONS &aDisplayOptions, wxWindow *aParent, wxEvtHandler *aMouseListener=nullptr, wxEvtHandler *aPaintListener=nullptr, const wxString &aName=wxT("GLCanvas"))
 Constructor OPENGL_GAL. More...
 
virtual ~OPENGL_GAL ()
 
virtual bool IsInitialized () const override
 Returns the initalization status for the canvas. More...
 
bool IsVisible () const override
 > More...
 
virtual void BeginDrawing () override
 Begin the drawing, needs to be called for every new frame. More...
 
virtual void EndDrawing () override
 End the drawing, needs to be called for every new frame. More...
 
virtual void BeginUpdate () override
 Enables item update mode. More...
 
virtual void EndUpdate () override
 Disables item update mode. More...
 
virtual void DrawLine (const VECTOR2D &aStartPoint, const VECTOR2D &aEndPoint) override
 Draw a line. More...
 
virtual void DrawSegment (const VECTOR2D &aStartPoint, const VECTOR2D &aEndPoint, double aWidth) override
 Draw a rounded segment. More...
 
virtual void DrawCircle (const VECTOR2D &aCenterPoint, double aRadius) override
 Draw a circle using world coordinates. More...
 
virtual void DrawArc (const VECTOR2D &aCenterPoint, double aRadius, double aStartAngle, double aEndAngle) override
 Draw an arc. More...
 
virtual void DrawArcSegment (const VECTOR2D &aCenterPoint, double aRadius, double aStartAngle, double aEndAngle, double aWidth) override
 Draw an arc segment. More...
 
virtual void DrawRectangle (const VECTOR2D &aStartPoint, const VECTOR2D &aEndPoint) override
 Draw a rectangle. More...
 
virtual void DrawPolyline (const std::deque< VECTOR2D > &aPointList) override
 Draw a polyline. More...
 
virtual void DrawPolyline (const VECTOR2D aPointList[], int aListSize) override
 
virtual void DrawPolyline (const SHAPE_LINE_CHAIN &aLineChain) override
 
virtual void DrawPolygon (const std::deque< VECTOR2D > &aPointList) override
 Draw a polygon. More...
 
virtual void DrawPolygon (const VECTOR2D aPointList[], int aListSize) override
 
virtual void DrawPolygon (const SHAPE_POLY_SET &aPolySet) override
 
virtual void DrawCurve (const VECTOR2D &startPoint, const VECTOR2D &controlPointA, const VECTOR2D &controlPointB, const VECTOR2D &endPoint) override
 Draw a cubic bezier spline. More...
 
virtual void BitmapText (const wxString &aText, const VECTOR2D &aPosition, double aRotationAngle) override
 Draws a text using a bitmap font. More...
 
virtual void DrawGrid () override
 > More...
 
virtual void ResizeScreen (int aWidth, int aHeight) override
 Resizes the canvas. More...
 
virtual bool Show (bool aShow) override
 Shows/hides the GAL canvas. More...
 
virtual void Flush () override
 Force all remaining objects to be drawn. More...
 
virtual void ClearScreen (const COLOR4D &aColor) 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 DrawCursor (const VECTOR2D &aCursorPosition) override
 Draw the cursor. More...
 
void PostPaint ()
 Function PostPaint posts an event to m_paint_listener. More...
 
void SetMouseListener (wxEvtHandler *aMouseListener)
 
void SetPaintListener (wxEvtHandler *aPaintListener)
 Parameters passed to the GLU tesselator. More...
 
const VECTOR2IGetScreenPixelSize () const
 Returns GAL canvas size in pixels. More...
 
virtual void SetIsFill (bool aIsFillEnabled)
 Enable/disable fill. More...
 
virtual void SetIsStroke (bool aIsStrokeEnabled)
 Enable/disable stroked outlines. More...
 
virtual void SetFillColor (const COLOR4D &aColor)
 Set the fill color. More...
 
virtual void SetStrokeColor (const COLOR4D &aColor)
 Set the stroke color. More...
 
const COLOR4DGetStrokeColor () const
 Get the stroke color. More...
 
virtual void SetLineWidth (double aLineWidth)
 Set the line width. More...
 
double GetLineWidth () const
 Get the line width. More...
 
virtual void SetLayerDepth (double aLayerDepth)
 Set the depth of the layer (position on the z-axis) More...
 
const STROKE_FONTGetStrokeFont () const
 
virtual void StrokeText (const wxString &aText, const VECTOR2D &aPosition, double aRotationAngle)
 Draws a vector type text using preloaded Newstroke font. More...
 
VECTOR2D GetTextLineSize (const UTF8 &aText) const
 Compute the X and Y size of a given text. More...
 
double GetOverbarVerticalPosition () const
 Compute the vertical position of an overbar, sometimes used in texts. More...
 
virtual void SetTextAttributes (const EDA_TEXT *aText)
 Loads attributes of the given text (bold/italic/underline/mirrored and so on). More...
 
void ResetTextAttributes ()
 Reset text attributes to default styling. More...
 
void SetGlyphSize (const VECTOR2D aGlyphSize)
 Set the font glyph size. More...
 
const VECTOR2DGetGlyphSize () const
 
void SetFontBold (const bool aBold)
 Set bold property of current font. More...
 
bool IsFontBold () const
 Returns true if current font has 'bold' attribute enabled. More...
 
void SetFontItalic (const bool aItalic)
 Set italic property of current font. More...
 
bool IsFontItalic () const
 Returns true if current font has 'italic' attribute enabled. More...
 
void SetTextMirrored (const bool aMirrored)
 Set a mirrored property of text. More...
 
bool IsTextMirrored () const
 Returns true if text should displayed mirrored. More...
 
void SetHorizontalJustify (const EDA_TEXT_HJUSTIFY_T aHorizontalJustify)
 Set the horizontal justify for text drawing. More...
 
EDA_TEXT_HJUSTIFY_T GetHorizontalJustify () const
 Returns current text horizontal justification setting. More...
 
void SetVerticalJustify (const EDA_TEXT_VJUSTIFY_T aVerticalJustify)
 Set the vertical justify for text drawing. More...
 
EDA_TEXT_VJUSTIFY_T GetVerticalJustify () const
 Returns current text vertical justification setting. More...
 
virtual void ComputeWorldScreenMatrix ()
 Compute the world <-> screen transformation matrix. More...
 
const MATRIX3x3DGetWorldScreenMatrix () const
 Get the world <-> screen transformation matrix. More...
 
const MATRIX3x3DGetScreenWorldMatrix () const
 Get the screen <-> world transformation matrix. More...
 
void SetWorldScreenMatrix (const MATRIX3x3D &aMatrix)
 Set the world <-> screen transformation matrix. More...
 
void SetWorldUnitLength (double aWorldUnitLength)
 Set the unit length. More...
 
void SetScreenDPI (double aScreenDPI)
 Set the dots per inch of the screen. More...
 
void SetLookAtPoint (const VECTOR2D &aPoint)
 Set the Point in world space to look at. More...
 
const VECTOR2DGetLookAtPoint () const
 Get the look at point. More...
 
void SetZoomFactor (double aZoomFactor)
 Set the zoom factor of the scene. More...
 
double GetZoomFactor () const
 Get the zoom factor. More...
 
void SetDepthRange (const VECTOR2D &aDepthRange)
 Set the range of the layer depth. More...
 
double GetMinDepth () const
 Returns the minimum depth in the currently used range (the top). More...
 
double GetMaxDepth () const
 Returns the maximum depth in the currently used range (the bottom). More...
 
double GetWorldScale () const
 Get the world scale. More...
 
void SetFlip (bool xAxis, bool yAxis)
 Sets flipping of the screen. More...
 
void SetGridVisibility (bool aVisibility)
 Sets the visibility setting of the grid. More...
 
void SetGridOrigin (const VECTOR2D &aGridOrigin)
 Set the origin point for the grid. More...
 
void SetGridSize (const VECTOR2D &aGridSize)
 Set the grid size. More...
 
const VECTOR2DGetGridSize () const
 Returns the grid size. More...
 
void SetGridColor (const COLOR4D &aGridColor)
 Set the grid color. More...
 
void SetAxesColor (const COLOR4D &aAxesColor)
 Set the axes color. More...
 
void SetAxesEnabled (bool aAxesEnabled)
 Enables drawing the axes. More...
 
void SetCoarseGrid (int aInterval)
 Draw every tick line wider. More...
 
double GetGridLineWidth () const
 Get the grid line width. More...
 
VECTOR2D GetGridPoint (const VECTOR2D &aPoint) const
 Function GetGridPoint() For a given point it returns the nearest point belonging to the grid in world coordinates. More...
 
VECTOR2D ToWorld (const VECTOR2D &aPoint) const
 Compute the point position in world coordinates from given screen coordinates. More...
 
VECTOR2D ToScreen (const VECTOR2D &aPoint) const
 Compute the point position in screen coordinates from given world coordinates. More...
 
void SetCursorEnabled (bool aCursorEnabled)
 Enable/disable cursor. More...
 
bool IsCursorEnabled () const
 Returns information about cursor visibility. More...
 
void SetCursorColor (const COLOR4D &aCursorColor)
 Set the cursor color. More...
 
void AdvanceDepth ()
 Changes the current depth to deeper, so it is possible to draw objects right beneath other. More...
 
void PushDepth ()
 Stores current drawing depth on the depth stack. More...
 
void PopDepth ()
 Restores previously stored drawing depth for the depth stack. More...
 

Static Public Attributes

static const double METRIC_UNIT_LENGTH = 1e9
 

Protected Member Functions

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

Protected Attributes

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

Static Protected Attributes

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

Private Types

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

Private Member Functions

bool updatedGalDisplayOptions (const GAL_DISPLAY_OPTIONS &aOptions) override
 Function updatedGalDisplayOptions. More...
 
void drawLineQuad (const VECTOR2D &aStartPoint, const VECTOR2D &aEndPoint)
 Draw a quad for the line. More...
 
void drawSemiCircle (const VECTOR2D &aCenterPoint, double aRadius, double aAngle)
 Draw a semicircle. More...
 
void drawFilledSemiCircle (const VECTOR2D &aCenterPoint, double aRadius, double aAngle)
 Draw a filled semicircle. More...
 
void drawStrokedSemiCircle (const VECTOR2D &aCenterPoint, double aRadius, double aAngle)
 Draw a stroked semicircle. More...
 
void drawPolyline (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...
 
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 wxString &aText) const
 Computes a size of text drawn using bitmap font with current text setting applied. More...
 
void onPaint (wxPaintEvent &aEvent)
 This is the OnPaint event handler. More...
 
void skipMouseEvent (wxMouseEvent &aEvent)
 Skip the mouse event to the parent. More...
 
void blitCursor ()
 Blits cursor into the current screen. More...
 
unsigned int getNewGroupNumber ()
 Returns a valid key that can be used as a new group number. More...
 
double calcAngleStep (double aRadius) const
 Compute the angle step when drawing arcs/circles approximated with lines. More...
 
void init ()
 Basic OpenGL initialization. More...
 

Private Attributes

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

Static Private Attributes

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

Detailed Description

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

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

Definition at line 65 of file opengl_gal.h.

Member Typedef Documentation

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

Definition at line 299 of file opengl_gal.h.

typedef GAL KIGFX::OPENGL_GAL::super
private

Super class definition.

Definition at line 285 of file opengl_gal.h.

Constructor & Destructor Documentation

OPENGL_GAL::OPENGL_GAL ( 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 66 of file opengl_gal.cpp.

References BLUE, cachedManager, 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, nonCachedManager, onPaint(), KIGFX::GAL::options, overlayManager, KIGFX::GAL::screenSize, KIGFX::OPENGL_COMPOSITOR::SetAntialiasingMode(), KIGFX::GAL::SetAxesColor(), KIGFX::GAL::SetGridColor(), SetTarget(), shader, skipMouseEvent(), KIGFX::TARGET_NONCACHED, and tesselator.

68  :
69  GAL( aDisplayOptions ),
70  wxGLCanvas( aParent, wxID_ANY, (int*) glAttributes, wxDefaultPosition, wxDefaultSize,
71  wxEXPAND, aName ),
72  mouseListener( aMouseListener ), paintListener( aPaintListener )
73 {
74  if( glMainContext == NULL )
75  {
78  shader = new SHADER();
79  }
80  else
81  {
83  }
84 
86 
89 
90  cachedManager = new VERTEX_MANAGER( true );
91  nonCachedManager = new VERTEX_MANAGER( false );
92  overlayManager = new VERTEX_MANAGER( false );
93 
94  // Initialize the flags
97  isInitialized = false;
98  isGrouping = false;
99  groupCounter = 0;
100 
101 #ifdef RETINA_OPENGL_PATCH
102  SetViewWantsBestResolution( true );
103 #endif
104 
105  // Connecting the event handlers
106  Connect( wxEVT_PAINT, wxPaintEventHandler( OPENGL_GAL::onPaint ) );
107 
108  // Mouse events are skipped to the parent
109  Connect( wxEVT_MOTION, wxMouseEventHandler( OPENGL_GAL::skipMouseEvent ) );
110  Connect( wxEVT_LEFT_DOWN, wxMouseEventHandler( OPENGL_GAL::skipMouseEvent ) );
111  Connect( wxEVT_LEFT_UP, wxMouseEventHandler( OPENGL_GAL::skipMouseEvent ) );
112  Connect( wxEVT_LEFT_DCLICK, wxMouseEventHandler( OPENGL_GAL::skipMouseEvent ) );
113  Connect( wxEVT_MIDDLE_DOWN, wxMouseEventHandler( OPENGL_GAL::skipMouseEvent ) );
114  Connect( wxEVT_MIDDLE_UP, wxMouseEventHandler( OPENGL_GAL::skipMouseEvent ) );
115  Connect( wxEVT_MIDDLE_DCLICK, wxMouseEventHandler( OPENGL_GAL::skipMouseEvent ) );
116  Connect( wxEVT_RIGHT_DOWN, wxMouseEventHandler( OPENGL_GAL::skipMouseEvent ) );
117  Connect( wxEVT_RIGHT_UP, wxMouseEventHandler( OPENGL_GAL::skipMouseEvent ) );
118  Connect( wxEVT_RIGHT_DCLICK, wxMouseEventHandler( OPENGL_GAL::skipMouseEvent ) );
119  Connect( wxEVT_MOUSEWHEEL, wxMouseEventHandler( OPENGL_GAL::skipMouseEvent ) );
120 #if wxCHECK_VERSION( 3, 1, 0 ) || defined( USE_OSX_MAGNIFY_EVENT )
121  Connect( wxEVT_MAGNIFY, wxMouseEventHandler( OPENGL_GAL::skipMouseEvent ) );
122 #endif
123 #if defined _WIN32 || defined _WIN64
124  Connect( wxEVT_ENTER_WINDOW, wxMouseEventHandler( OPENGL_GAL::skipMouseEvent ) );
125 #endif
126 
127  SetSize( aParent->GetSize() );
128  screenSize = VECTOR2I( aParent->GetSize() );
129 
130  // Grid color settings are different in Cairo and OpenGL
131  SetGridColor( COLOR4D( 0.8, 0.8, 0.8, 0.1 ) );
132  SetAxesColor( COLOR4D( BLUE ) );
133 
134  // Tesselator initialization
135  tesselator = gluNewTess();
137 
138  if( tesselator == NULL )
139  throw std::runtime_error( "Could not create the tesselator" );
140 
141  gluTessProperty( tesselator, GLU_TESS_WINDING_RULE, GLU_TESS_WINDING_POSITIVE );
142 
144 }
Definition: colors.h:57
static SHADER * shader
There is only one shader used for different objects.
Definition: opengl_gal.h:314
static wxGLContext * glMainContext
Parent OpenGL context.
Definition: opengl_gal.h:290
bool isBitmapFontInitialized
Is the shader set to use bitmap fonts?
Definition: opengl_gal.h:319
VERTEX_MANAGER * overlayManager
Container for storing overlaid VERTEX_ITEMs.
Definition: opengl_gal.h:305
GAL_DISPLAY_OPTIONS & options
static void InitTesselatorCallbacks(GLUtesselator *aTesselator)
VECTOR2< int > VECTOR2I
Definition: vector2d.h:590
bool isGrouping
Was a group started?
Definition: opengl_gal.h:322
OPENGL_ANTIALIASING_MODE gl_antialiasing_mode
VERTEX_MANAGER * nonCachedManager
Container for storing non-cached VERTEX_ITEMs.
Definition: opengl_gal.h:304
Auxiliary rendering target (noncached)
Definition: definitions.h:42
static int instanceCounter
GL GAL instance counter.
Definition: opengl_gal.h:292
void SetAntialiasingMode(OPENGL_ANTIALIASING_MODE aMode)
static GL_CONTEXT_MANAGER & Get()
Function Get returns the GL_CONTEXT_MANAGER instance (singleton).
GAL(GAL_DISPLAY_OPTIONS &aOptions)
void SetGridColor(const COLOR4D &aGridColor)
Set the grid color.
OPENGL_COMPOSITOR * compositor
Handles multiple rendering targets.
Definition: opengl_gal.h:308
wxEvtHandler * mouseListener
Definition: opengl_gal.h:293
void SetAxesColor(const COLOR4D &aAxesColor)
Set the axes color.
static const int glAttributes[]
Definition: opengl_gal.cpp:57
void onPaint(wxPaintEvent &aEvent)
This is the OnPaint event handler.
bool isFramebufferInitialized
Are the framebuffers initialized?
Definition: opengl_gal.h:317
Class SHADER provides the access to the OpenGL shaders.
Definition: shader.h:74
GLUtesselator * tesselator
The tessellator.
Definition: opengl_gal.h:329
VERTEX_MANAGER * cachedManager
Container for storing cached VERTEX_ITEMs.
Definition: opengl_gal.h:303
wxEvtHandler * paintListener
Definition: opengl_gal.h:294
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:320
unsigned int groupCounter
Counter used for generating keys for groups.
Definition: opengl_gal.h:301
VECTOR2I screenSize
Screen size in screen coordinates.
wxGLContext * glPrivContext
Canvas-specific OpenGL context.
Definition: opengl_gal.h:291
wxGLContext * CreateCtx(wxGLCanvas *aCanvas, const wxGLContext *aOther=NULL)
Function CreateCtx creates a managed OpenGL context.
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 147 of file opengl_gal.cpp.

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

148 {
150 
151  --instanceCounter;
152  glFlush();
153  gluDeleteTess( tesselator );
154  ClearCache();
155 
156  delete compositor;
157  delete cachedManager;
158  delete nonCachedManager;
159  delete overlayManager;
160 
162 
163  // If it was the main context, then it will be deleted
164  // when the last OpenGL GAL instance is destroyed (a few lines below)
167 
168  // Are we destroying the last GAL instance?
169  if( instanceCounter == 0 )
170  {
172 
173  if( isBitmapFontLoaded )
174  {
175  glDeleteTextures( 1, &fontTexture );
176  isBitmapFontLoaded = false;
177  }
178 
179  delete shader;
180 
183  glMainContext = NULL;
184  }
185 }
static SHADER * shader
There is only one shader used for different objects.
Definition: opengl_gal.h:314
static wxGLContext * glMainContext
Parent OpenGL context.
Definition: opengl_gal.h:290
static GLuint fontTexture
Bitmap font texture handle (shared)
Definition: opengl_gal.h:296
VERTEX_MANAGER * overlayManager
Container for storing overlaid VERTEX_ITEMs.
Definition: opengl_gal.h:305
void UnlockCtx(wxGLContext *aContext)
Function UnlockCtx allows other canvases to bind an OpenGL context.
VERTEX_MANAGER * nonCachedManager
Container for storing non-cached VERTEX_ITEMs.
Definition: opengl_gal.h:304
static int instanceCounter
GL GAL instance counter.
Definition: opengl_gal.h:292
static GL_CONTEXT_MANAGER & Get()
Function Get returns the GL_CONTEXT_MANAGER instance (singleton).
OPENGL_COMPOSITOR * compositor
Handles multiple rendering targets.
Definition: opengl_gal.h:308
virtual void ClearCache() override
Delete all data created during caching of graphic items.
GLUtesselator * tesselator
The tessellator.
Definition: opengl_gal.h:329
void LockCtx(wxGLContext *aContext, wxGLCanvas *aCanvas)
Function LockCtx sets a context as current and prevents other canvases from switching it...
VERTEX_MANAGER * cachedManager
Container for storing cached VERTEX_ITEMs.
Definition: opengl_gal.h:303
wxGLContext * glPrivContext
Canvas-specific OpenGL context.
Definition: opengl_gal.h:291
void DestroyCtx(wxGLContext *aContext)
Function DestroyCtx destroys a managed OpenGL context.
static bool isBitmapFontLoaded
Is the bitmap font texture loaded?
Definition: opengl_gal.h:318

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

References KIGFX::GAL::layerDepth.

941  {
942  layerDepth -= 0.05;
943  }
double layerDepth
The actual layer depth.
void OPENGL_GAL::BeginDrawing ( )
overridevirtual

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

Reimplemented from KIGFX::GAL.

Definition at line 209 of file opengl_gal.cpp.

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

210 {
211  if( !IsShownOnScreen() )
212  return;
213 
214 #ifdef __WXDEBUG__
215  PROF_COUNTER totalRealTime( "OPENGL_GAL::BeginDrawing()", true );
216 #endif /* __WXDEBUG__ */
217 
218  if( !isInitialized )
219  init();
220 
222 
223  // Set up the view port
224  glMatrixMode( GL_PROJECTION );
225  glLoadIdentity();
226 
227  // Create the screen transformation (Do the RH-LH conversion here)
228  glOrtho( 0, (GLint) screenSize.x, (GLsizei) screenSize.y, 0, -depthRange.x, -depthRange.y );
229 
231  {
232  try
233  {
234  // Prepare rendering target buffers
238  }
239  catch( std::runtime_error& )
240  {
242  throw; // DRAW_PANEL_GAL will handle it
243  }
244 
246  }
247 
248  compositor->Begin();
249 
250  // Disable 2D Textures
251  glDisable( GL_TEXTURE_2D );
252 
253  glShadeModel( GL_FLAT );
254 
255  // Enable the depth buffer
256  glEnable( GL_DEPTH_TEST );
257  glDepthFunc( GL_LESS );
258 
259  // Setup blending, required for transparent objects
260  glEnable( GL_BLEND );
261  glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
262 
263  glMatrixMode( GL_MODELVIEW );
264 
265  // Set up the world <-> screen transformation
267  GLdouble matrixData[16] = { 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1 };
268  matrixData[0] = worldScreenMatrix.m_data[0][0];
269  matrixData[1] = worldScreenMatrix.m_data[1][0];
270  matrixData[2] = worldScreenMatrix.m_data[2][0];
271  matrixData[4] = worldScreenMatrix.m_data[0][1];
272  matrixData[5] = worldScreenMatrix.m_data[1][1];
273  matrixData[6] = worldScreenMatrix.m_data[2][1];
274  matrixData[12] = worldScreenMatrix.m_data[0][2];
275  matrixData[13] = worldScreenMatrix.m_data[1][2];
276  matrixData[14] = worldScreenMatrix.m_data[2][2];
277  glLoadMatrixd( matrixData );
278 
279  // Set defaults
282 
283  // Remove all previously stored items
286 
290 
292  {
293  // Keep bitmap font texture always bound to the second texturing unit
294  const GLint FONT_TEXTURE_UNIT = 2;
295 
296  // Either load the font atlas to video memory, or simply bind it to a texture unit
297  if( !isBitmapFontLoaded )
298  {
299  glActiveTexture( GL_TEXTURE0 + FONT_TEXTURE_UNIT );
300  glGenTextures( 1, &fontTexture );
301  glBindTexture( GL_TEXTURE_2D, fontTexture );
302  glTexImage2D( GL_TEXTURE_2D, 0, GL_RGB8, font_image.width, font_image.height,
303  0, GL_RGB, GL_UNSIGNED_BYTE, font_image.pixels );
304  glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
305  glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
306  checkGlError( "loading bitmap font" );
307 
308  glActiveTexture( GL_TEXTURE0 );
309 
310  isBitmapFontLoaded = true;
311  }
312  else
313  {
314  glActiveTexture( GL_TEXTURE0 + FONT_TEXTURE_UNIT );
315  glBindTexture( GL_TEXTURE_2D, fontTexture );
316  glActiveTexture( GL_TEXTURE0 );
317  }
318 
319  // Set shader parameter
320  GLint ufm_fontTexture = shader->AddParameter( "fontTexture" );
321  GLint ufm_fontTextureWidth = shader->AddParameter( "fontTextureWidth" );
322  shader->Use();
323  shader->SetParameter( ufm_fontTexture, (int) FONT_TEXTURE_UNIT );
324  shader->SetParameter( ufm_fontTextureWidth, (int) font_image.width );
325  shader->Deactivate();
326  checkGlError( "setting bitmap font sampler as shader parameter" );
327 
329  }
330 
331  // Something betreen BeginDrawing and EndDrawing seems to depend on
332  // this texture unit being active, but it does not assure it itself.
333  glActiveTexture( GL_TEXTURE0 );
334 
335  // Unbind buffers - set compositor for direct drawing
337 
338 #ifdef __WXDEBUG__
339  totalRealTime.Stop();
340  wxLogTrace( "GAL_PROFILE",
341  wxT( "OPENGL_GAL::BeginDrawing(): %.1f ms" ), totalRealTime.msecs() );
342 #endif /* __WXDEBUG__ */
343 }
virtual void SetFillColor(const COLOR4D &aColor)
Set the fill color.
static SHADER * shader
There is only one shader used for different objects.
Definition: opengl_gal.h:314
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:310
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:319
void Use()
Use the shader.
Definition: shader.h:130
void SetParameter(int aParameterNumber, float aValue) const
Set a parameter of the shader.
Definition: shader.cpp:137
static GLuint fontTexture
Bitmap font texture handle (shared)
Definition: opengl_gal.h:296
VERTEX_MANAGER * overlayManager
Container for storing overlaid VERTEX_ITEMs.
Definition: opengl_gal.h:305
COLOR4D fillColor
The fill color.
VECTOR2D depthRange
Range of the depth.
int checkGlError(const std::string &aInfo, bool aThrow)
Checks if one of recent OpenGL operations has failed.
Definition: utils.cpp:30
static const unsigned int DIRECT_RENDERING
virtual void ComputeWorldScreenMatrix()
Compute the world <-> screen transformation matrix.
The class PROF_COUNTER is a small class to help profiling.
Definition: profile.h:45
void UnlockCtx(wxGLContext *aContext)
Function UnlockCtx allows other canvases to bind an OpenGL context.
VERTEX_MANAGER * nonCachedManager
Container for storing non-cached VERTEX_ITEMs.
Definition: opengl_gal.h:304
T m_data[3][3]
Definition: matrix3x3.h:64
static GL_CONTEXT_MANAGER & Get()
Function Get returns the GL_CONTEXT_MANAGER instance (singleton).
void init()
Basic OpenGL initialization.
OPENGL_COMPOSITOR * compositor
Handles multiple rendering targets.
Definition: opengl_gal.h:308
unsigned int mainBuffer
Main rendering target.
Definition: opengl_gal.h:309
COLOR4D strokeColor
The color of the outlines.
int AddParameter(const std::string &aParameterName)
Add a parameter to the parameter queue.
Definition: shader.cpp:124
void Deactivate()
Deactivate the shader and use the default OpenGL program.
Definition: shader.h:139
bool isFramebufferInitialized
Are the framebuffers initialized?
Definition: opengl_gal.h:317
FONT_IMAGE_TYPE font_image
Definition: gl_resources.cpp:4
unsigned char pixels[1024 *1024 *3]
Definition: gl_resources.h:38
MATRIX3x3D worldScreenMatrix
World transformation.
virtual void SetBuffer(unsigned int aBufferHandle) override
Function SetBuffer() sets the selected buffer as the rendering target.
void BeginDrawing() const
Function BeginDrawing() prepares buffers and items to start drawing.
void LockCtx(wxGLContext *aContext, wxGLCanvas *aCanvas)
Function LockCtx sets a context as current and prevents other canvases from switching it...
VERTEX_MANAGER * cachedManager
Container for storing cached VERTEX_ITEMs.
Definition: opengl_gal.h:303
virtual void Initialize() override
Function Reset() performs primary initialiation, necessary to use the object.
virtual void SetStrokeColor(const COLOR4D &aColor)
Set the stroke color.
bool isInitialized
Basic initialization flag, has to be done when the window is visible.
Definition: opengl_gal.h:320
VECTOR2I screenSize
Screen size in screen coordinates.
wxGLContext * glPrivContext
Canvas-specific OpenGL context.
Definition: opengl_gal.h:291
virtual unsigned int CreateBuffer() override
Function CreateBuffer() prepares a new buffer that may be used as a rendering target.
static bool isBitmapFontLoaded
Is the bitmap font texture loaded?
Definition: opengl_gal.h:318
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 1205 of file opengl_gal.cpp.

References getNewGroupNumber(), groups, and isGrouping.

1206 {
1207  isGrouping = true;
1208 
1209  std::shared_ptr<VERTEX_ITEM> newItem = std::make_shared<VERTEX_ITEM>( *cachedManager );
1210  int groupNumber = getNewGroupNumber();
1211  groups.insert( std::make_pair( groupNumber, newItem ) );
1212 
1213  return groupNumber;
1214 }
bool isGrouping
Was a group started?
Definition: opengl_gal.h:322
GROUPS_MAP groups
Stores informations about VBO objects (groups)
Definition: opengl_gal.h:300
unsigned int getNewGroupNumber()
Returns a valid key that can be used as a new group number.
void OPENGL_GAL::BeginUpdate ( )
overridevirtual

Enables item update mode.

Reimplemented from KIGFX::GAL.

Definition at line 380 of file opengl_gal.cpp.

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

381 {
382  if( !IsShownOnScreen() )
383  return;
384 
385  if( !isInitialized )
386  init();
387 
389  cachedManager->Map();
390 }
static GL_CONTEXT_MANAGER & Get()
Function Get returns the GL_CONTEXT_MANAGER instance (singleton).
void init()
Basic OpenGL initialization.
void Map()
Function Map() maps vertex buffer.
void LockCtx(wxGLContext *aContext, wxGLCanvas *aCanvas)
Function LockCtx sets a context as current and prevents other canvases from switching it...
VERTEX_MANAGER * cachedManager
Container for storing cached VERTEX_ITEMs.
Definition: opengl_gal.h:303
bool isInitialized
Basic initialization flag, has to be done when the window is visible.
Definition: opengl_gal.h:320
wxGLContext * glPrivContext
Canvas-specific OpenGL context.
Definition: opengl_gal.h:291
void 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 831 of file opengl_gal.cpp.

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

833 {
834  wxASSERT_MSG( !IsTextMirrored(), "No support for mirrored text using bitmap fonts." );
835 
836  // Compute text size, so it can be properly justified
837  VECTOR2D textSize;
838  float commonOffset;
839  std::tie( textSize, commonOffset ) = computeBitmapTextSize( aText );
840 
841  const double SCALE = GetGlyphSize().y / textSize.y;
842  int tildas = 0;
843  bool overbar = false;
844 
845  int overbarLength = 0;
846  double overbarHeight = textSize.y;
847 
848  Save();
849 
851  currentManager->Translate( aPosition.x, aPosition.y, layerDepth );
852  currentManager->Rotate( aRotationAngle, 0.0f, 0.0f, -1.0f );
853 
854  double sx = SCALE * ( globalFlipX ? -1.0 : 1.0 );
855  double sy = SCALE * ( globalFlipY ? -1.0 : 1.0 );
856 
857  currentManager->Scale( sx, sy, 0 );
858  currentManager->Translate( 0, -commonOffset, 0 );
859 
860  switch( GetHorizontalJustify() )
861  {
863  Translate( VECTOR2D( -textSize.x / 2.0, 0 ) );
864  break;
865 
867  //if( !IsTextMirrored() )
868  Translate( VECTOR2D( -textSize.x, 0 ) );
869  break;
870 
872  //if( IsTextMirrored() )
873  //Translate( VECTOR2D( -textSize.x, 0 ) );
874  break;
875  }
876 
877  switch( GetVerticalJustify() )
878  {
880  Translate( VECTOR2D( 0, -textSize.y ) );
881  overbarHeight = -textSize.y / 2.0;
882  break;
883 
885  Translate( VECTOR2D( 0, -textSize.y / 2.0 ) );
886  overbarHeight = 0;
887  break;
888 
890  break;
891  }
892 
893  for( unsigned int ii = 0; ii < aText.length(); ++ii )
894  {
895  const unsigned int c = aText[ii];
896 
897  wxASSERT_MSG( LookupGlyph(c) != nullptr, wxT( "Missing character in bitmap font atlas." ) );
898  wxASSERT_MSG( c != '\n' && c != '\r', wxT( "No support for multiline bitmap text yet" ) );
899 
900  // Handle overbar
901  if( c == '~' )
902  {
903  overbar = !overbar;
904  ++tildas;
905  continue;
906  }
907  else if( tildas > 0 )
908  {
909  if( tildas % 2 == 1 )
910  {
911  if( overbar ) // Overbar begins
912  overbarLength = 0;
913  else if( overbarLength > 0 ) // Overbar finishes
914  drawBitmapOverbar( overbarLength, overbarHeight );
915 
916  --tildas;
917  }
918 
919  // Draw tilda characters if there are any remaining
920  for( int jj = 0; jj < tildas / 2; ++jj )
921  overbarLength += drawBitmapChar( '~' );
922 
923  tildas = 0;
924  }
925 
926  overbarLength += drawBitmapChar( c );
927  }
928 
929  // Handle the case when overbar is active till the end of the drawn text
930  currentManager->Translate( 0, commonOffset, 0 );
931 
932  if( overbar )
933  drawBitmapOverbar( overbarLength, overbarHeight );
934 
935  Restore();
936 }
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:302
EDA_TEXT_HJUSTIFY_T GetHorizontalJustify() const
Returns current text horizontal justification setting.
EDA_TEXT_VJUSTIFY_T GetVerticalJustify() const
Returns current text vertical justification setting.
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:287
bool globalFlipX
Flag for X axis flipping.
const FONT_GLYPH_TYPE * LookupGlyph(unsigned int aCodepoint)
double b
Blue component.
Definition: color4d.h:288
virtual void Save() override
Save the context.
double a
Alpha component.
Definition: color4d.h:289
VECTOR2< double > VECTOR2D
Definition: vector2d.h:589
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...
bool globalFlipY
Flag for Y axis flipping.
int drawBitmapChar(unsigned long aChar)
Draws a single character using bitmap font.
void Scale(GLfloat aX, GLfloat aY, GLfloat aZ)
Function Scale() multiplies the current matrix by a scaling matrix, so the newly vertices will be sca...
std::pair< VECTOR2D, float > computeBitmapTextSize(const wxString &aText) const
Computes a size of text drawn using bitmap font with current text setting applied.
double r
Red component.
Definition: color4d.h:286
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 1657 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().

1658 {
1659  if( !IsCursorEnabled() )
1660  return;
1661 
1663 
1664  const int cursorSize = fullscreenCursor ? 8000 : 80;
1665 
1666  VECTOR2D cursorBegin = cursorPosition - cursorSize / ( 2 * worldScale );
1667  VECTOR2D cursorEnd = cursorPosition + cursorSize / ( 2 * worldScale );
1668  VECTOR2D cursorCenter = ( cursorBegin + cursorEnd ) / 2;
1669 
1670  const COLOR4D cColor = getCursorColor();
1671  const COLOR4D color( cColor.r * cColor.a, cColor.g * cColor.a,
1672  cColor.b * cColor.a, 1.0 );
1673 
1674  glDisable( GL_TEXTURE_2D );
1675  glLineWidth( 1.0 );
1676  glColor4d( color.r, color.g, color.b, color.a );
1677 
1678  glBegin( GL_LINES );
1679  glVertex2d( cursorCenter.x, cursorBegin.y );
1680  glVertex2d( cursorCenter.x, cursorEnd.y );
1681 
1682  glVertex2d( cursorBegin.x, cursorCenter.y );
1683  glVertex2d( cursorEnd.x, cursorCenter.y );
1684  glEnd();
1685 }
bool IsCursorEnabled() const
Returns information about cursor visibility.
VECTOR2D cursorPosition
Current cursor position (world coordinates)
double g
Green component.
Definition: color4d.h:287
static const unsigned int DIRECT_RENDERING
double b
Blue component.
Definition: color4d.h:288
double a
Alpha component.
Definition: color4d.h:289
OPENGL_COMPOSITOR * compositor
Handles multiple rendering targets.
Definition: opengl_gal.h:308
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:286
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 446 of file opengl_gal.h.

References min.

Referenced by DrawArc(), and DrawArcSegment().

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

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

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

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

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

Delete all data created during caching of graphic items.

Reimplemented from KIGFX::GAL.

Definition at line 1249 of file opengl_gal.cpp.

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

Referenced by ~OPENGL_GAL().

1250 {
1251  groups.clear();
1252  cachedManager->Clear();
1253 }
void Clear() const
Function Clear() removes all the stored vertices from the container.
GROUPS_MAP groups
Stores informations about VBO objects (groups)
Definition: opengl_gal.h:300
VERTEX_MANAGER * cachedManager
Container for storing cached VERTEX_ITEMs.
Definition: opengl_gal.h:303
void OPENGL_GAL::ClearScreen ( const COLOR4D aColor)
overridevirtual

Clear the screen.

Parameters
aColoris the color used for clearing.

Reimplemented from KIGFX::GAL.

Definition at line 1148 of file opengl_gal.cpp.

References KIGFX::COLOR4D::a, KIGFX::COLOR4D::b, compositor, KIGFX::OPENGL_COMPOSITOR::DIRECT_RENDERING, KIGFX::COLOR4D::g, KIGFX::COLOR4D::r, and KIGFX::OPENGL_COMPOSITOR::SetBuffer().

1149 {
1150  // Clear screen
1152  glClearColor( aColor.r, aColor.g, aColor.b, aColor.a );
1153  glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT );
1154 }
double g
Green component.
Definition: color4d.h:287
static const unsigned int DIRECT_RENDERING
double b
Blue component.
Definition: color4d.h:288
double a
Alpha component.
Definition: color4d.h:289
OPENGL_COMPOSITOR * compositor
Handles multiple rendering targets.
Definition: opengl_gal.h:308
virtual void SetBuffer(unsigned int aBufferHandle) override
Function SetBuffer() sets the selected buffer as the rendering target.
double r
Red component.
Definition: color4d.h:286
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 1296 of file opengl_gal.cpp.

References KIGFX::OPENGL_COMPOSITOR::ClearBuffer(), compositor, KIGFX::OPENGL_COMPOSITOR::GetBuffer(), mainBuffer, overlayBuffer, KIGFX::OPENGL_COMPOSITOR::SetBuffer(), KIGFX::TARGET_CACHED, KIGFX::TARGET_NONCACHED, and KIGFX::TARGET_OVERLAY.

1297 {
1298  // Save the current state
1299  unsigned int oldTarget = compositor->GetBuffer();
1300 
1301  switch( aTarget )
1302  {
1303  // Cached and noncached items are rendered to the same buffer
1304  default:
1305  case TARGET_CACHED:
1306  case TARGET_NONCACHED:
1308  break;
1309 
1310  case TARGET_OVERLAY:
1312  break;
1313  }
1314 
1316 
1317  // Restore the previous state
1318  compositor->SetBuffer( oldTarget );
1319 }
unsigned int overlayBuffer
Auxiliary rendering target (for menus etc.)
Definition: opengl_gal.h:310
Auxiliary rendering target (noncached)
Definition: definitions.h:42
virtual void ClearBuffer() override
Function ClearBuffer() clears the selected buffer (set by the SetBuffer() function).
OPENGL_COMPOSITOR * compositor
Handles multiple rendering targets.
Definition: opengl_gal.h:308
unsigned int mainBuffer
Main rendering target.
Definition: opengl_gal.h:309
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 wxString &  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 1604 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, KIGFX::BUILTIN_FONT::FONT_GLYPH_TYPE::maxy, KIGFX::BUILTIN_FONT::FONT_GLYPH_TYPE::miny, VECTOR2< T >::x, and VECTOR2< T >::y.

Referenced by BitmapText().

1605 {
1606  VECTOR2D textSize( 0, 0 );
1607  float commonOffset = std::numeric_limits<float>::max();
1608  bool wasTilda = false;
1609 
1610  for( unsigned int i = 0; i < aText.length(); ++i )
1611  {
1612  // Remove overbar control characters
1613  if( aText[i] == '~' )
1614  {
1615  if( !wasTilda )
1616  {
1617  // Only double tildas are counted as characters, so skip it as it might
1618  // be an overbar control character
1619  wasTilda = true;
1620  continue;
1621  }
1622  else
1623  {
1624  // Double tilda detected, reset the state and process as a normal character
1625  wasTilda = false;
1626  }
1627  }
1628 
1629  const FONT_GLYPH_TYPE* glyph = LookupGlyph(aText[i]);
1630  if( glyph ) {
1631  textSize.x += glyph->advance;
1632  textSize.y = std::max<float>( textSize.y, font_information.max_y - glyph->miny );
1633  commonOffset = std::min<float>( font_information.max_y - glyph->maxy, commonOffset );
1634  }
1635  }
1636 
1637  textSize.y -= commonOffset;
1638 
1639  return std::make_pair( textSize, commonOffset );
1640 }
const FONT_GLYPH_TYPE * LookupGlyph(unsigned int aCodepoint)
FONT_INFO_TYPE font_information
Definition: gl_resources.cpp:3
#define max(a, b)
Definition: auxiliary.h:86
double GAL::computeMinGridSpacing ( ) const
protectedinherited

compute minimum grid spacing from the grid settings

Returns
the minimum spacing to use for drawing the grid

Definition at line 205 of file graphics_abstraction_layer.cpp.

References KIGFX::GAL::gridMinSpacing.

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

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

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

Definition at line 1020 of file graphics_abstraction_layer.h.

References KIGFX::GAL::zoomFactor.

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

1021  {
1023  }
double zoomFactor
The zoom factor.
double worldUnitLength
The unit length of the world coordinates [inch].
double worldScale
The scale factor world->screen.
double screenDPI
The dots per inch of the screen.
void GAL::ComputeWorldScreenMatrix ( )
virtualinherited

Compute the world <-> screen transformation matrix.

Definition at line 177 of file graphics_abstraction_layer.cpp.

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

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

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

References groups.

1243 {
1244  // Frees memory in the container as well
1245  groups.erase( aGroupNumber );
1246 }
GROUPS_MAP groups
Stores informations about VBO objects (groups)
Definition: opengl_gal.h:300
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 526 of file opengl_gal.cpp.

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

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

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

594 {
595  if( aRadius <= 0 )
596  return;
597 
598  // Swap the angles, if start angle is greater than end angle
599  SWAP( aStartAngle, >, aEndAngle );
600 
601  const double alphaIncrement = calcAngleStep( aRadius );
602 
603  Save();
604  currentManager->Translate( aCenterPoint.x, aCenterPoint.y, 0.0 );
605 
606  if( isStrokeEnabled )
607  {
609 
610  double width = aWidth / 2.0;
611  VECTOR2D startPoint( cos( aStartAngle ) * aRadius,
612  sin( aStartAngle ) * aRadius );
613  VECTOR2D endPoint( cos( aEndAngle ) * aRadius,
614  sin( aEndAngle ) * aRadius );
615 
616  drawStrokedSemiCircle( startPoint, width, aStartAngle + M_PI );
617  drawStrokedSemiCircle( endPoint, width, aEndAngle );
618 
619  VECTOR2D pOuter( cos( aStartAngle ) * ( aRadius + width ),
620  sin( aStartAngle ) * ( aRadius + width ) );
621 
622  VECTOR2D pInner( cos( aStartAngle ) * ( aRadius - width ),
623  sin( aStartAngle ) * ( aRadius - width ) );
624 
625  double alpha;
626 
627  for( alpha = aStartAngle + alphaIncrement; alpha <= aEndAngle; alpha += alphaIncrement )
628  {
629  VECTOR2D pNextOuter( cos( alpha ) * ( aRadius + width ),
630  sin( alpha ) * ( aRadius + width ) );
631  VECTOR2D pNextInner( cos( alpha ) * ( aRadius - width ),
632  sin( alpha ) * ( aRadius - width ) );
633 
634  DrawLine( pOuter, pNextOuter );
635  DrawLine( pInner, pNextInner );
636 
637  pOuter = pNextOuter;
638  pInner = pNextInner;
639  }
640 
641  // Draw the last missing part
642  if( alpha != aEndAngle )
643  {
644  VECTOR2D pLastOuter( cos( aEndAngle ) * ( aRadius + width ),
645  sin( aEndAngle ) * ( aRadius + width ) );
646  VECTOR2D pLastInner( cos( aEndAngle ) * ( aRadius - width ),
647  sin( aEndAngle ) * ( aRadius - width ) );
648 
649  DrawLine( pOuter, pLastOuter );
650  DrawLine( pInner, pLastInner );
651  }
652  }
653 
654  if( isFillEnabled )
655  {
657  SetLineWidth( aWidth );
658 
659  VECTOR2D p( cos( aStartAngle ) * aRadius, sin( aStartAngle ) * aRadius );
660  double alpha;
661 
662  for( alpha = aStartAngle + alphaIncrement; alpha <= aEndAngle; alpha += alphaIncrement )
663  {
664  VECTOR2D p_next( cos( alpha ) * aRadius, sin( alpha ) * aRadius );
665  DrawLine( p, p_next );
666 
667  p = p_next;
668  }
669 
670  // Draw the last missing part
671  if( alpha != aEndAngle )
672  {
673  VECTOR2D p_last( cos( aEndAngle ) * aRadius, sin( aEndAngle ) * aRadius );
674  DrawLine( p, p_last );
675  }
676  }
677 
678  Restore();
679 }
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:302
double calcAngleStep(double aRadius) const
Compute the angle step when drawing arcs/circles approximated with lines.
Definition: opengl_gal.h:446
virtual void Restore() override
Restore the context.
double g
Green component.
Definition: color4d.h:287
COLOR4D fillColor
The fill color.
double b
Blue component.
Definition: color4d.h:288
virtual void Save() override
Save the context.
double a
Alpha component.
Definition: color4d.h:289
virtual void SetLineWidth(double aLineWidth)
Set the line width.
bool isStrokeEnabled
Are the outlines stroked ?
COLOR4D strokeColor
The color of the outlines.
void Translate(GLfloat aX, GLfloat aY, GLfloat aZ)
Function Translate() multiplies the current matrix by a translation matrix, so newly vertices will be...
virtual void DrawLine(const VECTOR2D &aStartPoint, const VECTOR2D &aEndPoint) override
Draw a line.
Definition: opengl_gal.cpp:403
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:286
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 1522 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, 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().

1523 {
1524  const float TEX_X = font_image.width;
1525  const float TEX_Y = font_image.height;
1526 
1527  const FONT_GLYPH_TYPE* glyph = LookupGlyph(aChar);
1528  if( !glyph ) return 0;
1529 
1530  const float X = glyph->atlas_x + font_information.smooth_pixels;
1531  const float Y = glyph->atlas_y + font_information.smooth_pixels;
1532  const float XOFF = glyph->minx;
1533 
1534  // adjust for height rounding
1535  const float round_adjust = ( glyph->maxy - glyph->miny )
1536  - float( glyph->atlas_h - font_information.smooth_pixels * 2 );
1537  const float top_adjust = font_information.max_y - glyph->maxy;
1538  const float YOFF = round_adjust + top_adjust;
1539  const float W = glyph->atlas_w - font_information.smooth_pixels *2;
1540  const float H = glyph->atlas_h - font_information.smooth_pixels *2;
1541  const float B = 0;
1542 
1543  currentManager->Reserve( 6 );
1544  Translate( VECTOR2D( XOFF, YOFF ) );
1545  /* Glyph:
1546  * v0 v1
1547  * +--+
1548  * | /|
1549  * |/ |
1550  * +--+
1551  * v2 v3
1552  */
1553  currentManager->Shader( SHADER_FONT, X / TEX_X, ( Y + H ) / TEX_Y );
1554  currentManager->Vertex( -B, -B, 0 ); // v0
1555 
1556  currentManager->Shader( SHADER_FONT, ( X + W ) / TEX_X, ( Y + H ) / TEX_Y );
1557  currentManager->Vertex( W + B, -B, 0 ); // v1
1558 
1559  currentManager->Shader( SHADER_FONT, X / TEX_X, Y / TEX_Y );
1560  currentManager->Vertex( -B, H + B, 0 ); // v2
1561 
1562 
1563  currentManager->Shader( SHADER_FONT, ( X + W ) / TEX_X, ( Y + H ) / TEX_Y );
1564  currentManager->Vertex( W + B, -B, 0 ); // v1
1565 
1566  currentManager->Shader( SHADER_FONT, X / TEX_X, Y / TEX_Y );
1567  currentManager->Vertex( -B, H + B, 0 ); // v2
1568 
1569  currentManager->Shader( SHADER_FONT, ( X + W ) / TEX_X, Y / TEX_Y );
1570  currentManager->Vertex( W + B, H + B, 0 ); // v3
1571 
1572  Translate( VECTOR2D( -XOFF + glyph->advance, -YOFF ) );
1573 
1574  return glyph->advance;
1575 }
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:302
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:589
FONT_IMAGE_TYPE font_image
Definition: gl_resources.cpp:4
FONT_INFO_TYPE font_information
Definition: gl_resources.cpp:3
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 1578 of file opengl_gal.cpp.

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

1579 {
1580  // To draw an overbar, simply draw an overbar
1581  const FONT_GLYPH_TYPE* glyph = LookupGlyph( '_' );
1582  const float H = glyph->maxy - glyph->miny;
1583 
1584  Save();
1585 
1586  Translate( VECTOR2D( -aLength, -aHeight-1.5*H ) );
1587 
1588  currentManager->Reserve( 6 );
1590 
1591  currentManager->Shader( 0 );
1592 
1593  currentManager->Vertex( 0, 0, 0 ); // v0
1594  currentManager->Vertex( aLength, 0, 0 ); // v1
1595  currentManager->Vertex( 0, H, 0 ); // v2
1596 
1597  currentManager->Vertex( aLength, 0, 0 ); // v1
1598  currentManager->Vertex( 0, H, 0 ); // v2
1599  currentManager->Vertex( aLength, H, 0 ); // v3
1600 
1601  Restore();
1602 }
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:302
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:287
const FONT_GLYPH_TYPE * LookupGlyph(unsigned int aCodepoint)
double b
Blue component.
Definition: color4d.h:288
virtual void Save() override
Save the context.
VECTOR2< double > VECTOR2D
Definition: vector2d.h:589
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 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:286
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 466 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.

467 {
468  if( isFillEnabled )
469  {
470  currentManager->Reserve( 3 );
472 
473  /* Draw a triangle that contains the circle, then shade it leaving only the circle.
474  * Parameters given to Shader() are indices of the triangle's vertices
475  * (if you want to understand more, check the vertex shader source [shader.vert]).
476  * Shader uses this coordinates to determine if fragments are inside the circle or not.
477  * v2
478  * /\
479  * //\\
480  * v0 /_\/_\ v1
481  */
483  currentManager->Vertex( aCenterPoint.x - aRadius * sqrt( 3.0f ), // v0
484  aCenterPoint.y - aRadius, layerDepth );
485 
487  currentManager->Vertex( aCenterPoint.x + aRadius * sqrt( 3.0f), // v1
488  aCenterPoint.y - aRadius, layerDepth );
489 
491  currentManager->Vertex( aCenterPoint.x, aCenterPoint.y + aRadius * 2.0f, // v2
492  layerDepth );
493  }
494 
495  if( isStrokeEnabled )
496  {
497  currentManager->Reserve( 3 );
499 
500  /* Draw a triangle that contains the circle, then shade it leaving only the circle.
501  * Parameters given to Shader() are indices of the triangle's vertices
502  * (if you want to understand more, check the vertex shader source [shader.vert]).
503  * and the line width. Shader uses this coordinates to determine if fragments are
504  * inside the circle or not.
505  * v2
506  * /\
507  * //\\
508  * v0 /_\/_\ v1
509  */
510  double outerRadius = aRadius + ( lineWidth / 2 );
512  currentManager->Vertex( aCenterPoint.x - outerRadius * sqrt( 3.0f ), // v0
513  aCenterPoint.y - outerRadius, layerDepth );
514 
516  currentManager->Vertex( aCenterPoint.x + outerRadius * sqrt( 3.0f ), // v1
517  aCenterPoint.y - outerRadius, layerDepth );
518 
520  currentManager->Vertex( aCenterPoint.x, aCenterPoint.y + outerRadius * 2.0f, // v2
521  layerDepth );
522  }
523 }
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:302
double layerDepth
The actual layer depth.
bool Reserve(unsigned int aSize)
Function Reserve() allocates space for vertices, so it will be used with subsequent Vertex() calls...
bool Vertex(const VERTEX &aVertex)
Function Vertex() adds a vertex with the given coordinates to the currently set item.
double g
Green component.
Definition: color4d.h:287
COLOR4D fillColor
The fill color.
double b
Blue component.
Definition: color4d.h:288
double lineWidth
The line width.
double a
Alpha component.
Definition: color4d.h:289
bool isStrokeEnabled
Are the outlines stroked ?
COLOR4D strokeColor
The color of the outlines.
void Color(const COLOR4D &aColor)
Function Color() changes currently used color that will be applied to newly added vertices...
bool isFillEnabled
Is filling of graphic objects enabled ?
void Shader(GLfloat aShaderType, GLfloat aParam1=0.0f, GLfloat aParam2=0.0f, GLfloat aParam3=0.0f)
Function Shader() changes currently used shader and its parameters that will be applied to newly adde...
double r
Red component.
Definition: color4d.h:286
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 1322 of file opengl_gal.cpp.

References KIGFX::GAL::cursorPosition.

1323 {
1324  // Now we should only store the position of the mouse cursor
1325  // The real drawing routines are in blitCursor()
1326  //VECTOR2D screenCursor = worldScreenMatrix * aCursorPosition;
1327  //cursorPosition = screenWorldMatrix * VECTOR2D( screenCursor.x, screenCursor.y );
1328  cursorPosition = aCursorPosition;
1329 }
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 799 of file opengl_gal.cpp.

References CURVE_POINTS, and DrawPolyline().

801 {
802  // FIXME The drawing quality needs to be improved
803  // FIXME Perhaps choose a quad/triangle strip instead?
804  // FIXME Brute force method, use a better (recursive?) algorithm
805 
806  std::deque<VECTOR2D> pointList;
807 
808  double t = 0.0;
809  double dt = 1.0 / (double) CURVE_POINTS;
810 
811  for( int i = 0; i <= CURVE_POINTS; i++ )
812  {
813  double omt = 1.0 - t;
814  double omt2 = omt * omt;
815  double omt3 = omt * omt2;
816  double t2 = t * t;
817  double t3 = t * t2;
818 
819  VECTOR2D vertex = omt3 * aStartPoint + 3.0 * t * omt2 * aControlPointA
820  + 3.0 * t2 * omt * aControlPointB + t3 * aEndPoint;
821 
822  pointList.push_back( vertex );
823 
824  t += dt;
825  }
826 
827  DrawPolyline( pointList );
828 }
static const int CURVE_POINTS
The number of points for curve approximation.
Definition: opengl_gal.h:288
virtual void DrawPolyline(const std::deque< VECTOR2D > &aPointList) override
Draw a polyline.
Definition: opengl_gal.cpp:720
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 1400 of file opengl_gal.cpp.

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

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

1402 {
1403  Save();
1404 
1405  currentManager->Reserve( 3 );
1406  currentManager->Translate( aCenterPoint.x, aCenterPoint.y, 0.0f );
1407  currentManager->Rotate( aAngle, 0.0f, 0.0f, 1.0f );
1408 
1409  /* Draw a triangle that contains the semicircle, then shade it to leave only
1410  * the semicircle. Parameters given to Shader() are indices of the triangle's vertices
1411  * (if you want to understand more, check the vertex shader source [shader.vert]).
1412  * Shader uses these coordinates to determine if fragments are inside the semicircle or not.
1413  * v2
1414  * /\
1415  * /__\
1416  * v0 //__\\ v1
1417  */
1419  currentManager->Vertex( -aRadius * 3.0f / sqrt( 3.0f ), 0.0f, layerDepth ); // v0
1420 
1422  currentManager->Vertex( aRadius * 3.0f / sqrt( 3.0f ), 0.0f, layerDepth ); // v1
1423 
1425  currentManager->Vertex( 0.0f, aRadius * 2.0f, layerDepth ); // v2
1426 
1427  Restore();
1428 }
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:302
double layerDepth
The actual layer depth.
bool Reserve(unsigned int aSize)
Function Reserve() allocates space for vertices, so it will be used with subsequent Vertex() calls...
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 939 of file opengl_gal.cpp.

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

940 {
943 
944  // sub-pixel lines all render the same
945  double minorLineWidth = std::max( 1.0, gridLineWidth );
946  double majorLineWidth = minorLineWidth * 2.0;
947 
948  // Draw the axis and grid
949  // For the drawing the start points, end points and increments have
950  // to be calculated in world coordinates
951  VECTOR2D worldStartPoint = screenWorldMatrix * VECTOR2D( 0.0, 0.0 );
952  VECTOR2D worldEndPoint = screenWorldMatrix * VECTOR2D( screenSize );
953 
954  // Draw axes if desired
955  if( axesEnabled )
956  {
957  glLineWidth( minorLineWidth );
958  glColor4d( axesColor.r, axesColor.g, axesColor.b, 1.0 );
959 
960  glBegin( GL_LINES );
961  glVertex2d( worldStartPoint.x, 0 );
962  glVertex2d( worldEndPoint.x, 0 );
963  glEnd();
964 
965  glBegin( GL_LINES );
966  glVertex2d( 0, worldStartPoint.y );
967  glVertex2d( 0, worldEndPoint.y );
968  glEnd();
969  }
970 
971  if( !gridVisibility )
972  return;
973 
974  int gridScreenSizeDense = KiROUND( gridSize.x * worldScale );
975  int gridScreenSizeCoarse = KiROUND( gridSize.x * static_cast<double>( gridTick ) * worldScale );
976 
977  const double gridThreshold = computeMinGridSpacing();
978 
979  // Check if the grid would not be too dense
980  if( std::max( gridScreenSizeDense, gridScreenSizeCoarse ) < gridThreshold )
981  return;
982 
983  // Compute grid staring and ending indexes to draw grid points on the
984  // visible screen area
985  // Note: later any point coordinate will be offsetted by gridOrigin
986  int gridStartX = KiROUND( (worldStartPoint.x-gridOrigin.x) / gridSize.x );
987  int gridEndX = KiROUND( (worldEndPoint.x-gridOrigin.x) / gridSize.x );
988  int gridStartY = KiROUND( (worldStartPoint.y-gridOrigin.y) / gridSize.y );
989  int gridEndY = KiROUND( (worldEndPoint.y-gridOrigin.y) / gridSize.y );
990 
991  // Ensure start coordinate > end coordinate
992  if( gridStartX > gridEndX )
993  std::swap( gridStartX, gridEndX );
994 
995  if( gridStartY > gridEndY )
996  std::swap( gridStartY, gridEndY );
997 
998  glDisable( GL_DEPTH_TEST );
999  glDisable( GL_TEXTURE_2D );
1000 
1001  if( gridStyle == GRID_STYLE::DOTS )
1002  {
1003  glEnable( GL_STENCIL_TEST );
1004  glStencilFunc( GL_ALWAYS, 1, 1 );
1005  glStencilOp( GL_KEEP, GL_KEEP, GL_INCR );
1006  glColor4d( 0.0, 0.0, 0.0, 0.0 );
1007  }
1008  else
1009  {
1010  glColor4d( gridColor.r, gridColor.g, gridColor.b, 1.0 );
1011  }
1012 
1014  {
1015  glLineWidth( minorLineWidth );
1016 
1017  // calculate a line len = 2 minorLineWidth, in internal unit value
1018  // (in fact the size of cross is lineLen*2)
1019  int lineLen = KiROUND( minorLineWidth / worldScale *2 );
1020 
1021  // Vertical positions
1022  for( int j = gridStartY-1; j <= gridEndY; j++ )
1023  {
1024  if( ( j % gridTick == 0 && gridScreenSizeCoarse > gridThreshold )
1025  || gridScreenSizeDense > gridThreshold )
1026  {
1027  int posY = j * gridSize.y + gridOrigin.y;
1028 
1029  // Horizontal positions
1030  for( int i = gridStartX-1; i <= gridEndX; i++ )
1031  {
1032  if( ( i % gridTick == 0 && gridScreenSizeCoarse > gridThreshold )
1033  || gridScreenSizeDense > gridThreshold )
1034  {
1035  int posX = i * gridSize.x + gridOrigin.x;
1036 
1037  glBegin( GL_LINES );
1038  glVertex2d( posX -lineLen, posY );
1039  glVertex2d( posX + lineLen, posY );
1040  glVertex2d( posX, posY - lineLen );
1041  glVertex2d( posX, posY + lineLen );
1042  glEnd();
1043  }
1044  }
1045  }
1046  }
1047  }
1048  else
1049  {
1050  // Vertical lines
1051  for( int j = gridStartY-1; j <= gridEndY; j++ )
1052  {
1053  const double y = j * gridSize.y + gridOrigin.y;
1054 
1055  // If axes are drawn, skip the lines that would cover them
1056  if( axesEnabled && y == 0 )
1057  continue;
1058 
1059  if( j % gridTick == 0 && gridScreenSizeDense > gridThreshold )
1060  glLineWidth( majorLineWidth );
1061  else
1062  glLineWidth( minorLineWidth );
1063 
1064  if( ( j % gridTick == 0 && gridScreenSizeCoarse > gridThreshold )
1065  || gridScreenSizeDense > gridThreshold )
1066  {
1067  glBegin( GL_LINES );
1068  glVertex2d( gridStartX * gridSize.x + gridOrigin.x, y );
1069  glVertex2d( gridEndX * gridSize.x + gridOrigin.x, y );
1070  glEnd();
1071  }
1072  }
1073 
1074  if( gridStyle == GRID_STYLE::DOTS )
1075  {
1076  glStencilFunc( GL_NOTEQUAL, 0, 1 );
1077  glColor4d( gridColor.r, gridColor.g, gridColor.b, 1.0 );
1078  }
1079 
1080  // Horizontal lines
1081  for( int i = gridStartX-1; i <= gridEndX; i++ )
1082  {
1083  const double x = i * gridSize.x + gridOrigin.x;
1084 
1085  // If axes are drawn, skip the lines that would cover them
1086  if( axesEnabled && x == 0 )
1087  continue;
1088 
1089  if( i % gridTick == 0 && gridScreenSizeDense > gridThreshold )
1090  glLineWidth( majorLineWidth );
1091  else
1092  glLineWidth( minorLineWidth );
1093 
1094  if( ( i % gridTick == 0 && gridScreenSizeCoarse > gridThreshold )
1095  || gridScreenSizeDense > gridThreshold )
1096  {
1097  glBegin( GL_LINES );
1098  glVertex2d( x, gridStartY * gridSize.y + gridOrigin.y );
1099  glVertex2d( x, gridEndY * gridSize.y + gridOrigin.y );
1100  glEnd();
1101  }
1102  }
1103 
1104  if( gridStyle == GRID_STYLE::DOTS )
1105  glDisable( GL_STENCIL_TEST );
1106  }
1107 
1108  glEnable( GL_DEPTH_TEST );
1109  glEnable( GL_TEXTURE_2D );
1110 }
double computeMinGridSpacing() const
compute minimum grid spacing from the grid settings
int gridTick
Every tick line gets the double width.
bool axesEnabled
Should the axes be drawn.
static int KiROUND(double v)
KiROUND rounds a floating point number to an int using "round halfway cases away from zero"...
Definition: common.h:107
GRID_STYLE gridStyle
Grid display style.
double g
Green component.
Definition: color4d.h:287
MATRIX3x3D screenWorldMatrix
Screen transformation.
double b
Blue component.
Definition: color4d.h:288
Auxiliary rendering target (noncached)
Definition: definitions.h:42
OPENGL_COMPOSITOR * compositor
Handles multiple rendering targets.
Definition: opengl_gal.h:308
VECTOR2< double > VECTOR2D
Definition: vector2d.h:589
unsigned int mainBuffer
Main rendering target.
Definition: opengl_gal.h:309
COLOR4D axesColor
Color of the axes.
VECTOR2D gridOrigin
The grid origin.
virtual void SetBuffer(unsigned int aBufferHandle) override
Function SetBuffer() sets the selected buffer as the rendering target.
Use dots for the grid.
Use small cross instead of dots for the grid.
virtual void SetTarget(RENDER_TARGET aTarget) override
Sets the target for rendering.
COLOR4D gridColor
Color of the grid.
bool gridVisibility
Should the grid be shown.
#define max(a, b)
Definition: auxiliary.h:86
double worldScale
The scale factor world->screen.
VECTOR2D gridSize
The grid size.
VECTOR2I screenSize
Screen size in screen coordinates.
double r
Red component.
Definition: color4d.h:286
double gridLineWidth
Line width of the grid.
virtual void KIGFX::GAL::drawGridLine ( const VECTOR2D aStartPoint,
const VECTOR2D aEndPoint 
)
inlineprotectedvirtualinherited

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

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

Reimplemented in KIGFX::CAIRO_GAL.

Definition at line 1038 of file graphics_abstraction_layer.h.

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

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

Draw the stored group.

Parameters
aGroupNumberis the group number.

Reimplemented from KIGFX::GAL.

Definition at line 1224 of file opengl_gal.cpp.

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

1225 {
1226  cachedManager->DrawItem( *groups[aGroupNumber] );
1227 }
GROUPS_MAP groups
Stores informations about VBO objects (groups)
Definition: opengl_gal.h:300
VERTEX_MANAGER * cachedManager
Container for storing cached VERTEX_ITEMs.
Definition: opengl_gal.h:303
void 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 403 of file opengl_gal.cpp.

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

Referenced by DrawArc(), and DrawArcSegment().

404 {
405  const VECTOR2D startEndVector = aEndPoint - aStartPoint;
406  double lineAngle = startEndVector.Angle();
407 
409 
410  drawLineQuad( aStartPoint, aEndPoint );
411 
412  // Line caps
413  if( lineWidth > 1.0 )
414  {
415  drawFilledSemiCircle( aStartPoint, lineWidth / 2, lineAngle + M_PI / 2 );
416  drawFilledSemiCircle( aEndPoint, lineWidth / 2, lineAngle - M_PI / 2 );
417  }
418 }
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:302
void drawLineQuad(const VECTOR2D &aStartPoint, const VECTOR2D &aEndPoint)
Draw a quad for the line.
double g
Green component.
Definition: color4d.h:287
double b
Blue component.
Definition: color4d.h:288
double lineWidth
The line width.
double Angle() const
Function Angle computes the angle of the vector.
Definition: vector2d.h:309
double a
Alpha component.
Definition: color4d.h:289
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:286
void drawFilledSemiCircle(const VECTOR2D &aCenterPoint, double aRadius, double aAngle)
Draw a filled semicircle.
void OPENGL_GAL::drawLineQuad ( const VECTOR2D aStartPoint,
const VECTOR2D aEndPoint 
)
private

Draw a quad for the line.

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

Definition at line 1332 of file opengl_gal.cpp.

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

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

1333 {
1334  /* Helper drawing: ____--- v3 ^
1335  * ____---- ... \ \
1336  * ____---- ... \ end \
1337  * v1 ____---- ... ____---- \ width
1338  * ---- ...___---- \ \
1339  * \ ___...-- \ v
1340  * \ ____----... ____---- v2
1341  * ---- ... ____----
1342  * start \ ... ____----
1343  * \... ____----
1344  * ----
1345  * v0
1346  * dots mark triangles' hypotenuses
1347  */
1348 
1349  VECTOR2D startEndVector = aEndPoint - aStartPoint;
1350  double lineLength = startEndVector.EuclideanNorm();
1351 
1352  if( lineLength <= 0.0 )
1353  return;
1354 
1355  double scale = 0.5 * lineWidth / lineLength;
1356 
1357  // The perpendicular vector also needs transformations
1358  glm::vec4 vector = currentManager->GetTransformation() *
1359  glm::vec4( -startEndVector.y * scale, startEndVector.x * scale, 0.0, 0.0 );
1360 
1361  currentManager->Reserve( 6 );
1362 
1363  // Line width is maintained by the vertex shader
1364  currentManager->Shader( SHADER_LINE, vector.x, vector.y, lineWidth );
1365  currentManager->Vertex( aStartPoint.x, aStartPoint.y, layerDepth ); // v0
1366 
1367  currentManager->Shader( SHADER_LINE, -vector.x, -vector.y, lineWidth );
1368  currentManager->Vertex( aStartPoint.x, aStartPoint.y, layerDepth ); // v1
1369 
1370  currentManager->Shader( SHADER_LINE, -vector.x, -vector.y, lineWidth );
1371  currentManager->Vertex( aEndPoint.x, aEndPoint.y, layerDepth ); // v3
1372 
1373  currentManager->Shader( SHADER_LINE, vector.x, vector.y, lineWidth );
1374  currentManager->Vertex( aStartPoint.x, aStartPoint.y, layerDepth ); // v0
1375 
1376  currentManager->Shader( SHADER_LINE, -vector.x, -vector.y, lineWidth );
1377  currentManager->Vertex( aEndPoint.x, aEndPoint.y, layerDepth ); // v3
1378 
1379  currentManager->Shader( SHADER_LINE, vector.x, vector.y, lineWidth );
1380  currentManager->Vertex( aEndPoint.x, aEndPoint.y, layerDepth ); // v2
1381 }
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:302
double layerDepth
The actual layer depth.
bool Reserve(unsigned int aSize)
Function Reserve() allocates space for vertices, so it will be used with subsequent Vertex() calls...
bool Vertex(const VERTEX &aVertex)
Function Vertex() adds a vertex with the given coordinates to the currently set item.
double lineWidth
The line width.
T EuclideanNorm() const
Destructor.
Definition: vector2d.h:295
const int scale
const glm::mat4 & GetTransformation() const
void Shader(GLfloat aShaderType, GLfloat aParam1=0.0f, GLfloat aParam2=0.0f, GLfloat aParam3=0.0f)
Function Shader() changes currently used shader and its parameters that will be applied to newly adde...
void OPENGL_GAL::DrawPolygon ( const std::deque< VECTOR2D > &  aPointList)
overridevirtual

Draw a polygon.

Parameters
aPointListis the list of the polygon points.

Reimplemented from KIGFX::GAL.

Definition at line 743 of file opengl_gal.cpp.

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

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

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

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

Reimplemented from KIGFX::GAL.

Definition at line 777 of file opengl_gal.cpp.

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

778 {
779  for( int j = 0; j < aPolySet.OutlineCount(); ++j )
780  {
781  const SHAPE_LINE_CHAIN& outline = aPolySet.COutline( j );
782  const int pointCount = outline.PointCount();
783  std::unique_ptr<GLdouble[]> points( new GLdouble[3 * pointCount] );
784  GLdouble* ptr = points.get();
785 
786  for( int i = 0; i < outline.PointCount(); ++i )
787  {
788  const VECTOR2I& p = outline.CPoint( i );
789  *ptr++ = p.x;
790  *ptr++ = p.y;
791  *ptr++ = layerDepth;
792  }
793 
794  drawPolygon( points.get(), pointCount );
795  }
796 }
double layerDepth
The actual layer depth.
int PointCount() const
Function PointCount()
void drawPolygon(GLdouble *aPoints, int aPointCount)
Draws a filled polygon.
int OutlineCount() const
Returns the number of outlines in the set
const SHAPE_LINE_CHAIN & COutline(int aIndex) const
Class SHAPE_LINE_CHAIN.
const VECTOR2I & CPoint(int aIndex) const
Function CPoint()
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 1465 of file opengl_gal.cpp.

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

Referenced by DrawPolygon().

1466 {
1469 
1470  // Any non convex polygon needs to be tesselated
1471  // for this purpose the GLU standard functions are used
1472  TessParams params = { currentManager, tessIntersects };
1473  gluTessBeginPolygon( tesselator, &params );
1474  gluTessBeginContour( tesselator );
1475 
1476  GLdouble* point = aPoints;
1477 
1478  for( int i = 0; i < aPointCount; ++i )
1479  {
1480  gluTessVertex( tesselator, point, point );
1481  point += 3; // 3 coordinates
1482  }
1483 
1484  gluTessEndContour( tesselator );
1485  gluTessEndPolygon( tesselator );
1486 
1487  // Free allocated intersecting points
1488  tessIntersects.clear();
1489 }
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:302
double g
Green component.
Definition: color4d.h:287
COLOR4D fillColor
The fill color.
double b
Blue component.
Definition: color4d.h:288
double a
Alpha component.
Definition: color4d.h:289
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:329
std::deque< boost::shared_array< GLdouble > > tessIntersects
Storage for intersecting points.
Definition: opengl_gal.h:331
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:286
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 720 of file opengl_gal.cpp.

References drawPolyline().

Referenced by DrawCurve(), and DrawRectangle().

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

References drawPolyline().

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

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

733 {
734  auto numPoints = aLineChain.PointCount();
735 
736  if( aLineChain.IsClosed() )
737  numPoints += 1;
738 
739  drawPolyline( [&](int idx) { return aLineChain.CPoint(idx); }, numPoints );
740 }
void drawPolyline(std::function< VECTOR2D(int)> aPointGetter, int aPointCount)
Generic way of drawing a polyline stored in different containers.
int PointCount() const
Function PointCount()
bool IsClosed() const
Function IsClosed()
const VECTOR2I & CPoint(int aIndex) const
Function CPoint()
void OPENGL_GAL::drawPolyline ( 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 1492 of file opengl_gal.cpp.

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

Referenced by DrawPolyline().

1493 {
1494  if( aPointCount < 2 )
1495  return;
1496 
1498  int i;
1499 
1500  for( i = 1; i < aPointCount; ++i )
1501  {
1502  auto start = aPointGetter( i - 1 );
1503  auto end = aPointGetter( i );
1504  const VECTOR2D startEndVector = ( end - start );
1505  double lineAngle = startEndVector.Angle();
1506 
1507  drawLineQuad( start, end );
1508 
1509  // There is no need to draw line caps on both ends of polyline's segments
1510  drawFilledSemiCircle( start, lineWidth / 2, lineAngle + M_PI / 2 );
1511  }
1512 
1513  // ..and now - draw the ending cap
1514  auto start = aPointGetter( i - 2 );
1515  auto end = aPointGetter( i - 1 );
1516  const VECTOR2D startEndVector = ( end - start );
1517  double lineAngle = startEndVector.Angle();
1518  drawFilledSemiCircle( end, lineWidth / 2, lineAngle - M_PI / 2 );
1519 }
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:302
void drawLineQuad(const VECTOR2D &aStartPoint, const VECTOR2D &aEndPoint)
Draw a quad for the line.
double g
Green component.
Definition: color4d.h:287
double b
Blue component.
Definition: color4d.h:288
double lineWidth
The line width.
double Angle() const
Function Angle computes the angle of the vector.
Definition: vector2d.h:309
double a
Alpha component.
Definition: color4d.h:289
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:286
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 682 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.

683 {
684  // Compute the diagonal points of the rectangle
685  VECTOR2D diagonalPointA( aEndPoint.x, aStartPoint.y );
686  VECTOR2D diagonalPointB( aStartPoint.x, aEndPoint.y );
687 
688  // Stroke the outline
689  if( isStrokeEnabled )
690  {
692 
693  std::deque<VECTOR2D> pointList;
694  pointList.push_back( aStartPoint );
695  pointList.push_back( diagonalPointA );
696  pointList.push_back( aEndPoint );
697  pointList.push_back( diagonalPointB );
698  pointList.push_back( aStartPoint );
699  DrawPolyline( pointList );
700  }
701 
702  // Fill the rectangle
703  if( isFillEnabled )
704  {
705  currentManager->Reserve( 6 );
708 
709  currentManager->Vertex( aStartPoint.x, aStartPoint.y, layerDepth );
710  currentManager->Vertex( diagonalPointA.x, diagonalPointA.y, layerDepth );
711  currentManager->Vertex( aEndPoint.x, aEndPoint.y, layerDepth );
712 
713  currentManager->Vertex( aStartPoint.x, aStartPoint.y, layerDepth );
714  currentManager->Vertex( aEndPoint.x, aEndPoint.y, layerDepth );
715  currentManager->Vertex( diagonalPointB.x, diagonalPointB.y, layerDepth );
716  }
717 }
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:302
double layerDepth
The actual layer depth.
bool Reserve(unsigned int aSize)
Function Reserve() allocates space for vertices, so it will be used with subsequent Vertex() calls...
bool Vertex(const VERTEX &aVertex)
Function Vertex() adds a vertex with the given coordinates to the currently set item.
double g
Green component.
Definition: color4d.h:287
COLOR4D fillColor
The fill color.
double b
Blue component.
Definition: color4d.h:288
double a
Alpha component.
Definition: color4d.h:289
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:720
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:286
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 421 of file opengl_gal.cpp.

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

423 {
424  VECTOR2D startEndVector = aEndPoint - aStartPoint;
425  double lineAngle = startEndVector.Angle();
426 
427  if( isFillEnabled )
428  {
429  // Filled tracks
431 
432  SetLineWidth( aWidth );
433  drawLineQuad( aStartPoint, aEndPoint );
434 
435  // Draw line caps
436  drawFilledSemiCircle( aStartPoint, aWidth / 2, lineAngle + M_PI / 2 );
437  drawFilledSemiCircle( aEndPoint, aWidth / 2, lineAngle - M_PI / 2 );
438  }
439  else
440  {
441  // Outlined tracks
442  double lineLength = startEndVector.EuclideanNorm();
443 
445 
446  Save();
447 
448  currentManager->Translate( aStartPoint.x, aStartPoint.y, 0.0 );
449  currentManager->Rotate( lineAngle, 0.0f, 0.0f, 1.0f );
450 
451  drawLineQuad( VECTOR2D( 0.0, aWidth / 2.0 ),
452  VECTOR2D( lineLength, aWidth / 2.0 ) );
453 
454  drawLineQuad( VECTOR2D( 0.0, -aWidth / 2.0 ),
455  VECTOR2D( lineLength, -aWidth / 2.0 ) );
456 
457  // Draw line caps
458  drawStrokedSemiCircle( VECTOR2D( 0.0, 0.0 ), aWidth / 2, M_PI / 2 );
459  drawStrokedSemiCircle( VECTOR2D( lineLength, 0.0 ), aWidth / 2, -M_PI / 2 );
460 
461  Restore();
462  }
463 }
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:302
void drawLineQuad(const VECTOR2D &aStartPoint, const VECTOR2D &aEndPoint)
Draw a quad for the line.
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:287
COLOR4D fillColor
The fill color.
double b
Blue component.
Definition: color4d.h:288
double Angle() const
Function Angle computes the angle of the vector.
Definition: vector2d.h:309
virtual void Save() override
Save the context.
double a
Alpha component.
Definition: color4d.h:289
virtual void SetLineWidth(double aLineWidth)
Set the line width.
T EuclideanNorm() const
Destructor.
Definition: vector2d.h:295
VECTOR2< double > VECTOR2D
Definition: vector2d.h:589
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:286
void drawFilledSemiCircle(const VECTOR2D &aCenterPoint, double aRadius, double aAngle)
Draw a filled semicircle.
void OPENGL_GAL::drawSemiCircle ( const VECTOR2D aCenterPoint,
double  aRadius,
double  aAngle 
)
private

Draw a semicircle.

Depending on settings (isStrokeEnabled & isFilledEnabled) it runs the proper function (drawStrokedSemiCircle or drawFilledSemiCircle).

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

Definition at line 1384 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.

1385 {
1386  if( isFillEnabled )
1387  {
1389  drawFilledSemiCircle( aCenterPoint, aRadius, aAngle );
1390  }
1391 
1392  if( isStrokeEnabled )
1393  {
1395  drawStrokedSemiCircle( aCenterPoint, aRadius, aAngle );
1396  }
1397 }
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:302
double g
Green component.
Definition: color4d.h:287
COLOR4D fillColor
The fill color.
double b
Blue component.
Definition: color4d.h:288
double a
Alpha component.
Definition: color4d.h:289
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:286
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 1431 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().

1433 {
1434  double outerRadius = aRadius + ( lineWidth / 2 );
1435 
1436  Save();
1437 
1438  currentManager->Reserve( 3 );
1439  currentManager->Translate( aCenterPoint.x, aCenterPoint.y, 0.0f );
1440  currentManager->Rotate( aAngle, 0.0f, 0.0f, 1.0f );
1441 
1442  /* Draw a triangle that contains the semicircle, then shade it to leave only
1443  * the semicircle. Parameters given to Shader() are indices of the triangle's vertices
1444  * (if you want to understand more, check the vertex shader source [shader.vert]), the
1445  * radius and the line width. Shader uses these coordinates to determine if fragments are
1446  * inside the semicircle or not.
1447  * v2
1448  * /\
1449  * /__\
1450  * v0 //__\\ v1
1451  */
1453  currentManager->Vertex( -outerRadius * 3.0f / sqrt( 3.0f ), 0.0f, layerDepth ); // v0
1454 
1456  currentManager->Vertex( outerRadius * 3.0f / sqrt( 3.0f ), 0.0f, layerDepth ); // v1
1457 
1459  currentManager->Vertex( 0.0f, outerRadius * 2.0f, layerDepth ); // v2
1460 
1461  Restore();
1462 }
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:302
double layerDepth
The actual layer depth.
bool Reserve(unsigned int aSize)
Function Reserve() allocates space for vertices, so it will be used with subsequent Vertex() calls...
virtual void Restore() override
Restore the context.
bool Vertex(const VERTEX &aVertex)
Function Vertex() adds a vertex with the given coordinates to the currently set item.
void Rotate(GLfloat aAngle, GLfloat aX, GLfloat aY, GLfloat aZ)
Function Rotate() multiplies the current matrix by a rotation matrix, so the newly vertices will be r...
double lineWidth
The line width.
virtual void Save() override
Save the context.
void Translate(GLfloat aX, GLfloat aY, GLfloat aZ)
Function Translate() multiplies the current matrix by a translation matrix, so newly vertices will be...
void Shader(GLfloat aShaderType, GLfloat aParam1=0.0f, GLfloat aParam2=0.0f, GLfloat aParam3=0.0f)
Function Shader() changes currently used shader and its parameters that will be applied to newly adde...
void OPENGL_GAL::EndDrawing ( )
overridevirtual

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

Reimplemented from KIGFX::GAL.

Definition at line 346 of file opengl_gal.cpp.

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

347 {
348 #ifdef __WXDEBUG__
349  PROF_COUNTER totalRealTime( "OPENGL_GAL::EndDrawing()", true );
350 #endif /* __WXDEBUG__ */
351 
352  // Cached & non-cached containers are rendered to the same buffer
356 
357  // Overlay container is rendered to a different buffer
360 
361  // Be sure that the framebuffer is not colorized (happens on specific GPU&drivers combinations)
362  glColor4d( 1.0, 1.0, 1.0, 1.0 );
363 
364  // Draw the remaining contents, blit the rendering targets to the screen, swap the buffers
367  compositor->Present();
368  blitCursor();
369 
370  SwapBuffers();
372 
373 #ifdef __WXDEBUG__
374  totalRealTime.Stop();
375  wxLogTrace( "GAL_PROFILE", wxT( "OPENGL_GAL::EndDrawing(): %.1f ms" ), totalRealTime.msecs() );
376 #endif /* __WXDEBUG__ */
377 }
virtual void DrawBuffer(unsigned int aBufferHandle) override
Function DrawBuffer() draws the selected buffer to the output buffer.
unsigned int overlayBuffer
Auxiliary rendering target (for menus etc.)
Definition: opengl_gal.h:310
VERTEX_MANAGER * overlayManager
Container for storing overlaid VERTEX_ITEMs.
Definition: opengl_gal.h:305
The class PROF_COUNTER is a small class to help profiling.
Definition: profile.h:45
void UnlockCtx(wxGLContext *aContext)
Function UnlockCtx allows other canvases to bind an OpenGL context.
VERTEX_MANAGER * nonCachedManager
Container for storing non-cached VERTEX_ITEMs.
Definition: opengl_gal.h:304
static GL_CONTEXT_MANAGER & Get()
Function Get returns the GL_CONTEXT_MANAGER instance (singleton).
OPENGL_COMPOSITOR * compositor
Handles multiple rendering targets.
Definition: opengl_gal.h:308
virtual void Present() override
Function Present() Call this to present the output buffer to the screen.
unsigned int mainBuffer
Main rendering target.
Definition: opengl_gal.h:309
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:303
wxGLContext * glPrivContext
Canvas-specific OpenGL context.
Definition: opengl_gal.h:291
void OPENGL_GAL::EndGroup ( )
overridevirtual

End the group.

Reimplemented from KIGFX::GAL.

Definition at line 1217 of file opengl_gal.cpp.

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

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

Disables item update mode.

Reimplemented from KIGFX::GAL.

Definition at line 393 of file opengl_gal.cpp.

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

394 {
395  if( !isInitialized )
396  return;
397 
398  cachedManager->Unmap();
400 }
void UnlockCtx(wxGLContext *aContext)
Function UnlockCtx allows other canvases to bind an OpenGL context.
static GL_CONTEXT_MANAGER & Get()
Function Get returns the GL_CONTEXT_MANAGER instance (singleton).
void Unmap()
Function Unmap() unmaps vertex buffer.
VERTEX_MANAGER * cachedManager
Container for storing cached VERTEX_ITEMs.
Definition: opengl_gal.h:303
bool isInitialized
Basic initialization flag, has to be done when the window is visible.
Definition: opengl_gal.h:320
wxGLContext * glPrivContext
Canvas-specific OpenGL context.
Definition: opengl_gal.h:291
void OPENGL_GAL::Flush ( )
overridevirtual

Force all remaining objects to be drawn.

Reimplemented from KIGFX::GAL.

Definition at line 1142 of file opengl_gal.cpp.

1143 {
1144  glFlush();
1145 }
COLOR4D GAL::getCursorColor ( ) const
protectedinherited

Gets the actual cursor color to draw.

Definition at line 406 of file graphics_abstraction_layer.cpp.

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

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

407 {
408  auto color = cursorColor;
409 
410  // dim the cursor if it's only on because it was forced
411  // (this helps to provide a hint for active tools)
412  if( !isCursorEnabled )
413  {
414  color.a = color.a * 0.5;
415  }
416 
417  return color;
418 }
bool isCursorEnabled
Is the cursor enabled?
COLOR4D cursorColor
Cursor color.
double KIGFX::GAL::GetGridLineWidth ( ) const
inlineinherited

Get the grid line width.

Returns
the grid line width

Definition at line 861 of file graphics_abstraction_layer.h.

References KIGFX::GAL::gridLineWidth.

862  {
863  return gridLineWidth;
864  }
double gridLineWidth
Line width of the grid.
VECTOR2D GAL::GetGridPoint ( const VECTOR2D aPoint) const
inherited

Function GetGridPoint() For a given point it returns the nearest point belonging to the grid in world coordinates.

Parameters
aPointis the point for which the grid point is searched.
Returns
The nearest grid point in world coordinates.

Definition at line 395 of file graphics_abstraction_layer.cpp.

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

Referenced by KIGFX::WX_VIEW_CONTROLS::GetCursorPosition(), and EDIT_POINTS_FACTORY::Make().

396 {
397  return VECTOR2D( KiROUND( ( aPoint.x - gridOffset.x ) / gridSize.x ) * gridSize.x + gridOffset.x,
398  KiROUND( ( aPoint.y - gridOffset.y ) / gridSize.y ) * gridSize.y + gridOffset.y );
399 }
VECTOR2D gridOffset
The grid offset to compensate cursor position.
static int KiROUND(double v)
KiROUND rounds a floating point number to an int using "round halfway cases away from zero"...
Definition: common.h:107
VECTOR2< double > VECTOR2D
Definition: vector2d.h:589
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 813 of file graphics_abstraction_layer.h.

References KIGFX::GAL::gridSize.

814  {
815  return gridSize;
816  }
VECTOR2D gridSize
The grid size.
EDA_TEXT_HJUSTIFY_T KIGFX::GAL::GetHorizontalJustify ( ) const
inlineinherited

Returns current text horizontal justification setting.

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

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

Get the look at point.

Returns
the look at point.

Definition at line 653 of file graphics_abstraction_layer.h.

References KIGFX::GAL::lookAtPoint.

654  {
655  return lookAtPoint;
656  }
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 702 of file graphics_abstraction_layer.h.

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

703  {
704  return depthRange.y;
705  }
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 694 of file graphics_abstraction_layer.h.

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

695  {
696  return depthRange.x;
697  }
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 1688 of file opengl_gal.cpp.

References groupCounter, groups, and max.

Referenced by BeginGroup().

1689 {
1690  wxASSERT_MSG( groups.size() < std::numeric_limits<unsigned int>::max(),
1691  wxT( "There are no free slots to store a group" ) );
1692 
1693  while( groups.find( groupCounter ) != groups.end() )
1694  {
1695  groupCounter++;
1696  }
1697 
1698  return groupCounter++;
1699 }
GROUPS_MAP groups
Stores informations about VBO objects (groups)
Definition: opengl_gal.h:300
#define max(a, b)
Definition: auxiliary.h:86
unsigned int groupCounter
Counter used for generating keys for groups.
Definition: opengl_gal.h:301
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 353 of file graphics_abstraction_layer.h.

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

354  {
356  }
STROKE_FONT strokeFont
Instance of object that stores information about how to draw texts.
double computeOverbarVerticalPosition() const
Compute the vertical position of an overbar, sometimes used in texts.
const VECTOR2I& KIGFX::GAL::GetScreenPixelSize ( ) const
inlineinherited
const MATRIX3x3D& KIGFX::GAL::GetScreenWorldMatrix ( ) const
inlineinherited

Get the screen <-> world transformation matrix.

Returns
the transformation matrix.

Definition at line 594 of file graphics_abstraction_layer.h.

References KIGFX::GAL::screenWorldMatrix.

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

595  {
596  return screenWorldMatrix;
597  }
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 256 of file graphics_abstraction_layer.h.

References KIGFX::GAL::strokeColor.

257  {
258  return strokeColor;
259  }
COLOR4D strokeColor
The color of the outlines.
const STROKE_FONT& KIGFX::GAL::GetStrokeFont ( ) const
inlineinherited

Definition at line 298 of file graphics_abstraction_layer.h.

References KIGFX::GAL::strokeFont.

Referenced by EDA_TEXT::GetTextBox().

299  {
300  return strokeFont;
301  }
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 1290 of file opengl_gal.cpp.

References currentTarget.

1291 {
1292  return currentTarget;
1293 }
RENDER_TARGET currentTarget
Current rendering target.
Definition: opengl_gal.h:311
VECTOR2D GAL::GetTextLineSize ( const UTF8 aText) const
inherited

Compute the X and Y size of a given text.

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

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

Definition at line 168 of file graphics_abstraction_layer.cpp.

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

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

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

Returns current text vertical justification setting.

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

477  {
479  }
EDA_TEXT_VJUSTIFY_T m_verticalJustify
Vertical justification.
struct KIGFX::GAL::TEXT_PROPERTIES textProperties
double KIGFX::GAL::GetWorldScale ( ) const
inlineinherited
const MATRIX3x3D& KIGFX::GAL::GetWorldScreenMatrix ( ) const
inlineinherited

Get the world <-> screen transformation matrix.

Returns
the transformation matrix.

Definition at line 584 of file graphics_abstraction_layer.h.

References KIGFX::GAL::worldScreenMatrix.

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

585  {
586  return worldScreenMatrix;
587  }
MATRIX3x3D worldScreenMatrix
World transformation.
double KIGFX::GAL::GetZoomFactor ( ) const
inlineinherited

Get the zoom factor.

Returns
the zoom factor.

Definition at line 673 of file graphics_abstraction_layer.h.

References KIGFX::GAL::zoomFactor.

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

674  {
675  return zoomFactor;
676  }
double zoomFactor
The zoom factor.
void OPENGL_GAL::init ( )
private

Basic OpenGL initialization.

Definition at line 1702 of file opengl_gal.cpp.

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

Referenced by BeginDrawing(), and BeginUpdate().

1703 {
1704  wxASSERT( IsShownOnScreen() );
1705 
1707 
1708  GLenum err = glewInit();
1709 
1710  try
1711  {
1712  if( GLEW_OK != err )
1713  throw std::runtime_error( (const char*) glewGetErrorString( err ) );
1714 
1715  // Check the OpenGL version (minimum 2.1 is required)
1716  if( !GLEW_VERSION_2_1 )
1717  throw std::runtime_error( "OpenGL 2.1 or higher is required!" );
1718 
1719  // Framebuffers have to be supported
1720  if( !GLEW_EXT_framebuffer_object )
1721  throw std::runtime_error( "Framebuffer objects are not supported!" );
1722 
1723  // Vertex buffer has to be supported
1724  if( !GLEW_ARB_vertex_buffer_object )
1725  throw std::runtime_error( "Vertex buffer objects are not supported!" );
1726 
1727  // Prepare shaders
1729  throw std::runtime_error( "Cannot compile vertex shader!" );
1730 
1732  throw std::runtime_error( "Cannot compile fragment shader!" );
1733 
1734  if( !shader->IsLinked() && !shader->Link() )
1735  throw std::runtime_error( "Cannot link the shaders!" );
1736 
1737  // Check if video card supports textures big enough to fit the font atlas
1738  int maxTextureSize;
1739  glGetIntegerv( GL_MAX_TEXTURE_SIZE, &maxTextureSize );
1740 
1741  if( maxTextureSize < (int) font_image.width || maxTextureSize < (int)font_image.height )
1742  {
1743  // TODO implement software texture scaling
1744  // for bitmap fonts and use a higher resolution texture?
1745  throw std::runtime_error( "Requested texture size is not supported" );
1746  }
1747  }
1748  catch( std::runtime_error& )
1749  {
1751  throw;
1752  }
1753 
1754  // Make VBOs use shaders
1758 
1760  isInitialized = true;
1761 }
static SHADER * shader
There is only one shader used for different objects.
Definition: opengl_gal.h:314
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:305
Fragment shader.
Definition: shader.h:45
bool Link()
Link the shaders.
Definition: shader.cpp:96
void UnlockCtx(wxGLContext *aContext)
Function UnlockCtx allows other canvases to bind an OpenGL context.
VERTEX_MANAGER * nonCachedManager
Container for storing non-cached VERTEX_ITEMs.
Definition: opengl_gal.h:304
static GL_CONTEXT_MANAGER & Get()
Function Get returns the GL_CONTEXT_MANAGER instance (singleton).
FONT_IMAGE_TYPE font_image
Definition: gl_resources.cpp:4
Vertex shader.
Definition: shader.h:44
void LockCtx(wxGLContext *aContext, wxGLCanvas *aCanvas)
Function LockCtx sets a context as current and prevents other canvases from switching it...
VERTEX_MANAGER * cachedManager
Container for storing cached VERTEX_ITEMs.
Definition: opengl_gal.h:303
bool isInitialized
Basic initialization flag, has to be done when the window is visible.
Definition: opengl_gal.h:320
wxGLContext * glPrivContext
Canvas-specific OpenGL context.
Definition: opengl_gal.h:291
void 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 914 of file graphics_abstraction_layer.h.

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

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

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

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

Definition at line 404 of file graphics_abstraction_layer.h.

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

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

405  {
406  return textProperties.m_bold;
407  }
struct KIGFX::GAL::TEXT_PROPERTIES textProperties
bool KIGFX::GAL::IsFontItalic ( ) const
inlineinherited

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

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

423  {
424  return textProperties.m_italic;
425  }
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();
94  }
bool KIGFX::GAL::IsTextMirrored ( ) const
inlineinherited

Returns true if text should displayed mirrored.

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

441  {
442  return textProperties.m_mirrored;
443  }
struct KIGFX::GAL::TEXT_PROPERTIES textProperties
bool KIGFX::OPENGL_GAL::IsVisible ( ) const
inlineoverridevirtual

>

Returns true if the GAL canvas is visible on the screen.

Reimplemented from KIGFX::GAL.

Definition at line 97 of file opengl_gal.h.

98  {
99  return IsShownOnScreen();
100  }
void GAL::OnGalDisplayOptionsChanged ( const GAL_DISPLAY_OPTIONS aOptions)
overrideprotectedvirtualinherited

Handler for observer settings changes.

Implements KIGFX::GAL_DISPLAY_OPTIONS_OBSERVER.

Definition at line 88 of file graphics_abstraction_layer.cpp.

References KIGFX::GAL::updatedGalDisplayOptions().

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

This is the OnPaint event handler.

Parameters
aEventis the OnPaint event.

Definition at line 1643 of file opengl_gal.cpp.

References PostPaint().

Referenced by OPENGL_GAL().

1644 {
1645  PostPaint();
1646 }
void PostPaint()
Function PostPaint posts an event to m_paint_listener.
Definition: opengl_gal.h:254
void KIGFX::GAL::PopDepth ( )
inlineinherited

Restores previously stored drawing depth for the depth stack.

Definition at line 956 of file graphics_abstraction_layer.h.

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

957  {
958  layerDepth = depthStack.top();
959  depthStack.pop();
960  }
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 254 of file opengl_gal.h.

References paintListener.

Referenced by onPaint().

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

Stores current drawing depth on the depth stack.

Definition at line 948 of file graphics_abstraction_layer.h.

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

949  {
950  depthStack.push( layerDepth );
951  }
double layerDepth
The actual layer depth.
std::stack< double > depthStack
Stored depth values.
void GAL::ResetTextAttributes ( )
inherited

Reset text attributes to default styling.

Normally, custom attributes will be set individually after this, otherwise you can use SetTextAttributes()

Definition at line 153 of file graphics_abstraction_layer.cpp.

References GR_TEXT_HJUSTIFY_CENTER, GR_TEXT_VJUSTIFY_CENTER, KIGFX::GAL::SetFontBold(), KIGFX::GAL::SetFontItalic(), KIGFX::GAL::SetGlyphSize(), KIGFX::GAL::SetHorizontalJustify(), KIGFX::GAL::SetTextMirrored(), and KIGFX::GAL::SetVerticalJustify().

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

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

Resizes the canvas.

Reimplemented from KIGFX::GAL.

Definition at line 1113 of file opengl_gal.cpp.

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

1114 {
1115  screenSize = VECTOR2I( aWidth, aHeight );
1116 
1117 #ifdef RETINA_OPENGL_PATCH
1118  const float scaleFactor = GetBackingScaleFactor();
1119 #else
1120  const float scaleFactor = 1.0f;
1121 #endif
1122 
1123  // Resize framebuffers
1124  compositor->Resize( aWidth * scaleFactor, aHeight * scaleFactor );
1125  isFramebufferInitialized = false;
1126 
1127  wxGLCanvas::SetSize( aWidth, aHeight );
1128 }
VECTOR2< int > VECTOR2I
Definition: vector2d.h:590
OPENGL_COMPOSITOR * compositor
Handles multiple rendering targets.
Definition: opengl_gal.h:308
bool isFramebufferInitialized
Are the framebuffers initialized?
Definition: opengl_gal.h:317
virtual void Resize(unsigned int aWidth, unsigned int aHeight) override
Function Resize() clears the state of COMPOSITOR, so it has to be reinitialized again with the new di...
VECTOR2I screenSize
Screen size in screen coordinates.
void OPENGL_GAL::Restore ( )
overridevirtual

Restore the context.

Reimplemented from KIGFX::GAL.

Definition at line 1199 of file opengl_gal.cpp.

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

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

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

Restore the screen contents.

Reimplemented from KIGFX::GAL.

Definition at line 1262 of file opengl_gal.cpp.

1263 {
1264  wxASSERT_MSG( false, wxT( "Not implemented yet" ) );
1265 }
void OPENGL_GAL::Rotate ( double  aAngle)
overridevirtual

Rotate the context.

Parameters
aAngleis the rotation angle in radians.

Reimplemented from KIGFX::GAL.

Definition at line 1175 of file opengl_gal.cpp.

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

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

Save the context.

Reimplemented from KIGFX::GAL.

Definition at line 1193 of file opengl_gal.cpp.

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

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

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

Save the screen contents.

Reimplemented from KIGFX::GAL.

Definition at line 1256 of file opengl_gal.cpp.

1257 {
1258  wxASSERT_MSG( false, wxT( "Not implemented yet" ) );
1259 }
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 1187 of file opengl_gal.cpp.

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

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

References KIGFX::GAL::axesColor.

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

834  {
835  axesColor = aAxesColor;
836  }
COLOR4D axesColor
Color of the axes.
void KIGFX::GAL::SetAxesEnabled ( bool  aAxesEnabled)
inlineinherited

Enables drawing the axes.

Definition at line 841 of file graphics_abstraction_layer.h.

References KIGFX::GAL::axesEnabled.

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

842  {
843  axesEnabled = aAxesEnabled;
844  }
bool axesEnabled
Should the axes be drawn.
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 851 of file graphics_abstraction_layer.h.

References KIGFX::GAL::gridTick.

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

852  {
853  gridTick = aInterval;
854  }
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 924 of file graphics_abstraction_layer.h.

References KIGFX::GAL::cursorColor.

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

925  {
926  cursorColor = aCursorColor;
927  }
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 905 of file graphics_abstraction_layer.h.

References KIGFX::GAL::isCursorEnabled.

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

906  {
907  isCursorEnabled = aCursorEnabled;
908  }
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 686 of file graphics_abstraction_layer.h.

References KIGFX::GAL::depthRange.

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

687  {
688  depthRange = aDepthRange;
689  }
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 723 of file graphics_abstraction_layer.h.

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

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

724  {
725  globalFlipX = xAxis;
726  globalFlipY = yAxis;
727  }
bool globalFlipX
Flag for X axis flipping.
bool globalFlipY
Flag for Y axis flipping.
void KIGFX::GAL::SetFontBold ( const bool  aBold)
inlineinherited

Set bold property of current font.

Parameters
aBoldtells if the font should be bold or not.

Definition at line 396 of file graphics_abstraction_layer.h.

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

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

397  {
398  textProperties.m_bold = aBold;
399  }
struct KIGFX::GAL::TEXT_PROPERTIES textProperties
void KIGFX::GAL::SetFontItalic ( const bool  aItalic)
inlineinherited

Set italic property of current font.

Parameters
aItalictells if the font should be italic or not.

Definition at line 414 of file graphics_abstraction_layer.h.

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

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

415  {
416  textProperties.m_italic = aItalic;
417  }
struct KIGFX::GAL::TEXT_PROPERTIES textProperties
void KIGFX::GAL::SetGlyphSize ( const VECTOR2D  aGlyphSize)
inlineinherited

Set the font glyph size.

Parameters
aGlyphSizeis the new font glyph size.

Definition at line 378 of file graphics_abstraction_layer.h.

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

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

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

Set the grid color.

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

Definition at line 823 of file graphics_abstraction_layer.h.

References KIGFX::GAL::gridColor.

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

824  {
825  gridColor = aGridColor;
826  }
COLOR4D gridColor
Color of the grid.
void KIGFX::GAL::SetGridOrigin ( const VECTOR2D aGridOrigin)
inlineinherited

Set the origin point for the grid.

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

Definition at line 784 of file graphics_abstraction_layer.h.

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

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

785  {
786  gridOrigin = aGridOrigin;
787 
788  if( gridSize.x == 0.0 || gridSize.y == 0.0 )
789  gridOffset = VECTOR2D(0.0, 0.0);
790  else
791  gridOffset = VECTOR2D( (long) gridOrigin.x % (long) gridSize.x,
792  (long) gridOrigin.y % (long) gridSize.y );
793  }
VECTOR2D gridOffset
The grid offset to compensate cursor position.
VECTOR2< double > VECTOR2D
Definition: vector2d.h:589
VECTOR2D gridOrigin
The grid origin.
VECTOR2D gridSize
The grid size.
void KIGFX::GAL::SetGridSize ( const VECTOR2D aGridSize)
inlineinherited

Set the grid size.

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

Definition at line 800 of file graphics_abstraction_layer.h.

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

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

801  {
802  gridSize = aGridSize;
803 
804  gridOffset = VECTOR2D( (long) gridOrigin.x % (long) gridSize.x,
805  (long) gridOrigin.y % (long) gridSize.y );
806  }
VECTOR2D gridOffset
The grid offset to compensate cursor position.
VECTOR2< double > VECTOR2D
Definition: vector2d.h:589
VECTOR2D gridOrigin
The grid origin.
VECTOR2D gridSize
The grid size.
void KIGFX::GAL::SetGridVisibility ( bool  aVisibility)
inlineinherited

Sets the visibility setting of the grid.

Parameters
aVisibilityis the new visibility setting of the grid.

Definition at line 774 of file graphics_abstraction_layer.h.

References KIGFX::GAL::gridVisibility.

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

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

Set the horizontal justify for text drawing.

Parameters
aHorizontalJustifyis the horizontal justify value.

Definition at line 450 of file graphics_abstraction_layer.h.

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

Referenced by KIGFX::PCB_PAINTER::draw(), KIGFX::PREVIEW::DrawTextNextToCursor(), drawTicksAlongLine(), KIGFX::GAL::ResetTextAttributes(), and KIGFX::GAL::SetTextAttributes().

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

Enable/disable fill.

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

Reimplemented in KIGFX::CAIRO_GAL.

Definition at line 216 of file graphics_abstraction_layer.h.

References KIGFX::GAL::isFillEnabled.

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

217  {
218  isFillEnabled = aIsFillEnabled;
219  }
bool isFillEnabled
Is filling of graphic objects enabled ?
virtual void KIGFX::GAL::SetIsStroke ( bool  aIsStrokeEnabled)
inlinevirtualinherited

Enable/disable stroked outlines.

Parameters
aIsStrokeEnabledis true, if the outline of an object should be stroked.

Reimplemented in KIGFX::CAIRO_GAL.

Definition at line 226 of file graphics_abstraction_layer.h.

References KIGFX::GAL::isStrokeEnabled.

Referenced by KIGFX::STROKE_FONT::Draw(), KIGFX::WORKSHEET_VIEWITEM::draw(), KIGFX::PCB_PAINTER::draw(), KIGFX::WORKSHEET_VIEWITEM::drawBorder(), KIGFX::GAL::DrawGrid(), KIGFX::GAL::GAL(), KIGFX::PREVIEW::SIMPLE_OVERLAY_ITEM::setupGal(), PCB_BRIGHT_BOX::ViewDraw(), KIGFX::RATSNEST_VIEWITEM::ViewDraw(), KIGFX::ORIGIN_VIEWITEM::ViewDraw(), and BRIGHT_BOX::ViewDraw().

227  {
228  isStrokeEnabled = aIsStrokeEnabled;
229  }
bool isStrokeEnabled
Are the outlines stroked ?
virtual void KIGFX::GAL::SetLayerDepth ( double  aLayerDepth)
inlinevirtualinherited

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

Parameters
aLayerDepththe layer depth for the objects.

Reimplemented in KIGFX::CAIRO_GAL.

Definition at line 286 of file graphics_abstraction_layer.h.

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

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

287  {
288  assert( aLayerDepth <= depthRange.y );
289  assert( aLayerDepth >= depthRange.x );
290 
291  layerDepth = aLayerDepth;
292  }
double layerDepth
The actual layer depth.
VECTOR2D depthRange
Range of the depth.
virtual void KIGFX::GAL::SetLineWidth ( double  aLineWidth)
inlinevirtualinherited
void KIGFX::GAL::SetLookAtPoint ( const VECTOR2D aPoint)
inlineinherited

Set the Point in world space to look at.

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

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

Definition at line 643 of file graphics_abstraction_layer.h.

References KIGFX::GAL::lookAtPoint.

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

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

Definition at line 263 of file opengl_gal.h.

References mouseListener.

264  {
265  mouseListener = aMouseListener;
266  }
wxEvtHandler * mouseListener
Definition: opengl_gal.h:293
void KIGFX::OPENGL_GAL::SetPaintListener ( wxEvtHandler *  aPaintListener)
inline

Parameters passed to the GLU tesselator.

Definition at line 268 of file opengl_gal.h.

References paintListener.

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

Set the dots per inch of the screen.

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

Parameters
aScreenDPIare the screen DPI.

Definition at line 631 of file graphics_abstraction_layer.h.

References KIGFX::GAL::screenDPI.

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

632  {
633  screenDPI = aScreenDPI;
634  }
double screenDPI
The dots per inch of the screen.
virtual void KIGFX::GAL::SetStrokeColor ( const COLOR4D aColor)
inlinevirtualinherited
void OPENGL_GAL::SetTarget ( RENDER_TARGET  aTarget)
overridevirtual

Sets the target for rendering.

Parameters
aTargetis the new target for rendering.

Reimplemented from KIGFX::GAL.

Definition at line 1268 of file opengl_gal.cpp.

References cachedManager, currentManager, currentTarget, nonCachedManager, overlayManager, KIGFX::TARGET_CACHED, KIGFX::TARGET_NONCACHED, and KIGFX::TARGET_OVERLAY.

Referenced by DrawGrid(), and OPENGL_GAL().

1269 {
1270  switch( aTarget )
1271  {
1272  default:
1273  case TARGET_CACHED:
1275  break;
1276 
1277  case TARGET_NONCACHED:
1279  break;
1280 
1281  case TARGET_OVERLAY:
1283  break;
1284  }
1285 
1286  currentTarget = aTarget;
1287 }
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:302
RENDER_TARGET currentTarget
Current rendering target.
Definition: opengl_gal.h:311
VERTEX_MANAGER * overlayManager
Container for storing overlaid VERTEX_ITEMs.
Definition: opengl_gal.h:305
VERTEX_MANAGER * nonCachedManager
Container for storing non-cached VERTEX_ITEMs.
Definition: opengl_gal.h:304
Auxiliary rendering target (noncached)
Definition: definitions.h:42
Items that may change while the view stays the same (noncached)
Definition: definitions.h:43
VERTEX_MANAGER * cachedManager
Container for storing cached VERTEX_ITEMs.
Definition: opengl_gal.h:303
Main rendering target (cached)
Definition: definitions.h:41
void GAL::SetTextAttributes ( const EDA_TEXT aText)
virtualinherited

Loads attributes of the given text (bold/italic/underline/mirrored and so on).

Parameters
aTextis the text item.

Definition at line 142 of file graphics_abstraction_layer.cpp.

References EDA_TEXT::GetHorizJustify(), EDA_TEXT::GetTextSize(), EDA_TEXT::GetVertJustify(), EDA_TEXT::IsBold(), EDA_TEXT::IsItalic(), EDA_TEXT::IsMirrored(), KIGFX::GAL::SetFontBold(), KIGFX::GAL::SetFontItalic(), KIGFX::GAL::SetGlyphSize(), KIGFX::GAL::SetHorizontalJustify(), KIGFX::GAL::SetTextMirrored(), and KIGFX::GAL::SetVerticalJustify().

Referenced by KIGFX::WORKSHEET_VIEWITEM::draw(), KIGFX::PCB_PAINTER::draw(), and DrawGraphicText().

143 {
144  SetGlyphSize( VECTOR2D( aText->GetTextSize() ) );
147  SetFontBold( aText->IsBold() );
148  SetFontItalic( aText->IsItalic() );
149  SetTextMirrored( aText->IsMirrored() );
150 }
void SetFontItalic(const bool aItalic)
Set italic property of current font.
bool IsItalic() const
Definition: eda_text.h:170
EDA_TEXT_HJUSTIFY_T GetHorizJustify() const
Definition: eda_text.h:190
bool IsBold() const
Definition: eda_text.h:173
void SetFontBold(const bool aBold)
Set bold property of current font.
VECTOR2< double > VECTOR2D
Definition: vector2d.h:589
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.
EDA_TEXT_VJUSTIFY_T GetVertJustify() const
Definition: eda_text.h:191
bool IsMirrored() const
Definition: eda_text.h:179
void SetGlyphSize(const VECTOR2D aGlyphSize)
Set the font glyph size.
const wxSize & GetTextSize() const
Definition: eda_text.h:215
void SetHorizontalJustify(const EDA_TEXT_HJUSTIFY_T aHorizontalJustify)
Set the horizontal justify for text drawing.
void KIGFX::GAL::SetTextMirrored ( const bool  aMirrored)
inlineinherited

Set a mirrored property of text.

Parameters
aMirroredtells if the text should be mirrored or not.

Definition at line 432 of file graphics_abstraction_layer.h.

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

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

433  {
434  textProperties.m_mirrored = aMirrored;
435  }
struct KIGFX::GAL::TEXT_PROPERTIES textProperties
void KIGFX::GAL::SetVerticalJustify ( const EDA_TEXT_VJUSTIFY_T  aVerticalJustify)
inlineinherited

Set the vertical justify for text drawing.

Parameters
aVerticalJustifyis the vertical justify value.

Definition at line 468 of file graphics_abstraction_layer.h.

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

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

469  {
470  textProperties.m_verticalJustify = aVerticalJustify;
471  }
EDA_TEXT_VJUSTIFY_T m_verticalJustify
Vertical justification.
struct KIGFX::GAL::TEXT_PROPERTIES textProperties
void KIGFX::GAL::SetWorldScreenMatrix ( const MATRIX3x3D aMatrix)
inlineinherited

Set the world <-> screen transformation matrix.

Parameters
aMatrixis the 3x3 world <-> screen transformation matrix.

Definition at line 604 of file graphics_abstraction_layer.h.

References KIGFX::GAL::worldScreenMatrix.

605  {
606  worldScreenMatrix = aMatrix;
607  }
MATRIX3x3D worldScreenMatrix
World transformation.
void KIGFX::GAL::SetWorldUnitLength ( double  aWorldUnitLength)
inlineinherited

Set the unit length.

This defines the length [inch] per one integer. For instance a value 0.001 means that the coordinate [1000, 1000] corresponds with a point at (1 inch, 1 inch) or 1 mil resolution per integer.

Parameters
aWorldUnitLengthis the world Unit length.

Definition at line 618 of file graphics_abstraction_layer.h.

References KIGFX::GAL::worldUnitLength.

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

619  {
620  worldUnitLength = aWorldUnitLength;
621  }
double worldUnitLength
The unit length of the world coordinates [inch].
void KIGFX::GAL::SetZoomFactor ( double  aZoomFactor)
inlineinherited

Set the zoom factor of the scene.

Parameters
aZoomFactoris the zoom factor.

Definition at line 663 of file graphics_abstraction_layer.h.

References KIGFX::GAL::zoomFactor.

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

664  {
665  zoomFactor = aZoomFactor;
666  }
double zoomFactor
The zoom factor.
bool OPENGL_GAL::Show ( bool  aShow)
overridevirtual

Shows/hides the GAL canvas.

Reimplemented from KIGFX::GAL.

Definition at line 1131 of file opengl_gal.cpp.

1132 {
1133  bool s = wxGLCanvas::Show( aShow );
1134 
1135  if( aShow )
1136  wxGLCanvas::Raise();
1137 
1138  return s;
1139 }
void OPENGL_GAL::skipMouseEvent ( wxMouseEvent &  aEvent)
private

Skip the mouse event to the parent.

Parameters
aEventis the mouse event.

Definition at line 1649 of file opengl_gal.cpp.

References mouseListener.

Referenced by OPENGL_GAL().

1650 {
1651  // Post the mouse event to the event listener registered in constructor, if any
1652  if( mouseListener )
1653  wxPostEvent( mouseListener, aEvent );
1654 }
wxEvtHandler * mouseListener
Definition: opengl_gal.h:293
virtual void KIGFX::GAL::StrokeText ( const wxString &  aText,
const VECTOR2D aPosition,
double  aRotationAngle 
)
inlinevirtualinherited

Draws a vector type text using preloaded Newstroke font.

Parameters
aTextis the text to be drawn.
aPositionis the text position in world coordinates.
aRotationAngleis the text rotation angle.

Definition at line 310 of file graphics_abstraction_layer.h.

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

Referenced by KIGFX::GAL::BitmapText(), KIGFX::WORKSHEET_VIEWITEM::draw(), KIGFX::PCB_PAINTER::draw(), and DrawGraphicText().

312  {
313  strokeFont.Draw( aText, aPosition, aRotationAngle );
314  }
STROKE_FONT strokeFont
Instance of object that stores information about how to draw texts.
void Draw(const UTF8 &aText, const VECTOR2D &aPosition, double aRotationAngle)
Draw a string.
VECTOR2D KIGFX::GAL::ToScreen ( const VECTOR2D aPoint) const
inlineinherited

Compute the point position in screen coordinates from given world coordinates.

Parameters
aPointthe pointposition in world coordinates.
Returns
the point position in screen coordinates.

Definition at line 895 of file graphics_abstraction_layer.h.

References KIGFX::GAL::worldScreenMatrix.

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

896  {
897  return VECTOR2D( worldScreenMatrix * aPoint );
898  }
VECTOR2< double > VECTOR2D
Definition: vector2d.h:589
MATRIX3x3D worldScreenMatrix
World transformation.
VECTOR2D KIGFX::GAL::ToWorld ( const VECTOR2D aPoint) const
inlineinherited

Compute the point position in world coordinates from given screen coordinates.

Parameters
aPointthe pointposition in screen coordinates.
Returns
the point position in world coordinates.

Definition at line 884 of file graphics_abstraction_layer.h.

References KIGFX::GAL::screenWorldMatrix.

885  {
886  return VECTOR2D( screenWorldMatrix * aPoint );
887  }
MATRIX3x3D screenWorldMatrix
Screen transformation.
VECTOR2< double > VECTOR2D
Definition: vector2d.h:589
void OPENGL_GAL::Transform ( const MATRIX3x3D aTransformation)
overridevirtual

Transform the context.

Parameters
aTransformationis the ransformation matrix.

Reimplemented from KIGFX::GAL.

Definition at line 1157 of file opengl_gal.cpp.

References MATRIX3x3< T >::m_data.

1158 {
1159  GLdouble matrixData[16] = { 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1 };
1160 
1161  matrixData[0] = aTransformation.m_data[0][0];
1162  matrixData[1] = aTransformation.m_data[1][0];
1163  matrixData[2] = aTransformation.m_data[2][0];
1164  matrixData[4] = aTransformation.m_data[0][1];
1165  matrixData[5] = aTransformation.m_data[1][1];
1166  matrixData[6] = aTransformation.m_data[2][1];
1167  matrixData[12] = aTransformation.m_data[0][2];
1168  matrixData[13] = aTransformation.m_data[1][2];
1169  matrixData[14] = aTransformation.m_data[2][2];
1170 
1171  glMultMatrixd( matrixData );
1172 }
T m_data[3][3]
Definition: matrix3x3.h:64
void OPENGL_GAL::Translate ( const VECTOR2D aTranslation)
overridevirtual

Translate the context.

Parameters
aTranslationis the translation vector.

Reimplemented from KIGFX::GAL.

Definition at line 1181 of file opengl_gal.cpp.

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

Referenced by BitmapText(), drawBitmapChar(), and drawBitmapOverbar().

1182 {
1183  currentManager->Translate( aVector.x, aVector.y, 0.0f );
1184 }
VERTEX_MANAGER * currentManager
Currently used VERTEX_MANAGER (for storing VERTEX_ITEMs)
Definition: opengl_gal.h:302
void Translate(GLfloat aX, GLfloat aY, GLfloat aZ)
Function Translate() multiplies the current matrix by a translation matrix, so newly vertices will be...
bool OPENGL_GAL::updatedGalDisplayOptions ( const GAL_DISPLAY_OPTIONS aOptions)
overrideprivatevirtual

Function updatedGalDisplayOptions.

handler for updated display options. Derived classes should call up to this to set base-class methods.

Returns
true if the new settings changed something. Derived classes can use this information to refresh themselves

Reimplemented from KIGFX::GAL.

Definition at line 188 of file opengl_gal.cpp.

References compositor, KIGFX::OPENGL_COMPOSITOR::GetAntialiasingMode(), KIGFX::GAL_DISPLAY_OPTIONS::gl_antialiasing_mode,