Hallo,

ich erkunde zur Zeit, welche Möglichkeiten es gibt, die Kamera zu verstellen, also praktisch in der Szenerie herumzuwandern. Dabei ist mir noch unklar, welche Vor- und Nachteile die verschiedenen Ansätze haben. Vielleicht könnt Ihr mir ein paar Tips dazu geben.

1. Bevor die Szenerie gezeichnet wird, rotiere und verschiebe ich das Ganze mit glRotate und glTranslate, wobei nach meiner Beobachtung diese Reihenfolge eingehalten werden muss. Damit habe ich, wenn ich das richtig verstanden habe, so etwas wie eine Grundmatrix erzeugt, auf der dann alles aufbaut. Offensichtlich muss ich anschließend glLoadIdentiy meiden.

2. In einem DGL-Wiki fand ich den Ansatz, nicht die Modelview-Matrix, sondern die Projektionsmatrix zu änderen, also glTranslate und glRotate direkt nach dem üblichen gluPerspective aufzurufen. Die Ergebnisse sind bei mir noch ein bisschen kraus, aber ich hab's auch noch nicht systematisch untersucht.

3. Ja, und dann fand ich bei einem Blick in ein anderes Programm noch folgende Methode: Aus Kameraposition und Blickrichtung wird eine 4x4-GL-Matrix berechnet (verdammt kompliziert) und dann mittels glMultMatrix mit der Identity-Matrix multipliziert. Die Wirkung scheint dieselbe zu sein wie beim Ansatz 1.

Gibt es Gründe, die eine oder andere Methode zu bevorzugen oder zu meiden? Oder gibt es noch andere Methoden (kleiner Tip genügt, untersuchen kann ich es selber).

Ich kann, vorallem, wenn du später noch kompliziertere Sachen, wie z.B. Shader, vorhast, die 2. Methode empfehlen. Denn sonst könnte es später schwierig werden, die glRotate/glTranslate-Aufrufe, die du für die Kamera gemacht hast, von denen zu trennen, die für Rotation oder Translation der einzelnen Modelle zuständig sind.

Da du gesagt hattest, dass du damit probleme hast, kann ich dir hier mal einen kleinen Tipp geben, der vorallem auch die Performance steigert:
Wenn du jetzt beim resize-Event (in der VCL OnResize) oder beim Initialisieren deine Projektionsmatrix setzt, speicherst du das, was da nach gluPerspective drin steht erstmal in eine Variable. Dazu gibt es glGetFloatv:

An der stelle, wo du während dem Rendern deine Kamera setzt, tust du jetzt folgendes:


Jetzt kannst du auch während dem Rendern, solange du in der ModelViewMatrix bleibst, nach belieben glLoadIdentity aufrufen, die Projektionsmatrix bleibt davon verschont.

Gruß Lord Horazont

_________________
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

@Lord Horazont:
Wie viel Performance gewinnt man denn dadurch? Wenn sich das lohnt, ist es eine gute Idee, dann werde ich das ab sofort auch so machen

@erin:
Ja, ich empfehle auch die Speicherung der Kamera in der Projektionsmatrix. Aber wenn du nicht vorhast mit shadern zu arbeiten, dann kannst du das auch in der ModelviewMatrix machen (hat den Vortel, dass die Projektionsmatrix gleich bleibt und du somit wiederum etwas Performance gewinnst).

Eine Matrix musst du nicht unbedingt erstellen (wie in 3.). Ich mache es zurzeit auch so, dass ich mit glrotate und gltranslate arbeite. Aber so eine Kamera-Matrix kann natürlich für spätere Effekte sinnvoll zu gebrauchen sein. Aber wenn du momentan keinen Vorteil darin siehst kannst du es auch wie in Punkt 1 machen.

_________________
http://texelviews.delphigl.com

Also ich hatte auch mal die dritte Variante mit der Berechnung der Matrix aus Translationsvektoren und Blickwinkeln mit einer ganzen Menge Cos und Sin... Das war sehr kompliziert und im Endeffekt war die Modifizierung sauanstrengend, deswegen bin ich nun auch wieder bei eine Translationsvektor und zwei Blickwinkeln, die ich dann per glTranslate und glRotate einsetze.

