The Cairo implementation of the graphics abstraction layer. More...

Namespaces
namespace	BUILTIN_FONT

namespace	DETAIL

namespace	PREVIEW

Classes
class	ACCELERATING_ZOOM_CONTROLLER
	Class that zooms faster if scroll events happen very close together. More...

class	ANCHOR_DEBUG
	View item to draw debug items for anchors. More...

class	ANTIALIASING_NONE

class	ANTIALIASING_SMAA

class	ANTIALIASING_SUPERSAMPLING

class	AUTOMATIC_FIT
	What the last zoom to fit showed, so a canvas that changes size can fit it again. More...

struct	BITMAP_DRAW_DESC
	One textured bitmap quad with its own vertex buffer and texture. More...

class	CACHED_CONTAINER
	Class to store VERTEX instances with caching. More...

class	CACHED_CONTAINER_GPU
	Specialization of CACHED_CONTAINER that stores data in video memory via memory mapping. More...

class	CACHED_CONTAINER_RAM
	Specialization of CACHED_CONTAINER that stores data in RAM. More...

class	CAIRO_COMPOSITOR

class	CAIRO_GAL

class	CAIRO_GAL_BASE

class	CAIRO_PRINT_CTX
	Provide a Cairo context created from wxPrintDC or an wxImage. More...

class	CAIRO_PRINT_GAL

class	COLOR4D
	A color representation with 4 components: red, green, blue, alpha. More...

class	COMPOSITOR

class	CONSTANT_ZOOM_CONTROLLER
	A CONSTANT_ZOOM_CONTROLLER that zooms by a fixed factor based only on the magnitude of the scroll wheel rotation. More...

class	CONSTRUCTION_GEOM
	Shows construction geometry for things like line extensions, arc centers, etc. More...

struct	CURSOR_UBO_DATA
	Cursor uniform block matching the CursorUBO layout in cursor.frag (std140). More...

class	DS_PAINTER
	Methods for painting drawing sheet items. More...

class	DS_RENDER_SETTINGS
	Store page-layout-specific render settings. More...

struct	FRAME_DRAW_DESC
	GPU geometry of one frame, built by GAL_MODERN after EndDrawing() and passed through the FRAME_MAILBOX. More...

class	FRAME_MAILBOX
	Lock-free single-slot mailbox carrying frame state from the main thread to the render thread. More...

struct	FRAME_PACKET
	Everything the render thread needs to draw one frame of a window. More...

struct	FRAME_UBO_DATA
	Per-frame uniform block matching FrameUBO in frame_ubo.glsl (std140). More...

class	GAL
	Abstract interface for drawing on a 2D-surface. More...

class	GAL_CONTEXT_LOCKER

class	GAL_DISPLAY_OPTIONS

class	GAL_DISPLAY_OPTIONS_OBSERVER

class	GAL_DRAWING_CONTEXT

class	GAL_MODERN
	GAL that turns drawing commands into instanced primitives for the RHI device. More...

class	GAL_PRINT
	Wrapper around GAL to provide information needed for printing. More...

class	GAL_SCOPED_ATTRS
	Attribute save/restore for GAL attributes. More...

class	GAL_UPDATE_CONTEXT

class	GERBVIEW_PAINTER
	Methods for drawing GerbView specific items. More...

class	GERBVIEW_RENDER_SETTINGS
	Store GerbView specific render settings. More...

class	GL_BITMAP_CACHE

class	GL_RESET_BUDGET
	Limit how often the OpenGL canvases are rebuilt after GPU resets. More...

class	GPU_CACHED_MANAGER

class	GPU_MANAGER
	Class to handle uploading vertices and indices to GPU in drawing purposes. More...

class	GPU_NONCACHED_MANAGER

class	GPU_OOM_ERROR
	Raised when a GPU buffer allocation is predicted to exceed the available video memory. More...

struct	GRID_SOURCE
	Render-time projection of a grid: GRID_GEOMETRY (kind/origin/pitch/orientation/extent) plus rendering and interaction flags. More...

struct	GRID_UBO_DATA
	Grid uniform block matching the GridUBO layout in grid.frag (std140). More...

struct	LAYER_DRAW_STEP
	One draw of a layer range. More...

struct	LAYER_RANGE
	One layer's instance ranges within the flat GPU buffers, normal instances before negatives. More...

class	NONCACHED_CONTAINER

class	OPENGL_COMPOSITOR

class	OPENGL_GAL
	OpenGL implementation of the Graphics Abstraction Layer. More...

class	OPENGL_PRESENTOR

class	ORIGIN_VIEWITEM

class	PAINTER
	Contains all the knowledge about how to draw graphical object onto any particular output device. More...

class	PCB_PAINTER
	Contains methods for drawing PCB-specific items. More...

class	PCB_PRINT_PAINTER
	Special flavor of PCB_PAINTER that contains modifications to handle printing options. More...

class	PCB_RENDER_SETTINGS
	PCB specific render settings. More...

class	PCB_VIEW

struct	POLARITY_RUN
	A stretch of one layer range drawn in one polarity. More...

class	PRINT_CONTEXT

class	RENDER_SETTINGS
	Container for all the knowledge about how graphical objects are drawn on any output surface/device. More...

class	RENDER_THREAD
	Thread that owns the RHI device. More...

struct	RETAINED_GROUP_ORDER

struct	RETAINED_ORDER_ITEM

struct	RHI_CULL_COUNT
	Runs a pass looked at and how many it drew, to tell how well culling works. More...

struct	RHI_CULL_VIEW
	The world rectangle a frame shows and the world size of one of its pixels. More...

class	RHI_DEVICE_PROXY
	UI-thread access to GPU resources without touching the device, which only the render thread may mutate. More...

struct	RHI_LAYER_DIM
	Fade of a whole layer towards a colour, laid out as the push constants of layer_dim.glsl. More...

struct	RHI_PHASE_STALL_RESULT

struct	RHI_PHASE_STALL_TRACKER

struct	RHI_RUN_BOUNDS

struct	RHI_RUN_TABLE
	Runs of each array a layer range draws from, indexed by element / RHI_CULL_RUN_LENGTH. More...

struct	RHI_VIEW_SHIFT
	How far the view has moved since the static target was drawn, in whole frame pixels. More...

class	SCH_PAINTER
	Contains methods for drawing schematic-specific items. More...

class	SCH_VIEW

class	SHADER
	Provide the access to the OpenGL shaders. More...

class	SNAP_INDICATOR
	View item to draw an origin marker with an optional snap type indicator. More...

class	SWAPCHAIN_CONTROLLER
	Turns one window's paint, resize and close events into render thread control commands. More...

