Content
IRenderer
Describes renderer which is used for all drawing operations.
Important notice: shader programs are optional feature and it depends on renderer if it is available or not. It means you can use them in programs you designed for using specific renderer which supports shaders. But when you create controls you alwas should check renderer technology to use proper shader language and after creation shader program always check if it was really created or not. If not, perform drawing by operating texture data directly using ITexture::Lock(). Remember, your controls shouldn't depend on optional features. Optional features can only be used to speed up drawing if possible. You can find more information about shader programs at the bottom of this page, right after IRenderer interface description.
In version 3.0.0 all primitive drawing methods have received overloaded versions which have added possibility of binary masking. It means you may specify 32-bit binary mask where each bit indicates whether pixel should be drawn(value 1) or omitted(value 0). Lines have only 1D binary mask. Other primitives have 2D binary masks which means you may specify two masks - for X and for Y directions. The starting point of mask is start point of line, left-top corner of primitive rectangle, or left-top corner of bounding rectangle(for triangles). The binary mask coordinates then calculated like this: for example, we have line from { 10, 10 } point to { 100, 10 } point. In this case a coordinate in binary mask space will be (X - 10) % 32, where X is coordinate on a line, 10 is a start coordinate, and 32 is count of bits in binary mask. The similar algorithm is used for two dimentional masks as well. Also, 2D binary masks have option how binary mask coordinates will be calculated. Either primitive or form coordinates can be used for calculation of binary mask coordinates. When primitive coordinates are used, they are applied before any transformations. When form ones are used, there is no any transformations at all. With binary masks you can easily achieve effects like on the following image.
In version 7.0.0 all primitive drawing methods have got variants with mask as a last argument. This mask's texture alpha channel is used to specify opacity of a drawn pixel. When its value is 0, a pixel wont be drawn at all. When its value is 127, a pixel will be drawn half transparent. When its value is 255, a pixel will be drawn as usually. It you specify nullptr in the mask argument, all methods will draw pimitives as usually without any mask applied.
You can find more information in comments below.
class IRenderer
{
public:
using BlockColors = Color[plOutside + 1]; // Array of colors for each parts of BLOCK
enum BLUR_TYPE // Blur type
{
btGaussian, // Use gauss function
btAverage // Use average value(visually it more thick than gaussian one)
};
enum TECHNOLOGY_TYPE // Renderer technology
{
ttNull, // Render nowhere
ttOpenGL, // OpenGL
ttDirectX, // DirectX
ttGDI, // GDI
ttGDIPlus, // GDI+
ttOther // Another
};
struct CUBIC_BEZIER_SPLINE // Describe cubic bezier spline
{
PointF P1; // Start point
PointF C1; // First control point
PointF C2; // Second control point
PointF P2; // End point
};
public:
virtual IWindow *getWindow() = 0; // Return associated window
virtual ITexture *getRenderTarget() = 0; // Return current rendering target. If nullptr, draw on window
virtual Rect getViewport() = 0; // Return current viewport(in render target or window client area coordinates)
virtual Color getClearColor() = 0; // Return color to be used to clear rendering target
virtual TECHNOLOGY_TYPE getTechnology() const = 0; // Return used technology for drawing
virtual Point getMinVersion() const = 0; // Return minimum required version for used rendering technology
virtual Point getVersion() = 0; // Return detected version of system's rendering technology
// Since 1.3.0 virtual IShaderProgram *getShaderProgram() = 0; // Return current active shader program. Empty means default one is in use
virtual bool setWindow(IWindow *value) = 0; // Assign window and initialize. Clean up if nullptr
virtual bool setRenderTarget(ITexture *value) = 0; // Set rendering target. If nullptr, draw on window. If not nullptr draw on rendering target
virtual void setClearColor(const Color &value) = 0; // Set render target clearing color
// Since 1.3.0
virtual bool setShaderProgram(IShaderProgram *value) = 0; // Activate new shader program. Return false if the same program is already active or another error happend
// Since 6.0.0
virtual INativeGraphics *getNativeGraphics() = 0; // Return interface which should be converted to the one corresponding to the current renderer and be used to access native graphic functions. Could return nullptr if this feature is not supported
// Since 9.0.0
virtual bool isWindowSupported(IWindow *window) = 0; // Return whether specified window can be used with the renderer. Should be called before real platform window creation. Usually handled by form automatically. May also change window private data so it will be created compatible with the renderer
virtual IPlatformFont *FontCreate(const String &fontname, const int height, const FONT_WEIGHT weight, const bool italic, const bool underline, const bool strikeout, const bool monospace) = 0; // Create platform font with specified parameters. Create only if not exists with same parameters
virtual ITexture *TextureCreate(const int width, const int height, const AnsiString &format) = 0; // Create texture. Windows OpenGL renderer supports "RGBA" and "R" as texture format
virtual ITexture *TextureCreate(const Bitmap &data) = 0; // Create texture by image data, if corresponding to data texture already exists, return existing one
// Since 1.3.0
virtual IShaderProgram *ShaderProgramCreate(const AnsiString &vertex, const AnsiString &fragment, const bool utils) = 0; // Create shader program from specified source codes of vertex and fragment shaders, optionally includes utils library. May return nullptr not only when error happend but also if shader programs are not supported. For more details see comment below
virtual IShaderProgram *ShaderProgramCreate(const AnsiString &fragment) = 0; // Create shader program from source code of predefened format. May return nullptr. For more details please see comments below
virtual void Release() = 0; // Destroy instance
virtual bool DrawBegin(Rect &viewport) = 0; // Prepare for drawing. Viewport may be changed(if client area of window was changed, it will be set to new client area). Should always be called before start drawing. It is done automatically in default form implementation
virtual bool DrawEnd() = 0; // Clean up after drawing. Should be called after all drawings. It is called automatically by default form implementation
virtual bool Present() = 0; // Draw to screen. Render target should be set to nullptr
virtual IRenderer *CreateInstance() = 0; // Create same class object(without initializing, with same constructor parameters - double buffering and multisampling if supported)
virtual bool PushMask(ITexture *mask, const Matrix &matrix) = 0; // Add mask in list. The matrix should be relative to prev mask. Texture is unchanged. Alpha channel of masks is used for clipping
virtual void PopMask() = 0; // Delete last added masking texture. Texture is unchanged
// Since 6.0.0
virtual void RestoreState() = 0; // Restore state(VAO, VBO, Program, Program subroutines, ...)
// Since 7.0.0
virtual bool BeginSplineLimitation( // Start limiting primitive drawing to the area between specified(by it's control points) cubic bezier splines. Return false if not supported or invalid arguments are used. Only pixels lying between splines will be drawn
const CUBIC_BEZIER_SPLINE &spline1, // First spline
const CUBIC_BEZIER_SPLINE &spline2, // Second spline
const bool apply_to_y_direction) = 0; // Whether the limitation will be applied in Y or X direction
virtual bool EndSplineLimitation() = 0; // Remove limitation by splines set by method above
// Fill entire area of current render target
virtual void Clear() = 0; // Clear with current clear color. Used in form rendering
virtual void Clear(const Color &color) = 0; // Clear with specified color. Clear color is unchanged after it. Use it for texture clean(when render target is texture)
virtual void Line( // Draw line
const PointF &p1, // Start point
const PointF &p2, // End point
const Color &color, // Color
const BLOCK *block) = 0; // Clipping block. Use nullptr if clipping is not required
virtual void Line( // Draw line with transformation
const PointF &p1, // Start point
const PointF &p2, // End point
const Color &color, // Color
const Matrix &m, // Transformation matrix
const BLOCK *block) = 0; // Clipping block. Use nullptr if clipping is not required
virtual void Line( // Draw line with gradiental filling
const PointF &p1, // Start point
const PointF &p2, // End point
const Color &c1, // Start point color
const Color &c2, // End point color
const BLOCK *block) = 0; // Clipping block. Use nullptr if clipping is not required
virtual void Line( // Draw line with gradiental filling and transformation
const PointF &p1, // Start point
const PointF &p2, // End point
const Color &c1, // Start point color
const Color &c2, // End point color
const Matrix &m, // Transformation matrix
const BLOCK *block) = 0; // Clipping block. Use nullptr if clipping is not required
// Since 3.0.0
virtual void Line( // Draw masked line
const PointF &p1, // Start point
const PointF &p2, // End point
const Color &color, // Color
const BLOCK *block, // Clipping block. Use nullptr if clipping is not required
const unsigned int bitmask) = 0; // 32-bit binary mask where 1 - draw, 0 - not draw. Calculated starting from start point. Uses distance from p1 to calculate current bit
virtual void Line( // Draw masked line with transformation
const PointF &p1, // Start point
const PointF &p2, // End point
const Color &color, // Color
const Matrix &m, // Transformation matrix
const BLOCK *block, // Clipping block. Use nullptr if clipping is not required
const unsigned int bitmask) = 0; // 32-bit binary mask where 1 - draw, 0 - not draw. Calculated starting from start point. Uses distance from p1 to calculate current bit
virtual void Line( // Draw masked line with gradiental filling
const PointF &p1, // Start point
const PointF &p2, // End point
const Color &c1, // Start point color
const Color &c2, // End point color
const BLOCK *block, // Clipping block. Use nullptr if clipping is not required
const unsigned int bitmask) = 0; // 32-bit binary mask where 1 - draw, 0 - not draw. Calculated starting from start point. Uses distance from p1 to calculate current bit
virtual void Line( // Draw masked line with gradiental filling and transformation
const PointF &p1, // Start point
const PointF &p2, // End point
const Color &c1, // Start point color
const Color &c2, // End point color
const Matrix &m, // Transformation matrix
const BLOCK *block, // Clipping block. Use nullptr if clipping is not required
const unsigned int bitmask) = 0; // 32-bit binary mask where 1 - draw, 0 - not draw. Calculated starting from start point. Uses distance from p1 to calculate current bit
// Since 7.0.0
virtual void Line( // Draw line
const PointF &p1, // Start point
const PointF &p2, // End point
const Color &color, // Color
const BLOCK *block, // Clipping block. Use nullptr if clipping is not required
ITexture *mask) = 0; // Mask to be applied when drawing. Only alpha channel is used
virtual void Line( // Draw line with transformation
const PointF &p1, // Start point
const PointF &p2, // End point
const Color &color, // Color
const Matrix &m, // Transformation matrix
const BLOCK *block, // Clipping block. Use nullptr if clipping is not required
ITexture *mask) = 0; // Mask to be applied when drawing. Only alpha channel is used
virtual void Line( // Draw line with gradiental filling
const PointF &p1, // Start point
const PointF &p2, // End point
const Color &c1, // Start point color
const Color &c2, // End point color
const BLOCK *block, // Clipping block. Use nullptr if clipping is not required
ITexture *mask) = 0; // Mask to be applied when drawing. Only alpha channel is used
virtual void Line( // Draw line with gradiental filling and transformation
const PointF &p1, // Start point
const PointF &p2, // End point
const Color &c1, // Start point color
const Color &c2, // End point color
const Matrix &m, // Transformation matrix
const BLOCK *block, // Clipping block. Use nullptr if clipping is not required
ITexture *mask) = 0; // Mask to be applied when drawing. Only alpha channel is used
virtual void Line( // Draw masked line
const PointF &p1, // Start point
const PointF &p2, // End point
const Color &color, // Color
const BLOCK *block, // Clipping block. Use nullptr if clipping is not required
const unsigned int bitmask, // 32-bit binary mask where 1 - draw, 0 - not draw. Calculated starting from start point. Uses distance from p1 to calculate current bit
ITexture *mask) = 0; // Mask to be applied when drawing. Only alpha channel is used
virtual void Line( // Draw masked line with transformation
const PointF &p1, // Start point
const PointF&p2, // End point
const Color &color, // Color
const Matrix &m, // Transformation matrix
const BLOCK *block, // Clipping block. Use nullptr if clipping is not required
const unsigned int bitmask, // 32-bit binary mask where 1 - draw, 0 - not draw. Calculated starting from start point. Uses distance from p1 to calculate current bit
ITexture *mask) = 0; // Mask to be applied when drawing. Only alpha channel is used
virtual void Line( // Draw masked line with gradiental filling
const PointF &p1, // Start point
const PointF &p2, // End point
const Color &c1, // Start point color
const Color &c2, // End point color
const BLOCK *block, // Clipping block. Use nullptr if clipping is not required
const unsigned int bitmask, // 32-bit binary mask where 1 - draw, 0 - not draw. Calculated starting from start point. Uses distance from p1 to calculate current bit
ITexture *mask) = 0; // Mask to be applied when drawing. Only alpha channel is used
virtual void Line( // Draw masked line with gradiental filling and transformation
const PointF &p1, // Start point
const PointF &p2, // End point
const Color &c1, // Start point color
const Color &c2, // End point color
const Matrix &m, // Transformation matrix
const BLOCK *block, // Clipping block. Use nullptr if clipping is not required
const unsigned int bitmask, // 32-bit binary mask where 1 - draw, 0 - not draw. Calculated starting from start point. Uses distance from p1 to calculate current bit
ITexture *mask) = 0; // Mask to be applied when drawing. Only alpha channel is used
virtual void Lines( // Draw lines
const std::vector<PointF> &points, // Line points
const Color &color, // Color of all lines
const bool loop, // Whether to draw line from last to first one(close the shape)
const BLOCK *block) = 0; // Clipping block. Use nullptr if clipping is not required
virtual void Lines( // Draw lines with transformation
const std::vector<PointF> &points, // Line points
const Color &color, // Color of all lines
const bool loop, // Whether to draw line from last to first one(close the shape)
const Matrix &m, // Transformation matrix
const BLOCK *block) = 0; // Clipping block. Use nullptr if clipping is not required
// Since 3.0.0
virtual void Lines( // Draw masked lines
const std::vector<PointF> &points, // Line points
const Color &color, // Color of all lines
const bool loop, // Whether to draw line from last to first one(close the shape)
const BLOCK *block, // Clipping block. Use nullptr if clipping is not required
const unsigned int bitmask) = 0; // 32-bit binary mask where 1 - draw, 0 - not draw. Calculated starting from first point. Uses distance from first point to calculate current bit
virtual void Lines( // Draw masked lines with transformation
const std::vector<PointF> &points, // Line points
const Color &color, // Color of all lines
const bool loop, // Whether to draw line from last to first one(close the shape)
const Matrix &m, // Transformation matrix
const BLOCK *block, // Clipping block. Use nullptr if clipping is not required
const unsigned int bitmask) = 0; // 32-bit binary mask where 1 - draw, 0 - not draw. Calculated starting from first point. Uses distance from first point to calculate current bit
// Since 7.0.0
virtual void Lines( // Draw lines
const std::vector<PointF> &points, // Line points
const Color &color, // Color of all lines
const bool loop, // Whether to draw line from last to first one(close the shape)
const BLOCK *block, // Clipping block. Use nullptr if clipping is not required
ITexture *mask) = 0; // Mask to be applied when drawing. Only alpha channel is used
virtual void Lines( // Draw lines with transformation
const std::vector<PointF> &points, // Line points
const Color &color, // Color of all lines
const bool loop, // Whether to draw line from last to first one(close the shape)
const Matrix &m, // Transformation matrix
const BLOCK *block, // Clipping block. Use nullptr if clipping is not required
ITexture *mask) = 0; // Mask to be applied when drawing. Only alpha channel is used
virtual void Lines( // Draw masked lines
const std::vector<PointF> &points, // Line points
const Color &color, // Color of all lines
const bool loop, // Whether to draw line from last to first one(close the shape)
const BLOCK *block, // Clipping block. Use nullptr if clipping is not required
const unsigned int bitmask, // 32-bit binary mask where 1 - draw, 0 - not draw. Calculated starting from first point. Uses distance from first point to calculate current bit
ITexture *mask) = 0; // Mask to be applied when drawing. Only alpha channel is used
virtual void Lines( // Draw masked lines with transformation
const std::vector<PointF> &points, // Line points
const Color &color, // Color of all lines
const bool loop, // Whether to draw line from last to first one(close the shape)
const Matrix &m, // Transformation matrix
const BLOCK *block, // Clipping block. Use nullptr if clipping is not required
const unsigned int bitmask, // 32-bit binary mask where 1 - draw, 0 - not draw. Calculated starting from first point. Uses distance from first point to calculate current bit
ITexture *mask) = 0; // Mask to be applied when drawing. Only alpha channel is used
virtual void Triangle( // Draw solid triangle
const PointF &p1, // 1st vertex
const PointF &p2, // 2nd vertex
const PointF &p3, // 3rd vertex
const Color &color, // Triangle color
const BLOCK *block) = 0; // Clipping block. Use nullptr if clipping is not required
virtual void Triangle( // Draw solid triangle with transformation
const PointF &p1, // 1st vertex
const PointF &p2, // 2nd vertex
const PointF &p3, // 3rd vertex
const Color &color, // Triangle color
const Matrix &m, // Transformation matrix
const BLOCK *block) = 0; // Clipping block. Use nullptr if clipping is not required
virtual void Triangle( // Draw gradientally filled triangle
const PointF &p1, // 1st vertex
const PointF &p2, // 2nd vertex
const PointF &p3, // 3rd vertex
const Color &c1, // 1st vertex color
const Color &c2, // 2nd vertex color
const Color &c3, // 3rd vertex color
const BLOCK *block) = 0; // Clipping block. Use nullptr if clipping is not required
virtual void Triangle( // Draw gradientally filled triangle with transformation
const PointF &p1, // 1st vertex
const PointF &p2, // 2nd vertex
const PointF &p3, // 3rd vertex
const Color &c1, // 1st vertex color
const Color &c2, // 2nd vertex color
const Color &c3, // 3rd vertex color
const Matrix &m, // Transformation matrix
const BLOCK *block) = 0; // Clipping block. Use nullptr if clipping is not required
// Since 3.0.0
virtual void Triangle( // Draw masked solid triangle
const PointF &p1, // 1st vertex
const PointF &p2, // 2nd vertex
const PointF &p3, // 3rd vertex
const Color &color, // Triangle color
const BLOCK *block, // Clipping block. Use nullptr if clipping is not required
const unsigned int bitmask_x, // 32-bit binary mask for X direction where 1 - draw, 0 - not draw
const unsigned int bitmask_y, // 32-bit binary mask for Y direction where 1 - draw, 0 - not draw
const bool bitmask_form) = 0; // How to start calculate coordinates for binary masking. If it is true, the form coordinates are used. If it is false, the primitive coordinates are used(without transformations)
virtual void Triangle( // Draw masked solid triangle with transformation
const PointF &p1, // 1st vertex
const PointF &p2, // 2nd vertex
const PointF &p3, // 3rd vertex
const Color &color, // Triangle color
const Matrix &m, // Transformation matrix
const BLOCK *block, // Clipping block. Use nullptr if clipping is not required
const unsigned int bitmask_x, // 32-bit binary mask for X direction where 1 - draw, 0 - not draw
const unsigned int bitmask_y, // 32-bit binary mask for Y direction where 1 - draw, 0 - not draw
const bool bitmask_form) = 0; // How to start calculate coordinates for binary masking. If it is true, the form coordinates are used. If it is false, the primitive coordinates are used(without transformations)
virtual void Triangle( // Draw masked gradientally filled triangle
const PointF &p1, // 1st vertex
const PointF &p2, // 2nd vertex
const PointF &p3, // 3rd vertex
const Color &c1, // 1st vertex color
const Color &c2, // 2nd vertex color
const Color &c3, // 3rd vertex color
const BLOCK *block, // Clipping block. Use nullptr if clipping is not required
const unsigned int bitmask_x, // 32-bit binary mask for X direction where 1 - draw, 0 - not draw
const unsigned int bitmask_y, // 32-bit binary mask for Y direction where 1 - draw, 0 - not draw
const bool bitmask_form) = 0; // How to start calculate coordinates for binary masking. If it is true, the form coordinates are used. If it is false, the primitive coordinates are used(without transformations)
virtual void Triangle( // Draw masked gradientally filled triangle with transformation
const PointF &p1, // 1st vertex
const PointF &p2, // 2nd vertex
const PointF &p3, // 3rd vertex
const Color &c1, // 1st vertex color
const Color &c2, // 2nd vertex color
const Color &c3, // 3rd vertex color
const Matrix &m, // Transformation matrix
const BLOCK *block, // Clipping block. Use nullptr if clipping is not required
const unsigned int bitmask_x, // 32-bit binary mask for X direction where 1 - draw, 0 - not draw
const unsigned int bitmask_y, // 32-bit binary mask for Y direction where 1 - draw, 0 - not draw
const bool bitmask_form) = 0; // How to start calculate coordinates for binary masking. If it is true, the form coordinates are used. If it is false, the primitive coordinates are used(without transformations)
// Since 7.0.0
virtual void Triangle( // Draw solid triangle
const PointF &p1, // 1st vertex
const PointF &p2, // 2nd vertex
const PointF &p3, // 3rd vertex
const Color &color, // Triangle color
const BLOCK *block, // Clipping block. Use nullptr if clipping is not required
ITexture *mask) = 0; // Mask to be applied when drawing. Only alpha channel is used
virtual void Triangle( // Draw solid triangle with transformation
const PointF &p1, // 1st vertex
const PointF &p2, // 2nd vertex
const PointF &p3, // 3rd vertex
const Color &color, // Triangle color
const Matrix &m, // Transformation matrix
const BLOCK *block, // Clipping block. Use nullptr if clipping is not required
ITexture *mask) = 0; // Mask to be applied when drawing. Only alpha channel is used
virtual void Triangle( // Draw gradientally filled triangle
const PointF &p1, // 1st vertex
const PointF &p2, // 2nd vertex
const PointF &p3, // 3rd vertex
const Color &c1, // 1st vertex color
const Color &c2, // 2nd vertex color
const Color &c3, // 3rd vertex color
const BLOCK *block, // Clipping block. Use nullptr if clipping is not required
ITexture *mask) = 0; // Mask to be applied when drawing. Only alpha channel is used
virtual void Triangle( // Draw gradientally filled triangle with transformation
const PointF &p1, // 1st vertex
const PointF &p2, // 2nd vertex
const PointF &p3, // 3rd vertex
const Color &c1, // 1st vertex color
const Color &c2, // 2nd vertex color
const Color &c3, // 3rd vertex color
const Matrix &m, // Transformation matrix
const BLOCK *block, // Clipping block. Use nullptr if clipping is not required
ITexture *mask) = 0; // Mask to be applied when drawing. Only alpha channel is used
virtual void Triangle( // Draw masked solid triangle
const PointF &p1, // 1st vertex
const PointF &p2, // 2nd vertex
const PointF &p3, // 3rd vertex
const Color &color, // Triangle color
const BLOCK *block, // Clipping block. Use nullptr if clipping is not required
const unsigned int bitmask_x, // 32-bit binary mask for X direction where 1 - draw, 0 - not draw
const unsigned int bitmask_y, // 32-bit binary mask for Y direction where 1 - draw, 0 - not draw
const bool bitmask_form, // How to start calculate coordinates for binary masking. If it is true, the form coordinates are used. If it is false, the primitive coordinates are used(without transformations)
ITexture *mask) = 0; // Mask to be applied when drawing. Only alpha channel is used
virtual void Triangle( // Draw masked solid triangle with transformation
const PointF &p1, // 1st vertex
const PointF &p2, // 2nd vertex
const PointF &p3, // 3rd vertex
const Color &color, // Triangle color
const Matrix &m, // Transformation matrix
const BLOCK *block, // Clipping block. Use nullptr if clipping is not required
const unsigned int bitmask_x, // 32-bit binary mask for X direction where 1 - draw, 0 - not draw
const unsigned int bitmask_y, // 32-bit binary mask for Y direction where 1 - draw, 0 - not draw
const bool bitmask_form, // How to start calculate coordinates for binary masking. If it is true, the form coordinates are used. If it is false, the primitive coordinates are used(without transformations)
ITexture *mask) = 0; // Mask to be applied when drawing. Only alpha channel is used
virtual void Triangle( // Draw masked gradientally filled triangle
const PointF &p1, // 1st vertex
const PointF &p2, // 2nd vertex
const PointF &p3, // 3rd vertex
const Color &c1, // 1st vertex color
const Color &c2, // 2nd vertex color
const Color &c3, // 3rd vertex color
const BLOCK *block, // Clipping block. Use nullptr if clipping is not required
const unsigned int bitmask_x, // 32-bit binary mask for X direction where 1 - draw, 0 - not draw
const unsigned int bitmask_y, // 32-bit binary mask for Y direction where 1 - draw, 0 - not draw
const bool bitmask_form, // How to start calculate coordinates for binary masking. If it is true, the form coordinates are used. If it is false, the primitive coordinates are used(without transformations)
ITexture *mask) = 0; // Mask to be applied when drawing. Only alpha channel is used
virtual void Triangle( // Draw masked gradientally filled triangle with transformation
const PointF &p1, // 1st vertex
const PointF &p2, // 2nd vertex
const PointF &p3, // 3rd vertex
const Color &c1, // 1st vertex color
const Color &c2, // 2nd vertex color
const Color &c3, // 3rd vertex color
const Matrix &m, // Transformation matrix
const BLOCK *block, // Clipping block. Use nullptr if clipping is not required
const unsigned int bitmask_x, // 32-bit binary mask for X direction where 1 - draw, 0 - not draw
const unsigned int bitmask_y, // 32-bit binary mask for Y direction where 1 - draw, 0 - not draw
const bool bitmask_form, // How to start calculate coordinates for binary masking. If it is true, the form coordinates are used. If it is false, the primitive coordinates are used(without transformations)
ITexture *mask) = 0; // Mask to be applied when drawing. Only alpha channel is used
virtual void Rectangle( // Draw solid rectangle
const RectF &rect, // Rectangle
const Color &color, // Rectangle color
const BLOCK *block) = 0; // Clipping block. Use nullptr if clipping is not required
virtual void Rectangle( // Draw solid rectangle with transformation
const RectF &rect, // Rectangle
const Color &color, // Rectangle color
const Matrix &m, // Transformation matrix
const BLOCK *block) = 0; // Clipping block. Use nullptr if clipping is not required
virtual void Rectangle( // Draw gradientally filled rectangle
const RectF &rect, // Rectangle
const Color &c1, // Left-top vertex color
const Color &c2, // Right-top vertex color
const Color &c3, // Right-bottom vertex color
const Color &c4, // Left-bottom vertex color
const BLOCK *block) = 0; // Clipping block. Use nullptr if clipping is not required
virtual void Rectangle( // Draw gradientally filled rectangle with transformation
const RectF &rect, // Rectangle
const Color &c1, // Left-top vertex color
const Color &c2, // Right-top vertex color
const Color &c3, // Right-bottom vertex color
const Color &c4, // Left-bottom vertex color
const Matrix &m, // Transformation matrix
const BLOCK *block) = 0; // Clipping block. Use nullptr if clipping is not required
// Since 3.0.0
virtual void Rectangle( // Draw masked solid rectangle
const RectF &rect, // Rectangle
const Color &color, // Rectangle color
const BLOCK *block, // Clipping block. Use nullptr if clipping is not required
const unsigned int bitmask_x, // 32-bit binary mask for X direction where 1 - draw, 0 - not draw
const unsigned int bitmask_y, // 32-bit binary mask for Y direction where 1 - draw, 0 - not draw
const bool bitmask_form) = 0; // How to start calculate coordinates for binary masking. If it is true, the form coordinates are used. If it is false, the primitive coordinates are used(without transformations)
virtual void Rectangle( // Draw masked solid rectangle with transformation
const RectF &rect, // Rectangle
const Color &color, // Rectangle color
const Matrix &m, // Transformation matrix
const BLOCK *block, // Clipping block. Use nullptr if clipping is not required
const unsigned int bitmask_x, // 32-bit binary mask for X direction where 1 - draw, 0 - not draw
const unsigned int bitmask_y, // 32-bit binary mask for Y direction where 1 - draw, 0 - not draw
const bool bitmask_form) = 0; // How to start calculate coordinates for binary masking. If it is true, the form coordinates are used. If it is false, the primitive coordinates are used(without transformations)
virtual void Rectangle( // Draw masked gradientally filled rectangle
const RectF &rect, // Rectangle
const Color &c1, // Left-top vertex color
const Color &c2, // Right-top vertex color
const Color &c3, // Right-bottom vertex color
const Color &c4, // Left-bottom vertex color
const BLOCK *block, // Clipping block. Use nullptr if clipping is not required
const unsigned int bitmask_x, // 32-bit binary mask for X direction where 1 - draw, 0 - not draw
const unsigned int bitmask_y, // 32-bit binary mask for Y direction where 1 - draw, 0 - not draw
const bool bitmask_form) = 0; // How to start calculate coordinates for binary masking. If it is true, the form coordinates are used. If it is false, the primitive coordinates are used(without transformations)
virtual void Rectangle( // Draw masked gradientally filled rectangle with transformation
const RectF &rect, // Rectangle
const Color &c1, // Left-top vertex color
const Color &c2, // Right-top vertex color
const Color &c3, // Right-bottom vertex color
const Color &c4, // Left-bottom vertex color
const Matrix &m, // Transformation matrix
const BLOCK *block, // Clipping block. Use nullptr if clipping is not required
const unsigned int bitmask_x, // 32-bit binary mask for X direction where 1 - draw, 0 - not draw
const unsigned int bitmask_y, // 32-bit binary mask for Y direction where 1 - draw, 0 - not draw
const bool bitmask_form) = 0; // How to start calculate coordinates for binary masking. If it is true, the form coordinates are used. If it is false, the primitive coordinates are used(without transformations)
// Since 7.0.0
virtual void Rectangle( // Draw solid rectangle
const RectF &rect, // Rectangle
const Color &color, // Rectangle color
const BLOCK *block, // Clipping block. Use nullptr if clipping is not required
ITexture *mask) = 0; // Mask to be applied when drawing. Only alpha channel is used
virtual void Rectangle( // Draw solid rectangle with transformation
const RectF &rect, // Rectangle
const Color &color, // Rectangle color
const Matrix &m, // Transformation matrix
const BLOCK *block, // Clipping block. Use nullptr if clipping is not required
ITexture *mask) = 0; // Mask to be applied when drawing. Only alpha channel is used
virtual void Rectangle( // Draw gradientally filled rectangle
const RectF &rect, // Rectangle
const Color &c1, // Left-top vertex color
const Color &c2, // Right-top vertex color
const Color &c3, // Right-bottom vertex color
const Color &c4, // Left-bottom vertex color
const BLOCK *block, // Clipping block. Use nullptr if clipping is not required
ITexture *mask) = 0; // Mask to be applied when drawing. Only alpha channel is used
virtual void Rectangle( // Draw gradientally filled rectangle with transformation
const RectF &rect, // Rectangle
const Color &c1, // Left-top vertex color
const Color &c2, // Right-top vertex color
const Color &c3, // Right-bottom vertex color
const Color &c4, // Left-bottom vertex color
const Matrix &m, // Transformation matrix
const BLOCK *block, // Clipping block. Use nullptr if clipping is not required
ITexture *mask) = 0; // Mask to be applied when drawing. Only alpha channel is used
virtual void Rectangle( // Draw masked solid rectangle
const RectF &rect, // Rectangle
const Color &color, // Rectangle color
const BLOCK *block, // Clipping block. Use nullptr if clipping is not required
const unsigned int bitmask_x, // 32-bit binary mask for X direction where 1 - draw, 0 - not draw
const unsigned int bitmask_y, // 32-bit binary mask for Y direction where 1 - draw, 0 - not draw
const bool bitmask_form, // How to start calculate coordinates for binary masking. If it is true, the form coordinates are used. If it is false, the primitive coordinates are used(without transformations)
ITexture *mask) = 0; // Mask to be applied when drawing. Only alpha channel is used
virtual void Rectangle( // Draw masked solid rectangle with transformation
const RectF &rect, // Rectangle
const Color &color, // Rectangle color
const Matrix &m, // Transformation matrix
const BLOCK *block, // Clipping block. Use nullptr if clipping is not required
const unsigned int bitmask_x, // 32-bit binary mask for X direction where 1 - draw, 0 - not draw
const unsigned int bitmask_y, // 32-bit binary mask for Y direction where 1 - draw, 0 - not draw
const bool bitmask_form, // How to start calculate coordinates for binary masking. If it is true, the form coordinates are used. If it is false, the primitive coordinates are used(without transformations)
ITexture *mask) = 0; // Mask to be applied when drawing. Only alpha channel is used
virtual void Rectangle( // Draw masked gradientally filled rectangle
const RectF &rect, // Rectangle
const Color &c1, // Left-top vertex color
const Color &c2, // Right-top vertex color
const Color &c3, // Right-bottom vertex color
const Color &c4, // Left-bottom vertex color
const BLOCK *block, // Clipping block. Use nullptr if clipping is not required
const unsigned int bitmask_x, // 32-bit binary mask for X direction where 1 - draw, 0 - not draw
const unsigned int bitmask_y, // 32-bit binary mask for Y direction where 1 - draw, 0 - not draw
const bool bitmask_form, // How to start calculate coordinates for binary masking. If it is true, the form coordinates are used. If it is false, the primitive coordinates are used(without transformations)
ITexture *mask) = 0; // Mask to be applied when drawing. Only alpha channel is used
virtual void Rectangle( // Draw masked gradientally filled rectangle with transformation
const RectF &rect, // Rectangle
const Color &c1, // Left-top vertex color
const Color &c2, // Right-top vertex color
const Color &c3, // Right-bottom vertex color
const Color &c4, // Left-bottom vertex color
const Matrix &m, // Transformation matrix
const BLOCK *block, // Clipping block. Use nullptr if clipping is not required
const unsigned int bitmask_x, // 32-bit binary mask for X direction where 1 - draw, 0 - not draw
const unsigned int bitmask_y, // 32-bit binary mask for Y direction where 1 - draw, 0 - not draw
const bool bitmask_form, // How to start calculate coordinates for binary masking. If it is true, the form coordinates are used. If it is false, the primitive coordinates are used(without transformations)
ITexture *mask) = 0; // Mask to be applied when drawing. Only alpha channel is used
virtual void Gradient( // Draw gradient
const RectF &rect, // Rectangle
nitisa::Gradient &g, // Gradient
const BLOCK *block) = 0; // Clipping block. Use nullptr if clipping is not required
virtual void Gradient( // Draw gradient with transformation
const RectF &rect, // Rectangle
nitisa::Gradient &g, // Gradient
const Matrix &m, // Transformation matrix
const BLOCK *block) = 0; // Clipping block. Use nullptr if clipping is not required
// Since 3.0.0
virtual void Gradient( // Draw masked gradient
const RectF &rect, // Rectangle
nitisa::Gradient &g, // Gradient
const BLOCK *block, // Clipping block. Use nullptr if clipping is not required
const unsigned int bitmask_x, // 32-bit binary mask for X direction where 1 - draw, 0 - not draw
const unsigned int bitmask_y, // 32-bit binary mask for Y direction where 1 - draw, 0 - not draw
const bool bitmask_form) = 0; // How to start calculate coordinates for binary masking. If it is true, the form coordinates are used. If it is false, the primitive coordinates are used(without transformations)
virtual void Gradient( // Draw masked gradient with transformation
const RectF &rect, // Rectangle
nitisa::Gradient &g, // Gradient
const Matrix &m, // Transformation matrix
const BLOCK *block, // Clipping block. Use nullptr if clipping is not required
const unsigned int bitmask_x, // 32-bit binary mask for X direction where 1 - draw, 0 - not draw
const unsigned int bitmask_y, // 32-bit binary mask for Y direction where 1 - draw, 0 - not draw
const bool bitmask_form) = 0; // How to start calculate coordinates for binary masking. If it is true, the form coordinates are used. If it is false, the primitive coordinates are used(without transformations)
// Since 7.0.0
virtual void Gradient( // Draw gradient
const RectF &rect, // Rectangle
nitisa::Gradient &g, // Gradient
const BLOCK *block, // Clipping block. Use nullptr if clipping is not required
ITexture *mask) = 0; // Mask to be applied when drawing. Only alpha channel is used
virtual void Gradient( // Draw gradient with transformation
const RectF &rect, // Rectangle
nitisa::Gradient &g, // Gradient
const Matrix &m, // Transformation matrix
const BLOCK *block, // Clipping block. Use nullptr if clipping is not required
ITexture *mask) = 0; // Mask to be applied when drawing. Only alpha channel is used
virtual void Gradient( // Draw masked gradient
const RectF &rect, // Rectangle
nitisa::Gradient &g, // Gradient
const BLOCK *block, // Clipping block. Use nullptr if clipping is not required
const unsigned int bitmask_x, // 32-bit binary mask for X direction where 1 - draw, 0 - not draw
const unsigned int bitmask_y, // 32-bit binary mask for Y direction where 1 - draw, 0 - not draw
const bool bitmask_form, // How to start calculate coordinates for binary masking. If it is true, the form coordinates are used. If it is false, the primitive coordinates are used(without transformations)
ITexture *mask) = 0; // Mask to be applied when drawing. Only alpha channel is used
virtual void Gradient( // Draw masked gradient with transformation
const RectF &rect, // Rectangle
nitisa::Gradient &g, // Gradient
const Matrix &m, // Transformation matrix
const BLOCK *block, // Clipping block. Use nullptr if clipping is not required
const unsigned int bitmask_x, // 32-bit binary mask for X direction where 1 - draw, 0 - not draw
const unsigned int bitmask_y, // 32-bit binary mask for Y direction where 1 - draw, 0 - not draw
const bool bitmask_form, // How to start calculate coordinates for binary masking. If it is true, the form coordinates are used. If it is false, the primitive coordinates are used(without transformations)
ITexture *mask) = 0; // Mask to be applied when drawing. Only alpha channel is used
virtual void Image( // Draw image at specified position
ITexture *image, // Image
const PointF &p, // Position where to draw
const float transparency, // Transparency(0..1)
const BLOCK *block) = 0; // Clipping block. Use nullptr if clipping is not required
virtual void Image( // Draw image with transformation
ITexture *image, // Image
const Matrix &m, // Transformation matrix
const float transparency, // Transparency(0..1)
const BLOCK *block) = 0; // Clipping block. Use nullptr if clipping is not required
virtual void Image( // Draw image part at specified position
ITexture *image, // Image
const RectF &part, // Part to be drawn
const PointF &p, // Position where to draw
const float transparency, // Transparency(0..1)
const BLOCK *block) = 0; // Clipping block. Use nullptr if clipping is not required
virtual void Image( // Draw image part with transformation
ITexture *image, // Image
const RectF &part, // Part to be drawn
const Matrix &m, // Transformation matrix
const float transparency, // Transparency(0..1)
const BLOCK *block) = 0; // Clipping block. Use nullptr if clipping is not required
// Since 3.0.0
virtual void Image( // Draw masked image at specified position
ITexture *image, // Image
const PointF &p, // Position where to draw
const float transparency, // Transparency(0..1)
const BLOCK *block, // Clipping block. Use nullptr if clipping is not required
const unsigned int bitmask_x, // 32-bit binary mask for X direction where 1 - draw, 0 - not draw
const unsigned int bitmask_y, // 32-bit binary mask for Y direction where 1 - draw, 0 - not draw
const bool bitmask_form) = 0; // How to start calculate coordinates for binary masking. If it is true, the form coordinates are used. If it is false, the primitive coordinates are used(without transformations)
virtual void Image( // Draw masked image with transformation
ITexture *image, // Image
const Matrix &m, // Transformation matrix
const float transparency, // Transparency(0..1)
const BLOCK *block, // Clipping block. Use nullptr if clipping is not required
const unsigned int bitmask_x, // 32-bit binary mask for X direction where 1 - draw, 0 - not draw
const unsigned int bitmask_y, // 32-bit binary mask for Y direction where 1 - draw, 0 - not draw
const bool bitmask_form) = 0; // How to start calculate coordinates for binary masking. If it is true, the form coordinates are used. If it is false, the primitive coordinates are used(without transformations)
virtual void Image( // Draw masked image part at specified position
ITexture *image, // Image
const RectF &part, // Part to be drawn
const PointF &p, // Position where to draw
const float transparency, // Transparency(0..1)
const BLOCK *block, // Clipping block. Use nullptr if clipping is not required
const unsigned int bitmask_x, // 32-bit binary mask for X direction where 1 - draw, 0 - not draw
const unsigned int bitmask_y, // 32-bit binary mask for Y direction where 1 - draw, 0 - not draw
const bool bitmask_form) = 0; // How to start calculate coordinates for binary masking. If it is true, the form coordinates are used. If it is false, the primitive coordinates are used(without transformations)
virtual void Image( // Draw masked image part with transformation
ITexture *image, // Image
const RectF &part, // Part to be drawn
const Matrix &m, // Transformation matrix
const float transparency, // Transparency(0..1)
const BLOCK *block, // Clipping block. Use nullptr if clipping is not required
const unsigned int bitmask_x, // 32-bit binary mask for X direction where 1 - draw, 0 - not draw
const unsigned int bitmask_y, // 32-bit binary mask for Y direction where 1 - draw, 0 - not draw
const bool bitmask_form) = 0; // How to start calculate coordinates for binary masking. If it is true, the form coordinates are used. If it is false, the primitive coordinates are used(without transformations)
// Since 7.0.0
virtual void Image( // Draw image at specified position
ITexture *image, // Image
const PointF &p, // Position where to draw
const float transparency, // Transparency(0..1)
const BLOCK *block, // Clipping block. Use nullptr if clipping is not required
ITexture *mask) = 0; // Mask to be applied when drawing. Only alpha channel is used
virtual void Image( // Draw image with transformation
ITexture *image, // Image
const Matrix &m, // Transformation matrix
const float transparency, // Transparency(0..1)
const BLOCK *block, // Clipping block. Use nullptr if clipping is not required
ITexture *mask) = 0; // Mask to be applied when drawing. Only alpha channel is used
virtual void Image( // Draw image part at specified position
ITexture *image, // Image
const RectF &part, // Part to be drawn
const PointF &p, // Position where to draw
const float transparency, // Transparency(0..1)
const BLOCK *block, // Clipping block. Use nullptr if clipping is not required
ITexture *mask) = 0; // Mask to be applied when drawing. Only alpha channel is used
virtual void Image( // Draw image part with transformation
ITexture *image, // Image
const RectF &part, // Part to be drawn
const Matrix &m, // Transformation matrix
const float transparency, // Transparency(0..1)
const BLOCK *block, // Clipping block. Use nullptr if clipping is not required
ITexture *mask) = 0; // Mask to be applied when drawing. Only alpha channel is used
virtual void Image( // Draw masked image at specified position
ITexture *image, // Image
const PointF &p, // Position where to draw
const float transparency, // Transparency(0..1)
const BLOCK *block, // Clipping block. Use nullptr if clipping is not required
const unsigned int bitmask_x, // 32-bit binary mask for X direction where 1 - draw, 0 - not draw
const unsigned int bitmask_y, // 32-bit binary mask for Y direction where 1 - draw, 0 - not draw
const bool bitmask_form, // How to start calculate coordinates for binary masking. If it is true, the form coordinates are used. If it is false, the primitive coordinates are used(without transformations)
ITexture *mask) = 0; // Mask to be applied when drawing. Only alpha channel is used
virtual void Image( // Draw masked image with transformation
ITexture *image, // Image
const Matrix &m, // Transformation matrix
const float transparency, // Transparency(0..1)
const BLOCK *block, // Clipping block. Use nullptr if clipping is not required
const unsigned int bitmask_x, // 32-bit binary mask for X direction where 1 - draw, 0 - not draw
const unsigned int bitmask_y, // 32-bit binary mask for Y direction where 1 - draw, 0 - not draw
const bool bitmask_form, // How to start calculate coordinates for binary masking. If it is true, the form coordinates are used. If it is false, the primitive coordinates are used(without transformations)
ITexture *mask) = 0; // Mask to be applied when drawing. Only alpha channel is used
virtual void Image( // Draw masked image part at specified position
ITexture *image, // Image
const RectF &part, // Part to be drawn
const PointF &p, // Position where to draw
const float transparency, // Transparency(0..1)
const BLOCK *block, // Clipping block. Use nullptr if clipping is not required
const unsigned int bitmask_x, // 32-bit binary mask for X direction where 1 - draw, 0 - not draw
const unsigned int bitmask_y, // 32-bit binary mask for Y direction where 1 - draw, 0 - not draw
const bool bitmask_form, // How to start calculate coordinates for binary masking. If it is true, the form coordinates are used. If it is false, the primitive coordinates are used(without transformations)
ITexture *mask) = 0; // Mask to be applied when drawing. Only alpha channel is used
virtual void Image( // Draw masked image part with transformation
ITexture *image, // Image
const RectF &part, // Part to be drawn
const Matrix &m, // Transformation matrix
const float transparency, // Transparency(0..1)
const BLOCK *block, // Clipping block. Use nullptr if clipping is not required
const unsigned int bitmask_x, // 32-bit binary mask for X direction where 1 - draw, 0 - not draw
const unsigned int bitmask_y, // 32-bit binary mask for Y direction where 1 - draw, 0 - not draw
const bool bitmask_form, // How to start calculate coordinates for binary masking. If it is true, the form coordinates are used. If it is false, the primitive coordinates are used(without transformations)
ITexture *mask) = 0; // Mask to be applied when drawing. Only alpha channel is used
virtual void Block( // Draw block
const RectF &block, // Block rectangle
const RectF &border, // Border widthes
const RectF &radius, // Corner radiuses
const BlockColors &colors) = 0; // Part colors(left border, top border, right border, bottom border, internal area, external area)
virtual void Block( // Draw block part visible through specified rectangle
const RectF &rect, // Rectangle to be drawn
const RectF &block, // Block rectangle
const RectF &border, // Border widthes
const RectF &radius, // Corner radiuses
const BlockColors &colors) = 0; // Part colors(left border, top border, right border, bottom border, internal area, external area)
// Since 3.0.0
virtual void Block( // Draw masked block
const RectF &block, // Block rectangle
const RectF &border, // Border widthes
const RectF &radius, // Corner radiuses
const BlockColors &colors, // Part colors(left border, top border, right border, bottom border, internal area, external area)
const unsigned int bitmask_x, // 32-bit binary mask for X direction where 1 - draw, 0 - not draw
const unsigned int bitmask_y, // 32-bit binary mask for Y direction where 1 - draw, 0 - not draw
const bool bitmask_form) = 0; // How to start calculate coordinates for binary masking. If it is true, the form coordinates are used. If it is false, the primitive coordinates are used(without transformations)
virtual void Block( // Draw masked block part visible through specified rectangle
const RectF &rect, // Rectangle to be drawn
const RectF &block, // Block rectangle
const RectF &border, // Border widthes
const RectF &radius, // Corner radiuses
const BlockColors &colors, // Part colors(left border, top border, right border, bottom border, internal area, external area)
const unsigned int bitmask_x, // 32-bit binary mask for X direction where 1 - draw, 0 - not draw
const unsigned int bitmask_y, // 32-bit binary mask for Y direction where 1 - draw, 0 - not draw
const bool bitmask_form) = 0; // How to start calculate coordinates for binary masking. If it is true, the form coordinates are used. If it is false, the primitive coordinates are used(without transformations)
// Since 7.0.0
virtual void Block( // Draw block
const RectF &block, // Block rectangle
const RectF &border, // Border widthes
const RectF &radius, // Corner radiuses
const BlockColors &colors, // Part colors(left border, top border, right border, bottom border, internal area, external area)
ITexture *mask) = 0; // Mask to be applied when drawing. Only alpha channel is used
virtual void Block( // Draw block part visible through specified rectangle
const RectF &rect, // Rectangle to be drawn
const RectF &block, // Block rectangle
const RectF &border, // Border widthes
const RectF &radius, // Corner radiuses
const BlockColors &colors, // Part colors(left border, top border, right border, bottom border, internal area, external area)
ITexture *mask) = 0; // Mask to be applied when drawing. Only alpha channel is used
virtual void Block( // Draw masked block
const RectF &block, // Block rectangle
const RectF &border, // Border widthes
const RectF &radius, // Corner radiuses
const BlockColors &colors, // Part colors(left border, top border, right border, bottom border, internal area, external area)
const unsigned int bitmask_x, // 32-bit binary mask for X direction where 1 - draw, 0 - not draw
const unsigned int bitmask_y, // 32-bit binary mask for Y direction where 1 - draw, 0 - not draw
const bool bitmask_form, // How to start calculate coordinates for binary masking. If it is true, the form coordinates are used. If it is false, the primitive coordinates are used(without transformations)
ITexture *mask) = 0; // Mask to be applied when drawing. Only alpha channel is used
virtual void Block( // Draw masked block part visible through specified rectangle
const RectF &rect, // Rectangle to be drawn
const RectF &block, // Block rectangle
const RectF &border, // Border widthes
const Rect &radius, // Corner radiuses
const BlockColors &colors, // Part colors(left border, top border, right border, bottom border, internal area, external area)
const unsigned int bitmask_x, // 32-bit binary mask for X direction where 1 - draw, 0 - not draw
const unsigned int bitmask_y, // 32-bit binary mask for Y direction where 1 - draw, 0 - not draw
const bool bitmask_form, // How to start calculate coordinates for binary masking. If it is true, the form coordinates are used. If it is false, the primitive coordinates are used(without transformations)
ITexture *mask) = 0; // Mask to be applied when drawing. Only alpha channel is used
virtual void Text( // Draw text at specified position
const String &text, // Text
IPlatformFont *font, // Font
const float distance, // Additional distance between characters
const Color &color, // Color
const PointF &p, // Position
const BLOCK *block) = 0; // Clipping block. Use nullptr if clipping is not required
virtual void Text( // Draw text with transformation
const String &text, // Text
IPlatformFont *font, // Font
const float distance, // Additional distance between characters
const Color &color, // Color
const Matrix &m, // Transformation matrix
const BLOCK *block) = 0; // Clipping block. Use nullptr if clipping is not required
// Since 3.0.0
virtual void Text( // Draw masked text at specified position
const String &text, // Text
IPlatformFont *font, // Font
const float distance, // Additional distance between characters
const Color &color, // Color
const PointF &p, // Position
const BLOCK *block, // Clipping block. Use nullptr if clipping is not required
const unsigned int bitmask_x, // 32-bit binary mask for X direction where 1 - draw, 0 - not draw
const unsigned int bitmask_y, // 32-bit binary mask for Y direction where 1 - draw, 0 - not draw
const bool bitmask_form) = 0; // How to start calculate coordinates for binary masking. If it is true, the form coordinates are used. If it is false, the primitive coordinates are used(without transformations)
virtual void Text( // Draw masked text with transformation
const String &text, // Text
IPlatformFont *font, // Font
const float distance, // Additional distance between characters
const Color &color, // Color
const Matrix &m, // Transformation matrix
const BLOCK *block, // Clipping block. Use nullptr if clipping is not required
const unsigned int bitmask_x, // 32-bit binary mask for X direction where 1 - draw, 0 - not draw
const unsigned int bitmask_y, // 32-bit binary mask for Y direction where 1 - draw, 0 - not draw
const bool bitmask_form) = 0; // How to start calculate coordinates for binary masking. If it is true, the form coordinates are used. If it is false, the primitive coordinates are used(without transformations)
// Since 7.0.0
virtual void Text( // Draw text at specified position
const String &text, // Text
IPlatformFont *font, // Font
const float distance, // Additional distance between characters
const Color &color, // Color
const PointF &p, // Position
const BLOCK *block, // Clipping block. Use nullptr if clipping is not required
ITexture *mask) = 0; // Mask to be applied when drawing. Only alpha channel is used
virtual void Text( // Draw text with transformation
const String &text, // Text
IPlatformFont *font, // Font
const float distance, // Additional distance between characters
const Color &color, // Color
const Matrix &m, // Transformation matrix
const BLOCK *block, // Clipping block. Use nullptr if clipping is not required
ITexture *mask) = 0; // Mask to be applied when drawing. Only alpha channel is used
virtual void Text( // Draw masked text at specified position
const String &text, // Text
IPlatformFont *font, // Font
const float distance, // Additional distance between characters
const Color &color, // Color
const PointF &p, // Position
const BLOCK *block, // Clipping block. Use nullptr if clipping is not required
const unsigned int bitmask_x, // 32-bit binary mask for X direction where 1 - draw, 0 - not draw
const unsigned int bitmask_y, // 32-bit binary mask for Y direction where 1 - draw, 0 - not draw
const bool bitmask_form, // How to start calculate coordinates for binary masking. If it is true, the form coordinates are used. If it is false, the primitive coordinates are used(without transformations)
ITexture *mask) = 0; // Mask to be applied when drawing. Only alpha channel is used
virtual void Text( // Draw masked text with transformation
const String &text, // Text
IPlatformFont *font, // Font
const float distance, // Additional distance between characters
const Color &color, // Color
const Matrix &m, // Transformation matrix
const BLOCK *block, // Clipping block. Use nullptr if clipping is not required
const unsigned int bitmask_x, // 32-bit binary mask for X direction where 1 - draw, 0 - not draw
const unsigned int bitmask_y, // 32-bit binary mask for Y direction where 1 - draw, 0 - not draw
const bool bitmask_form, // How to start calculate coordinates for binary masking. If it is true, the form coordinates are used. If it is false, the primitive coordinates are used(without transformations)
ITexture *mask) = 0; // Mask to be applied when drawing. Only alpha channel is used
virtual void Blur( // Add blur to image
ITexture *image, // Image to be blured
const int radius, // Blur radius(>= 1)
const BLUR_TYPE type) = 0; // Blur type
virtual void Blur( // Blur image without modifying originl one. Store result in target
ITexture *target, // Storage for result image
ITexture *source, // Image which blured representation is required
const int radius, // Blur radius(>= 1)
const BLUR_TYPE type) = 0; // Blur type
// Since 3.0.0
virtual void Blur( // Add masked blur to image
ITexture *image, // Image to be blured
const int radius, // Blur radius(>= 1)
const BLUR_TYPE type, // Blur type
const unsigned int bitmask_x, // 32-bit binary mask for X direction where 1 - draw, 0 - not draw
const unsigned int bitmask_y, // 32-bit binary mask for Y direction where 1 - draw, 0 - not draw
const bool bitmask_form) = 0; // How to start calculate coordinates for binary masking. If it is true, the form coordinates are used. If it is false, the primitive coordinates are used(without transformations)
virtual void Blur( // Blur image without modifying originl one and using binary mask on target. Store result in target
ITexture *target, // Storage for result image
ITexture *source, // Image which blured representation is required
const int radius, // Blur radius(>= 1)
const BLUR_TYPE type, // Blur type
const unsigned int bitmask_x, // 32-bit binary mask for X direction where 1 - draw, 0 - not draw
const unsigned int bitmask_y, // 32-bit binary mask for Y direction where 1 - draw, 0 - not draw
const bool bitmask_form) = 0; // How to start calculate coordinates for binary masking. If it is true, the form coordinates are used. If it is false, the primitive coordinates are used(without transformations)
// Since 7.0.0
virtual void Blur( // Add blur to image
ITexture *image, // Image to be blured
const int radius, // Blur radius(>= 1)
const BLUR_TYPE type, // Blur type
ITexture *mask) = 0; // Mask to be applied when drawing. Only alpha channel is used
virtual void Blur( // Blur image without modifying originl one. Store result in target
ITexture *target, // Storage for result image
ITexture *source, // Image which blured representation is required
const int radius, // Blur radius(>= 1)
const BLUR_TYPE type, // Blur type
ITexture *mask) = 0; // Mask to be applied when drawing. Only alpha channel is used
virtual void Blur( // Add masked blur to image
ITexture *image, // Image to be blured
const int radius, // Blur radius(>= 1)
const BLUR_TYPE type, // Blur type
const unsigned int bitmask_x, // 32-bit binary mask for X direction where 1 - draw, 0 - not draw
const unsigned int bitmask_y, // 32-bit binary mask for Y direction where 1 - draw, 0 - not draw
const bool bitmask_form, // How to start calculate coordinates for binary masking. If it is true, the form coordinates are used. If it is false, the primitive coordinates are used(without transformations)
ITexture *mask) = 0; // Mask to be applied when drawing. Only alpha channel is used
virtual void Blur( // Blur image without modifying originl one and using binary mask on target. Store result in target
ITexture *target, // Storage for result image
ITexture *source, // Image which blured representation is required
const int radius, // Blur radius(>= 1)
const BLUR_TYPE type, // Blur type
const unsigned int bitmask_x, // 32-bit binary mask for X direction where 1 - draw, 0 - not draw
const unsigned int bitmask_y, // 32-bit binary mask for Y direction where 1 - draw, 0 - not draw
const bool bitmask_form, // How to start calculate coordinates for binary masking. If it is true, the form coordinates are used. If it is false, the primitive coordinates are used(without transformations)
ITexture *mask) = 0; // Mask to be applied when drawing. Only alpha channel is used
// Since 7.0.0
virtual void Polygon( // Draw polygon
const std::vector<PointF> &points, // Polygon points. Should be at least 3 points and polygon should be convex. 3000 points maximum
const Color &color, // Polygon color
const BLOCK *block) = 0; // Clipping block. Use nullptr if clipping is not required
virtual void Polygon( // Draw transformed polygon
const std::vector<PointF> &points, // Polygon points. Should be at least 3 points and polygon should be convex. 3000 points maximum
const Matrix &m, // Transformation matrix
const Color &color, // Polygon color
const BLOCK *block) = 0; // Clipping block. Use nullptr if clipping is not required
virtual void Polygon( // Draw polygon using binary mask
const std::vector<PointF> &points, // Polygon points. Should be at least 3 points and polygon should be convex. 3000 points maximum
const Color &color, // Polygon color
const BLOCK *block, // Clipping block. Use nullptr if clipping is not required
const unsigned int bitmask_x, // 32-bit binary mask for X direction where 1 - draw, 0 - not draw
const unsigned int bitmask_y, // 32-bit binary mask for Y direction where 1 - draw, 0 - not draw
const bool bitmask_form) = 0; // How to start calculate coordinates for binary masking. If it is true, the form coordinates are used. If it is false, the primitive coordinates are used(without transformations)
virtual void Polygon( // Draw transformed polygon using binary mask
const std::vector<PointF> &points, // Polygon points. Should be at least 3 points and polygon should be convex. 3000 points maximum
const Matrix &m, // Transformation matrix
const Color &color, // Polygon color
const BLOCK *block, // Clipping block. Use nullptr if clipping is not required
const unsigned int bitmask_x, // 32-bit binary mask for X direction where 1 - draw, 0 - not draw
const unsigned int bitmask_y, // 32-bit binary mask for Y direction where 1 - draw, 0 - not draw
const bool bitmask_form) = 0; // How to start calculate coordinates for binary masking. If it is true, the form coordinates are used. If it is false, the primitive coordinates are used(without transformations)
virtual void Polygon( // Draw polygon
const std::vector<PointF> &points, // Polygon points. Should be at least 3 points and polygon should be convex. 3000 points maximum
const Color &color, // Polygon color
const BLOCK *block, // Clipping block. Use nullptr if clipping is not required
ITexture *mask) = 0; // Mask to be applied when drawing. Only alpha channel is used
virtual void Polygon( // Draw transformed polygon
const std::vector<PointF> &points, // Polygon points. Should be at least 3 points and polygon should be convex. 3000 points maximum
const Matrix &m, // Transformation matrix
const Color &color, // Polygon color
const BLOCK *block, // Clipping block. Use nullptr if clipping is not required
ITexture *mask) = 0; // Mask to be applied when drawing. Only alpha channel is used
virtual void Polygon( // Draw polygon using binary mask
const std::vector<PointF> &points, // Polygon points. Should be at least 3 points and polygon should be convex. 3000 points maximum
const Color &color, // Polygon color
const BLOCK *block, // Clipping block. Use nullptr if clipping is not required
const unsigned int bitmask_x, // 32-bit binary mask for X direction where 1 - draw, 0 - not draw
const unsigned int bitmask_y, // 32-bit binary mask for Y direction where 1 - draw, 0 - not draw
const bool bitmask_form, // How to start calculate coordinates for binary masking. If it is true, the form coordinates are used. If it is false, the primitive coordinates are used(without transformations)
ITexture *mask) = 0; // Mask to be applied when drawing. Only alpha channel is used
virtual void Polygon( // Draw transformed polygon using binary mask
const std::vector<PointF> &points, // Polygon points. Should be at least 3 points and polygon should be convex. 3000 points maximum
const Matrix &m, // Transformation matrix
const Color &color, // Polygon color
const BLOCK *block, // Clipping block. Use nullptr if clipping is not required
const unsigned int bitmask_x, // 32-bit binary mask for X direction where 1 - draw, 0 - not draw
const unsigned int bitmask_y, // 32-bit binary mask for Y direction where 1 - draw, 0 - not draw
const bool bitmask_form, // How to start calculate coordinates for binary masking. If it is true, the form coordinates are used. If it is false, the primitive coordinates are used(without transformations)
ITexture *mask) = 0; // Mask to be applied when drawing. Only alpha channel is used
// Since 7.0.0
virtual void Polygons( // Draw polygon
const std::vector<std::vector<PointF>> &polygons, // Array of polygons. Each polygon should have from 3 to 3000 points
const Color &color, // Polygon color
const BLOCK *block) = 0; // Clipping block. Use nullptr if clipping is not required
virtual void Polygons( // Draw transformed polygon
const std::vector<std::vector<PointF>> &polygons, // Array of polygons. Each polygon should have from 3 to 3000 points
const Matrix &m, // Transformation matrix
const Color &color, // Polygon color
const BLOCK *block) = 0; // Clipping block. Use nullptr if clipping is not required
virtual void Polygons( // Draw polygon using binary mask
const std::vector<std::vector<PointF>> &polygons, // Array of polygons. Each polygon should have from 3 to 3000 points
const Color &color, // Polygon color
const BLOCK *block, // Clipping block. Use nullptr if clipping is not required
const unsigned int bitmask_x, // 32-bit binary mask for X direction where 1 - draw, 0 - not draw
const unsigned int bitmask_y, // 32-bit binary mask for Y direction where 1 - draw, 0 - not draw
const bool bitmask_form) = 0; // How to start calculate coordinates for binary masking. If it is true, the form coordinates are used. If it is false, the primitive coordinates are used(without transformations)
virtual void Polygon( // Draw transformed polygon using binary mask
const std::vector<std::vector<PointF>> &polygons, // Array of polygons. Each polygon should have from 3 to 3000 points
const Matrix &m, // Transformation matrix
const Color &color, // Polygon color
const BLOCK *block, // Clipping block. Use nullptr if clipping is not required
const unsigned int bitmask_x, // 32-bit binary mask for X direction where 1 - draw, 0 - not draw
const unsigned int bitmask_y, // 32-bit binary mask for Y direction where 1 - draw, 0 - not draw
const bool bitmask_form) = 0; // How to start calculate coordinates for binary masking. If it is true, the form coordinates are used. If it is false, the primitive coordinates are used(without transformations)
virtual void Polygons( // Draw polygon
const std::vector<std::vector<PointF>> &polygons, // Array of polygons. Each polygon should have from 3 to 3000 points
const Color &color, // Polygon color
const BLOCK *block, // Clipping block. Use nullptr if clipping is not required
ITexture *mask) = 0; // Mask to be applied when drawing. Only alpha channel is used
virtual void Polygons( // Draw transformed polygon
const std::vector<std::vector<PointF>> &polygons, // Array of polygons. Each polygon should have from 3 to 3000 points
const Matrix &m, // Transformation matrix
const Color &color, // Polygon color
const BLOCK *block, // Clipping block. Use nullptr if clipping is not required
ITexture *mask) = 0; // Mask to be applied when drawing. Only alpha channel is used
virtual void Polygons( // Draw polygon using binary mask
const std::vector<std::vector<PointF>> &polygons, // Array of polygons. Each polygon should have from 3 to 3000 points
const Color &color, // Polygon color
const BLOCK *block, // Clipping block. Use nullptr if clipping is not required
const unsigned int bitmask_x, // 32-bit binary mask for X direction where 1 - draw, 0 - not draw
const unsigned int bitmask_y, // 32-bit binary mask for Y direction where 1 - draw, 0 - not draw
const bool bitmask_form, // How to start calculate coordinates for binary masking. If it is true, the form coordinates are used. If it is false, the primitive coordinates are used(without transformations)
ITexture *mask) = 0; // Mask to be applied when drawing. Only alpha channel is used
virtual void Polygons( // Draw transformed polygon using binary mask
const std::vector<std::vector<PointF>> &polygons, // Array of polygons. Each polygon should have from 3 to 3000 points
const Matrix &m, // Transformation matrix
const Color &color, // Polygon color
const BLOCK *block, // Clipping block. Use nullptr if clipping is not required
const unsigned int bitmask_x, // 32-bit binary mask for X direction where 1 - draw, 0 - not draw
const unsigned int bitmask_y, // 32-bit binary mask for Y direction where 1 - draw, 0 - not draw
const bool bitmask_form, // How to start calculate coordinates for binary masking. If it is true, the form coordinates are used. If it is false, the primitive coordinates are used(without transformations)
ITexture *mask) = 0; // Mask to be applied when drawing. Only alpha channel is used
};More about shader programs
There are two methods for creation of shader programs in renderer. The first one require to specify both vertex and fragment shader source code and the second one requires only a fragment shader source code. All source codes should be in language particular renderer uses. GLSL for renderer which uses OpenGL or HLSL for renderer which uses DirectX and so on.
The first method allow you to create completely custom shader programs and is also allow to include unility functions renderer uses. The second method will use all the renderer default functionality except for pixel color calculation which should be impemented in your source code.
For information about available utility functions and reserved variables as well as color calculation function please see particular renderer implementation.
Limiting drawing by splines
The feature of limitation drawing operations by two splines was added in version 7.0.0. It is represented in the interface by two methods: first one is BeginSplineLimitation() and the second one is EndSplineLimitation. The first one can be called many times without calling the second one if you need to change splines. After successfull calling of BeginSplineLimitation() all primitive drawing operations will draw only those pixels that lies between specified two splines. When limitation is no longer needed, you have to call EndSplineLimitation(). On the picture below you can see rectangles drawn with such a limitation. The first spline in this case is a cubic bezier spline and the second one is a line lying on the X axis.
As you can see from definition of CUBIC_BEZIER_SPLINE at the beginning of the IRenderer class declaration each spline consists of 4 points. The P1 and P2 points are the beginning and the ending of the spline. Points C1 and C2 are control points. So it is actually a cubic bezier curve(it is also clear from the name of the structure). If you need quadratic bezier curve instead, just set both control points same value so they are equal. If you need stright line, set C1 the same value as you have for line start(P1) and set C2 the same value as you have for line end(P2).
| Namespace: | nitisa |
| Include: | Nitisa/Interfaces/IRenderer.h |