FastUIDraw

Purpose

FastUIDraw is a library that provides a higher performance Canvas interface. It is designed so that it always draws using a GPU.

In contrast to many common implementations of Canvas drawing, FastUIDraw has that changes in clipping are very cheap and optimized for GPU's. In addition, FastUIDraw has, with the GL backend, very few pipeline states. Indeed an API trace of an application using FastUIDraw will see only a handful of draw calls per frame, even under high Canvas state trashing, and high clip state changes. Indeed, for the GL backend, only one Canvas state change invokes a pipeline state change: changing the blend mode.

The class to execute drawing is fastuidraw::Painter which supplies the expected standard drawing features: stroking and filling paths, drawing text, applying a brush (image and/or gradient), blending (including all Porter-Duff modes), a 3x3 transformation allowing for perspective drawing, clipping in by a rectangle or filled path and clipping out by a filled path.

In addition, FastUIDraw gives an application the ability to make their own shaders for custom drawing.

Concepts

If one needs to create its own custom way of drawing, one needs to know the drawing concepts in FastUIDraw. There are three distinct ingredients of drawing in FastUIDraw:

• Attribute and index data processed by the GPU. This data should be immutable to be created/calculated once and reused greatly. At the very bottom of this stack is fastuidraw::PainterIndex to represent an index and fastuidraw::PainterAttribute to represent an attribute. A fastuidraw::PainterAttributeData represents a collection of attribute and index chunks. The classes, fastuidraw::StrokedPath, fastuidraw::FilledPath, fastuidraw::GlyphRun and fastuidraw::GlyphSequence hold fastuidraw::PainterAttributeData objects ready for drawing. For futher reading, see Painter Attribute.
• The shader to draw the attribute and index data. FastUIDraw has three shader types in its vertex and fragment pipeline (defined in the module Painter Shaders).
  • An item shader is represented by fastuidraw::PainterItemShader. This shader represents how the attribute and index data are processed.
  • A brush shader is represented by fastuidraw::PainterBrushShader. This shader represents computing a per-pixel color, for example an image or gradient applied.
  • A blend shader is represented by fastuidraw::PainterBlendShader. This shader represents how blending is performed (for example the Porter-Duff modes).
• A small amount of data that is cheap to recalculate that is constant for all vertices and pixels of an item. Each of the shader stages has their own data classes (defined in the module Painter Shader Data).
  • For item shading, the class fastuidraw::PainterItemShaderData is used to hold values that are constant for all attributes across an item. One example are stroking paremeters such as stroking width and miter-limit to apply to stroking as realized by fastuidraw::PainterStrokeParams and fastuidraw::PainterDashedStrokeParams.
  • For brush shading, the class fastuidraw::PainterBrushShaderData is used to hold values that are constant for the purpose of appliying a brush. The main example is fastuidraw::PainterBrush which holds all the data needed to apply a standard brush consisting of an image, gradient, repeat pattern and brush transformation.
  • For blend shading, the class fastuidraw::PainterBlendShaderData is used to hold constants values for doing blending.

The GL/GLES backends of FastUIDraw represents shaders as portions of GLSL shader code, see the classes fastuidraw::glsl::PainterItemShaderGLSL, fastuidraw::glsl::PainterBlendShaderGLSL and fastuidraw::glsl::PainterBrushShaderGLSL for the shader class types and their interfaces.

Examples

• See Example FrameWork for the example framework to get started with the examples.
• See Example Initialization for the how to create a fastuidraw::Painter.
• See Example Text for an example of using fastuidraw::GlyphSequence to draw text with fastuidraw::Painter.
• See Example Gradient for an example of using fastuidraw::PainterBrush to render gradients.
• See Example Image for an example of using fastuidraw::PainterBrush to render an image.
• See Example Custom Brush for an example of creating a custom brush
• See Example Path for an example of using fastuidraw::Path to stroke and fill paths.
• See Example Path 2 for creating a fastuidraw::Path with the operator<< overloads and filling it with a custom fill rule.
• See Example Packed Value for an example of using fastuidraw::PainterPackedValue and coordinate transformations of fastuidraw::Painter.
• See Example Custom Stroking Shader for an example of using shader chaining to create an animated wave-effect of stroking via shader chaining