struct	VC_SETTINGS
	Structure to keep VIEW_CONTROLS settings for easy store/restore operations. More...

struct	VERTEX

class	VERTEX_CONTAINER

class	VERTEX_ITEM

class	VERTEX_MANAGER
	Class to control vertex container and GPU with possibility of emulating old-style OpenGL 1.0 state machine using modern OpenGL methods. More...

class	VIEW
	Hold a (potentially large) number of VIEW_ITEMs and renders them on a graphics device provided by the GAL. More...

class	VIEW_CONTROLS
	An interface for classes handling user events controlling the view behavior such as zooming, panning, mouse grab, etc. More...

class	VIEW_GROUP
	Extend VIEW_ITEM by possibility of grouping items into a single object. More...

class	VIEW_ITEM
	An abstract base class for deriving all objects that can be added to a VIEW. More...

class	VIEW_ITEM_DATA

class	VIEW_OVERLAY

class	VIEW_RTREE
	Implement a non-owning R-tree for fast spatial indexing of VIEW items. More...

struct	WINDOW_STATE
	Per-window state owned by the render thread. More...

class	WX_VIEW_CONTROLS
	An implementation of class VIEW_CONTROLS for wxWidgets library. More...

class	ZOOM_CONTROLLER
	Handle the response of the zoom scale to external inputs. More...

Typedefs
using	RHI_SHAPE_COUNTS = std::array<uint32_t, RHI_SHAPES>
	Elements of each shape, indexed by RHI_SHAPE.

using	RHI_DEVICE_FACTORY = std::function<std::unique_ptr<RHI_DEVICE>()>
	Creates the RHI_DEVICE.

Enumerations
enum	RENDER_TARGET { TARGET_CACHED = 0 , TARGET_NONCACHED , TARGET_OVERLAY , TARGET_TEMP , TARGETS_NUMBER }
	RENDER_TARGET: Possible rendering targets. More...

enum class	GRID_STYLE { DOTS , LINES , SMALL_CROSS }
	Type definition of the grid style. More...

enum class	GAL_ANTIALIASING_MODE { AA_NONE , AA_FAST , AA_HIGHQUALITY }

enum class	GRID_SNAPPING { ALWAYS , WITH_GRID , NEVER }

enum class	CROSS_HAIR_MODE : int { SMALL_CROSS , FULLSCREEN_CROSS , FULLSCREEN_DIAGONAL }

enum class	GAL_CONTEXT_LOSS { NONE , RECOVERABLE , REPEATED }
	State of a canvas' rendering context after a GPU reset. More...

enum	SHADER_TYPE { SHADER_TYPE_VERTEX = GL_VERTEX_SHADER , SHADER_TYPE_FRAGMENT = GL_FRAGMENT_SHADER , SHADER_TYPE_GEOMETRY = GL_GEOMETRY_SHADER }
	Type definition for the shader. More...

enum class	VRAM_RESIZE_STRATEGY { GPU_COPY , RAM_STAGE , REFUSE }
	Strategy for growing a GPU vertex buffer, trading copy speed against peak video memory. More...

enum	SHADER_MODE { SHADER_NONE = 0 , SHADER_FILLED_CIRCLE = 2 , SHADER_STROKED_CIRCLE = 3 , SHADER_FONT = 4 , SHADER_LINE_A = 5 , SHADER_LINE_B = 6 , SHADER_LINE_C = 7 , SHADER_LINE_D = 8 , SHADER_LINE_E = 9 , SHADER_LINE_F = 10 , SHADER_HOLE_WALL = 11 }
	< Possible types of shaders (keep consistent with the actual shader source in kicad_vert.glsl and kicad_frag.glsl). More...

enum class	RHI_LINE_PIPELINE_KIND : uint8_t { PCB_TRACKS , SCH_WIRES }

enum	RHI_SHAPE : uint8_t { RHI_SHAPE_TRACK , RHI_SHAPE_ARC , RHI_SHAPE_PAD , RHI_SHAPE_POLYGON }
	Shapes a frame draws, each with its own array and pipelines. More...

enum class	LAYER_DRAW_MODE : uint8_t { BLEND , NEGATIVE , ONCE , MARK }

enum	VIEW_UPDATE_FLAGS { NONE = 0x00 , APPEARANCE = 0x01 , COLOR = 0x02 , GEOMETRY = 0x04 , LAYERS = 0x08 , INITIAL_ADD = 0x10 , REPAINT = 0x20 , ALL = 0xef }
	Define the how severely the appearance of the item has been changed. More...

enum	VIEW_VISIBILITY_FLAGS { VISIBLE = 0x01 , HIDDEN = 0x02 , OVERLAY_HIDDEN = 0x04 }
	Define the visibility of the item (temporarily hidden, invisible, etc). More...

Functions
wxImage	FitImageToTexture (const wxImage &aImage, int aMaxTextureSize)
	Fit an image into the largest texture a GPU can hold.

std::vector< uint8_t >	RgbToRgba (const uint8_t aRgb, const uint8_t aAlpha, size_t aPixelCount)
	Expand packed RGB to tightly packed RGBA.

std::vector< uint8_t >	ImageToRgba (const wxImage &aImage)
	The pixels of aImage as tightly packed RGBA, transparent where it has alpha or a mask.

bool	operator== (const COLOR4D &lhs, const COLOR4D &rhs)
	Equality operator, are two colors equal.

bool	operator!= (const COLOR4D &lhs, const COLOR4D &rhs)
	Not equality operator, are two colors not equal.

bool	operator< (const COLOR4D &lhs, const COLOR4D &rhs)

std::ostream &	operator<< (std::ostream &aStream, COLOR4D const &aColor)
	Syntactic sugar for outputting colors to strings.

void	to_json (nlohmann::json &aJson, const COLOR4D &aColor)

void	from_json (const nlohmann::json &aJson, COLOR4D &aColor)

size_t	queryFreeVideoMemoryBytes ()
	Query the amount of free video memory the driver reports.

VRAM_RESIZE_STRATEGY	chooseResizeStrategy (size_t aFreeVRAM, size_t aOldBytes, size_t aNewBytes, double aMarginFrac)
	Decide how to grow a GPU vertex buffer given the free video memory budget.

static RETAINED_GROUP_ORDER	retainedOrderKey (VIEW_ITEM *aItem, int aPriority, const BOX2I &aBBox, bool aUseDrawPriority, bool aReverseDrawOrder, double aLodScale)

template<typename T>
static void	sortRetainedOrder (VIEW *aView, std::vector< T > &aEntries)

