Multithreaded-OpenGL Rendering mit Picking-Fähigkeit mit Qt

Unlike the rest of the website this page is in German. I drag it along, since still quite a few people read it. However, it hasn’t been updated for a while and is only provided in case somebody still finds it useful.

Im Netz findet man einige Beispiele zum Thema Picking mit OpenGL (zum Beispiel Lesson 32 bei Nehe) und zum Thema Multithreaded-OpenGL Rendering mit Qt wird man bei Trolltechs Qt Quarterly: Glimpsing the Third Dimension fündig. Ein wenig schwieriger sieht es da schon aus, wenn man nach Code für GL-Picking mit Qt sucht. Aber auch hier gibt es mindestens ein Beispiel. Ich konnte jedoch kein einfaches Beispiel für Multithreaded-OpenGL Rendering mit Picking-Fähigkeit mit Qt finden.

Nun könnte man sagen: Na klar, ist ja auch so einfach. Genau! Und damit sich keiner mit einer so einfachen Sache aufhalten muss, kommt hier das Bespiel:

Beispiel: Multithreaded Cube

Dieses Beispiel ist eine Kombination aus zwei bereits existierenden. Das erste ist ein kleines Programm aus dem Buch C++ GUI Programming with Qt 3 von Jasmin Blanchette und Mark Summerfield (Kapitel 8; Programm: cube). Es demonstriert GL-Picking mit einem QGLWidget. Der Code kann hier heruntergeladen werden. Das zweite Beispiel ist der schon erwähnte Qt Quarterly Artikel Glimpsing the Third Dimension.

Der hier dargestellte Code übernimmt die Funktionalität des cube Programms, verlagert jedoch das Rendering in einen separaten Thread. Darüber hinaus wird GL-Picking in einer Funktion demonstriert, die nicht nur aus dem GL-Render-Thread aufgerufen werden kann.

Update

Ich habe das Beispiel von Qt3 nach Qt4 portiert (siehe Download). Dabei habe ich noch einige kleiner Mängel beseitigt, so dass es jetzt auch problemlos mit dem gcc-4.0 übersetzt werden kann.

2. Update

Aus einem mir nicht ersichtlichen Grund funktioniert dieses Beispiel nicht mit der derzeit populären Version 6.8.2 vom Xorg XServer (Debian Etch, Ubuntu Breezy Badger, u.a.). Der Aufruf von XInitThreads() resultiert in einem Mehr-oder-weniger-Absturz beim Anlegen des QApplication-Objektes. Dagegen gibt es keine Probleme mit Xfree86 (Debian Sarge) oder (ich wage es nicht zu sagen) MS Windows.

3. Update

Robert Visser schrieb mir: I looked into this problem on the internet and found a solution that worked for me: recompile qt4, with tablet support disabled (use an additional flag during configure -no-tablet ). This worked for me!

4. Update

Nach einer kleinen Änderung funktioniert jetzt alles auch mit GCC 4.1.2 und Qt 4.2.2

Download

• threaded_cube.tar.gz (14.8 KB)
• threaded_cube.tar.gz (Qt4 Version, GCC4 kompatibel, 16.1 KB)

Screenshot

Das Wichtigste vom Quelltext im Überblick

main.cpp

 #ifdef Q_WS_X11
 #include <X11/Xlib.h>  // for XInitThreads() call
 #endif

...

 #ifdef Q_WS_X11
     // this needs to be the first in the app to make Xlib calls thread save
     // needed for OpenGl rendering threads
     XInitThreads();
 #endif

Dieser Header ist unter X11 wichtig um Xlib-Aufrufe mit XInitThreads() thread-safe machen zu können. Der Rest des Codes in main.cpp ist der normale Code für die Initialisierung einer minimalen Qt-Anwendung.

