Das mit dem Mü meinte ich, wenn man den Help aus dem Richtungsvektor zieht (also richtung x glob. oben). Irgendwann werden die x und y. Komponenten sooo klein, dass sich keine Vernünftige Richtung für Help mehr ermitteln lassen (Thema Float und Runden). Jetzt sagt man folgendes: Wenn die Bewegung einen bestimmten Steilheitsgrad überschreitet (nahe ez), dann berechnet man help nicht mehr, sondern lässt ihn so wie er ist (hat aber den Nachteil, dass sich das 'Fahrzeug' nicht mehr um die eigene Achse drehen kann).
mu wäre also ein Schwellenwert für den Winkel zwischen richtung und oben.
Das Gefummel mit mu kann man sich allerdings sparen, wenn man den help-Vektor bei der tastaturabfrage 'mitpflegt', also nicht nur die Richtung aus den Eingaben ermitteln, sondern auch help um 90° verdreht auf der x/y Ebene (mit Einheitslänge). Dann wied das Keruzproduckt aus Richtung und help nie undefiniert oder uneindeutig (ausser man codiert die Geschwindigkeit auch in den Richtungsvektor und das 'fahrzeug' hält an).

_________________
Manchmal sehen Dinge, die wie Dinge aussehen wollen, mehr wie Dinge aus, als Dinge.
<Esmerelda Wetterwax>
Es kann vorkommen, dass die Nachkommen trotz Abkommen mit ihrem Einkommen nicht auskommen und umkommen.

Also ich habe mich heut in der Schule nochmal dran gesetzt und habe mir gedacht, dass ich evtl auch bei der Translation eine Matrizenmultiplikation ausführen muss. Ich habe es ja bisher so gemacht, dass ich beim Rotieren eine Zwischenmatrix erstelle und diese mit meiner Rotationsmatrix multipliziere, die ich dann lade. Da hatte ich es aber immer so gehandhabt, dass ich die Translationsvektoren (also die 4. Spalte) manuell eingetragen hab zb: x=0, y=0, z=-2 und dann sehe ich mein Objekt direkt vor mir.

Ich habe es jetzt mal umstellt, sodass ich auch bei der Translation eine Zwischenmatrix erstelle, dort den Translationsvektor angleiche (also in diesem Fall Zwischenvektor[14]:=-2) und dann die Matrix wieder mit meiner Rotationsmatrix multipliziere. Das Resultat war... das selbe ^^ Es sah ganz genauso aus wie vorher.

Ich weiss selber, in welcher Reihenfolge ich Translate und Rotate ausführen muss, dass ich mich um das Objekt drehe, aber ich will ja kein Rotate und Translate nutzen.

Also nochmal alle wichtigen Prozeduren:






Die erzeugte Matrix lade ich am Ende mit:
glLoadMatrixf(@Camera.Rotation);


Noch einmal zum Problem (:)) : Das Objekt selber dreht sich wunderbar ganz toll in alle Richtungen, alles funkt super.
Ich will mich aber ums Objekt drehen ^^

(habe auch bereits mal den Translationsvektor aud der Matrix rausgenommen und manuell nach dem Laden der Matrix die Verschiebung durch Translate versucht und auch das hat kein anderes Resultat gebracht)

Hallo Shaddow,
diese etwas abgehobene Diskussion hat Dir nicht viel genutzt, das sehe ich ein. Bitte entschuldige, ich versuche es noch mal, und verweise auf meine Antwort von heute morgen, wie man ein Objekt von links anschauen kann.

Wenn Du dieses Beispiel so expandierst, dass Du es
--- von vorne,
--- von links,
--- von hinten,
--- von rechts
ansehen kannst, dann bist Du doch einmal um das Objekt herumgefahren, mit anderen Worten: Du hast Dich um das Objekt herumgedreht. Für den einfachen Fall, dass Du Dich nur um die Y-Achse drehst (das ist eigentlich ein 2D-Fall), bedeutet das:

1) Die KAMERA-POSITION befindet sich auf einem Kreis um das Objekt. Die einzelnen Positionen kannst Du über Sinus/Cosinus auffinden: der Vektor Koordinatenursprung-->Kamera-Position. Das nötige glTranslate ist jetzt der genau umgekehrte Vektor davon: der Vektor Kamera-Position-->Koordinatenursprung.