EESCHEMA_SETTINGS *	eeconfig ()

static bool	isFieldsLayer (int aLayer)

static void	drawText (KIGFX::GAL &aGal, const wxString &aText, const VECTOR2D &aPosition, const TEXT_ATTRIBUTES &aAttrs, float aShadowWidth, const KIFONT::METRICS &aFontMetrics, std::optional< VECTOR2I > aMousePos=std::nullopt, wxString *aActiveUrl=nullptr)

static void	bitmapText (KIGFX::GAL &aGal, const wxString &aText, const VECTOR2D &aPosition, const TEXT_ATTRIBUTES &aAttrs)

static void	drawCache (KIGFX::GAL &aGal, std::vector< std::unique_ptr< KIFONT::GLYPH > > *aCache, float aStrokeWidth, float aShadowWidth)

static void	knockoutText (KIGFX::GAL &aGal, const wxString &aText, const VECTOR2D &aPosition, const TEXT_ATTRIBUTES &aAttrs, const KIFONT::METRICS &aFontMetrics)

static void	drawAltPinModesIcon (GAL &aGal, const VECTOR2D &aPos, double aSize, bool aBaseSelected, bool aRotate, int aExtraLineWidth, const COLOR4D &aColor)
	Draw an alternate pin mode indicator icon.

static bool	symbolDrawsOnOverlay (const SCH_SYMBOL *aSymbol, int aLayer)

double	AutoSparsePitch (double aPitch, unsigned aTick, double aThreshold)
	Multiply aPitch by aTick until it exceeds aThreshold, so a sub-threshold grid still shows every Nth line.

void	DrawCross (GAL &aGal, const VECTOR2I &aPosition, int aSize)
	Draw a cross at a given position.

void	DrawDashedLine (GAL &aGal, const SEG &aSeg, double aDashSize)
	Draw a dashed line.

std::vector< LAYER_DRAW_STEP >	RhiPlanLayerDraws (const LAYER_RANGE &aRange, const std::vector< POLARITY_RUN > &aRuns={})
	Order the draws of one layer range.

void	RhiInstanceReach (const RHI_INSTANCE &aInstance, RHI_SHAPE aShape, float &aWorld, float &aPixels)
	How far an instance reaches from its position, in world units and in pixels.

RHI_RUN_BOUNDS	RhiInstanceRun (const RHI_INSTANCE *aInstances, size_t aCount, RHI_SHAPE aShape)

RHI_RUN_BOUNDS	RhiVertexRun (const RHI_VERTEX *aVertices, size_t aCount)

constexpr uint32_t	RhiCullRunLength (int aShape)

RHI_CULL_VIEW	RhiCullView (const FRAME_UBO_DATA &aFrame)
	Invert the frame's 2D projection over the normalized device square.

template<typename DRAW>
void	RhiForVisibleStretches (const std::vector< RHI_RUN_BOUNDS > aRuns, uint32_t aRunLength, uint32_t aStart, uint32_t aCount, const RHI_CULL_VIEW &aView, DRAW &&aDraw, RHI_CULL_COUNT aTally=nullptr)
	Call aDraw( first, count ) for each stretch of [aStart, aStart + aCount) whose runs can reach aView.

bool	RhiRangeReaches (const LAYER_RANGE &aRange, const RHI_CULL_VIEW &aView)
	A range without runs or with bitmaps always reaches.

FRAME_UBO_DATA	RhiWidenFrame (const FRAME_UBO_DATA &aFrame, uint32_t aMargin)

GRID_UBO_DATA	RhiWidenGrid (const GRID_UBO_DATA &aGrid, uint32_t aMargin)

bool	RhiViewMovedOnly (const FRAME_UBO_DATA &aDrawn, const FRAME_UBO_DATA &aNow)

std::optional< RHI_VIEW_SHIFT >	RhiViewShift (const FRAME_UBO_DATA &aDrawn, const FRAME_UBO_DATA &aNow)

bool	RhiGridMovedOnly (const GRID_UBO_DATA &aDrawn, const GRID_UBO_DATA &aNow)

FRAME_UBO_DATA	RhiSupersampleFrame (const FRAME_UBO_DATA &aFrame, uint32_t aFactor)

GRID_UBO_DATA	RhiSupersampleGrid (const GRID_UBO_DATA &aGrid, uint32_t aFactor)

RHI_PHASE_STALL_RESULT	EvaluateRenderThreadPhaseStall (RHI_PHASE_STALL_TRACKER &aTracker, int aPhase, uint64_t aGeneration, RHI_PHASE_STALL_TRACKER::CLOCK::time_point aNow, std::chrono::milliseconds aStallThreshold=std::chrono::milliseconds(1000), uint64_t aGenerationThreshold=60, std::chrono::milliseconds aRepeatThreshold=std::chrono::milliseconds(1000))

bool	ZoneOutlineDrawnOnLayer (bool aOutlineOnly, int aLayer)
	Decide which GAL draw pass paints a zone's outline.

Variables
constexpr size_t	BITMAP_CACHE_MAX_BYTES = 256 * 1024 * 1024
	Texture memory the GPU canvases may hold for placed bitmaps before they evict the oldest.

constexpr double	GRID_DIM_ALPHA = 0.4
	Opacity of the background wash laid over a selected grid item's area, to fade the grids showing through it.

constexpr double	GRID_EDGE_DARKEN = 0.75
	How far the hairline round a grid's coverage sits below its own colour.

constexpr double	GRID_SELECTED_BRIGHTEN = 0.5
	How far the grid being edited is lifted above its own colour.

static constexpr size_t	VERTEX_SIZE = sizeof( VERTEX )

static constexpr size_t	VERTEX_STRIDE = VERTEX_SIZE / sizeof( GLfloat )

static constexpr size_t	COORD_OFFSET = offsetof( VERTEX, x )

static constexpr size_t	COORD_SIZE

static constexpr size_t	COORD_STRIDE = COORD_SIZE / sizeof( GLfloat )

static constexpr size_t	COLOR_OFFSET = offsetof( VERTEX, r )

static constexpr size_t	COLOR_SIZE

static constexpr size_t	COLOR_STRIDE = COLOR_SIZE / sizeof( GLubyte )

static constexpr size_t	SHADER_OFFSET = offsetof( VERTEX, shader )

static constexpr size_t	SHADER_SIZE = sizeof( VERTEX::shader )

static constexpr size_t	SHADER_STRIDE = SHADER_SIZE / sizeof( GLfloat )

static constexpr size_t	INDEX_SIZE = sizeof( GLuint )

constexpr int	RHI_INSTANCED_SHAPES = RHI_SHAPE_POLYGON

