| \section1 Introduction |
| |
| \l {http://www.opengl.org}{OpenGL} is an industry standard API for |
| 2D/3D graphics. It provides a powerful, low-level interface between |
| software and acceleration hardware, and it is operating system and |
| window system independent. \l {http://www.khronos.org/opengles}{OpenGL ES} |
| is a subset of the \l {http://www.opengl.org}{OpenGL} standard. Because it |
| is designed for use with embedded systems, it has a smaller, more |
| constrained API. |
| |
| \l {http://www.khronos.org/opengles/1_X}{OpenGL ES version 1.x} is designed for |
| fixed function hardware, while its successor \l |
| {http://www.khronos.org/opengles/2_X}{OpenGL ES version 2.x} is designed for |
| programmable hardware. It is worth noting that there is a significant |
| difference between the two, and that they are not compatible with each |
| other. OpenGL ES 1.x limits processing to a pre-defined set of fixed |
| options for drawing and lighting objects. OpenGL 2.x has a significantly |
| shorter graphics pipeline than 1.x. Instead of using function |
| transformation and a fragment pipeline, 2.x uses the \l |
| {http://www.khronos.org/registry/gles/specs/2.0/GLSL_ES_Specification_1.0.17.pdf}{OpenGL |
| ES Shading Language (GLSL ES)}. Instead of using the pre-defined functions, |
| the programmer writes small shader programs telling the hardware in detail |
| how to render each object. |
| |
| The \l {Qt OpenGL} module offers classes that make it easy to draw 3D |
| graphics in GUI applications using OpenGL ES. Qt provides a plugin that |
| integrates both OpenGL ES versions \l |
| {http://www.khronos.org/opengles/1_X}{1.x} and \l |
| {http://www.khronos.org/opengles/2_X}{2.x} with Qt for Embedded. However, |
| Qt for Embedded can be adapted to a wide range of OpenGL versions. |
| |
| To translate QPainter operations into OpenGL ES calls (there are actually |
| two subclasses, one for OpenGL/ES 1.1 and another for OpenGL/ES 2.0), Qt |
| uses a subclass of QPaintEngine. This specialized paint engine can be used |
| to improve 2D rendering performance on appropriate hardware. It can also |
| overlay controls and decorations onto 3D scenes drawn using OpenGL. |
| |
| \tableofcontents |
| |
| \section1 Using OpenGL ES with Qt |
| To use OpenGL-enabled widgets in a Qt for Embedded application, all that is |
| required is to subclass QGLWidget and draw into instances of the subclass |
| with standard OpenGL functions. The current implementation only |
| supports OpenGL ES and 2D painting within a QGLWidget. Using OpenGL ES to |
| accelerate regular widgets as well as compositing top-level windows with |
| OpenGL ES are not currently supported. These issues will be addressed in |
| future versions of Qt. |
| |
| \note The OpenGL paint engine is not currently supported in regular |
| widgets. However, any application that uses QGraphicsView can set a |
| QGLWidget as the viewport and obtain access to the OpenGL paint engine that |
| way: |
| |
| \code |
| QGraphicsView view(&scene); |
| view.setViewport(new QGLWidget()); |
| view.setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff); |
| view.setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff); |
| view.setViewportUpdateMode(QGraphicsView::FullViewportUpdate); |
| view.setFrameStyle(0); |
| view.showFullScreen(); |
| \endcode |
| |
| It is recommended that the QGraphicsView::FullViewportUpdate flag |
| be set because the default double-buffered behavior of QGLWidget |
| does not support partial updates. It is also recommended that the |
| window be shown full-screen because that usually has the best |
| performance on current OpenGL ES implementations. |
| |
| Once a QGraphicsView has been initialized as above, regular widgets |
| can be added to the canvas using QGraphicsProxyWidget if the |
| application requires them. |
| |
| \note OpenGL ES 2.X does not support PBuffers, so QGLPixelBuffer will not |
| work. In this case, QGLFramebufferObject should be used instead. However, |
| OpenGL ES 1.X does not support Framebuffer objects, with the exception of |
| some OpenGL ES 1.X extensions. In this case, please use QGLPixelBuffer. |
| |
| \note On most embedded hardware, the OpenGL implementation is |
| actually \l{http://www.khronos.org/opengles/1_X/}{OpenGL/ES 1.1} or |
| \l{http://www.khronos.org/opengles/2_X/}{OpenGL/ES 2.0}. When painting |
| within a QGLWidget::paintGL() override, it is necessary to limit the |
| application to only the features that are present in the OpenGL/ES |
| implementation. |
| |