2D-SceneGraph Transformationen

[shadow]

Hallo,

ich hab mal ne Anfängerfrage zu OpenGL-Matrix-Transformationen in einem 2D-SceneGraph an die Profis hier...

Ich baue gerade meinen 2D-SceneGraph von Softwarerendering auf OpenGL um, daraus ergeben sich einige Umstellungen. Jede Transformation (translate/rotate/scale) wird nun an die Unterknoten weitergegeben, wie man das eben auch aus 3D-Engine-SceneGraphs so kennt. Soweit hab ich das auch ohne Probleme hingekriegt.
Jetzt bin ich allerdings an einem Problem angelangt, das ich hier hoffentlich verständlich schildern kann (auch wenn ich mir als Neuling hier etwas schwer tue): Ich möchte von einem bestimmten (Unter-)Knoten die Transformations-Matrix wissen, auch wenn ich gerade nicht in der render()-Routine bin. Z. B. brauche ich das für Kollisionserkennung und weitere Sachen.

Das Problem stellt sich erst seit der Umstellung auf OpenGL, und noch nicht vorher, aus folgendem Grund:

Jetzt transformiere ich die GL_MODELVIEW_MATRIX immer mit den glTranslatef(), glRotatef(), glScalef() Methoden und OpenGL erzeugt für mich so nach und nach die Matrix für meinene (Unter-)Knoten.
Vor dieser Umstellung hab ich die Transformations-Matrix für jeden Knoten einzeln selbst berechnet und konnte bisher diesen Schritt natürlich auch einmal willkührlich ausführen, also einen Konten nach seiner Matrix fragen, auch wenn ich nicht gerade diesen Knoten zeichnen wollte...

Mögliche Lösung: Ich könnte jetzt natürlich recht einfach dabei bleiben und das rendern bzw. das schrittweise Zusammenbauen der Transformations-Matrix für jeden Knoten über die OpenGL-Methoden glTranslatef(), glRotatef(), glScalef() machen, und wenn ich zu einem anderen Zeitpunkt außerhalb von SceneGraph.render() eine Matrix für einen Konten brauche, diesen dann wie "früher" selbst über Matrizen-Multiplikation etc. berechnen. Allerdings hab ich zu diesem Verfahren irgendwo aufgeschnappt, dass man OpenGL die Matrix-Transformationen überlassen und das nicht selbst berechnen soll. Für das rendern würde ich das ja auch tun, nur wenn ich sonst einmal eine Matrix brauche (was wahrscheinlich trotzdem sehr oft vorkommt), würde ich diese selbst berechnen. Daraus ergibt sich aber, dass es in meiner Software zwei Verfahren gibt, wie Knoten-Matrizen berechnet werden (einmal über die OpenGL-Funktionen und einmal über eine Matrizen-Berechnung) und das ist vielleicht nicht so schön...
Oder ich berechne einfach wie vorher auch für das rendern die Matrizen selbst. Ist u. U. etwas ungewöhnlich (?), weil es ja für diesen Schritt auch einfacher ginge, aber zumindest hätte ich dann eine zentrale Stelle für die Matrizen-Berechnung der Knoten...

Oder geh ich die Geschichte ganz falsch an? Mir fehlen da irgendwie die best practices...

Thanks a lot!
Stefan

/edit: und sorry für den langen Text, aber ich hatte befürchtet es kommt sonst nicht klar rüber :|

[kristof]

Du schreibst zwar nicht welche Version von OpenGL du nutzt, aber die fixed function pipeline ist schon eine ganze Weile deprecated. Das heisst, dass auch die Funktionen glTranslatef, glRotatef usw. deprecated sind.
Statt dessen war dein Bisheriger Weg schon ganz richtig. Du berechnest also die Matrizen selbst und übergibst sie dann als uniform deinem eigenen Shader.

[dot]

Allerdings hab ich zu diesem Verfahren irgendwo aufgeschnappt, dass man OpenGL die Matrix-Transformationen überlassen und das nicht selbst berechnen soll.