constexpr int	RHI_SHAPES = RHI_SHAPE_POLYGON + 1

constexpr uint32_t	RHI_CULL_RUN_LENGTH = 256

constexpr float	RHI_CULL_PIXEL_SLACK = 4.0f
	Reach of every element beyond its own extent for antialiasing padding, pixel snapping and the edge.

constexpr uint32_t	RHI_CULL_VERTEX_RUN_LENGTH = 3 * RHI_CULL_RUN_LENGTH
	Polygon vertices per run, three per triangle.

constexpr float	RHI_SUPERSAMPLE_OFFSET = 0.5f
	Offset of a supersampled target from where its frame puts the scene, in pixels.

Detailed Description

The Cairo implementation of the graphics abstraction layer.

High quality antialiasing draws several texels per pixel and the present averages them, so the shaders draw hard edges in such a target, as the OpenGL canvas does.

The static scene is drawn into a target larger than the view by a margin on each side, so a pan within the margin shifts the target instead of redrawing the scene.

Off-screen culling of instanced geometry in runs of RHI_CULL_RUN_LENGTH elements in draw order.

View item to draw an origin marker.

Quote from Wikipedia: " Cairo is a software library used to provide a vector graphics-based, device-independent API for software developers. It is designed to provide primitives for 2-dimensional drawing across a number of different backends. "

Cairo offers also backends for PostScript and PDF surfaces. So it can be used for printing of KiCad graphics surfaces as well.

Only whole runs that cannot reach the target are dropped, so culling never changes a covered pixel. Bounds carry a reach in pixels because pixel padding and antialiasing do not scale with zoom.

Margins and shifts are in FRAME_UBO_DATA::viewport pixels, the units the shaders snap in. Target rows run with normalized device Y on every backend, so one shift serves both a copy and a composite.

Like the OpenGL canvas, strokes snap to pixel corners and the scene is drawn half a pixel right and down so odd-width strokes land on whole pixels. The uniforms built here carry that offset.

Typedef Documentation

◆ RHI_DEVICE_FACTORY

using KIGFX::RHI_DEVICE_FACTORY = std::function<std::unique_ptr<RHI_DEVICE>()>

Creates the RHI_DEVICE.

It runs on the render thread so the GPU context is bound to that thread.

Definition at line 59 of file render_thread.h.

◆ RHI_SHAPE_COUNTS

using KIGFX::RHI_SHAPE_COUNTS = std::array<uint32_t, RHI_SHAPES>

Elements of each shape, indexed by RHI_SHAPE.

Definition at line 61 of file frame_packet.h.

Enumeration Type Documentation

◆ CROSS_HAIR_MODE

enum class KIGFX::CROSS_HAIR_MODE : int

strong

Enumerator
SMALL_CROSS
FULLSCREEN_CROSS
FULLSCREEN_DIAGONAL

Definition at line 63 of file gal_display_options.h.

◆ GAL_ANTIALIASING_MODE

enum class KIGFX::GAL_ANTIALIASING_MODE

strong

Enumerator
AA_NONE
AA_FAST
AA_HIGHQUALITY

Definition at line 49 of file gal_display_options.h.

◆ GAL_CONTEXT_LOSS

enum class KIGFX::GAL_CONTEXT_LOSS

strong

State of a canvas' rendering context after a GPU reset.

Enumerator
NONE	Context is usable.
RECOVERABLE	Context was lost; rebuild the canvas.
REPEATED	Contexts keep being lost; stop using this backend.

Definition at line 126 of file graphics_abstraction_layer.h.

◆ GRID_SNAPPING

enum class KIGFX::GRID_SNAPPING

strong

Enumerator
ALWAYS
WITH_GRID
NEVER

Definition at line 56 of file gal_display_options.h.

◆ GRID_STYLE

enum class KIGFX::GRID_STYLE

strong

Type definition of the grid style.

Enumerator
DOTS	Use dots for the grid.
LINES	Use lines for the grid.
SMALL_CROSS	Use small cross instead of dots for the grid.

Definition at line 42 of file gal_display_options.h.

◆ LAYER_DRAW_MODE

enum class KIGFX::LAYER_DRAW_MODE : uint8_t

strong

Enumerator
BLEND	ordinary alpha blending
NEGATIVE	erase what the layer has drawn so far, inside a temp target
ONCE	blend, but let each pixel take the layer only once
MARK	write depth only, so the layer's later draws stay out of these pixels

Definition at line 31 of file layer_draw_plan.h.

◆ RENDER_TARGET

enum KIGFX::RENDER_TARGET

RENDER_TARGET: Possible rendering targets.

Enumerator
TARGET_CACHED	Main rendering target (cached)
TARGET_NONCACHED	Auxiliary rendering target (noncached)
TARGET_OVERLAY	Items that may change while the view stays the same (noncached)
TARGET_TEMP	Temporary target for drawing in separate layer.
TARGETS_NUMBER	Number of available rendering targets.

Definition at line 31 of file definitions.h.

◆ RHI_LINE_PIPELINE_KIND

enum class KIGFX::RHI_LINE_PIPELINE_KIND : uint8_t

strong

Enumerator
PCB_TRACKS
SCH_WIRES

Definition at line 37 of file frame_packet.h.

◆ RHI_SHAPE

enum KIGFX::RHI_SHAPE : uint8_t

Shapes a frame draws, each with its own array and pipelines.

Instanced shapes come first so arrays of RHI_INSTANCED_SHAPES leave polygons out.

Enumerator
RHI_SHAPE_TRACK
RHI_SHAPE_ARC
RHI_SHAPE_PAD
RHI_SHAPE_POLYGON

Definition at line 47 of file frame_packet.h.

◆ SHADER_MODE

enum KIGFX::SHADER_MODE

< Possible types of shaders (keep consistent with the actual shader source in kicad_vert.glsl and kicad_frag.glsl).

Enumerator
SHADER_NONE
SHADER_FILLED_CIRCLE
SHADER_STROKED_CIRCLE
SHADER_FONT
SHADER_LINE_A
SHADER_LINE_B
SHADER_LINE_C
SHADER_LINE_D
SHADER_LINE_E
SHADER_LINE_F
SHADER_HOLE_WALL

Definition at line 41 of file vertex_common.h.

◆ SHADER_TYPE

enum KIGFX::SHADER_TYPE

Type definition for the shader.

Enumerator
SHADER_TYPE_VERTEX	Vertex shader.
SHADER_TYPE_FRAGMENT	Fragment shader.
SHADER_TYPE_GEOMETRY	Geometry shader.