Du kannst sehr wohl glLoadidentity benutzen, nur musst du vorher die Matrix speichern.
Das könnte dann so aussehen:



So funktioniert das auch. Also ich hatte bisher noch nie Probleme bei der Positionierung von Modellen ueber diese Variante, wenn man etwas dreht, sichert man eben kurz die Matrix und restored sie danach wieder und alles ist wunderbar. Mit Translate und Rotate kann man sich zuweilen sogar sehr umständliche Rechnungen ersparen, da man letztlich nur die Differenzwerte zwischen dem aktuellen Objekt und dem zuletzt gerenderten benötigt; ruft man stattdessen dazwischen immer glLoadIdentity auf, müsste man immer wieder die absoluten (also auf den Nullpunkt bezogenen) Koordinaten einsetzen.

Vor allem, wenn du Camerabewegungen- und Drehungen simulieren willst, ist diese Variante über Rotate und Translate meiner Meinung nach hübsch einfach; vor einigen Wochen hatte ich das alles mal über selbsterrechnete Matrizen gelöst und als ich dann Camerapathmovements einbauen wollte, bin ich beinahe wahnsinnig geworden und hab alles wieder umgeschrieben.

Meine Meinung

Soweit hat die Methode auch kein Problem, aber sobald du dann versuchst, Modelkoordinaten mit Shadern zu verarbeiten wirds haarig, weil du die Kamerabewegungen wieder wegbekommen musst, ohne aber gleich die ganze Modelmatrix wegzulassen, da das Modell z.B. auch gedreht sein könnte.

Solange man keine Shader benutzt, ist die Methode einwandfrei. Aber es ist vielleicht besser, sich jetzt schonmal das andere anzugewöhnen, wenn man später irgendwann mit shadern arbeiten will.

Meine Meinung ²

Gruß Lord Horazont

_________________
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

Vielen Dank für Eure Antworten, sie haben mir sehr geholfen, und ich sehe nun deutlich klarer. Ich bin ein Verfechter von möglichst einfachen, gradlinigen Verfahren und werde deshalb die beiden Ansätze mit glRotate und glTranslate gründlich untersuchen.

Trotzdem möchte ich das Matrix-Verfahren nicht ganz unter den Tisch fallen lassen, auch deshalb, weil man eine Menge daran lernen kann. Nicht zuletzt hat sich die Funktion erwiesenermaßen bewährt (sie stammt aus Tuxracer) und ist vor allem geeignet, wenn die Kamera z.B. einem bewegten Objekt folgen soll. Ich gebe den Code hier mal wieder. Es ist zwar C-Code, aber auch für einen Pascaller problemlos zu lesen. Außerdem lässt er sich fast 1 : 1 nach Pascal übersetzen.



Ich habe die Funktion mal in einem kleinen C-Testprogramm ausprobiert und war insofern begeistert, als man hier alle Bewegungsfreiheiten hat. Für die Kamerabewegung mit Tastatur oder Joystick ist sie jedoch nicht geeignet. Zwar kann man die Kamera sehr schön in allen drei Dimensionen verschieben, aber es hapert bei der Rotation. Der Blickwinkel wird hier als Vektor verarbeitet (viewdir). Die Vektor-Komponenten zu verstellen, hat keinen Sinn. Erstens ist die Rotation dabei nicht linear, zweitens ist bei 90° Drehung Schluss, d.h. dier Winkel nähert sich asymptotisch der 90°-Grenze.

Das Fehlen von "griffigen" Rotationswinkeln macht sich ferner bei Bewegungen nach einer Rotation bemerkbar. Ich will mich ja vorwärts in Blickrichtung bewegen und nicht stur längs der Z-Achse. Für die Positionskorrektur brauche ich aber die Drehwinkel, oder?

Egal, ich werde auch dieses Teil demnächst nach Delphi umschreiben und für Fälle bereitstellen, wo sich die Blickrichtung als Vektor ergibt.

Gruß
Reinhard