Hallo,

ich stehe gerade vor dem Problem, dass ich für einen Editor eine GUI brauche. Eigentlich hatte ich vor es mit wxwidgets oder Qt zu machen, aber das ist mir nach ein wenig ausprobieren viel zu unhandlich. Für Qt braucht man noch extra Buildschritte und auch mit wxwidgets ist es nicht einfach mit dem Includen der Header Dateien und linken getan. Ich habe also nach etwas leichtgewichtigem gesucht und dann mal GLUT benutzt um das Fenster zu erstellen, mit GLUI wollte ich die GUI machen. Jetzt hab ich aber gemerkt, dass man mit GLUT nichtmal einfach aus dem Main-Loop rauskommt, was nicht gerade viel verspricht.

Ich bin also auf der Suche nach einer Möglichkeit eine simple, leichtgewichtige GUI mit OpenGL zu benutzen. Am besten sollte man einfach nur einen Header einbinden und gegen die Library linken und dann alle Fenster direkt mit Code erstellen. Ob die GUI wie bei Qt außerhalb des OpenGL Fensters ist, oder wie bei GLUI in OpenGL selbst ist, ist mir vollkommen egal.

Mit Delphi war das irgendwie viel einfacher, entweder man nimmt sich die VCL, oder eine der OpenGL GUIs, die hier so rumgeistern. Hier sind aber ja auch ein paar Leute, die sich mit C++ befassen, vielleicht hat ja schon jemand das gleiche Problem gehabt

SDL ausm SVN sollte inzwischen mit mehreren Fenstern klarkommen (citation needed).
Ansonsten kannst du vermutlich wenn du nur nen GL-Kontext willst auch mit rohem X11 arbeiten… Da gibt es hier schon einigen Pascal-Code zu, der sich einwandfrei nach C++ übertragen lassen sollte (stichwort: glPasGUI)

greetings

_________________
If you find any deadlinks, please send me a notification – Wenn du tote Links findest, sende mir eine Benachrichtigung.
current projects: ManiacLab; aioxmpp
zombofant network • my photostream
„Writing code is like writing poetry“ - source unknown

„Give a man a fish, and you feed him for a day. Teach a man to fish and you feed him for a lifetime. “ ~ A Chinese Proverb

Oh, ich dachte das wird aus meinem Posting klar: Es geht mir NICHT darum, nur ein Fenster für einen OpenGL-Kontext zu erstellen! Es geht darum, eine GUI zu haben, mit der ich Buttons, Textboxen, Listboxen ect. neben meinem OpenGL Fenster haben kann. (Oder eben innerhalb mit einer GUI basierend auf OpenGL). Ich will auch nicht so gerne was eigenes basteln, das verbraucht zu viel Zeit...

Edit: Ach ja, es soll auch Plattformunabhängig sein, X11 geht also nicht. Da müsste ich ja auch was für Win32 machen.. Das ist außerdem etwas zu low-level

Wenn du es hinbekommst eine GUI ohne OpenGL zu machen sollte das in Verbindung mit SDL funktionieren.

Ich hatte damals in Delphi es hinbekommen eine normale Konsole neben dem SDL-Fenster zu verwenden, vllt kriegst du das in C/C++ irgendwie mit einem "normalen"-Fenster und einem SDL-Fenster hin. Sollte das GUI-Fenster aber komplett mit OpenGL gerendert werden, dann hab ich keine Ahnung wie du das machen kannst.

Ich würde an deiner Stelle nochmal einen Blick auf QT werfen (keine Ahnung wie sehr du dich damit beschäftigt hast). Die extra Buildschritte fallen garnicht mehr auf wenn du sie erstmal in dein Buildsystem integriert hast (CMake kann das sehr gut, bei Code::Blocks ist das schon etwas aufwändiger glaub ich, QMake ist dafür gemacht). QT als ausgewachsenes GUI Framework bietet einfach unglaublich viele Möglichkeiten, die du bei vielen (meist bei Weitem nicht so ausgereiften) OpenGL/SDL/whatever GUIs vermissen wirst. z.B. kannst du schon vieles im Designer erledigen und das Binden deiner Funktionen an die Aktionen der Elemente (ButtonClick z.B.) wird dir auch abgenommen.

Wenn du dennoch eine OpenGL GUI vorziehst habe ich bis jetzt nur Erfahrung mit guichan gemacht http://code.google.com/p/guichan/
Aber obwohl ich damit schon recht zufrieden war, habe ich mich in meinem aktuellen Projekt doch dagegen entschieden, weil mir das einfach zu viel Gefrickel ist und GUI Programmierung meiner Meinung nach überflüssig sein sollte.

_________________
Der Mensch hat neben dem Trieb der Fortpflanzung und dem zu essen und zu trinken zwei Leidenschaften: Krach zu machen und nicht zuzuhören. (Kurt Tucholsky)
Schwabbeldiwapp, hier kommt die Grütze. (Der Quästor)

