Here are the classes, structs, unions and interfaces with brief descriptions:
[detail level 1234]
| ►Nfastuidraw | All classes and functions of FastUIDraw are in the namespace fastuidraw |
| ►Ngl | Namespace to encapsulate GL backend end implementation, utility functions and utility classes. Part of the GL backend libraries, libFastUIDrawGL and libFastUIDrawGLES |
| CBindAttribute | A BindAttribute inherits from PreLinkAction, it's purpose is to bind named attributes to named locations, i.e. it calls glBindAttributeLocation() |
| CBindFragDataLocation | A BindFragDataLocation inherits from PreLinkAction, its purpose is to bind a fragment shader out to a named location and index. Using a BindFragDataLocation requires: |
| CContextProperties | A ContextProperties provides an interface to query GL/GLES version and extensions |
| ►CPainterEngineGL | A PainterEngineGL implements PainterEngine using the GL (or GLES) API. The PainterShaderRegistrar object returned by painter_shader_registrar() derives from glsl::PainterShaderRegistrarGLSL. In addition, when adding custom shaders, the shader types need to be derived from the shader types of the GLSL module, i.e |
| CColorStopAtlasParams | Class to hold the construction parameters for creating a GL-backend ColorStopAtlas for a PainterEngineGL |
| CConfigurationGL | A ConfigurationGL gives parameters how to contruct a PainterEngineGL |
| CGlyphAtlasParams | Class to hold the construction parameters for creating a GL-backend GlyphAtlas for a PainterEngineGL |
| CImageAtlasParams | Class to hold the construction parameters for creating the GL-backend ImageAtlas for a PainterEngineGL |
| CPainterSurfaceGL | |
| CPreLinkAction | A PreLinkAction is an action to apply to a Program after attaching shaders but before linking |
| CPreLinkActionArray | A PreLinkActionArray is a conveniance class wrapper over an array of PreLinkAction handles |
| ►CProgram | Class for creating and using GLSL programs |
| Catomic_buffer_info | An atomic_buffer_info represents an object from which one can query the data of an atomic buffer |
| Cblock_info | A block_info represents an object from which one can query the members of a uniform or shader storage block |
| Cshader_variable_info | A shader_variable_info holds the type, size and name of a uniform or an attribute of a GL program |
| CProgramInitializer | A ProgramInitializer is a functor object called the first time a Program is bound (i.e. the first time Program::use_program() is called). It's main purpose is to facilitate initializing uniform values |
| CProgramInitializerArray | Conveniance class to hold an array of handles of ProgramInitializer objects |
| CProgramSeparable | A ProgramSeparable inherits from PreLinkAction, its purpose is to set a GLSL program as separable, so that it can be used by a GLSL pipeline. Using a ProgramSeparable requires: |
| CSamplerInitializer | Class to intialize the binding points of samplers. If the uniform is an array, the first element will be given the specified binding point and successive elements in the array will be given successive binding points |
| CShader | Simple Shader utility class providing a simple interface to build GL shader objects using a glsl::ShaderSouce as its source code |
| CShaderStorageBlockInitializer | A ShaderStorageBlockInitializer is used to initalize the binding point used by a shader storage block (see the GL spec on glShaderStorageBlockBinding). Initializer is not supported in OpenGL ES |
| CTextureImage | |
| CTransformFeedbackVarying | A TransformFeedbackVarying encapsulates a call to glTransformFeedbackVarying. Note that if there are multiple TransformFeedbackVarying objects on a single PreLinkActionArray, then only the last one added has effect |
| CUniformBlockInitializer | A UniformBlockInitializer is used to initalize the binding point used by a bindable uniform (aka Uniform buffer object, see the GL spec on glGetUniformBlockIndex and glUniformBlockBinding |
| CUniformInitalizerBase | A UniformInitalizerBase is a base class for initializing a uniform, the actual GL call to set the uniform value is to be implemented by a derived class in init_uniform() |
| CUniformInitializer | Initialize a uniform via the templated overloaded function fastuidraw::gl::Uniform() |
| CUniformInitializer< c_array< const T > > | Specialization for type c_array<const T> for UniformInitializer so that data behind the c_array is copied |
| ►Ngl_binding | Provides interface for application to use GL where function pointers are auto-resolved transparently and under debug provides error checking. Built as a part of a seperate library; for GL it is libNGL; for GLES it is NGLES. The header defines for each GL/GLES function, glFoo, the macro fastuidraw_glFoo |
| CCallbackGL | A CallbackGL defines the interface (via its base class) for callbacks before and after each GL call |
| ►Nglsl | Namespace to encapsulate shader building to GLSL shaders, part of the main library libFastUIDraw |
| ►CPainterBlendShaderGLSL | A PainterBlendShaderGLSL is a PainterBlendShader whose shader code fragment is via GLSL |
| CDependencyList | If one wishes to make use of other PainterBlendShaderGLSL fastuidraw_gl_compute_blend_value(), fastuidraw_gl_compute_blend_factors() or fastuidraw_gl_compute_post_blended_value() routines of other shaders (for example to have a simple shader that adds on to a previous shader), a DependencyList provides the means to do so |
| ►CPainterBrushShaderGLSL | A PainterBrushShaderGLSL is a PainterBrushShader whose shader code fragment is via GLSL.The vertex shader code needs to implement the function: |
| CDependencyList | If one wishes to make use of other PainterBrushShaderGLSL fastuidraw_gl_vert_brush_main()/fastuidraw_gl_frag_brush_main() of other shaders (for example to have a simple shader that adds on to a previous shader), a DependencyList provides the means to do so |
| ►CPainterItemCoverageShaderGLSL | A PainterItemCoverageShaderGLSL is a collection of GLSL source code fragments for a PainterShaderRegistrarGLSL |
| CDependencyList | If one wishes to make use of other PainterItemCoverageShaderGLSL fastuidraw_gl_vert_main()/fastuidraw_gl_frag_main() of other shaders (for example to have a simple shader that adds on to a previous shader), a DependencyList provides the means to do so |
| ►CPainterItemShaderGLSL | A PainterItemShaderGLSL is a collection of GLSL source code fragments for a PainterShaderRegistrarGLSL |
| CDependencyList | If one wishes to make use of other PainterItemShaderGLSL fastuidraw_gl_vert_main()/fastuidraw_gl_frag_main() of other shaders (for example to have a simple shader that adds on to a previous shader), a DependencyList provides the means to do so |
| CPainterShaderRegistrarGLSL | A PainterShaderRegistrarGLSL is an implementation of PainterRegistrar that assembles the shader source code of PainterItemShaderGLSL and PainterBlendShaderGLSL into an uber-shader |
| ►CPainterShaderRegistrarGLSLTypes | |
| CBackendConstants | |
| CShaderFilter | An ShaderFilter is used to specify whether or not to include a named shader when creating an uber-shader |
| CUberShaderParams | An UberShaderParams specifies how to construct an uber-shader. Note that the usage of HW clip-planes is specified by ConfigurationGLSL, NOT UberShaderParams |
| ►CShaderSource | A ShaderSource represents the source code to a GLSL shader, specifying blocks of source code and macros to use |
| CMacroSet | |
| Cshareable_value_list | A shareable_value_list is a list of values and their types that a shader will have computed after running. These can be used is shader-chaining to get some of the values made from a dependee shader |
| Csymbol_list | A symbol_list embodies a varying_list along with a set of shareable values for the vertex and fragment shaders |
| CUnpackSourceGenerator | An unpack source generator is used to generate shader source code to unpack data from the data store buffer into a GLSL struct |
| Cvarying_list | A varying_list lists all the in's of a frag shader (and their names) which is the same as the out's of the vertex shader which which it is paired |
| ►NStrokedPointPacking | Namespace to encompass packing values and functions of path data for stroking using StrokedPoint |
| Cpacking_size | Template class taking as argument a PainterEnums::join_style or cap_type_t which defines two enumerations: |
| ►CAPICallbackSet | |
| CCallBack | |
| CArcStrokedPoint | An ArcStrokedPoint holds the data for a point of stroking where the segments can be arcs of a circle. The upshot is that a fragment shader will determine per-pixel coverage. In addition, the data is so that changing the stroking width or miter limit does not change the stroking data |
| CAtlasColorBackingStoreBase | Represents the interface for a backing store for color data of images |
| CAtlasIndexBackingStoreBase | Represents the interface for the backing store for index data of images |
| CBlendMode | Class to hold the blend mode as exposed by typical 3D APIs |
| Cc_array | A c_array is a wrapper over a C pointer with a size parameter to facilitate bounds checking and provide an STL-like iterator interface |
| CColorStop | A ColorStop is a pair consisting of an RGBA value and a place. The value of the place is a floating point value in the range [0, 1] |
| CColorStopArray | A ColorStopArray is a sequence of ColorStop values used to define the color stops of a gradient |
| CColorStopAtlas | A ColorStopAtlas is a common location to all color stop data of an application. Ideally, all color stop sequences are placed into a single ColorStopAtlas (changes of ColorStopAtlas force draw-call breaks) |
| CColorStopBackingStore | Represents the interface for the backing store for the texels of a sequence of color stops. The expectation is that linear filtering acting on the underlying backing store is all that is needed for correct color interpolation from a gradient interpolate. For example in GL, this can be GL_TEXTURE_1D_ARRAY with both minification and magnification filters set as GL_LINEAR. An implementation of the class does NOT need to be thread safe because the user of the backing store (ColorStopAtlas) performs calls to the backing store behind its own mutex |
| CColorStopSequence | A ColorStopSequence is a ColorStopArray on a ColorStopAtlas. A ColorStopAtlas is backed by a 1D texture array with linear filtering. The values of ColorStop::m_place are discretized. Values in between the ColorStop 's of a ColorStopArray are interpolated |
| CCustomFillRuleBase | Base class to specify a custom fill rule |
| CCustomFillRuleFunction | Class to specify a custom fill rule from a function |
| CDataBuffer | DataBuffer is an implementation of DataBufferBase where the data is directly backed by memory |
| CDataBufferBackingStore | Represents a buffer directly stored in memory |
| CDataBufferBase | Base class for passing around buffers of data; derived classes have the responsibility of maintaining storage cleanup at destruction |
| Cfalse_type | Class for type traits to indicate true. Functionally, a simplified version of std::false_type |
| ►CFilledPath | A FilledPath represents the data needed to draw a path filled. It contains -all- the data needed to fill a path regardless of the fill rule |
| CScratchSpace | Opaque object to hold work room needed for functions of FilledPath that require scratch space |
| CSubset | A Subset represents a handle to a portion of a FilledPath. The handle is invalid once the FilledPath from which it comes goes out of scope. Do not save these handle values without also saving a handle of the FilledPath from which they come |
| CFontBase | FontBase provides an interface for a font to generate glyph rendering data |
| ►CFontDatabase | A FontDatabase performs the act of font selection and glyph selection. It uses the values of FontProperties (except for FontProperties::source_label()) to select suitable font or fonts |
| CFontGeneratorBase | A FontGeneratorBase is a means to create a font. Adding a font via a FontGenerator allows one to avoid opening and creating the font until the font is actually needed |
| CFontGroup | A FontGroup represents a group of fonts which is selected from a FontProperties value. The accessors for FontGroup are methods of FontDatabase::parent_group(FontGroup), FontDatabase::fetch_font(FontGroup, unsigned int) and FontDatabase::number_fonts(FontGroup) |
| CFontFreeType | A FontFreeType implements the interface of FontBase from a scalable font loaded by libfreetype |
| CFontMetrics | Represents various metric values global to an entire font |
| CFontProperties | Represents defining properties of a font used by FontDatabase to perform font merging |
| ►CFreeTypeFace | A FreeTypeFace wraps an FT_Face object of the FreeType library together with a mutex in a reference counted object |
| CGeneratorBase | A Generator provides an interface to create FreeTypeFace objects |
| CGeneratorFile | Implementation of GeneratorBase to create a FreeTypeFace from a face index / file pair via lib FreeType's FT_New_Face |
| CGeneratorMemory | Implementation of GeneratorBase to create a FreeTypeFace from a face index / file pair via lib FreeType's FT_New_Memory_Face |
| CFreeTypeLib | A FreeTypeLib wraps an FT_Library object of the FreeType library together with a mutex in a reference counted object |
| CGlyph | A Glyph is essentially an opaque pointer to data for rendering and performing layout of a glyph |
| CGlyphAtlas | A GlyphAtlas is a common location to place glyph data of an application. Ideally, all glyph data is placed into a single GlyphAtlas. Methods of GlyphAtlas are thread safe, protected behind atomics and a mutex within the GlyphAtlas |
| CGlyphAtlasBackingStoreBase | GlyphAtlasStoreBase represents an interface to an aray of uint32_t values |
| CGlyphAtlasProxy | An GlyphAtlasProxy is a proxy for a GlyphAtlas; one can allocate through it. Internally it tracks all that was allocated with it |
| ►CGlyphAttribute | A GlyphAttribute represents one Painter Attribute per glyph corner |
| CArray | Represents an opaque array of GlyphAttribute values |
| CGlyphAttributePacker | A GlyphAttributePacker provides an interface to customize how glyph attribute and index data is realized by a GlyphRun and GlyphSequence |
| ►CGlyphCache | A GlyphCache represents a cache of glyphs and manages the uploading of the data to a GlyphAtlas. The methods of GlyphAtlas are thread safe because it maintains an internal mutex lock for the durations of its methods |
| CAllocationHandle | |
| CGlyphMetrics | A GlyphMetrics provides information on the metrics of a glyph, all the values are in units of the font glyph. The function units_per_EM() provides the conversion factor to pixel coordinates via  where PixelSize is the pixel size in which one is to render the text |
| CGlyphMetricsValue | A GlyphMetricsValue is to be used by a FontBase derived object to specify the values of a GlyphMetrics object |
| CGlyphRenderCostInfo | |
| CGlyphRenderData | GlyphRenderData provides an interface to specify data used for rendering glyphs and to pack that data onto a GlyphAtlas |
| ►CGlyphRenderDataBandedRays | |
| Cquery_info | |
| ►CGlyphRenderDataRestrictedRays | |
| Cquery_info | |
| CGlyphRenderDataTexels | A GlyphRenderDataTexels holds texel data for rendering a glyph. Such texel data can be for both distance field and coverage glyph rendeding |
| CGlyphRenderer | Specifies how to render a glyph |
| CGlyphRun | A GlyphRun represents a sequence of glyph codes with positions. A GlyphRun provides an interface to grab the glyph-codes realized as different renderers for the purpose of rendering text in response to the transformation that a Painter currently has. In contrast to a GlyphSequence, a GlyphRun does NOT maintain a hierarchy to perform culling. However, it does provide an interface to select continuous subsets of the glyphs for the purporse of rendering. In addition, since it does not carry a hierarchy for culling, it is also a lighter weight object than GlyphSequence. Like GlyphSequence, the methods of GlyphRun are re-entrant but not thread safe, i.e. if an application uses the same GlyphRun from multiple threads it needs to explicitely handle locking itself when using it |
| ►CGlyphSequence | A GlyphSequence represents a sequence of glyph codes with positions. A GlyphSequence provides an interface to grab the glyph-codes realized as different renderers for the purpose of rendering text in response to the transformation that a Painter currently has. A GlyphSequence maintains a hierarchy so that Painter can quickly cull glyphs that are not visible. The methods of GlyphSequence are re-entrant but not thread safe, i.e. if an application uses the same GlyphSequence from multiple threads it needs to explicitely handle locking itself when using it |
| CScratchSpace | Opaque object to hold work room needed for functions of GlyphSequence that require scratch space |
| CSubset | |
| CGlyphSource | |
| Cgpu_dirty_state | |
| ►CImage | An Image represents an image comprising of RGBA8 values. The texel values themselves are stored in a ImageAtlas |
| CResourceReleaseAction | |
| CImageAtlas | An ImageAtlas is a common location to place images of an application |
| CImageSourceBase | ImageSourceBase defines the inteface for copying texel data from a source (CPU memory, a file, etc) to an AtlasColorBackingStoreBase derived object |
| CImageSourceCArray | An implementation of ImageSourceBase where the data is backed by a c_array<const u8vec4> data |
| Cis_const | |
| Cmatrix3x3 | A representation of a 3x3 matrix, that in addition to the NxN matrix functionality provides function for calculating the determinant |
| CmatrixNxM | A generic matrix class. The operator() is overloaded to access elements of the matrix as follows: |
| ►CMutex | |
| CGuard | |
| Cnoncopyable | Class for which copy ctor and assignment operator are private functions |
| Corthogonal_projection_params | An orthogonal_projection_params holds the data to describe an orthogonal projection matrix without perspective |
| ►CPainter | Painter implements a canvas rendering interface |
| CGlyphRendererChooser | A GlyphRendererChooser provides an interface for choosing how to render glyphs depending on the current transformation matrix, Painter::transformation() |
| CNormalizedCoordRect | A NormalizedCoordRect is used to specify a rectangle in -normalized- device coordinates. Recall that normalized device coordinates hae that the bottom-left is (-1, 1) and the top right is (+1, +1) ALWAYS |
| CPainterAttribute | The attribute data generated/filled by Painter. Attribute data is sent to 3D API as raw bits with the expectation that shaders will cast the bits to the appropiate types for themselves |
| CPainterAttributeData | PainterAttributeData represents the attribute and index data ready to be consumed by a Painter. Data is organized into individual chuncks that can be drawn seperately |
| CPainterAttributeDataFiller | A PainterAttributeDataFiller is the interfaceto fill the data held by a PainterAttributeData |
| ►CPainterAttributeWriter | Provides an interface to write attribute and index data when a simple copy of data from c_array objects is not sufficient |
| CWriteState | |
| CPainterBackend | A PainterBackend is an interface that defines the API-specific elements to implement Painter. A fixed PainterBackend will only be used by a single Painter |
| CPainterBlendShader | A PainterBlendShader represents a shader for performing blending operations |
| CPainterBlendShaderData | PainterBlendShaderData holds custom data for blend shaders |
| CPainterBlendShaderSet | A PainterBlendShaderSet represents a set of shaders for the blend modes enumerated by PainterEnums::blend_mode_t |
| CPainterBrush | A PainterBrush defines a brush for painting via Painter |
| CPainterBrushAdjust | A PainterBrushAdjust holds the value for applying a tranformation to the brush position before it is handed off to brush shading. The transformation is shearing composited with a translation, i.e. the transformation is given by |
| CPainterBrushEnums | Class to contain various enumerations needed for describing a brush |
| CPainterBrushShader | A PainterBrushShader represents a shader for performing a custom brush coloring |
| CPainterBrushShaderData | Base class to hold custom data for custom brush shaders |
| CPainterBrushShaderSet | A PainterBrushShaderSet holds the PainterBrushShader objects to be used with the default brushes |
| CPainterClipEquations | A PainterClipEquations stores the clip equation for Painter |
| CPainterCustomBrush | A PainterCustomBrush is just a conveniance to wrap a pointer to a PainterBrushShader together with a PainterDataValue<PainterBrushShaderData> |
| ►CPainterDashedStrokeParams | Class to specify dashed stroking parameters, data is packed as according to PainterDashedStrokeParams::stroke_data_offset_t. Data for dashing is packed [TODO describe] |
| CDashPatternElement | A DashPatternElement is an element of a dash pattern. It specifies how long to draw then how much space to emit before the next DashPatternElement |
| CPainterDashedStrokeShaderSet | A PainterDashedStrokeShaderSet holds a collection of PainterStrokeShaderSet objects for the purpose of dashed stroking. The shaders within a PainterDashedStrokeShaderSet are expected to draw any caps of dashed stroking from using just the edge data. In particular, attributes/indices for caps induced by stroking are NOT given to a shader within a PainterDashedStrokeShaderSet |
| ►CPainterData | A PainterData provides the data for how for a Painter to draw content |
| Cbrush_value | A brush_value stores the brush applied; it stores a pointer to a PainterBrushShader together with a PainterDataValue<PainterBrushShaderData>. If the pointer to the PainterBrushShader is null, then it indicates to use the standard brush shader, PainterBrushShaderSet::standard_brush() |
| CPainterDataValue | Element of PainterData to hold shader data either reference directly to unpacked data or to reuseable packed data |
| ►CPainterDraw | Store for attributes, indices of items and shared data of items for items to draw. Indices (stored in m_indices) are -ALWAYS- in groups of three where each group is a single triangle and each index is an index into m_attributes. The PainterDraw object is NOT thread safe, neither is its reference count. A PainterDraw object is used Painter to send attributer and index data to a Painter Backend |
| CDelayedAction | A delayed action is an action that is to be called just before the buffers of a PainterDraw are to be unmapped. Typically, this is used to write values using information that is ready after the original values are written by Painter. A fixed DelayedAction object may only be added to one PainterDraw object, but a single PainterDraw can have many DelayedAction objects added to it |
| CPainterDrawBreakAction | A PainterDrawBreakAction represents an action on the 3D API between two indices to be fed the the GPU; a PainterDrawBreakAction will imply an draw break in the underlying 3D API. Typical example of such an action would be to bind a texture |
| CPainterEffect | A PainterEffect represents the interface to define and effect to apply to image data. At its core, it is made up of a sequence of passes |
| CPainterEffectBrush | A PainterEffectBrush represents applying a brush. The PainterEffectParams derived object to use with a PainterEffectBrush is PainterEffectBrushParams |
| CPainterEffectBrushParams | |
| CPainterEffectParams | |
| ►CPainterEngine | A PainterEngine provides an interface to create Painter Backend derived objects |
| CConfigurationBase | A ConfigurationBase holds properties common to all Painter Backend objects returned by PainterEngine::create_backend() from a fixed PainterEngine |
| CPerformanceHints | PerformanceHints provides miscellaneous data about Painter Backend objects returned by PainterEngine::create_backend() from a fixed PainterEngine |
| CPainterEnums | Class to encapsulate enumerations used in Painter interface, part of the main library libFastUIDraw |
| CPainterFillShader | A PainterFillShader holds the shaders for drawing filled paths. Anti-aliasing is accomplished by drawing 1-pixel thick rects about the boundary of the filled path |
| CPainterGlyphShader | A PainterGlyphShader holds a shader for each glyph_type. The shaders are to handle attribute data as packed by Glyph::pack_glyph() |
| CPainterGradientBrushShader | A PainterGradientBrushShader represents a set of brush shaders to to perform a gradient. Internally it containts four generic parent shaders: |
| CPainterGradientBrushShaderData | A PainterGradientBrushShaderData defines the PainterBrushShaderData that the shaders of a PainterGradientBrushShader consume. It specifies what ColorStopSequence to use together with the geometric properties of the gradient |
| CPainterHeader | A PainterHeader represents the values of the header for the shaders to read to draw data. The header holds data that is common for all vertices and fragments for an item to draw, including with what shader and the data for the shader |
| CPainterImageBrushShader | A PainterImageBrushShader represents a single PainterBrushShader together with sub-shaders of it that can be used to apply an Image. The sub-shader ID is used to describe the Image::type(), Image::format(), what filtering and mipmapping to apply to the image data |
| CPainterImageBrushShaderData | A PainterImageBrushShaderData defines the PainterBrushShaderData that the shaders of a PainterImageBrushShader consume. It specifies what Image and what rectangular region within it from which to source image data |
| CPainterItemCoverageShader | A PainterItemCoverageShader represents a shader to draw an item to a coverage buffer (see PainterSurface::deferred_coverage_buffer_type). Typically such a shader represents both a vertex and fragment shader |
| CPainterItemMatrix | A PainterItemMatrix holds the value for the transformation from item coordinates to the coordinates in which the clipping rectangle applies |
| CPainterItemShader | A PainterItemShader represents a shader to draw an item (typically a vertex and fragment shader pair) |
| CPainterItemShaderData | PainterItemShaderData holds custom data for item shaders |
| CPainterPackedValue | A PainterPackedValue represents a handle to an object that stores packed state data and tracks if that underlying data is already is already copied to PainterDraw::m_store |
| CPainterPackedValueBase | (Private) base class used for PainterPackedValue |
| CPainterPackedValuePool | A PainterPackedValuePool can be used to create PainterPackedValue objects |
| ►CPainterShader | A PainterShader encapsulates how to draw or blend |
| CTag | A Tag is how a PainterShader is described for and by a PainterShaderRegistrar |
| CPainterShaderData | Common base class to PainterItemShaderData, PainterBrushShaderData and PainterBlendShaderData to hold shader data for custom shaders |
| CPainterShaderGroup | A PainterShaderGroup gives to what groups the active shaders of a Painter belong |
| CPainterShaderRegistrar | A PainterShaderRegistrar is an interface that defines the assigning of PainterShader::ID() to a PainterShader. PainterShader objects are registered to a unique PainterShaderRegistrar for their lifetime |
| CPainterShaderSet | A PainterShaderSet provides shaders for blending and drawing each of the item types glyphs, stroking paths and filling paths |
| CPainterStrokeParams | Class to specify stroking parameters, data is packed as according to PainterStrokeParams::stroke_data_offset_t |
| CPainterStrokeShader | A PainterStrokeShader holds shaders for stroking. It is to hold shaders for stroking paths linearly or via arcs with and without anti-aliasing along with meta-data to inform what shading is faster |
| ►CPainterSurface | PainterSurface represents an interface to specify a buffer to which a PainterBackend renders content |
| CViewport | |
| ►CPartitionedTessellatedPath | A PartitionedTessellatedPath represents partitioning a TessellatedPath for quick computation of what TessellatedPath::segment intersect a region |
| CSubset | A Subset represents a handle to a portion of a PartitionedTessellatedPath. The handle is invalid once the PartitionedTessellatedPath from which it comes goes out of scope. Do not save these handle values without also saving a handle of the PartitionedTessellatedPath from which they come |
| CSubsetSelection | |
| ►CPath | A Path represents a collection of PathContour objects |
| Carc | Wraps the data to specify an arc |
| Ccontour_close | Tag class to mark the close of a contour |
| Ccontour_close_arc | Tag class to mark the close of an contour with an arc |
| Ccontour_end | Tag class to mark the end of a contour without adding a closing edge of the contour and start a new contour |
| Ccontour_start | Indicates to end the existing contour with adding a closing edge of the contour and start a new contour |
| Ccontrol_point | Class that wraps a vec2 to mark a point as a control point for a Bezier curve |
| ►CPathContour | An PathContour represents a single contour within a Path |
| Carc | An arc is for connecting one point to the next via an arc of a circle |
| Cbezier | Derived class of interpolator_base to indicate a Bezier curve. Supports Bezier curves of any degree |
| Cflat | A flat interpolator represents a flat edge |
| Cinterpolator_base | Base class to describe how to interpolate from one point of a PathContour to the next, i.e. describes the shape of an edge |
| ►Cinterpolator_generic | Interpolator generic implements tessellation by recursion and relying on analytic derivative provided by derived class |
| Ctessellated_region | |
| Ctessellation_state | Provides an interface to resume from a previous tessellation of a interpolator_base derived object |
| CPathDashEffect | |
| ►CPathEffect | A PathEffect allows one to process a sequence of TessellatedPath::segment_chain, TessellatedPath::join and TessellatedPath::cap values to produce a new sequence of such values for the purpose of effecting stroking |
| CStorage | A Storage is to where TessellatedPath::segment, TessellatedPath::join and TessellatedPath::cap values are stored from being processed by a PathEffect |
| CPathEnums | Class to encapsulate enumerations used by Path and PathContour |
| Cprojection_params | A projection_params holds the data to describe a projection matrix with perspective |
| Crange_type | A class reprenting the STL range [m_begin, m_end) |
| CRectEnums | |
| CRectT | |
| Creference_count_atomic | Reference counter that is thread safe by having increment and decrement operations by atomic operations, this is usually faster (and much faster) than reference_count_mutex |
| Creference_count_non_concurrent | Reference counter that is NOT thread safe |
| Creference_counted | Defines default reference counting base classes |
| Creference_counted_base | Base class to use for reference counted objects, for using reference_counted_ptr. See also reference_counted. Object deletion (when the reference count goes to zero) is performed via FASTUIDRAWdelete. As a consequence of using FASTUIDRAWdelete, objects must be created with FASTUIDRAWnew |
| Creference_counted_ptr | A wrapper over a pointer to implement reference counting |
| Cremove_const | |
| Cremove_const< T const > | |
| Cresource_base | A common base class to use for resources that need to be saved opaquely |
| CRoundedRect | |
| Csame_const | |
| ►CShaderFilledPath | A ShaderFilledPath represents a path that is drawn as a rectangle where the fragment shader acting on the rectangle performs the coverage computation of each pixel. Generally speaking, one should only fill paths via a ShaderFilledPath when a filled path when drawn has very high density of edges |
| CBuilder | |
| Cstatic_resource | Provided as a conveniance. The ctor calls generate_static_resource() |
| Cstring_array | |
| ►CStrokedPath | A StrokedPath represents the data needed to draw a path stroked. It contains -all- the data needed to stroke a path regardless of stroking style. In particular, for a given TessellatedPath, one only needs to construct a StrokedPath once regardless of how one strokes the original path for drawing |
| CSubset | A Subset represents a handle to a portion of a StrokedPath. The handle is invalid once the StrokedPath from which it comes goes out of scope. Do not save these handle values without also saving a handle of the StrokedPath from which they come. The region of a Subset is the exact same region as a PartitionedTessellatedPath::Subset object. Also, the ID() value for a Subset is the same value as PartitionedTessellatedPath::Subset::ID() as well |
| CSubsetSelection | |
| CStrokedPoint | A StrokedPoint holds the data for a point of stroking where all segments are line segments (coming from curve tessellation). The upshot is that the fragment shader does NOT perform any coverage computation for non-dashed stroking. In addition, the data is so that changing the stroking width or miter limit does not change the stroking data |
| ►CStrokingAttributeWriter | A StrokingAttributeWriter is an implementation of PainterAttributeWriter for the purpose of stroking a path |
| CStrokingMethod | StrokingMethod specifies how to pack the join and pack values from the source PathEffect::Storage |
| CStrokingDataSelectorBase | A StrokingDataSelector is an interface to assist Painter to select correct LOD for rounded joins and caps when drawing rounded joins and caps. In addition it also informs Painter if stroking via arcs is possible with the stroking parameters |
| CStrokingStyle | |
| ►CTessellatedPath | An TessellatedPath represents the tessellation of a Path into line segments and arcs |
| Ccap | Represents the geometric data for a cap |
| Cjoin | Represents the geometric data for a join |
| CRefiner | |
| Csegment | Represents segment of a tessellated or arc-tessellated path |
| Csegment_chain | |
| CSegmentStorage | A wrapper over a dynamic array of segment objects; segment values added to SegmentStorage must be added in order of time along the domain of a PathContour::interpolator_base |
| CTessellationParams | A TessellationParams stores how finely to tessellate the curves of a path |
| Ctrue_type | Class for type traits to indicate true. Functionally, a simplified version of std::true_type |
| CunvecN | |
| CvecN | VecN is a simple static array class with no virtual functions and no memory overhead. Supports runtim array index checking and STL style iterators via pointer iterators |
| Cfastuidraw_compute_image_atlas_coord_type | Structure to give information about what tile and where within a tile an image texel is located. Only available if FASTUIDRAW_IMAGE_ATLAS_DISABLED is not defined |
| Cfastuidraw_dashed_stroking_params_header | |
| Cfastuidraw_image_extended_info_type | Structure that fully describes a fastuidraw::Image or a sub-image of one. Only available if FASTUIDRAW_IMAGE_ATLAS_DISABLED is not defined |
| Cfastuidraw_image_info_type | Structure that describes the relationship between the master index tile and the color tiles of an image. Only available if FASTUIDRAW_IMAGE_ATLAS_DISABLED is not defined |
| Cfastuidraw_image_texture_gather_output_type | Structure that holds the 2x2 texel block. Only available if FASTUIDRAW_IMAGE_ATLAS_DISABLED is not defined |
| Cfastuidraw_stroking_params |