Und wieso sollte das so sein? Vergiss das einfach ;)

[Jonathan]

Ich den neuen OpenGL Versionen ist der ganze Matrix Kram eh rausgeflogen und die Programmierer müssen sich selber darum kümmern. Es spricht also nichts dagegen, Matrizen selbst zu verwalten und OpenGL beim Rendern die aktuelle Matrix zu übergeben.

[shadow]

Ok, dann werd ich die Matritzen-Berechnung wie bisher selbst vornehmen.

Was ist die Alternative für die "fixed functions pipeline"-Methoden, wenn man so einen SceneGraph wie ich erreichen will? Ich hab etwas recherchiert und stoße immer wieder auf Shader, was ja hier auch schon genannt wurde. Sind damit diese Dinger gemeint: http://de.wikipedia.org/wiki/OpenGL_Shading_Language :D ? Hört sich sehr aufwändig an, um ein paar Objekte auf dem Screen hin und her zu schieben...

Da ich grad erst frisch mit OpenGL angefangen hab, hab ich mir ein paar TexturedQuads-2D-Tutorials reingezogen, und da wurde mit glTranslatef, glRotatef etc. gearbeitet, das hab ich dann einfach auf meinen SceneGraph übertragen...
Welche OpenGL-Version sollte man aktuell benutzen... 2, 3, 4 ? Mein Binding reicht von OpenGL 1.1 bis 4.2... Ich hatte die Befürchtung dass ich mich mit einer zu neuen OpenGL-Version bei älteren Grafikkarten ins Aus schieße. Meine Zielgruppe ist der CasualGamer und da wäre es schwer zu erklären, warum man für ein Popel-2D-Spiel 'ne nagelneue GraKa bräuchte... ich würde mich auf einem Mittelweg wohl fühlen, der halbwegs moderne OpenGL-Programmierung erlaubt, aber trotzdem soweit verbreitet und unterstützt ist, dass ich da nicht in die Bredouille komme...

Danke für die bisheren infos, das bringt mich schon ein Stück weiter!

[Artificial Mind]

Also mit OpenGL 3 hast du schon die meisten neuen Features und es läuft auf sehr vielen Rechnern. Allerdings haben diese ganzen NetBook, Convertible und auch einige "normale" Laptops die ganz einfachen Grafikchipsätze wie z. B. einen Intel GMA, die unterstützen nur OpenGL 2.

Um schnell und gut die Shader und das "neue" OpenGL kennezulernen, kann ich diese Seite empfehlen: http://www.opengl-tutorial.org/

[Jonathan]

Bei CasualGamer dürfte das Problem sein, dass diese noch nie einen neuen Grafikkartentreiber installiert haben. Ich weiß nicht, ob sich das mittlerweile gebessert hat, aber viele fertig PCs werden mit Treibern ausgeliefert, die einen miserablen OpenGL Support haben. Bei Desktoprechnern lässt sich das meist durch ein Treiberupdate beseitigen, aber bei Laptops und Co. könntest du da echte Probleme bekommen.

Allerdings reicht natürlich OpenGL2 für 2d Spiele aus. Wenn du keine Shadereffekte haben willst. Und du musst ja auch in OGl2 nicht die Matrixfunktionen nutzen, sondern kannst alles selber berechnen und dann glLoadMatrix() benutzen.

[shadow]

Danke für den Link, werd ich mir bei Gelegenheit ansehen. Vorerst muss ich allerdings bei OpenGL 2 bleiben. Hab gesehen, dass sogar mein eines Notebook hier nur OpenGL 2 unterstützt und das Teil ist nicht unbedingt uralt, sondern Durchschnitt würde ich sagen :/ ...
Ich werd jetzt wie vorgeschlagen bis auf Weiteres so vorgehen, dass ich die direkten translate, rotate, scale Methoden von OpenGL umgehe, und alle Matrizen selbst berechne, diese dann mit glLoadMatrix lade.

Danke für die Unterstützung :!: