Wußte jetzt nicht besser wie ich das Thema beschreiben sollte.

Mein Problem ist, dass ich mit glTranslatef meine Szene verschiebe, nur nach Y-Richtung um einen Faktor CamPosY.
Dann habe ich noch eine interne Datenstruktur, ein 2-dimensionales Array von Mittelpunkten, das sich entsprechend bewegen soll.
Also setze ich die Y-Koordinaten der Mittelpunkte auch auf CamPosY.

Mein Problem ist jetzt, dass sich die Szene senkrecht nach oben bewegt, aber die Mittelpunkte schräg nach links oben.
Richtet sich Translatef nach der Kameraposition ? Also bewegen sich die tatsächlichen X/Y/Z Koordinaten bei Translatef(0,1,0) nicht immer +1 für die Y-Werte ?

BTW: Z-Koordinaten sind eigentlich egal, liegt alles in der Ebene mit Z=0

Hier mal meine Zeichenfunktion:


Und hier Ausschnitte aus der Funktion die die Datenstruktur anpaßt

Das hat was mit Matrizen zu tun. (Ich schreib gerade an ner nicht wissenschaftlichen erklärung dazu hab aber mom. keine Zeit dran zu basteln )

Die erklärung is an sich aber ganz simpel:

Wenn du deine Welt rotierst dann zeigen die Achsen in andere Richtungen. Eine verschiebung hat nach einer Rotation damit ein anderes ergebnis als wenn du zuerst verschiebst und dann rotierst.

Das heißt: glTranslatef(0,1,0) verschiebt nicht 1 nach oben sondern 1 in Y-Richtung. Und diese Richtung ist abhängig von den zuvor gemachten rotationen.

_________________
Blog: kevin-fleischer.de und fbaingermany.com

Die Operationen werden auf die Aufrufsreihenfolgee bezogen rückwärts ausgeführt

@Lars: Wie bitte? Das versteh ich jetzt ned ich hab obiges zwar (fast) immer automatisch richtig gemacht, aber deine Antwort irritiert mich a bissl, ich möchte ja auch die Hintergründe ein bisschen checken.

_________________
"Du musst ein Schwein sein in dieser Welt, sangen die Prinzen, das ist so 1.0. Du musst auf YouTube zeigen, dass dir dein Schweinsein gefällt, das ist leuchtendes, echtes Web 2.0."
- Hal Faber
Meine Homepage: http://laboda.delphigl.com

Ahh danke und schon wieder wurde mir geholfen
Jetzt muss ich nur noch rausfinden wie ich die Achsen auch für mein Array mitdrehe. Ich vermute mal Sin, Cos und Poolarkoordinaten sind hier die richtige Methode, oder ?

Wenn man ein Object an (x|y|z) darstellen will und dort drehen will, macht man ja
glTranslatef(x,y,z)
glRotatef(...)

glRotatef dreht aber immer nur um den Ursprung. Also ist es ja eigentlich so, dass das Objekt erst um sich selbst gedreht und dann an x,y,z verschoben wird.

Nein! Der Teufel steckt bei OpenGL im detail und ist Technisch bedingt anders.

Das was du beschreibst ist exakt die Vorgehensweise, die man rein Mathematisch macht, wenn man Matrizen aufstellt um eine bestimmte Transformation/Rotation/Scalierung was auch immer zu bewerkstelligen.

OpenGL/oder ein PC im allgemeinen kann das nicht machen (Außer er kennt alle! Operationen). Wann immer du bei OpenGL Translate oder Rotate aufrufst, wird sofort die Matrix geändert. Da dies der Umgekehrten Reihenfolge entspricht, die z.B. im CompGeo-Script erklärt wird, kann man das so auslegen:

Während die Mathematische herangehensweise von globalen Koordinatentransformationen ausgeht, arbeitet OpenGL mit einem Lokalen Modell. D.h. jedes Objekt "besitzt" seine eigene Matrix.

Für den OpenGL User ist nur folgendes wichtig:

Rotier ich bevor ich verschiebe, entspricht die Verschieberichtung NICHT den ausgangskoordinatensystem sondern dem neuen durch die Drehung entstandenen. Im allgemeinen (außer man macht es bewusst) gilt: erst verschieben dann drehen.



Wie gesagt wollte ich dazu ein Tutorial verfassen und ich hab mich gewundert, wieso die OpenGL ergebnisse net mit meinen rechnungen übereinstimmten. Dadurch bin ich darauf gekommen. Das sind quasi meine Erklärungsversuche zu dem Thema. Hoffe ihr seit dadurch net dodal verwirrt.

_________________
Blog: kevin-fleischer.de und fbaingermany.com

Also um das ganze mal zu verdeutlichen habe ich von der Szene eine Skizze von oben gemacht (in wirklichkeit liegt das ganze isometrisch, aber das spielt ja keine Rolle)

