Kicad gal

KiCad Graphics Abstraction Layer

Description

Introduction of the Graphics Abstraction Layer has the 3 main purposes:

decouple drawing from editing tools

allow to change a backend depending on the necessity

speed up of rendering process

Currently the burden of managing redraws in KiCad falls on editing
tools. For example, while routing a track, the tool code must take care
of erasing the old trace, painting over the new one and making sure that
there will be no rubbish on the screen when the view is panned or
zoomed. This may introduce some difficulties in bug fixing or creating
new code, as the developer has to think of drawing routines instead of
focusing on the tool functionality.
Splitting drawing functionality into a few abstraction layers has a few
advantages. One class (PAINTER) takes the responsibility for drawing
items using a basic command set. For example, to draw a via you need to
draw two circles: first makes for a via itself and second represents its
hole. The PAINTER gets information about an item (like diameters of via
& its hole) and uses the backend (the GAL class and its derivatives) to
draw it. That means that you can use any library to do the drawing tasks
and the result should always look exactly the same.
This kind of a division of tasks makes it easy to add new rendering
backends. Right now, there is a plan to use two types of backends. The
Cairo backend is going to be used for drawing vector graphics, which is
very useful in creating documents, but at the cost of performance. In
that case usually it does not matter if it takes a few milliseconds or a
few seconds to prepare a document. The second backend is going to be
based on OpenGL. Its main purpose is to boost the rendering speed, so
even quite complex board can be rendered without a performance drop. It
can take an advantage of commonly available modern graphic cards, in
opposite to the default KiCad software rendering engine relying only on
CPU speed.
Another change introduced by the GAL engine is a different method of
drawing layers. Previously it was done by simply XORing colors of items,
which is fast but does not look very natural. Modern CAD programs use
blending and semitransparent layers for multilayer display. The
difference you may see on pictures below (click to zoom; the left
picture is the default KiCad rendering, the right one shows the OpenGL
GAL rendering
backend):

It is a good idea to use the most complex board available to test it out
and see the performance difference. If you want, you may try it out with
a 12 copper layers
PCB
(please do not pay attention to the wrongly placed labels, the plugin we
used to import the board is incomplete).

What is done?*

the View component is integrated in the pcbnew with a non-editable
view

the backends are switchable during the runtime, using menu or hot
keys