Hello GL ES Example

Using QGLPainter

Since the QGLPainter is slower for OpenGL ES we paint the bubbles with the rasterizer and cache them in a QImage. This happends only once during the initialiazation.

 void Bubble::updateCache()
 {
     if (cache)
         delete cache;
     cache = new QImage(qRound(radius * 2 + 2), qRound(radius * 2 + 2), QImage::Format_ARGB32);
     cache->fill(0x00000000);
     QPainter p(cache);
     p.setRenderHint(QPainter::HighQualityAntialiasing);
     QPen pen(Qt::white);
     pen.setWidth(2);
     p.setPen(pen);
     p.setBrush(brush);
     p.drawEllipse(0, 0, int(2*radius), int(2*radius));
 }

For each bubble this QImage is then drawn to the QGLWidget by using the according QPainter with transparency enabled.

 void Bubble::drawBubble(QPainter *painter)
 {
     painter->save();
     painter->translate(position.x() - radius, position.y() - radius);
     painter->setOpacity(0.8);
     painter->drawImage(0, 0, *cache);
     painter->restore();
 }

Another difference beetwen OpenGL and OpenGL ES is that OpenGL ES does not support glPushAttrib(GL_ALL_ATTRIB_BITS). So we have to restore all the OpenGL states ourselves, after we created the QPainter in GLWidget::paintGL().

     QPainter painter;
     painter.begin(this);

     glMatrixMode(GL_PROJECTION);
     glPushMatrix();
     glLoadIdentity();

Setting up up the model view matrix and setting the right OpenGL states is done in the same way as for standard OpenGL.

     glMatrixMode(GL_MODELVIEW);
     glPushMatrix();
     glMatrixMode(GL_TEXTURE);
     glPushMatrix();

     //Since OpenGL ES does not support glPush/PopAttrib(GL_ALL_ATTRIB_BITS)
     //we have to take care of the states ourselves

     glClearColor(0.1f, 0.1f, 0.2f, 1.0f);
     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
     glEnable(GL_TEXTURE_2D);

     glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
     glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
     glEnable(GL_LIGHTING);
     glEnable(GL_LIGHT0);

     glShadeModel(GL_FLAT);
     glFrontFace(GL_CW);
     glCullFace(GL_FRONT);
     glEnable(GL_CULL_FACE);
     glEnable(GL_DEPTH_TEST);

     glMatrixMode(GL_MODELVIEW);
     glLoadIdentity();

     glRotatef(m_fAngle, 0.0f, 1.0f, 0.0f);
     glRotatef(m_fAngle, 1.0f, 0.0f, 0.0f);
     glRotatef(m_fAngle, 0.0f, 0.0f, 1.0f);
     glScalef(m_fScale, m_fScale,m_fScale);
     glTranslatef(0.0f,-0.2f,0.0f);

     GLfloat matDiff[] = {0.40f, 1.0f, 0.0f, 1.0f};
     glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, matDiff);

     if (qtLogo)
         paintQtLogo();
     else
         paintTexturedCube();

Now we have to restore the OpenGL state for the QPainter. This is not done automatically for OpenGL ES.

     glMatrixMode(GL_MODELVIEW);
     glPopMatrix();
     glMatrixMode(GL_PROJECTION);
     glPopMatrix();
     glMatrixMode(GL_TEXTURE);
     glPopMatrix();

     glDisable(GL_LIGHTING);
     glDisable(GL_LIGHT0);

     glDisable(GL_DEPTH_TEST);
     glDisable(GL_CULL_FACE);

Now we use the QPainter to draw the transparent bubbles.

     if (m_showBubbles)
         foreach (Bubble *bubble, bubbles) {
             bubble->drawBubble(&painter);
     }

In the end, we calculate the framerate and display it using the QPainter again.

     QString framesPerSecond;
     framesPerSecond.setNum(frames /(time.elapsed() / 1000.0), 'f', 2);

     painter.setPen(Qt::white);

     painter.drawText(20, 40, framesPerSecond + " fps");

     painter.end();

After we finished all the drawing operations we swap the screen buffer.

     swapBuffers();