Definition at line 40 of file shader.h.

◆ VIEW_UPDATE_FLAGS

enum KIGFX::VIEW_UPDATE_FLAGS

Define the how severely the appearance of the item has been changed.

Enumerator
NONE	No updates are required.
APPEARANCE	Visibility flag has changed.
COLOR	Color has changed.
GEOMETRY	Position or shape has changed.
LAYERS	Layers have changed.
INITIAL_ADD	Item is being added to the view.
REPAINT	Item needs to be redrawn.
ALL	All except INITIAL_ADD.

Definition at line 47 of file view_item.h.

◆ VIEW_VISIBILITY_FLAGS

enum KIGFX::VIEW_VISIBILITY_FLAGS

Define the visibility of the item (temporarily hidden, invisible, etc).

Enumerator

VISIBLE

Item is visible (in general)

HIDDEN

Item is temporarily hidden (usually in favor of a being drawn from an overlay, such as a SELECTION).

Overrides VISIBLE flag.

OVERLAY_HIDDEN

Item is temporarily hidden from being drawn on an overlay.

Definition at line 61 of file view_item.h.

◆ VRAM_RESIZE_STRATEGY

enum class KIGFX::VRAM_RESIZE_STRATEGY

strong

Strategy for growing a GPU vertex buffer, trading copy speed against peak video memory.

Enumerator
GPU_COPY	Fast GPU-side copy; the old and new buffers are briefly co-resident.
RAM_STAGE	Stage through host memory so only the larger of the two buffers is resident.
REFUSE	Neither path fits; the caller should fall back to software rendering.

Definition at line 57 of file utils.h.

Function Documentation

◆ AutoSparsePitch()

double KIGFX::AutoSparsePitch	(	double	aPitch,
		unsigned	aTick,
		double	aThreshold )

inline

Multiply aPitch by aTick until it exceeds aThreshold, so a sub-threshold grid still shows every Nth line.

aTick <= 1 is clamped to 2.

Returns: the sparsified pitch.

Definition at line 82 of file graphics_abstraction_layer.h.

Referenced by KIGFX::GAL::GetVisibleGridSize(), and KIGFX::GAL::gridLattice().

◆ bitmapText()

static void KIGFX::bitmapText	(	KIGFX::GAL &	aGal,
		const wxString &	aText,
		const VECTOR2D &	aPosition,
		const TEXT_ATTRIBUTES &	aAttrs )

static

Definition at line 647 of file sch_painter.cpp.

References KIGFX::GAL::BitmapText(), EDA_ORIENTATION::GetAngle(), KiROUND(), TEXT_ATTRIBUTES::m_Angle, TEXT_ATTRIBUTES::m_Halign, TEXT_ATTRIBUTES::m_Size, TEXT_ATTRIBUTES::m_StrokeWidth, TEXT_ATTRIBUTES::m_Valign, KIGFX::GAL::SetGlyphSize(), KIGFX::GAL::SetHorizontalJustify(), KIGFX::GAL::SetLineWidth(), KIGFX::GAL::SetVerticalJustify(), VECTOR2< T >::x, and VECTOR2< T >::y.

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

◆ chooseResizeStrategy()

GAL_API VRAM_RESIZE_STRATEGY KIGFX::chooseResizeStrategy	(	size_t	aFreeVRAM,
		size_t	aOldBytes,
		size_t	aNewBytes,
		double	aMarginFrac )

Decide how to grow a GPU vertex buffer given the free video memory budget.

A doubling resize would otherwise hold the old and new buffers in VRAM at the same time, which can exceed the budget on a large board and trip a fatal driver out-of-memory abort.

Parameters

aFreeVRAM	is the free video memory in bytes, or 0 when unknown.
aOldBytes	is the size of the existing buffer in bytes.
aNewBytes	is the size of the requested buffer in bytes.
aMarginFrac	is the headroom kept free, as a fraction of the allocation size.

Returns: the resize strategy to use.

Definition at line 242 of file utils.cpp.

References GPU_COPY, RAM_STAGE, and REFUSE.

Referenced by KIGFX::CACHED_CONTAINER_GPU::defragmentResize().

◆ drawAltPinModesIcon()

static void KIGFX::drawAltPinModesIcon	(	GAL &	aGal,
		const VECTOR2D &	aPos,
		double	aSize,
		bool	aBaseSelected,
		bool	aRotate,
		int	aExtraLineWidth,
		const COLOR4D &	aColor )

static

Draw an alternate pin mode indicator icon.

Definition at line 870 of file sch_painter.cpp.

References ANGLE_0, ANGLE_180, ANGLE_270, ANGLE_90, KIGFX::GAL::DrawArc(), KIGFX::GAL::DrawLine(), KIGFX::GAL::Restore(), KIGFX::GAL::Rotate(), KIGFX::GAL::Save(), KIGFX::GAL::SetIsFill(), KIGFX::GAL::SetIsStroke(), KIGFX::GAL::SetLineWidth(), KIGFX::GAL::SetStrokeColor(), and KIGFX::GAL::Translate().

Referenced by KIGFX::SCH_PAINTER::draw().

◆ drawCache()

static void KIGFX::drawCache	(	KIGFX::GAL &	aGal,
		std::vector< std::unique_ptr< KIFONT::GLYPH > > *	aCache,
		float	aStrokeWidth,
		float	aShadowWidth )

static

Definition at line 662 of file sch_painter.cpp.

References KIGFX::GAL::DrawGlyphs(), KIGFX::GAL::DrawPolygon(), SHAPE_POLY_SET::Outline(), SHAPE_POLY_SET::OutlineCount(), KIGFX::GAL::SetIsStroke(), and KIGFX::GAL::SetLineWidth().

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

◆ DrawCross()

void KIGFX::DrawCross	(	GAL &	aGal,
		const VECTOR2I &	aPosition,
		int	aSize )

Draw a cross at a given position.

Parameters

aGal	The graphics abstraction layer to draw with.
aPosition	The position to draw the cross at.
aSize	The size of the cross.

Definition at line 29 of file item_drawing_utils.cpp.

References KIGFX::GAL::DrawLine().

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

◆ DrawDashedLine()

void KIGFX::DrawDashedLine	(	GAL &	aGal,
		const SEG &	aSeg,
		double	aDashSize )

Draw a dashed line.

Parameters

aGal	The graphics abstraction layer to draw with.
aSeg	The line to draw.
aDashSize	The size of the dashes.

Definition at line 37 of file item_drawing_utils.cpp.