2) Die nötige KAMERA-ROTATION findest Du, indem Du den Winkel zwischen dem Forward-Vektor der Kamera (das ist der Vektor (0,0,+1)) und dem (Einheits-)Vektor KameraPosition -> Koordinatenursprung berechnest. Das nötige glRotate ist nun die genau entgegengesetzte Drehung um die Y-Achse: wenn die Drehung vorher positiv (gegen den Uhrzeigersinn) war, muss es jetzt eine negative Drehung (im Uhrzeigersinn) sein.

Diese Berechnungen machst Du jetzt so oft wie Du das für nötig hältst, - das heißt, z.B. 360 mal wenn Du pro Grad rendern willst - und fährst auf diese Weise um Dein Objekt herum.
Traude

Ich dachte zwar kurzzeitig, ich haette es jetz verstanden... aber verstanden hab ichs trotzdem nich.
Ich versteh einfach nich, wie ich das berechnen soll. Ich verstehe weder wie ich das mit der Kreisbahn realisieren soll, noch wie ich das ganze dann fuer jedes einzelne Objekt umsetzen soll.

Im Grunde will ich ja nur wissen, wie man aus


einen Code macht, der genau das gegenteil tut ^^

Ich habe mir deinen post jetzt echt sicher 3 mal durchgelesen, aber ich kriegs nicht ^^

Du willst in die andere Richtung drehen? Leute die sich mit Matrizenrechnung auskennen, werden dir antworten: Transposition. Sprich Du must Zeilen mit Spalten in der Matrix vertauschen - also eigentlich nur die Indizes richtig verändern. Dieser Trick Funktioniert allerdings nur mit Rotationsmatrizen! Ansonstern kann man aber auch mit negaitvem Winkel drehen, das läuft auf das selbe hinaus - bei Rotationsmatrizen von denen man nur weiss, daß es sich um Rotationsmatrizen handelt, ist aber der Transpositionstrick sinnvoll.

Nein nico ^^ das will ich nicht das mit der transposition kenn ich ja.
mit "das gegenteil" meinte ich:
Ein Objekt soll sic nict um sich selbst sonder um mich drehen und da weiss ih noch immer nicht wie ich das realisieren soll

Hallo Shaddow,
ich hatte heute und gestern ziemlich viel zu tun, und dann noch gestern weggewesen und "gelumpt", heute steht mir das nochmal bevor, kann daher heute nicht. Aber ich hatte ein Beispielgrogramm für Dein erstes Programm gemacht (sonst hätte ich den Fehler nicht gefunden). Ich mache Dir einen Vorschlag: ich schreibe morgen einen Beispielcode und poste das, wenns fertig ist.
Traude

Hallo Shaddow,

Vorneweg gleich ein Paar Dinge:

1. die Reihenfolge, die ich oben beschrieben habe (zuerst Translation, dann Rotation) war falsch. Es ist genau andersrum.
2. Sei nicht enttäuscht, wenn das Resultat genauso aussieht, wie eine normale Objektrotation. Denn wenn man nur ein Objekt rotiert, kann man keinen Unterschied erkennen. Aber Du weißt ja selbst, dass es ein großer Unterschied ist, ob man zuerst rotiert und dann verschiebt, oder es andersrum macht.
3. Ich habe das Demo nur mit den OpenGL-Befehlen gemacht. Wie Du das in Deine Matrizen packst, musst Du selber wissen.
4. Das Demo arbeitet mit der Höhe/Breite des Fensters in Pixeln.
5. Ich habe drei verschiedene Fälle hineingeschrieben, die ersten beiden sind auskommentiert
6. Die globale Variable "Angle" muss zu Programmbeginn auf Null gesetzt werden.
7. Die Prozedur braucht die Units Math und dglOpenGl zum Kompilieren.




Fürs Prinzip ist es völlig egal ob Du das mit Matrizen oder mit Translate/Rotate machst. VIEL WICHTIGER IST ABER, zu erkennen, dass man mit diesen beiden Befehlen Rotate/Translate bereits alles in der Tasche hat. Ehrlich! Du kannst damit komplexe animierte Objekte herstellen, wenn Du diesen Schritt jetzt schaffst. Es ist alles Trigonometrie und 3D-Mathe, häufig sogar gar nicht kompliziert. Was Du mit OpenGL machen kannst, hängt NUR VON DEINER VORSTELLUNGSKRAFT AB.
Traude

Erst ma danke fuer deine Mühe

Aber alles was du da geschrieben hast, wusste ich schon ^^


Genau das ist es, was ich wissen wollte ^^ Wie uebersetze ich Rotate+Translate in eine Matrix

Öh, das hab ich aus Deinen Fragen nicht herausgehört.