exampleglwidget.cpp

 ExampleGLWidget::ExampleGLWidget(QWidget *parent, const char *name)
     : QGLWidget(parent, name),
     glt(*this)

 {
     setFormat(QGLFormat(DoubleBuffer | DepthBuffer));

     // Buffer swap is handled in the rendering thread
     setAutoBufferSwap(false);

     // start the rendering thread
     initRendering();
 }

Hier ist der Konstruktor der QGLWidget Subklasse. Es wird der OpenGL-Rendering-Thread glt mit einer Referenz auf das ExampleGLWidget initialisiert. Desweitern wird das automatische Umschalten des Buffers abgeschaltet, da dies im Render-Thread geschieht. Der Aufruf in Zeile 50 aktiviert den Render-Thread.

 void ExampleGLWidget::mouseDoubleClickEvent(QMouseEvent *event)
 {
     // get the name of the clicked surface
     int face = glt.faceAtPosition(event->pos());
     if (face != -1)
     {
         QColor color = QColorDialog::getColor(glt.faceColors[face],
                                               this);
         if (color.isValid())
         {
             glt.faceColors[face] = color;
         }
     }
 }

Diese Funktion demonstriert das Picking. Der Aufruf in Zeile 81 holt die ID-Nummer der angeklickten Würfel-Fläche. faceAtPosition() ist eine Methode der Rendering-Thread-Klasse, in der das GL-Picking implementiert ist (siehe unten). Zu beachten ist hier, dass dieser Methoden-Aufruf aus dem Haupt-GUI-Thread heraus erfolgt. Aus diesem Grund müssen alle Aufrufe in der faceAtPosition() besonders gesichert werden.

 void ExampleGLWidget::resizeEvent( QResizeEvent * _e )
 {
     // signal the rendering thread that a resize is needed
     glt.resizeViewport(_e->size());

     render();
 }

Ist eine Größenänderung des OpenGL-Viewports nötig, zum Beispiel weil die Fenstergröße geändert wurde, so wird die neue Größe dem Rendering-Thread mitgeteilt: resizeViewport(). Danach weckt ein render() den Thread auf und die Änderung wird umgesetzt.

 void ExampleGLWidget::lockGLContext( )
 {
     // lock the render mutex for the calling thread
     renderMutex().lock();
     // make the render context current for the calling thread
     makeCurrent();
 }

 void ExampleGLWidget::unlockGLContext( )
 {
     // release the render context for the calling thread
     // to make it available for other threads
     doneCurrent();
     // unlock the render mutex for the calling thread
     renderMutex().unlock();
 }

Die beiden obigen Methoden dienen dazu, den Rendering-Kontext des QGLWidgets aus mehren Threads heraus benutzen zu können. In diesem Beispiel ist dies wichtig, da das Picking aus dem Haupt-GUI-Thread heraus aufgerufen wird. lockGLContext() sichert über einen QMutex den Zugriff auf den Rendering-Context für den aufrufenden Thread und aktiviert ihn: makeCurrent(). Analog dazu macht unlockGLContext() dies wieder rückgängig und gibt den Rendering-Context frei.

 void ExampleGLWidget::render( )
 {
     // let the wait condition wake up the waiting thread
     renderCondition().wakeAll();
 }

Die render() Methode tut nicht mehr, als mit Hilfe einer QWaitCondition den wartenden Rendering-Thread aufzuwecken, damit dieser einen neuen Frame erzeugen kann.