References SEG::A, SEG::B, BOX2ISafe(), ClipLine(), KIGFX::GAL::DrawLine(), VECTOR2< T >::EuclideanNorm(), KIGFX::GAL::GetWorldScale(), KiROUND(), VECTOR2< T >::x, and VECTOR2< T >::y.

Referenced by BOOST_AUTO_TEST_CASE(), BOOST_AUTO_TEST_CASE(), BOOST_AUTO_TEST_CASE(), and KIGFX::CONSTRUCTION_GEOM::ViewDraw().

◆ drawText()

static void KIGFX::drawText	(	KIGFX::GAL &	aGal,
		const wxString &	aText,
		const VECTOR2D &	aPosition,
		const TEXT_ATTRIBUTES &	aAttrs,
		float	aShadowWidth,
		const KIFONT::METRICS &	aFontMetrics,
		std::optional< VECTOR2I >	aMousePos = std::nullopt,
		wxString *	aActiveUrl = nullptr )

static

◆ eeconfig()

EESCHEMA_SETTINGS * KIGFX::eeconfig ( )

◆ EvaluateRenderThreadPhaseStall()

RHI_PHASE_STALL_RESULT KIGFX::EvaluateRenderThreadPhaseStall	(	RHI_PHASE_STALL_TRACKER &	aTracker,
		int	aPhase,
		uint64_t	aGeneration,
		RHI_PHASE_STALL_TRACKER::CLOCK::time_point	aNow,
		std::chrono::milliseconds	aStallThreshold = std::chrono::milliseconds( 1000 ),
		uint64_t	aGenerationThreshold = 60,
		std::chrono::milliseconds	aRepeatThreshold = std::chrono::milliseconds( 1000 ) )

inline

Definition at line 56 of file swapchain_controller.h.

References KIGFX::RHI_PHASE_STALL_TRACKER::generationAtPhaseStart, KIGFX::RHI_PHASE_STALL_TRACKER::lastLogTime, KIGFX::RHI_PHASE_STALL_TRACKER::observedPhase, KIGFX::RHI_PHASE_STALL_TRACKER::phaseStartTime, and result.

Referenced by KIGFX::SWAPCHAIN_CONTROLLER::OnPaint().

◆ FitImageToTexture()

GAL_API wxImage KIGFX::FitImageToTexture	(	const wxImage &	aImage,
		int	aMaxTextureSize )

Fit an image into the largest texture a GPU can hold.

Parameters

aMaxTextureSize is the largest texture width or height the GPU takes, or 0 if unknown.

Returns: aImage when it fits, else a copy scaled down with its aspect ratio kept, invalid if scaling failed.

Definition at line 32 of file bitmap_texture.cpp.

References KiROUND(), and scale.

Referenced by KIGFX::GL_BITMAP_CACHE::cacheBitmap(), and KIGFX::GAL_MODERN::DrawBitmap().

◆ from_json()

KICOMMON_API void KIGFX::from_json	(	const nlohmann::json &	aJson,
		COLOR4D &	aColor )

Definition at line 301 of file color4d.cpp.

References KIGFX::COLOR4D::SetFromWxString().

◆ ImageToRgba()

GAL_API std::vector< uint8_t > KIGFX::ImageToRgba ( const wxImage & aImage )

The pixels of aImage as tightly packed RGBA, transparent where it has alpha or a mask.

Definition at line 66 of file bitmap_texture.cpp.

References RgbToRgba().

Referenced by KIGFX::GL_BITMAP_CACHE::cacheBitmap(), and KIGFX::GAL_MODERN::DrawBitmap().

◆ isFieldsLayer()

static bool KIGFX::isFieldsLayer ( int aLayer )

static

Definition at line 594 of file sch_painter.cpp.

References LAYER_FIELDS, LAYER_INTERSHEET_REFS, LAYER_NETCLASS_REFS, LAYER_REFERENCEPART, LAYER_SHEETFIELDS, LAYER_SHEETFILENAME, LAYER_SHEETNAME, and LAYER_VALUEPART.

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

◆ knockoutText()

static void KIGFX::knockoutText	(	KIGFX::GAL &	aGal,
		const wxString &	aText,
		const VECTOR2D &	aPosition,
		const TEXT_ATTRIBUTES &	aAttrs,
		const KIFONT::METRICS &	aFontMetrics )

static

◆ operator!=()

KICOMMON_API bool KIGFX::operator!=	(	const COLOR4D &	lhs,
		const COLOR4D &	rhs )

Not equality operator, are two colors not equal.

Definition at line 259 of file color4d.cpp.

◆ operator<()

KICOMMON_API bool KIGFX::operator<	(	const COLOR4D &	lhs,
		const COLOR4D &	rhs )

Definition at line 265 of file color4d.cpp.

References KIGFX::COLOR4D::a, KIGFX::COLOR4D::b, KIGFX::COLOR4D::g, KIGFX::COLOR4D::m_text, and KIGFX::COLOR4D::r.

◆ operator<<()

KICOMMON_API std::ostream & KIGFX::operator<<	(	std::ostream &	aStream,
		COLOR4D const &	aColor )

Syntactic sugar for outputting colors to strings.

Definition at line 283 of file color4d.cpp.

References KIGFX::COLOR4D::m_text, and KIGFX::COLOR4D::ToCSSString().

◆ operator==()

KICOMMON_API bool KIGFX::operator==	(	const COLOR4D &	lhs,
		const COLOR4D &	rhs )

Equality operator, are two colors equal.

Definition at line 250 of file color4d.cpp.

References KIGFX::COLOR4D::a, KIGFX::COLOR4D::b, KIGFX::COLOR4D::g, KIGFX::COLOR4D::m_text, and KIGFX::COLOR4D::r.

◆ queryFreeVideoMemoryBytes()

GAL_API size_t KIGFX::queryFreeVideoMemoryBytes ( )

Query the amount of free video memory the driver reports.

Uses GL_NVX_gpu_memory_info or GL_ATI_meminfo when present. On Mesa, which places buffers that do not fit in VRAM in system memory, the GL_ATI_meminfo auxiliary pool counts too. Requires a current OpenGL context.

Returns: the free video memory in bytes, or 0 when no driver query is available.

Definition at line 205 of file utils.cpp.

References bytes().

Referenced by KIGFX::CACHED_CONTAINER_GPU::defragmentResize().

◆ retainedOrderKey()

static RETAINED_GROUP_ORDER KIGFX::retainedOrderKey	(	VIEW_ITEM *	aItem,
		int	aPriority,
		const BOX2I &	aBBox,
		bool	aUseDrawPriority,
		bool	aReverseDrawOrder,
		double	aLodScale )

static

Definition at line 241 of file view.cpp.