Wenn Du glRotate sagst, brauchst Du ja einen Winkel. Also HAST Du einen Winkel, nicht wahr? den übergibst Du an Deine MatrixErzeugungs-Funktion (Du hast ja sogar schon eine geschrieben!), und als Ergebnis kommt jetzt eine X- oder Y- oder Z-Rotationsmatrix heraus. Diese Rotationsmatrix fütterst Du mit glLoadMatrix oder glMultMatrix (je nachdem) ins OpenGl hinein.
Aber das weißt Du doch selber oder?


Nachtrag: oder möchtest Du wissen, wie man um eine beliebige Achse rotiert? Genau das tut glRotate ja schließlich.
Ich habe das nach diesem Link gemacht: http://www.gris.informatik.tu-darmstadt.de/~tkirste/GDV-I/03-Affin.pdf,
Du findest die nötigen Unterlagen auf Seite 14.

Genau das hab ich ja schon alles. Ich lasse ein Objekt um seine Achse rotieren. Aber ich willl, dass das Objekt um mich herum rotiert. Mir gehts jetz nur drum: wie veraendere ich meinen Code, dass genau das passiert?

Neuerlicher Anlauf,
diesmal hab ich die glRotate-Befehle in DEINE Matrixschreibweise übersetzt und habe bei Punkt drei noch eine Objektrotation hinzugefügt (wenn Dir das jetzt auch nicht gefällt, dann geb ichs auf):

Wir kommen der Sache ja jetz immer naeher ^^

Also das hatte ich soweit schon ma in etwa:



Rotation ist jetzt eine Rotationsmatrix, wo die vierte Spalte die Form (0,0,0,1) hat, also keine Auswirkungen.

Wenn ich jetz "manuell" mit Translate um einen Vektor verschiebe, dann funkt alles so wie ich möchte. Aber in der Matrix gibt es ja nicht umsonst diese 4. Spalte, das ist ja die Verschiebungsvektor, den will ich ja nutzen. Wenn ich jetz die vierte Spalte in der Form (0,0,-2,1) mache und das Translate nutze, dann dreht sich wieder nur das Objekt.

Ich muss jetz einfach dieses Translate irgendwie in die Rotationsmatrix einbauen. Habe das bereits ueber das erzeugen einer seperaten Matrix, die dann mit der Rotationsmatrix multipliziert wird, getestet, aber bringt nix.

Wie sich Deine endgültige Transformations-Matrix verhält, hängt davon ab wie Du sie erzeugt hast. Du musst dazu einfach Deine Kenntnisse über Matrizenmultiplikation zu Hilfe rufen (Matrixmultiplikationen sind nicht kommutativ):

Wenn Du eine Matrix basteln willst, die SOWOHL rotiert ALS AUCH verschiebt, musst Du Dir überlegen, was Du haben willst:



----- Wenn Du zuerst verschieben und dann erst rotieren möchtest, musst du zuerst eine Translationsmatrix erzeugen und sie dann mit einer Rotationsmatrix multiplizieren. Das Gleiche kommt heraus, wenn man es wie Du macht, indem man einfach die letzte Spalte mit Werten besetzt. Offenbar warst Du Dir nicht bewußt, dass Du damit bereits eine Rechenoperation vollzogen hast.

TRANSFORMATIONSMATRIX1 = TRANSLATIONSMATRIX X ROTATIONSMATRIX



----- Wenn Du zuerst rotieren und dann verschieben willst, dann erzeugst du einfach Deine Rotationsmatrix zuerst und multiplizierst Deine Translationsmatrix dazu:

TRANSFORMATIONSMATRIX2 = ROTATIONSMATRIX X TRANSLATIONSMATRIX


und die beiden sind nicht identisch:

TRANSFORMATIONSMATRIX1 <> TRANSFORMATIONSMATRIX2

Also ich habe jetzt (dank der aktiven Hilfe von Traude ^^) die Lösung ^^


Es geht nicht, dass ich nur eine Matrix habe und diese Matrix dann du Multiplikation immer wieder verändere.
Ich brauche
1 Translationsmatrix (Eine Einheitsmatrix, bei der nur die 4. Spalte verändert wird (Translationsvektor)
1 Rotationmatrix (EIne Matrix, bei der die ersten 3 spalten per Sin/Cos berechnet werden, wie im Tutorial Nachhilfe beschrieben wird)

1 Transformationsmatrix, die das Produkt aus beiden Matrizen ist

Wenn man diese Matrix lädt, geht alles Wunderbar.
Ich habe das jetz nur kurz getestet und es geht. Ich gleiche das nachher noch kurz auf die Funktionen an und poste hier den Code ^^
Danke nochma