Qt for Windows CE and OpenVG
|
Feature | Description |
---|---|
Context modes | The default configuration is "single-context" mode, where a single EGLContext object is used for all drawing, regardless of the surface. Multiple EGLSurfaces are created, one for each window surface or pixmap. eglMakeCurrent() is called with the same EGLContext every time, but a different EGLSurface. Single-context mode is necessary for QPixmapData to be implemented in terms of a VGImage. If single-context mode is not enabled, then QPixmapData will use the fallback QRasterPixmapData implementation, which is less efficient performance-wise. Single-context mode can be disabled with the QVG_NO_SINGLE_CONTEXT define if the OpenVG engine does not support one context with multiple surfaces. |
Transformation matrices | All affine and projective transformation matrices are supported. QVGPaintEngine will use the engine to accelerate affine transformation matrices only. When a projective transformation matrix is used, QVGPaintEngine will transform the coordinates before passing them to the engine. This will probably incur a performance penalty. Pixmaps and images are always transformed by the engine, because OpenVG specifies that projective transformations must work for images. It is recommended that client applications should avoid using projective transformations for non-image elements in performance critical code. |
Composition modes | The following composition modes are supported:
The other members of QPainter::CompositionMode are not supported because OpenVG 1.1 does not have an equivalent in its VGBlendMode enumeration. Any attempt to set an unsupported mode will result in the actual mode being set to QPainter::CompositionMode_SourceOver. Client applications should avoid using unsupported modes. |
Pens and brushes | All pen styles are supported, including cosmetic pens. All brush styles are supported except for conical gradients, which are not supported by OpenVG 1.1. Conical gradients will be converted into a solid color brush corresponding to the first color in the gradient's color ramp. Affine matrices are supported for brush transforms, but not projective matrices. |
Rectangles, lines, and points | Rectangles, lines, and rounded rectangles use cached VGPath objects to try to accelerate drawing operations. vgModifyPathCoords() is used to modify the co-ordinates in the cached VGPath object each time fillRect(), drawRects(), drawLines(), or drawRoundedRect() is called. If the engine does not implement vgModifyPathCoords() properly, then the QVG_NO_MODIFY_PATH define can be set to disable path caching. This will incur a performance penalty. Points are implemented as lines from the point to itself. The cached line drawing VGPath object is used when drawing points. |
Polygons and Ellipses | Polygon and ellipse drawing creates a new VGPath object every time drawPolygon() or drawEllipse() is called. If the client application is making heavy use of these functions, the constant creation and destruction of VGPath objects could have an impact on performance. If a projective transformation is active, ellipses are converted into cubic curves prior to transformation, which may further impact performance. Client applications should avoid polygon and ellipse drawing in performance critical code if possible. |
Other Objects | Most other objects (arcs, pies, etc) use drawPath(), which takes a QPainterPath argument. The default implementation in QPainterEngineEx converts the QPainterPath into a QVectorPath and then calls draw(), which in turn converts the QVectorPath into a VGPath for drawing. To reduce the overhead, we have overridden drawPath() in QVGPaintEngine to convert QPainterPath's directly into VGPath's. This should help improve performance compared to the default implementation. Client applications should try to avoid these types of objects in performance critical code because of the QPainterPath to VGPath conversion cost. |
Clipping | Clipping with QRect, QRectF, and QRegion objects is supported on all OpenVG engines with vgMask() if the transformation matrix is the identity or a simple origin translation. Clipping with an arbitrary QPainterPath, or setting the clip region when the transformation matrix is simple, is supported only if the OpenVG engine has the vgRenderToMask() function (OpenVG 1.1 and higher). The QVG_NO_RENDER_TO_MASK define will disable the use of vgRenderToMask(). The QVG_SCISSOR_CLIP define will disable clipping with vgMask() or vgRenderToMask() and instead use the scissor rectangle list to perform clipping. Clipping with an arbitrary QPainterPath will not be supported. The QVG_SCISSOR_CLIP define should only be used if the OpenVG engine does not support vgMask() or vgRenderToMask(). |
Opacity | Opacity is supported for all drawing operations. Solid color pens, solid color brushes, gradient brushes, and image drawing with drawPixmap() and drawImage() will probably have the best performance compared to other kinds of pens and brushes. |
Text Drawing | If OpenVG 1.1 is used, the paint engine will use VG fonts to cache glyphs while drawing. If the engine does not support VG fonts correctly, QVG_NO_DRAW_GLYPHS can be defined to disable this mode. Text drawing performance will suffer if VG fonts are not used. By default, image-based glyphs are used. If QVG_NO_IMAGE_GLYPHS is defined, then path-based glyphs will be used instead. QVG_NO_IMAGE_GLYPHS is ignored if QVG_NO_DRAW_GLYPHS is defined. If path-based glyphs are used, then the OpenVG engine will need to support hinting to render text with good results. Image-based glyphs avoids the need for hinting and will usually give better results than path-based glyphs. |
Pixmaps | In single-context mode, pixmaps will be implemented using VGImage unless QVG_NO_PIXMAP_DATA is defined. QVGPixmapData will convert QImage's into VGImage's when the application calls drawPixmap(), and the pixmap will be kept in VGImage form for the lifetime of the QVGPixmapData object. When the application tries to paint into a QPixmap with QPainter, the data will be converted back into a QImage and the raster paint engine will be used to render into the QImage. This arrangement optimizes for the case of drawing the same static pixmap over and over (e.g. for icons), but does not optimize the case of drawing into pixmaps. Bitmaps must use QRasterPixmapData. They are not accelerated with VGImage at present. |
Pixmap filters | Convolution, colorize, drop shadow, and blur filters are accelerated using OpenVG operations. |
Scrolling | Accelerated scrolling is implemented but disabled by default unless QVG_BUFFER_SCROLLING is defined. This should only be enabled on OpenVG engines where vgCopyPixels() is known to be efficient. |
Performance of copying the contents of an OpenVG-rendered window to the screen needs platform-specific work in the QVGWindowSurface class.
Clipping with arbitrary non-rectangular paths only works on engines that support vgRenderToMask(). Simple rectangular paths are supported on all engines that correctly implement vgMask().
The paint engine is not yet thread-safe, so it is not recommended for use in threaded Qt applications that draw from multiple threads. Drawing should be limited to the main GUI thread.
Performance of projective matrices for non-image drawing is not as good as for affine matrices.
QPixmap's are implemented as VGImage objects so that they can be quickly rendered with drawPixmap(). Rendering into a QPixmap using QPainter will use the default Qt raster paint engine on a QImage copy of the QPixmap, and will not be accelerated. This issue may be addressed in a future version of the engine.
ShivaVG support is highly experimental and limited to Qt/X11. It is provided as an example of how to integrate a non-EGL engine.
Qt for Windows CE uses EGL 1.1 to embed OpenVG windows within the Windows CE window manager.
Note: Make sure that your Windows CE SDK have a working EGL implementation. If not, OpenVG will not work.
Note: There is currently no support for Blitting and Alpha blending in Qt for Windows CE.
Note: To configure Qt for Windows Mobile 5.0 and OpenVG support you can run configure like this:
configure -platform win32-msvc2005 -xplatform wincewm50pocket-msvc2005 -opengl-es-cl
Cette page est une traduction d'une page de la documentation de Qt, écrite par Nokia Corporation and/or its subsidiary(-ies). Les éventuels problèmes résultant d'une mauvaise traduction ne sont pas imputables à Nokia. | Qt 4.6-snapshot | |
Copyright © 2012 Developpez LLC. Tous droits réservés Developpez LLC. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents et images sans l'autorisation expresse de Developpez LLC. Sinon, vous encourez selon la loi jusqu'à 3 ans de prison et jusqu'à 300 000 E de dommages et intérêts. Cette page est déposée à la SACD. | ||
Vous avez déniché une erreur ? Un bug ? Une redirection cassée ? Ou tout autre problème, quel qu'il soit ? Ou bien vous désirez participer à ce projet de traduction ? N'hésitez pas à nous contacter ou par MP ! |
Copyright © 2000-2012 - www.developpez.com