References KIGFX::RETAINED_GROUP_ORDER::bbox, KIGFX::RETAINED_GROUP_ORDER::className, BOX2< Vec >::GetBottom(), KIGFX::VIEW_ITEM::GetClass(), BOX2< Vec >::GetLeft(), BOX2< Vec >::GetRight(), BOX2< Vec >::GetTop(), KIGFX::RETAINED_GROUP_ORDER::lodScale, and KIGFX::RETAINED_GROUP_ORDER::priority.

Referenced by KIGFX::VIEW::placeCachedGroup(), KIGFX::VIEW::placeRetainedInOrder(), and KIGFX::VIEW::UpdateItems().

◆ RgbToRgba()

GAL_API std::vector< uint8_t > KIGFX::RgbToRgba	(	const uint8_t *	aRgb,
		const uint8_t *	aAlpha,
		size_t	aPixelCount )

Expand packed RGB to tightly packed RGBA.

Parameters

aAlpha is one alpha byte per pixel, or nullptr for opaque pixels.

Definition at line 50 of file bitmap_texture.cpp.

Referenced by ImageToRgba().

◆ RhiCullRunLength()

uint32_t KIGFX::RhiCullRunLength ( int aShape )

constexpr

Definition at line 179 of file rhi_cull_runs.h.

References RHI_CULL_RUN_LENGTH, RHI_CULL_VERTEX_RUN_LENGTH, and RHI_SHAPE_POLYGON.

Referenced by KIGFX::RENDER_THREAD::RenderGeometryInto(), and RhiRangeReaches().

◆ RhiCullView()

RHI_CULL_VIEW KIGFX::RhiCullView ( const FRAME_UBO_DATA & aFrame )

inline

Invert the frame's 2D projection over the normalized device square.

Column-major, so NDC = M * world + t.

Measured as the shaders do, from how far a world unit moves along X on screen.

Definition at line 220 of file rhi_cull_runs.h.

References KIGFX::RHI_CULL_VIEW::maxX, KIGFX::RHI_CULL_VIEW::maxY, KIGFX::RHI_CULL_VIEW::minX, KIGFX::RHI_CULL_VIEW::minY, KIGFX::FRAME_UBO_DATA::projection, KIGFX::RHI_CULL_VIEW::valid, KIGFX::FRAME_UBO_DATA::viewport, KIGFX::FRAME_UBO_DATA::viewScale, KIGFX::RHI_CULL_VIEW::viewScale, and KIGFX::RHI_CULL_VIEW::worldPerPixel.

Referenced by KIGFX::RENDER_THREAD::RenderGeometryInto(), and KIGFX::RENDER_THREAD::RenderWindow().

◆ RhiForVisibleStretches()

template<typename DRAW>

void KIGFX::RhiForVisibleStretches	(	const std::vector< RHI_RUN_BOUNDS > *	aRuns,
		uint32_t	aRunLength,
		uint32_t	aStart,
		uint32_t	aCount,
		const RHI_CULL_VIEW &	aView,
		DRAW &&	aDraw,
		RHI_CULL_COUNT *	aTally = nullptr )

Call aDraw( first, count ) for each stretch of [aStart, aStart + aCount) whose runs can reach aView.

Without runs the whole span is one stretch.

Definition at line 288 of file rhi_cull_runs.h.

References DRAW, end, KIGFX::RHI_CULL_VIEW::Reaches(), and KIGFX::RHI_CULL_VIEW::valid.

Referenced by KIGFX::RENDER_THREAD::RenderGeometryInto(), and RhiRangeReaches().

◆ RhiGridMovedOnly()

bool KIGFX::RhiGridMovedOnly	(	const GRID_UBO_DATA &	aDrawn,
		const GRID_UBO_DATA &	aNow )

inline

Returns: true when the grid of aNow is that of aDrawn moved, as RhiViewShift() found the frame.

The inverse is recomputed each frame, so entries other than the offset may round differently.

Definition at line 150 of file rhi_static_margin.h.

References std::abs(), KIGFX::GRID_UBO_DATA::invProjection, and moved.

Referenced by planMarginTarget().

◆ RhiInstanceReach()

void KIGFX::RhiInstanceReach	(	const RHI_INSTANCE &	aInstance,
		RHI_SHAPE	aShape,
		float &	aWorld,
		float &	aPixels )

inline

How far an instance reaches from its position, in world units and in pixels.

A screen-space track gives its size in pixels. The other shaders ignore the flag.

Definition at line 103 of file rhi_cull_runs.h.

References std::abs(), RHI_INSTANCE::HasFlag(), RHI_INSTANCE::params, RHI_INSTANCE::pixelPad, RHI_INSTANCE_LENGTH_PAD, RHI_INSTANCE_SCREEN_SPACE, RHI_SHAPE_PAD, RHI_SHAPE_TRACK, scale, RHI_INSTANCE::scaleX, and RHI_INSTANCE::scaleY.

Referenced by RhiInstanceRun().

◆ RhiInstanceRun()

RHI_RUN_BOUNDS KIGFX::RhiInstanceRun	(	const RHI_INSTANCE *	aInstances,
		size_t	aCount,
		RHI_SHAPE	aShape )

inline

A removed element is collapsed to a point and covers nothing.

Definition at line 135 of file rhi_cull_runs.h.

References KIGFX::RHI_RUN_BOUNDS::Add(), RHI_INSTANCE::HasFlag(), RHI_INSTANCE::params, RHI_INSTANCE_SCALE_LOD, RHI_SHAPE_TRACK, and RhiInstanceReach().

◆ RhiPlanLayerDraws()

std::vector< LAYER_DRAW_STEP > KIGFX::RhiPlanLayerDraws	(	const LAYER_RANGE &	aRange,
		const std::vector< POLARITY_RUN > &	aRuns = {} )

inline

Order the draws of one layer range.

Depth knockouts are marked in the nearer half of the layer's depth slice before the rest is drawn in the farther half, so the marks always win without reaching the next layer. Through a temp target, normal elements come before the negatives that erase them. Polarity runs are drawn in emission order.

Definition at line 60 of file layer_draw_plan.h.

Referenced by KIGFX::RENDER_THREAD::RenderGeometryInto().

◆ RhiRangeReaches()

bool KIGFX::RhiRangeReaches	(	const LAYER_RANGE &	aRange,
		const RHI_CULL_VIEW &	aView )

inline

A range without runs or with bitmaps always reaches.

Definition at line 353 of file rhi_cull_runs.h.

