| Cfastuidraw::GlyphCache::AllocationHandle | |
| Cfastuidraw::Path::arc | Wraps the data to specify an arc |
| Cfastuidraw::ArcStrokedPoint | 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 |
| Cfastuidraw::gl::Program::atomic_buffer_info | An atomic_buffer_info represents an object from which one can query the data of an atomic buffer |
| Cfastuidraw::glsl::PainterShaderRegistrarGLSLTypes::BackendConstants | |
| Cfastuidraw::BlendMode | Class to hold the blend mode as exposed by typical 3D APIs |
| Cfastuidraw::gl::Program::block_info | A block_info represents an object from which one can query the members of a uniform or shader storage block |
| Cfastuidraw::PainterData::brush_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() |
| Cfastuidraw::c_array< T > | 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 |
| Cfastuidraw::c_array< const fastuidraw::c_array< const fastuidraw::vecN > > | |
| Cfastuidraw::c_array< const fastuidraw::TessellatedPath::segment > | |
| Cfastuidraw::c_array< const T > | |
| Cfastuidraw::c_array< const uint32_t > | |
| Cfastuidraw::c_array< const uint8_t > | |
| Cfastuidraw::c_array< fastuidraw::PainterAttribute > | |
| Cfastuidraw::c_array< fastuidraw::vecN > | |
| Cfastuidraw::c_array< PainterIndex > | |
| Cfastuidraw::c_array< uint32_t > | |
| Cfastuidraw::c_array< uint8_t > | |
| Cfastuidraw::c_array< unsigned int > | |
| Cfastuidraw::TessellatedPath::cap | Represents the geometric data for a cap |
| Cfastuidraw::ColorStop | 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] |
| Cfastuidraw::gl::PainterEngineGL::ColorStopAtlasParams | Class to hold the construction parameters for creating a GL-backend ColorStopAtlas for a PainterEngineGL |
| Cfastuidraw::PainterEngine::ConfigurationBase | A ConfigurationBase holds properties common to all Painter Backend objects returned by PainterEngine::create_backend() from a fixed PainterEngine |
| Cfastuidraw::gl::PainterEngineGL::ConfigurationGL | A ConfigurationGL gives parameters how to contruct a PainterEngineGL |
| Cfastuidraw::Path::contour_close | Tag class to mark the close of a contour |
| Cfastuidraw::Path::contour_close_arc | Tag class to mark the close of an contour with an arc |
| Cfastuidraw::Path::contour_end | Tag class to mark the end of a contour without adding a closing edge of the contour and start a new contour |
| Cfastuidraw::Path::contour_start | Indicates to end the existing contour with adding a closing edge of the contour and start a new contour |
| Cfastuidraw::Path::control_point | Class that wraps a vec2 to mark a point as a control point for a Bezier curve |
| ►Cfastuidraw::CustomFillRuleBase | Base class to specify a custom fill rule |
| Cfastuidraw::CustomFillRuleFunction | Class to specify a custom fill rule from a function |
| Cfastuidraw::PainterDashedStrokeParams::DashPatternElement | 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 |
| ►Cfastuidraw::DataBufferBackingStore | Represents a buffer directly stored in memory |
| Cfastuidraw::DataBuffer | DataBuffer is an implementation of DataBufferBase where the data is directly backed by memory |
| Cfastuidraw::glsl::PainterBlendShaderGLSL::DependencyList | 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 |
| Cfastuidraw::glsl::PainterBrushShaderGLSL::DependencyList | 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 |
| Cfastuidraw::glsl::PainterItemCoverageShaderGLSL::DependencyList | 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 |
| Cfastuidraw::glsl::PainterItemShaderGLSL::DependencyList | 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 |
| ►Cfastuidraw::false_type | Class for type traits to indicate true. Functionally, a simplified version of std::false_type |
| Cfastuidraw::is_const< T > | |
| 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 | |
| Cfastuidraw::FontDatabase::FontGroup | 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) |
| Cfastuidraw::FontMetrics | Represents various metric values global to an entire font |
| Cfastuidraw::FontProperties | Represents defining properties of a font used by FontDatabase to perform font merging |
| Cfastuidraw::Glyph | A Glyph is essentially an opaque pointer to data for rendering and performing layout of a glyph |
| Cfastuidraw::gl::PainterEngineGL::GlyphAtlasParams | Class to hold the construction parameters for creating a GL-backend GlyphAtlas for a PainterEngineGL |
| Cfastuidraw::GlyphAttribute | A GlyphAttribute represents one Painter Attribute per glyph corner |
| Cfastuidraw::GlyphMetrics | 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 |
| Cfastuidraw::GlyphMetricsValue | A GlyphMetricsValue is to be used by a FontBase derived object to specify the values of a GlyphMetrics object |
| Cfastuidraw::GlyphRenderCostInfo | |
| Cfastuidraw::GlyphRenderer | Specifies how to render a glyph |
| Cfastuidraw::Painter::GlyphRendererChooser | A GlyphRendererChooser provides an interface for choosing how to render glyphs depending on the current transformation matrix, Painter::transformation() |
| Cfastuidraw::GlyphSource | |
| Cfastuidraw::gpu_dirty_state | |
| Cfastuidraw::gl::PainterEngineGL::ImageAtlasParams | Class to hold the construction parameters for creating the GL-backend ImageAtlas for a PainterEngineGL |
| ►Cfastuidraw::ImageSourceBase | ImageSourceBase defines the inteface for copying texel data from a source (CPU memory, a file, etc) to an AtlasColorBackingStoreBase derived object |
| Cfastuidraw::ImageSourceCArray | An implementation of ImageSourceBase where the data is backed by a c_array<const u8vec4> data |
| Cfastuidraw::TessellatedPath::join | Represents the geometric data for a join |
| Cfastuidraw::glsl::ShaderSource::MacroSet | |
| Cfastuidraw::matrixNxM< N, M, T > | A generic matrix class. The operator() is overloaded to access elements of the matrix as follows: |
| Cfastuidraw::matrixNxM< 2, 2, float > | |
| ►Cfastuidraw::matrixNxM< 3, 3, float > | |
| Cfastuidraw::matrix3x3< float > | |
| ►Cfastuidraw::matrixNxM< 3, 3, T > | |
| Cfastuidraw::matrix3x3< T > | A representation of a 3x3 matrix, that in addition to the NxN matrix functionality provides function for calculating the determinant |
| ►Cfastuidraw::noncopyable | Class for which copy ctor and assignment operator are private functions |
| Cfastuidraw::APICallbackSet | |
| Cfastuidraw::ColorStopArray | A ColorStopArray is a sequence of ColorStop values used to define the color stops of a gradient |
| Cfastuidraw::FilledPath::ScratchSpace | Opaque object to hold work room needed for functions of FilledPath that require scratch space |
| Cfastuidraw::gl::ContextProperties | A ContextProperties provides an interface to query GL/GLES version and extensions |
| Cfastuidraw::GlyphAtlasProxy | An GlyphAtlasProxy is a proxy for a GlyphAtlas; one can allocate through it. Internally it tracks all that was allocated with it |
| Cfastuidraw::GlyphAttribute::Array | Represents an opaque array of GlyphAttribute values |
| ►Cfastuidraw::GlyphRenderData | GlyphRenderData provides an interface to specify data used for rendering glyphs and to pack that data onto a GlyphAtlas |
| Cfastuidraw::GlyphRenderDataBandedRays | |
| Cfastuidraw::GlyphRenderDataRestrictedRays | |
| Cfastuidraw::GlyphRenderDataTexels | A GlyphRenderDataTexels holds texel data for rendering a glyph. Such texel data can be for both distance field and coverage glyph rendeding |
| Cfastuidraw::GlyphRun | 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 |
| Cfastuidraw::GlyphSequence | 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 |
| Cfastuidraw::GlyphSequence::ScratchSpace | Opaque object to hold work room needed for functions of GlyphSequence that require scratch space |
| Cfastuidraw::Mutex | |
| Cfastuidraw::Mutex::Guard | |
| Cfastuidraw::PainterAttributeData | 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 |
| Cfastuidraw::PainterAttributeDataFiller | A PainterAttributeDataFiller is the interfaceto fill the data held by a PainterAttributeData |
| ►Cfastuidraw::PainterAttributeWriter | Provides an interface to write attribute and index data when a simple copy of data from c_array objects is not sufficient |
| Cfastuidraw::StrokingAttributeWriter | A StrokingAttributeWriter is an implementation of PainterAttributeWriter for the purpose of stroking a path |
| ►Cfastuidraw::PainterBrushShaderData | Base class to hold custom data for custom brush shaders |
| Cfastuidraw::PainterBrush | A PainterBrush defines a brush for painting via Painter |
| Cfastuidraw::PainterGradientBrushShaderData | 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 |
| Cfastuidraw::PainterImageBrushShaderData | 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 |
| ►Cfastuidraw::PainterEffectParams | |
| Cfastuidraw::PainterEffectBrushParams | |
| Cfastuidraw::PainterPackedValuePool | A PainterPackedValuePool can be used to create PainterPackedValue objects |
| ►Cfastuidraw::PainterShaderData | Common base class to PainterItemShaderData, PainterBrushShaderData and PainterBlendShaderData to hold shader data for custom shaders |
| Cfastuidraw::PainterBlendShaderData | PainterBlendShaderData holds custom data for blend shaders |
| ►Cfastuidraw::PainterItemShaderData | PainterItemShaderData holds custom data for item shaders |
| Cfastuidraw::PainterDashedStrokeParams | Class to specify dashed stroking parameters, data is packed as according to PainterDashedStrokeParams::stroke_data_offset_t. Data for dashing is packed [TODO describe] |
| Cfastuidraw::PainterStrokeParams | Class to specify stroking parameters, data is packed as according to PainterStrokeParams::stroke_data_offset_t |
| Cfastuidraw::PainterShaderGroup | A PainterShaderGroup gives to what groups the active shaders of a Painter belong |
| Cfastuidraw::PartitionedTessellatedPath::SubsetSelection | |
| Cfastuidraw::Path | A Path represents a collection of PathContour objects |
| ►Cfastuidraw::PathEffect | 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 |
| Cfastuidraw::PathDashEffect | |
| Cfastuidraw::PathEffect::Storage | A Storage is to where TessellatedPath::segment, TessellatedPath::join and TessellatedPath::cap values are stored from being processed by a PathEffect |
| Cfastuidraw::reference_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 |
| Cfastuidraw::reference_count_non_concurrent | Reference counter that is NOT thread safe |
| ►Cfastuidraw::reference_counted_base< T, Counter > | 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 |
| ►Cfastuidraw::APICallbackSet::CallBack | |
| Cfastuidraw::gl_binding::CallbackGL | A CallbackGL defines the interface (via its base class) for callbacks before and after each GL call |
| Cfastuidraw::AtlasColorBackingStoreBase | Represents the interface for a backing store for color data of images |
| Cfastuidraw::AtlasIndexBackingStoreBase | Represents the interface for the backing store for index data of images |
| Cfastuidraw::ColorStopAtlas | 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) |
| Cfastuidraw::ColorStopBackingStore | 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 |
| ►Cfastuidraw::DataBufferBase | Base class for passing around buffers of data; derived classes have the responsibility of maintaining storage cleanup at destruction |
| Cfastuidraw::DataBuffer | DataBuffer is an implementation of DataBufferBase where the data is directly backed by memory |
| Cfastuidraw::FilledPath | 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 |
| ►Cfastuidraw::FontBase | FontBase provides an interface for a font to generate glyph rendering data |
| Cfastuidraw::FontFreeType | A FontFreeType implements the interface of FontBase from a scalable font loaded by libfreetype |
| Cfastuidraw::FontDatabase | 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 |
| Cfastuidraw::FontDatabase::FontGeneratorBase | 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 |
| Cfastuidraw::FreeTypeFace | A FreeTypeFace wraps an FT_Face object of the FreeType library together with a mutex in a reference counted object |
| ►Cfastuidraw::FreeTypeFace::GeneratorBase | A Generator provides an interface to create FreeTypeFace objects |
| Cfastuidraw::FreeTypeFace::GeneratorFile | Implementation of GeneratorBase to create a FreeTypeFace from a face index / file pair via lib FreeType's FT_New_Face |
| Cfastuidraw::FreeTypeFace::GeneratorMemory | Implementation of GeneratorBase to create a FreeTypeFace from a face index / file pair via lib FreeType's FT_New_Memory_Face |
| Cfastuidraw::FreeTypeLib | A FreeTypeLib wraps an FT_Library object of the FreeType library together with a mutex in a reference counted object |
| ►Cfastuidraw::gl::PreLinkAction | A PreLinkAction is an action to apply to a Program after attaching shaders but before linking |
| Cfastuidraw::gl::BindAttribute | A BindAttribute inherits from PreLinkAction, it's purpose is to bind named attributes to named locations, i.e. it calls glBindAttributeLocation() |
| Cfastuidraw::gl::BindFragDataLocation | A BindFragDataLocation inherits from PreLinkAction, its purpose is to bind a fragment shader out to a named location and index. Using a BindFragDataLocation requires: |
| Cfastuidraw::gl::ProgramSeparable | 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: |
| Cfastuidraw::gl::TransformFeedbackVarying | 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 |
| Cfastuidraw::gl::Program | Class for creating and using GLSL programs |
| ►Cfastuidraw::gl::ProgramInitializer | 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 |
| Cfastuidraw::gl::ShaderStorageBlockInitializer | 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 |
| Cfastuidraw::gl::UniformBlockInitializer | 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 |
| ►Cfastuidraw::gl::UniformInitalizerBase | 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() |
| Cfastuidraw::gl::SamplerInitializer | 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 |
| Cfastuidraw::gl::UniformInitializer< T > | Initialize a uniform via the templated overloaded function fastuidraw::gl::Uniform() |
| Cfastuidraw::gl::UniformInitializer< c_array< const T > > | Specialization for type c_array<const T> for UniformInitializer so that data behind the c_array is copied |
| Cfastuidraw::gl::Shader | Simple Shader utility class providing a simple interface to build GL shader objects using a glsl::ShaderSouce as its source code |
| Cfastuidraw::GlyphAtlas | 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 |
| Cfastuidraw::GlyphAtlasBackingStoreBase | GlyphAtlasStoreBase represents an interface to an aray of uint32_t values |
| Cfastuidraw::GlyphAttributePacker | A GlyphAttributePacker provides an interface to customize how glyph attribute and index data is realized by a GlyphRun and GlyphSequence |
| Cfastuidraw::GlyphCache | 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 |
| Cfastuidraw::Image::ResourceReleaseAction | |
| Cfastuidraw::ImageAtlas | An ImageAtlas is a common location to place images of an application |
| Cfastuidraw::Painter | Painter implements a canvas rendering interface |
| Cfastuidraw::PainterBackend | 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 |
| Cfastuidraw::PainterDraw | 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 |
| Cfastuidraw::PainterDraw::DelayedAction | 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 |
| Cfastuidraw::PainterDrawBreakAction | 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 |
| ►Cfastuidraw::PainterEffect | 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 |
| Cfastuidraw::PainterEffectBrush | A PainterEffectBrush represents applying a brush. The PainterEffectParams derived object to use with a PainterEffectBrush is PainterEffectBrushParams |
| ►Cfastuidraw::PainterEngine | A PainterEngine provides an interface to create Painter Backend derived objects |
| Cfastuidraw::gl::PainterEngineGL | 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 |
| Cfastuidraw::PainterGradientBrushShader | A PainterGradientBrushShader represents a set of brush shaders to to perform a gradient. Internally it containts four generic parent shaders: |
| Cfastuidraw::PainterImageBrushShader | 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 |
| ►Cfastuidraw::PainterShader | A PainterShader encapsulates how to draw or blend |
| ►Cfastuidraw::PainterBlendShader | A PainterBlendShader represents a shader for performing blending operations |
| Cfastuidraw::glsl::PainterBlendShaderGLSL | A PainterBlendShaderGLSL is a PainterBlendShader whose shader code fragment is via GLSL |
| ►Cfastuidraw::PainterBrushShader | A PainterBrushShader represents a shader for performing a custom brush coloring |
| Cfastuidraw::glsl::PainterBrushShaderGLSL | A PainterBrushShaderGLSL is a PainterBrushShader whose shader code fragment is via GLSL.The vertex shader code needs to implement the function: |
| ►Cfastuidraw::PainterItemCoverageShader | 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 |
| Cfastuidraw::glsl::PainterItemCoverageShaderGLSL | A PainterItemCoverageShaderGLSL is a collection of GLSL source code fragments for a PainterShaderRegistrarGLSL |
| ►Cfastuidraw::PainterItemShader | A PainterItemShader represents a shader to draw an item (typically a vertex and fragment shader pair) |
| Cfastuidraw::glsl::PainterItemShaderGLSL | A PainterItemShaderGLSL is a collection of GLSL source code fragments for a PainterShaderRegistrarGLSL |
| ►Cfastuidraw::PainterShaderRegistrar | 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 |
| Cfastuidraw::glsl::PainterShaderRegistrarGLSL | A PainterShaderRegistrarGLSL is an implementation of PainterRegistrar that assembles the shader source code of PainterItemShaderGLSL and PainterBlendShaderGLSL into an uber-shader |
| ►Cfastuidraw::PainterSurface | PainterSurface represents an interface to specify a buffer to which a PainterBackend renders content |
| Cfastuidraw::gl::PainterSurfaceGL | |
| Cfastuidraw::PartitionedTessellatedPath | A PartitionedTessellatedPath represents partitioning a TessellatedPath for quick computation of what TessellatedPath::segment intersect a region |
| Cfastuidraw::PathContour | An PathContour represents a single contour within a Path |
| ►Cfastuidraw::PathContour::interpolator_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 |
| Cfastuidraw::PathContour::arc | An arc is for connecting one point to the next via an arc of a circle |
| Cfastuidraw::PathContour::flat | A flat interpolator represents a flat edge |
| ►Cfastuidraw::PathContour::interpolator_generic | Interpolator generic implements tessellation by recursion and relying on analytic derivative provided by derived class |
| Cfastuidraw::PathContour::bezier | Derived class of interpolator_base to indicate a Bezier curve. Supports Bezier curves of any degree |
| Cfastuidraw::PathContour::interpolator_generic::tessellated_region | |
| Cfastuidraw::PathContour::tessellation_state | Provides an interface to resume from a previous tessellation of a interpolator_base derived object |
| ►Cfastuidraw::resource_base | A common base class to use for resources that need to be saved opaquely |
| Cfastuidraw::ColorStopSequence | 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 |
| ►Cfastuidraw::Image | An Image represents an image comprising of RGBA8 values. The texel values themselves are stored in a ImageAtlas |
| Cfastuidraw::gl::TextureImage | |
| Cfastuidraw::ShaderFilledPath | 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 |
| Cfastuidraw::StrokedPath | 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 |
| Cfastuidraw::StrokingDataSelectorBase | 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 |
| Cfastuidraw::TessellatedPath | An TessellatedPath represents the tessellation of a Path into line segments and arcs |
| Cfastuidraw::TessellatedPath::Refiner | |
| Cfastuidraw::ShaderFilledPath::Builder | |
| Cfastuidraw::StrokedPath::SubsetSelection | |
| Cfastuidraw::TessellatedPath::SegmentStorage | 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 |
| Cfastuidraw::Painter::NormalizedCoordRect | 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 |
| Cfastuidraw::orthogonal_projection_params< T > | An orthogonal_projection_params holds the data to describe an orthogonal projection matrix without perspective |
| Cfastuidraw::StrokedPointPacking::packing_size< T, T > | Template class taking as argument a PainterEnums::join_style or cap_type_t which defines two enumerations: |
| Cfastuidraw::PainterAttribute | 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 |
| Cfastuidraw::PainterBlendShaderSet | A PainterBlendShaderSet represents a set of shaders for the blend modes enumerated by PainterEnums::blend_mode_t |
| Cfastuidraw::PainterBrushAdjust | 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 |
| ►Cfastuidraw::PainterBrushEnums | Class to contain various enumerations needed for describing a brush |
| Cfastuidraw::PainterBrush | A PainterBrush defines a brush for painting via Painter |
| ►Cfastuidraw::PainterEnums | Class to encapsulate enumerations used in Painter interface, part of the main library libFastUIDraw |
| Cfastuidraw::Painter | Painter implements a canvas rendering interface |
| Cfastuidraw::PainterGradientBrushShader | A PainterGradientBrushShader represents a set of brush shaders to to perform a gradient. Internally it containts four generic parent shaders: |
| Cfastuidraw::PainterGradientBrushShaderData | 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 |
| Cfastuidraw::PainterImageBrushShader | 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 |
| Cfastuidraw::PainterImageBrushShaderData | 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 |
| Cfastuidraw::PainterBrushShaderSet | A PainterBrushShaderSet holds the PainterBrushShader objects to be used with the default brushes |
| Cfastuidraw::PainterClipEquations | A PainterClipEquations stores the clip equation for Painter |
| Cfastuidraw::PainterCustomBrush | A PainterCustomBrush is just a conveniance to wrap a pointer to a PainterBrushShader together with a PainterDataValue<PainterBrushShaderData> |
| Cfastuidraw::PainterDashedStrokeShaderSet | 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 |
| Cfastuidraw::PainterData | A PainterData provides the data for how for a Painter to draw content |
| Cfastuidraw::PainterDataValue< T > | Element of PainterData to hold shader data either reference directly to unpacked data or to reuseable packed data |
| Cfastuidraw::PainterDataValue< fastuidraw::PainterBlendShaderData > | |
| Cfastuidraw::PainterDataValue< fastuidraw::PainterBrushShaderData > | |
| Cfastuidraw::PainterDataValue< fastuidraw::PainterItemShaderData > | |
| Cfastuidraw::PainterFillShader | 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 |
| Cfastuidraw::PainterGlyphShader | A PainterGlyphShader holds a shader for each glyph_type. The shaders are to handle attribute data as packed by Glyph::pack_glyph() |
| Cfastuidraw::PainterHeader | 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 |
| Cfastuidraw::PainterItemMatrix | A PainterItemMatrix holds the value for the transformation from item coordinates to the coordinates in which the clipping rectangle applies |
| ►Cfastuidraw::PainterPackedValueBase | (Private) base class used for PainterPackedValue |
| Cfastuidraw::PainterPackedValue< T > | 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 |
| Cfastuidraw::PainterPackedValue< fastuidraw::PainterBlendShaderData > | |
| Cfastuidraw::PainterPackedValue< fastuidraw::PainterBrushShaderData > | |
| Cfastuidraw::PainterPackedValue< fastuidraw::PainterItemShaderData > | |
| ►Cfastuidraw::glsl::PainterShaderRegistrarGLSLTypes | |
| Cfastuidraw::gl::PainterEngineGL | 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 |
| Cfastuidraw::glsl::PainterShaderRegistrarGLSL | A PainterShaderRegistrarGLSL is an implementation of PainterRegistrar that assembles the shader source code of PainterItemShaderGLSL and PainterBlendShaderGLSL into an uber-shader |
| Cfastuidraw::PainterShaderSet | A PainterShaderSet provides shaders for blending and drawing each of the item types glyphs, stroking paths and filling paths |
| Cfastuidraw::PainterStrokeShader | 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 |
| ►Cfastuidraw::PathEnums | Class to encapsulate enumerations used by Path and PathContour |
| Cfastuidraw::StrokingDataSelectorBase | 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 |
| Cfastuidraw::PainterEngine::PerformanceHints | PerformanceHints provides miscellaneous data about Painter Backend objects returned by PainterEngine::create_backend() from a fixed PainterEngine |
| Cfastuidraw::gl::PreLinkActionArray | A PreLinkActionArray is a conveniance class wrapper over an array of PreLinkAction handles |
| Cfastuidraw::gl::ProgramInitializerArray | Conveniance class to hold an array of handles of ProgramInitializer objects |
| Cfastuidraw::projection_params< T > | A projection_params holds the data to describe a projection matrix with perspective |
| Cfastuidraw::GlyphRenderDataBandedRays::query_info | |
| Cfastuidraw::GlyphRenderDataRestrictedRays::query_info | |
| Cfastuidraw::range_type< T > | A class reprenting the STL range [m_begin, m_end) |
| Cfastuidraw::range_type< float > | |
| Cfastuidraw::range_type< int > | |
| ►Cfastuidraw::RectEnums | |
| Cfastuidraw::RectT< T > | |
| ►Cfastuidraw::RectT< float > | |
| Cfastuidraw::RoundedRect | |
| Cfastuidraw::reference_counted< T > | Defines default reference counting base classes |
| Cfastuidraw::reference_counted_ptr< T > | A wrapper over a pointer to implement reference counting |
| Cfastuidraw::reference_counted_ptr< const fastuidraw::ColorStopSequence > | |
| Cfastuidraw::reference_counted_ptr< const fastuidraw::Image > | |
| Cfastuidraw::reference_counted_ptr< fastuidraw::PainterItemCoverageShader > | |
| Cfastuidraw::remove_const< T > | |
| Cfastuidraw::remove_const< T const > | |
| Cfastuidraw::same_const< T, S > | |
| Cfastuidraw::TessellatedPath::segment | Represents segment of a tessellated or arc-tessellated path |
| Cfastuidraw::TessellatedPath::segment_chain | |
| Cfastuidraw::gl::Program::shader_variable_info | A shader_variable_info holds the type, size and name of a uniform or an attribute of a GL program |
| Cfastuidraw::glsl::PainterShaderRegistrarGLSLTypes::ShaderFilter< ShaderType > | An ShaderFilter is used to specify whether or not to include a named shader when creating an uber-shader |
| Cfastuidraw::glsl::ShaderSource | A ShaderSource represents the source code to a GLSL shader, specifying blocks of source code and macros to use |
| Cfastuidraw::glsl::shareable_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 |
| Cfastuidraw::static_resource | Provided as a conveniance. The ctor calls generate_static_resource() |
| Cfastuidraw::string_array | |
| Cfastuidraw::StrokedPoint | 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 |
| Cfastuidraw::StrokingAttributeWriter::StrokingMethod | StrokingMethod specifies how to pack the join and pack values from the source PathEffect::Storage |
| Cfastuidraw::StrokingStyle | |
| Cfastuidraw::FilledPath::Subset | 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 |
| Cfastuidraw::GlyphSequence::Subset | |
| Cfastuidraw::PartitionedTessellatedPath::Subset | 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 |
| Cfastuidraw::StrokedPath::Subset | 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 |
| Cfastuidraw::glsl::symbol_list | A symbol_list embodies a varying_list along with a set of shareable values for the vertex and fragment shaders |
| Cfastuidraw::PainterShader::Tag | A Tag is how a PainterShader is described for and by a PainterShaderRegistrar |
| Cfastuidraw::TessellatedPath::TessellationParams | A TessellationParams stores how finely to tessellate the curves of a path |
| Cfastuidraw::true_type | Class for type traits to indicate true. Functionally, a simplified version of std::true_type |
| Cfastuidraw::glsl::PainterShaderRegistrarGLSLTypes::UberShaderParams | An UberShaderParams specifies how to construct an uber-shader. Note that the usage of HW clip-planes is specified by ConfigurationGLSL, NOT UberShaderParams |
| Cfastuidraw::glsl::UnpackSourceGenerator | An unpack source generator is used to generate shader source code to unpack data from the data store buffer into a GLSL struct |
| Cfastuidraw::unvecN< T > | |
| Cfastuidraw::glsl::varying_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 |
| Cfastuidraw::vecN< T, N > | 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::vecN< fastuidraw::string_array, type_number_types > | |
| Cfastuidraw::vecN< fastuidraw::vecN, 4 > | |
| Cfastuidraw::vecN< float, 2 > | |
| Cfastuidraw::vecN< float, 4 > | |
| Cfastuidraw::vecN< float, N *M > | |
| Cfastuidraw::vecN< int32_t, 2 > | |
| Cfastuidraw::vecN< T, 2 > | |
| Cfastuidraw::vecN< T, N *M > | |
| Cfastuidraw::vecN< uint32_t, 2 > | |
| Cfastuidraw::vecN< uint32_t, 4 > | |
| Cfastuidraw::vecN< uint8_t, 4 > | |
| Cfastuidraw::vecN< vecN< float, 2 >, 4 > | |
| Cfastuidraw::PainterSurface::Viewport | |
| Cfastuidraw::PainterAttributeWriter::WriteState | |
