Hi alle zusammen,

ich habe eine grundlegende Verständnisfrage zu der OpenGL Rendering Pipeline:

1.)
Wir beleuchten ja nach der ModelView-Matrix, da wir dann die Eckpunkte und Normalen haben und die Kamera richtig angeordnet ist. Das ganze ist zu dem Zeitpunkt im Rechtssystem. Warum beleuchtet man im Rechtssystem? Könnte man nicht prinzipiell von hier auch ins Linkssystem gehen und dann beleuchten? Warum passiert die Rechts-Links-Transformation erst nach der Projektion?

2.)
Wie kann man mathematisch auf Augpunkt, Center-of-Interest und UP-Vektor die Kamerakoordinaten berechnen?

3.)
Wie kann ich die View-Matrix berechnen? Aus gluLookAt()?

4.)
Wieso muss vor der Beleuchtung die Normale mit der transponierten Inversen multipliziert werden?


Danke schonmal für alle kommenden Antworten

LG RapidM

Ich versuch mal so gut wie möglich auf die Fragen zu antworten:

1) Warum im Rechtssystem? Ich nehme mal an man musste sich auf irgendwas einigen und hat das einfach so festgelegt. Wenn man ins Linkssystem wollte, müsste man alle Koordinaten umrechnen, oder man ändert die Kamera-Matrix. In GLSL-Shadern herrscht natürlich auch das Rechtssystem und da alles umzurechnen würde dann auch eine Zeit dauern und wäre nicht gerade geschwindigkeitfördernd.

2) Kamera-Koordinaten? Meinst du die Matrix?
Die ergibt sich eigentlich ganz einfach aus den Vektoren die den Raum aufspannen. Also der erste Vektor zeigt aus sich der Kamera nach rechts und ergibt sich aus dem Kreuzprodukt der Blickrichtung und dem Up-Vektor (im Rechtssystem). Der zweite wäre dann der Up-Vektor und der dritte die Blickrichtung. Der Vierte ist die Kamera-Position (Augpunkt). Ob die Vektoren jetzt nach Spalten oder Zeilen sortiert in der Matrix stehen kann ich jetzt nicht sagen.
Die Vektoren sollten (müssen?) senkrecht aufeinander stehen, also wenn man leicht nach unten guckt, muss der Up-Vektor auch in diese Richtung geneigt werden. Außerdem sollten die Vektoren normiert sein, ansonsten bekommt man wahrscheinlich merkwürdige Verzerrungen.

3) Kurz, Ja.
Ansonsten "manuell" wie oben beschrieben und mit glLoadMatrix bzw glMultMatrix laden.

4) Also nachdem die Positionen der Vertices aus dem World-Space in den Eye-Space umgerechnet wurden (indem sie mit der Modelview-Matrix multipliziert wurden) müssen, natürlich die Normalen auch umgerechnet werden, damit sie relativ zu den anderen Vertices wieder in die richtige Richtung zeigen.
Allerdings sollen die Normalen nur gedreht werden, weshalb man sie mit der transponierten Inverse der ModelView-Matrix transformiert. Einfach nur den vierten Vektor der Matrix auf (0,0,0) setzen, funktioniert in den meisten Fällen leider nicht, insbesondere wenn man mehrere Drehungen gemacht hat. Das kann man auch zeigen und irgendwo in dem Forum hier steht der Beweis auch.

Vielen Dank für die Antwort.

Nochmal zu dem Punkt 1.)
Also die Normalen zeigen ja im Rechtssystem nach innen. Wechselt man ins Linksssystem zeigen sie nach außen.
Die beleuchtung geschieht allerdings im Rechtssystem, weswegen man dann wahrscheinlich die Normalen mit der transponierten Inverse umrechnen muss, damit sie logischerweise nach außen zeigen.
Ist nun die Frage, wieso man die Beleuchtung nicht erst nach dem Schritt R-> L macht, wo die Normalen eh umgdreht werden... ??


Bei der Stelle komm ich noch nicht ganz zurecht.... Jemand eine Lösung? Oder einen Ansatz?

Danke

Also eigentlich zeigen die Normalen im Rechtssystem auch nach außen. Oder kommt drauf an was innen und außen ist.
Wenn ich zum Beispiel eine Kugel habe und die soll von einer Lichtquelle die außerhalb liegt angeleuchtet werden, müssen die Normalen vom Mittelpunkt der Kugel weg zeigen.
Ich nehme mal an wenn man die Koordinaten im Linkssystem angibt, also zB die x-Koordinate umkehrt und dann das Kreuzprodukt im Linkssystem anwendet zeigen die Normalen in die selbe Richtung wie im Rechtssystem (wenn auch die Koordinaten natürlich noch unterschiedlich sind). Das könnte man auch einfach mal mit einem Zahlenbeispiel durchtesten.
Und um die Normalen umzudrehen würde es auch reichen das Vorzeichen zu ändern.

Ich hab nochmal im Internet nachgeschaut wegen der transponierten Inverse. Der Grund warum man die verwendet waren nicht die Drehungen sondern "non-uniform scaling". Also die transponierte inverse Matrix wird nicht zur Umrechnung vom Links ins Rechtssystem benutzt, sondern um die Normale zu drehen.
Non-uniform scaling ist wenn ein Faktor anders ist als die anderen. Also wenn man mit (2,2,2) skaliert, also alles doppelt so groß macht kann man auch den oberen linken 3x3 Teil der Modelview-Matrix nehmen um die Normalen zu transformieren. Bei (1,2,1) zB aber nicht mehr. => Lösung: die transponierte inverse Matrix verwenden.
Das Errechnen macht OpenGL (zum Glück) alles selber.

Nochwas was ich oben falsch geschireben hatte: Der dritte Vektor der Kamera-Matrix ist die umgekehrte Blickrichtung. Wodurch sich dann auch aus der Standard-Kamera-Position die Einheitsmatrix ergibt (oder anders rum).

Also ich weiß nicht ob du das jetzt verstanden hast. Alles versteh' ich leider auch nicht, aber vielleicht hatts ja ein bischen geholfen. Ansonsten erschließt sich dir das vielleicht nach und nach wenn du mit OpenGL arbeitest.