References KIGFX::LAYER_RANGE::bitmapCount, KIGFX::LAYER_RANGE::count, KIGFX::LAYER_RANGE::cullRuns, KIGFX::LAYER_RANGE::negCount, KIGFX::RHI_RUN_TABLE::negRuns, KIGFX::LAYER_RANGE::negStart, RHI_SHAPES, RhiCullRunLength(), RhiForVisibleStretches(), KIGFX::RHI_RUN_TABLE::runs, KIGFX::LAYER_RANGE::start, and KIGFX::RHI_CULL_VIEW::valid.

◆ RhiSupersampleFrame()

FRAME_UBO_DATA KIGFX::RhiSupersampleFrame	(	const FRAME_UBO_DATA &	aFrame,
		uint32_t	aFactor )

inline

Returns: frame uniforms that draw aFrame into a target of aFactor texels per pixel.

A move in normalized device X and Y adds the last row to the first two.

Definition at line 44 of file rhi_supersample.h.

References KIGFX::FRAME_UBO_DATA::projection, KIGFX::FRAME_UBO_DATA::renderScale, RHI_SUPERSAMPLE_OFFSET, and KIGFX::FRAME_UBO_DATA::viewport.

Referenced by KIGFX::RENDER_THREAD::RenderGeometryInto().

◆ RhiSupersampleGrid()

GRID_UBO_DATA KIGFX::RhiSupersampleGrid	(	const GRID_UBO_DATA &	aGrid,
		uint32_t	aFactor )

inline

Returns: grid uniforms for the target of RhiSupersampleFrame().

The inverse takes the move back out before anything else.

Definition at line 68 of file rhi_supersample.h.

References grid, KIGFX::GRID_UBO_DATA::invProjection, RHI_SUPERSAMPLE_OFFSET, and KIGFX::GRID_UBO_DATA::viewport.

Referenced by KIGFX::RENDER_THREAD::RenderGeometryInto().

◆ RhiVertexRun()

RHI_RUN_BOUNDS KIGFX::RhiVertexRun	(	const RHI_VERTEX *	aVertices,
		size_t	aCount )

inline

Definition at line 162 of file rhi_cull_runs.h.

References KIGFX::RHI_RUN_BOUNDS::Add(), RHI_VERTEX::x, and RHI_VERTEX::y.

Referenced by KIGFX::GAL_MODERN::Flush(), and KIGFX::GAL_MODERN::updateSceneCullRuns().

◆ RhiViewMovedOnly()

bool KIGFX::RhiViewMovedOnly	(	const FRAME_UBO_DATA &	aDrawn,
		const FRAME_UBO_DATA &	aNow )

inline

Returns: true when two frames differ only by translation.

Definition at line 105 of file rhi_static_margin.h.

References std::abs(), KIGFX::FRAME_UBO_DATA::projection, and KIGFX::FRAME_UBO_DATA::viewport.

Referenced by planMarginTarget(), and RhiViewShift().

◆ RhiViewShift()

std::optional< RHI_VIEW_SHIFT > KIGFX::RhiViewShift	(	const FRAME_UBO_DATA &	aDrawn,
		const FRAME_UBO_DATA &	aNow )

inline

Returns: the shift from aDrawn to aNow when they differ only by whole pixels, or nothing.

A fractional shift would land elements on different pixels than a fresh draw snaps them to. The tolerance absorbs float error in a large board's offset.

Definition at line 132 of file rhi_static_margin.h.

References std::abs(), KIGFX::FRAME_UBO_DATA::projection, RhiViewMovedOnly(), and KIGFX::FRAME_UBO_DATA::viewport.

Referenced by planMarginTarget().

◆ RhiWidenFrame()

FRAME_UBO_DATA KIGFX::RhiWidenFrame	(	const FRAME_UBO_DATA &	aFrame,
		uint32_t	aMargin )

inline

Returns: frame uniforms that draw the same view, at the same pixel size, centred in a target aMargin pixels larger on each side.

Scaling normalized device X and Y about the centre scales the first two rows.

Definition at line 53 of file rhi_static_margin.h.

References KIGFX::FRAME_UBO_DATA::projection, and KIGFX::FRAME_UBO_DATA::viewport.

Referenced by KIGFX::RENDER_THREAD::RenderGeometryInto(), and KIGFX::RENDER_THREAD::RenderWindow().

◆ RhiWidenGrid()

GRID_UBO_DATA KIGFX::RhiWidenGrid	(	const GRID_UBO_DATA &	aGrid,
		uint32_t	aMargin )

inline

Returns: grid uniforms for the target of RhiWidenFrame().

The inverse takes the scale back out of the first two columns.

Definition at line 79 of file rhi_static_margin.h.

References KIGFX::GRID_UBO_DATA::invProjection, and KIGFX::GRID_UBO_DATA::viewport.

Referenced by KIGFX::RENDER_THREAD::RenderGeometryInto().

◆ sortRetainedOrder()

template<typename T>

static void KIGFX::sortRetainedOrder	(	VIEW *	aView,
		std::vector< T > &	aEntries )

static

Definition at line 257 of file view.cpp.

References KIGFX::VIEW::GetGAL(), KIGFX::GAL::GroupContentFingerprint(), and T.

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

◆ symbolDrawsOnOverlay()

static bool KIGFX::symbolDrawsOnOverlay	(	const SCH_SYMBOL *	aSymbol,
		int	aLayer )

static

Definition at line 2691 of file sch_painter.cpp.

References SCH_SYMBOL::GetRawPins(), EDA_ITEM::IsBrightened(), EDA_ITEM::IsSelected(), LAYER_SELECTION_SHADOWS, and pin.

Referenced by KIGFX::SCH_PAINTER::draw().

◆ to_json()

KICOMMON_API void KIGFX::to_json	(	nlohmann::json &	aJson,
		const COLOR4D &	aColor )

Definition at line 292 of file color4d.cpp.

References KIGFX::COLOR4D::m_text, and KIGFX::COLOR4D::ToCSSString().

◆ ZoneOutlineDrawnOnLayer()

bool KIGFX::ZoneOutlineDrawnOnLayer	(	bool	aOutlineOnly,
		int	aLayer )

Decide which GAL draw pass paints a zone's outline.

When the outline is the zone's only visual (rule area, or outline-only display) it is drawn on the zone layer, which sorts above copper, so tracks and pads can't paint over it. A zone shown filled draws its outline on the copper layer, beneath its own fill on the zone layer.

Definition at line 3691 of file pcb_painter.cpp.

References IsZoneFillLayer().

Referenced by BOOST_AUTO_TEST_CASE(), KIGFX::PCB_PAINTER::draw(), and KIGFX::PCB_PAINTER::HasUniformColor().