Cookies info

This website uses Google cookies to analyse traffic. Information about your use of our site is shared with Google for that purpose. See details.

Implementation details

AmanithVG SRE and AmanithVG GLE implement the whole OpenVG 1.0.1 and OpenVG 1.1 features, without limitations; while for pure software rendering solutions this is quite common, for solutions that relay on top of OpenGL ES 1.x+ this is an hard task. AmanithVG GLE is one of the few OpenVG engines that accomplishes this task using 2 texture units and one auxiliary buffer (depth or stencil) only, using few software fallbacks where specific GL extensions aren’t available and just to realize a couple of features.

OpenVG featureAmanithVG SREAmanithVG GLE
Alpha MaskingCPUGPU
Matrices & transformationsCPUGPU
Fill & stroke (solid, dashed)CPUGPU
Fill ruleCPUCPU
Paints (color, gradient, pattern)CPUGPU
Color ramp spread modesCPUGPU
Pattern tiling modesCPUGPU
Image modes (normal, multiply, stencil)CPUGPU
Image qualityCPUGPU
Rendering qualityCPUGPU*
Blend modesCPUGPU**
Color transformCPUGPU***
Font & textCPUGPU
Color spacesCPUGPU****
* antialiasing relays on GL multisampling.
** darken & lighten without GL_EXT_blend_minmax are realized on CPU.
*** color transform on images in multiply mode, when bias != 0, are realized on CPU.
**** except unpremultiplied drawing surfaces format.

Requirements and limitations

AmanithVG SRE is thread-safe: all the exposed functions can be called from multiple threads at the same time. Implementation makes use of the following libraries to implement thread-safety:

There is a limitation in the maximum number of different threads that can be made “current” at the same time; this parameter can be configured at compile time and can be retrieved (at runtime) by calling vgConfigGetMZT(VG_CONFIG_MAX_CURRENT_THREADS_MZT).

AmanithVG uses 32 bit single precision floating point arithmetic, as defined by IEEE 754-1985 standard, to perform some internal computations. All input data that describe geometries such as (but not limited to) path coordinates, paint parameters and matrices, will be converted from relative to absolute forms (if applicable), normalized (if applicable) and internally stored as a 32 bit floating point number. After these steps, it could result that different input values will become the same value under the 32 bit floating point precision.

AmanithVG uses fixed point arithmetic to perform the rasterization; in this case internal rendering surface coordinates are represented using 16bit. Fixed point format can be configured (at compile time) as:

AmanithVG supports rendering surfaces with dimensions less than or equal to 4096 pixels only.

GLE specific requirements and limitations

AmanithVG GLE is a single thread library, it’s not thread safe, it doesn’t support multiple rendering context at the same time; so it can be bound a single OpenGL / OpenGL ES rendering context / rendering surface and, on it, a single OpenVG context at once.

AmanithVG GLE uses integer arithmetic to perform robust polygon triangulation; in this case internal normalized object space coordinates (relative to the axes-aligned bounding box of the polygon) are represented using 16 bits or 21 bits (this option is customizable at compile time).

The drawing surface content persistence is the same of the underlying GL drawing surface; this means that after a “swap buffers” operation on GL Graphic System with non-persistent buffers, the buffers content couldn’t be consistent. On such cases, it’s highly recommendable to perform a vgClear of the whole drawing surface (disabling the scissoring), as the first OpenVG operation after the vgPostSwapBuffersMZT call.

Edge antialiasing (VGRenderingQuality): AmanithVG GLE has no control over edge antialiasing, so VGRenderingQuality values (VG_RENDERING_QUALITY_NONANTIALIASED, VG_RENDERING_QUALITY_FASTER, VG_RENDERING_QUALITY_BETTER) have no effect.

OpenGL and OpenGL ES requirements and limitations

AmanithVG GLE uses standard OpenGL ES functions available since OpenGL ES 1.0 version, and standard OpenGL functions available since OpenGL 1.2 taking advantage of the following extensions if supported by the GL Graphic System:

To run, AmanithVG GLE requires at least:

Furthermore, to ensure an OpenVG rendering output as described, AmanithVG GLE requires also:

The following limitations will affect some OpenVG features:

glTexImage2D(target, 0, GL_RGBA, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, pixels)

If the GL Graphic System internally stores textures using less than 32bit per-pixel, there will be a visual quality loss (e.g. gradients band effect).

AmanithVG GLE may provide software rendering fallbacks to realize OpenVG features that cannot be accelerated by the GL Graphic System.