Bild 1 zeigt wie es nach dem oben geschrieben Code sich verhält. Genauso sollte es auch sein, die Fläche soll sich immer nach oben/unten/rechts/links bewegen.
Bild 2 zeigt wie es wäre, wenn ich die Reihenfolge von Translate und Rotate verschiebe, bzw. wie sich im Moment meine Datenstruktur verschiebt.

Ich will dann sozusagen, dass meine Datenstruktur sich auch wie in Bild eins bewegt

genau!

_________________
Blog: kevin-fleischer.de und fbaingermany.com

Ich bekomms nicht hin. Meine blöde Datenstruktur bewegt sich immer noch wie in Bild zwei.

Ich hab diese Formeln benutzt: http://mo.mathematik.uni-stuttgart.de/inhalt/aussage/aussage611/ um die Koordinaten anzupassen, aber da scheint bei mir ein Fehler zu sein.


MovementAngel soll den Winkel angeben in dem sich der Punkt eigentlich bewegt. Darauf addiere ich dann weiter unten den Winkel um den die ganze Szene gedreht ist. CamPosX und CamPosY geben ja an um welchen Wert die Szene verschoben wird, also dachte ich das wäre dann der Radius und der Winkel eben die Addition aus orbitAngel (bzw. radiant) und movementAngel.

Was machst du denn da?

Willst du die Matrizen wirklich per Hand berechnen? OpenGL macht doch alles für dich!

_________________
Blog: kevin-fleischer.de und fbaingermany.com

Das Problem ist, dass ich zu jedem Feld einen Haufen Meta-Daten benötige.
Also habe ich einmal die Darstellung und dann ein zwei-dimensionales Array, das die Fläche in Quadrate aufteilt und Zusatzinformationen speichert. (Anzahl Bäume, Displaylisten, LoD-Geschichten, etc...)
Und ich muss über eine Funktion immer zumindest den Mittelpunkt aller dieser Quadrate bestimmen und diese mit der tatsächlichen Darstellung synchronisieren. D.h., wenn ich die Szene mit rotate drehe müssen die Mittelpunkte des Arrays auch rotieren, skalieren, bewegen.
Rotieren und Skalieren tut, Bewegen leider eben nicht.

Hmmm der Sinn erschließt sich immer noch net ganz... Wieso müssen die Sachen den Mitgedreht werden. (Erklär mal deine Intension. Eventuell gehts leichter.)

Wenn du die Metadaten in einem Feld abspeicherst, dass deiner Karte entspricht, dann benötigst du nur den Index des entspr. Feldelements um deine Metadaten wiederzufinden. Fürs zeichnen musst du da nicht drehen...

Wenn du irgendwas an den Mittelpunkt eines Feldes Zeichnen willst, dann zeichne es einfach direkt nachdem das Feld selbst gezeichnet wurde. Dadurch hats das selbe KOS und du musst gar nich rechnen. Schließlich dreht sich (im Normalfall) ja nur die Kamera um die Welt. Die Koordinaten der Welt bleiben dadurch unverändert.

Naja erzähl erstmal, dann schaun mer weida...

_________________
Blog: kevin-fleischer.de und fbaingermany.com

Also allgemein wird das ganze ein 3D Previewer für eine Pflanzenverteilung. Da aber um die 2 Millionen Pflanzen gegen Ende berücksichtigt werden müssen will ich sehr starke Optimierungen programmieren.
Dafür habe ich die Verteilung der Pflanzen in ein Raster eingeteilt damit ich später nicht für jede Pflanze Culling und LoD machen muss sondern grober nur die Quadrate berücksichtigen muss.

Die Kamera steht die ganze Zeit fest, drehen und bewegen tut sich die komplette Szene. Und wenn ich mit translate, rotate und scale arbeite müssen ja die X- und Y-Koordinaten meiner Quadrate entsprechend geupdatet werden. (es geht ja nicht nur ums Aussehen der matrize sondern auch Abstandsmaße und Lage müssen für LoD und Culling stimmen)
Also hab ich eine Update-Funktion die die X- und Y-Werte meiner Datenstruktur eben immer anpassen.

Inzwischen habe ich es mit einigen Mühen selbst hinbekommen die Werte richtig zu verschieben.

Ein Beobachter merkt solange nicht, ob sich die Welt oder er selbst dreht, solange sich nur eins dreht. Du hättest also auch einfach nur die Cam drehen müssen.

Der User kann die Bewegungen erst auseinander halten, wenn beide Zeitgleich auftreten. (Solche Phylosophische Fragen ("Dreht sich das universum um dich oder du ums Universum") werden in den ersten Tuts geklärt.

Eventuell hätte das deinen Code bisl einfacher gehalten.

Naja jetzt gehts anscheinend.

_________________
Blog: kevin-fleischer.de und fbaingermany.com