Wie stehts denn mit GTK+ ? Mit Glade kann man da sehr bequem seine Fenster zusammenbasteln und mit GtkGLExt kannst du in dem Fenster dann auch OpenGL nutzen.

_________________
Traue keinem Computer, den du nicht aus dem Fenster werfen kannst -- Steve Wozniak

Richtig, aber qmake macht das für dich, du brauchst dich da quasi nicht drum kümmern. Oben drein ist Qt extrem gut dokumentiert. GUI-Elemente kannst du bequem mit dem QtDesigner machen und dort auch schon einen großen Teil der Verbindungen zwischen den GUI-Elementen (*) realisieren. QtDesigner erzeugt dir ein XML-File (*.ui). Qmake baut dir daraus eine Klasse (*.h und *.cpp) die du ganz normal in deinen Code inkludierst und dann davon ableitest.

(*) z.B. wenn Button X gedrückt, verstecke Widget Y, etc....


Hier als Beispiel mal ein einfaches Projektfile für qmake welches sich bei jedem qmake-Aufruf automatisch Header und Sourcefiles sucht. Es kümmert sich ebenfalls um *.ui-Files und die Einbindung von Icons als Ressource in die Binary. Die dazu notwendige images.qrc wird von QtDesigner erzeugt. In diesem Fall liegen sämtliche Quellcodedateien und auch das Projectfile in einem Ordner "src". Temporäre Dateien werden in "tmp" erzeugt, die Binary findet sich später in "bin". Wenn du eine IDE benutzt musst du dieser nur beibringen, dass sie nacheinander qmake und dann make aufruft.

_________________
Yeah!

Danke für die Kommentare. Ich habe mir nochmal kurz Qt angeschaut und bin gerade dabei zu überlegen, wie genau ich das am Besten einbinde. Da ich überhaupt keinen Designer brauche/will, geht das offenbar ganz einfach indem man seine Header durch den moc-Compiler jagt und dann die Quelldateien kompiliert. So bekomme ich es auf jeden Fall hin nur mit make zu arbeiten (Ich benutze Eclipse CDT, deswegen will ich ungern auf qmake oder cmake ect. umsteigen).

Ich probiere noch ein bisschen rum und melde mich, wenn es Fragen gibt

Richtig, wie gesagt, qmake benutzen und das geht von alleine.


qmake und cmake machen jeweils nichts anderes als ein "Makefile" zu generieren das man dann mit make ausführen kann.

_________________
Yeah!

Ja, aber genau das macht Eclipse eigentlich auch - nur nicht mit den Anpassungen für Qt.

http://qt.nokia.com/developer/eclipse-integration/

Was ist denn die korrekte Art mit einem QGLWidget zu rendern? Ich habe versucht im OnIdle-Event QGLWidget::update() aufzurufen, wobei OnIdle von QAbstractEventDispatcher::aboutToBlock() ausgeführt wird. paintGL() wird zwar immer schön aufgerufen, aber gerendert wird nichts. Dazu müsste ich QGLWidget->swapBuffers() am Ende der paintGL-Methode aufrufen, allerdings ist das laut Dokomentation eigentlich überflüssig.

Ich habe auch versucht einen QTimer auf die updateGL()-Methode zu setzen, allerdings wird dann paintGL garnicht erst aufgerufen (das timout() vom Timer geht aber).

Mein Programm ist ganz simpel: Ein QMainWindow mit dem QGLWidget als centralWidget, sonst nichts.

Eine Unterklasse von QGLWidget erstellen und die folgenden Methoden überschreiben:
initializeGL() // wird einmal vor dem ersten paintGL ausgeführt
paintGL() // hier kommt der Render-Code rein
resizeGL(int width, int height) // Viewport-Größe setzen! => glViewport(0, 0, width, height);

Dann in irgendeiner Form updateGL() aufrufen. Z.B. mit einem QTimer.

Fragen:
Sicher das das QGLWidget auch wirklich sichtbar ist? Ggf. hat es die Größe "0" oder ähnliches. Dem QMainWindow musst du ggf. zuerst ein Layout zuweisen damit es weiß wie es das das QGLWidget behandeln soll.

_________________
Yeah!

Ach, sowas dämliches... Ich habe nicht paintGL, sondern paintEvent überschrieben....

Danke, jetzt hab ich es gemerkt

Noch zwei Hinweise zu Qt:

1. Falls du außerhalb der drei GL-Funktionen OpenGL-Befehle benutzen möchtest musst du makeCurrent() aufrufen. Ist z.B. nötig, wenn du in den Maus-Events für Selektion/Picking in ein FBO rendern willst. Das gilt immer wenn du irgendwie auf Events oder Signals reagierst.
2. Unter Linux und Windows ist es möglich andere QWidgets als Kinder eines QGLWidget zu haben. Unter Mac OS X klappt das aber nicht, also das ist nicht platformunabhängig. Allerdings ist es angeblich mit Hilfe der Klasse QGraphicsView möglich beliebige Qt-Widgets direkt mit OpenGL rendern zu lassen. Mir ist das aber noch nicht gelungen.

_________________
Yeah!