examplerenderthread.cpp

 void ExampleRenderThread::run( )
 {
     // lock the render mutex of the Gl widget
     // and makes the rendering context of the glwidget current in this thread
     glw.lockGLContext();

Den GL-Rendering-Kontext für das Rendern aus diesem Thread sichern.

     // general GL init
     initializeGL();

     // do as long as the flag is true
     while( render_flag )
     {
         // resize the GL viewport if requested
         if (resize_flag)
         {
             resizeGL(viewport_size.width(), viewport_size.height());
             resize_flag = false;
         }

         // render code goes here
         paintGL();

         // swap the buffers of the GL widget
         glw.swapBuffers();

Da das automatische Wechseln des Buffers im QGLWidget deaktiviert wurde, muss es hier manuell nach dem Zeichnen geschehen.

         glw.doneCurrent(); // release the GL render context to make picking work!

         // wait until the gl widget says that there is something to render
         // glwidget.lockGlContext() had to be called before (see top of the function)!
         // this will release the render mutex until the wait condition is met
         // and will lock the render mutex again before exiting
         // waiting this way instead of insane looping will not waste any CPU ressources
         glw.renderCondition().wait(&glw.renderMutex());

         glw.makeCurrent(); // get the GL render context back

Der Thread gibt nach jedem Frame den Rendering-Kontext frei und legt sich schlafen. Wenn er über die QWaitCondition wieder geweckt wird, wird der Rendering-Kontext erneut für diesen Thread gesichert.

     }
     // unlock the render mutex before exit
     glw.unlockGLContext();
 }

Am Ende muss der Rendering-Kontext wieder freigegeben werden.

 void ExampleRenderThread::draw()
 {

...

     for (int i = 0; i < 6; ++i)
     {
         // assign names for each surface
         // this make picking work
         glLoadName(i);
         glBegin(GL_QUADS);
         glw.qglColor(faceColors[i]);
         for (int j = 0; j < 4; ++j)
         {
             glVertex3f(coords[i][j][0], coords[i][j][1],
                        coords[i][j][2]);
         }
         glEnd();
     }
 }

Zeile 181 ist der Schlüssel für das Picking: jeder Würfelfläche wird hier ein “Name” zugewiesen, über den diese identifiziert werden kann. Leider gibt es davon nur 64. Aber das ist ein anderes Thema.

 int ExampleRenderThread::faceAtPosition(const QPoint &pos)
 {
     // we need to lock the rendering context
     glw.lockGLContext();

     // this is the same as in every OpenGL picking example
     const int MaxSize = 512; // see below for an explanation on the buffer content
     GLuint buffer[MaxSize];
     GLint viewport[4];

     glGetIntegerv(GL_VIEWPORT, viewport);
     glSelectBuffer(MaxSize, buffer);
     // enter select mode
     glRenderMode(GL_SELECT);

     glInitNames();
     glPushName(0);

     glMatrixMode(GL_PROJECTION);
     glPushMatrix();
     glLoadIdentity();
     gluPickMatrix((GLdouble)pos.x(),
                   (GLdouble)(viewport[3] - pos.y()),
                   5.0, 5.0, viewport);
     GLfloat x = (GLfloat)viewport_size.width() / viewport_size.height();
     glFrustum(-x, x, -1.0, 1.0, 4.0, 15.0);
     draw();
     glMatrixMode(GL_PROJECTION);
     glPopMatrix();


     // finally release the rendering context again
     if (!glRenderMode(GL_RENDER))
     {
         glw.unlockGLContext();
         return -1;
     }
     glw.unlockGLContext();

     // Each hit takes 4 items in the buffer.
     // The first item is the number of names on the name stack when the hit occured.
     // The second item is the minimum z value of all the verticies that intersected
     // the viewing area at the time of the hit. The third item is the maximum z value
     // of all the vertices that intersected the viewing area at the time of the hit
     // and the last item is the content of the name stack at the time of the hit
     // (name of the object). We are only interested in the object name
     // (number of the surface).

     // return the name of the clicked surface
     return buffer[3];
 }

Hier nun die Implementation des GL-Picking. Damit diese Methode gefahrlos aus einem anderen Thread aufgerufen werden kann, muss sie sich erst den Rendering-Kontext sichern. Wurde eine Fläche des Würfels angeklickt so findet sich der “Name” der Fläche (siehe Zeile 181 oben) im Hit-Buffer an der vierten Stelle.

Lizenz

Dieser Code ist unter der GNU Public License (GPL) lizensiert.