Punkt auf Kreis berechnen

Hallo zusammen,

ich habe derzeit ein kleines Problem und weiss nicht recht wie ich das lösen soll:

Ich habe zwei Punkte (0, 0) [= Standort] und (0, 4) [= Ziel].
Man schaut vom Standort immer in Richtung Ziel.

Mein Problem ist nun folgendes.
Gegeben ist ein Wert, der je nach Mausbewegung bestimmt wird.
Bei einem positiven Wert soll sich das Ziel weiter nach rechts bewegen (auf einem Kreis) bei einem negativen Wert nach links, so eine Art Umsicht.

Je nach Wertgröße, bewegt sich das Ziel, auf einem Kreis nach links oder rechts um den Standort.

Ich dachte mir, dass ich die Sache so berechnen kann:

Bsp: Standort = [0, 0] ; Ziel = [0, 4]

Erstmal einen Richtungsvektor bilden: vec(r) = [ZielX - StandortX, ZielY - StandortY] = [0, 4]
Daraus den Radius berechnen: radius = sqrt(vec[0]^2 + vec[1]^2) = sqrt(0^2 + 4^2). Somit ist der Radius = 4

Anschließend verschiebe ich die Zielkoordinaten wie folgt:
Ziel.x = sin(offset) * radius
Ziel.y = cos(offset) * radius

Diese ganze Berechnung geschieht in einem MouseDown-Handler, welcher nach 50ms aktualisiert wird, solange der Maus-Btn gedrückt wird.

In einem weiteren MouseMove-Handler wird das offset berechnet.
D.h. der Verschiebungsgrad der Maus, was ohne Probleme funktioniert.

Wenn die Maus nun losgelassen wird, und erneut gedrückt wird, springt die ganze Geschichte wieder zu der Ausgangsposition. Warum das so ist, weiss ich leider noch nicht, wahrscheinlich weil das offset anfangs 0 ist.

Jetzt bin ich mir nicht sicher, ob diese Kreisbewegung korrekt ist, oder ich da Müll zusammenrechnen.

Weiss jemand Rat ?

Liebe Grüße.

P.s. HIERevtl. ein Bild zur Verdeutlichung. Target = Ziel; Eye = Standort

SeppJ

Deine Kreisbewegung ist nicht ganz korrekt, du musst den Richtungsvektor transformieren, nicht den Radius. Guck dir dazu mal das Stichwort Drehmatrix an. Keine Angst, das ist ganz einfach!

Danke für die Antwort!

Das mit der Drehmatrix funktioniert soweit, jedoch wird der Radius immer größer.
Hier den jetztigen Berechnungsablauf:

Ich berechne wieder den Richtungsvektor wie im vorherigen Post angegeben.
Anschließend den Radius auch wie im vorherigen Post.

Dann berechne ich die Rotationsmatrix, wie HIER (siehe Matrix-Schreibweise).

D.h. so (wie aktive Drehmatrix):
rotationsMatrix[0] = (cos(offsetX) * direction[0]) + (-sin(offsetX)*direction[1])
rotationsMatrix[1] = (sin(offsetX) * direction[0]) + (cos(offsetX)*direction[1])

Anschließend nur noch die Zuweisung:
targetX = rotationsMatrix[0];
targetY = rotationsMatrix[1];

Habe ich das soweit richtig verstanden ?
Wenn ja, warum ändert sich dann der Radius ?

SeppJ

Im Prinzip ist das richtig (sofern dein Mittelpunkt (0,0) ist, ansonsten musst du den Mittelpunkt nochmal addieren). Daher nehme ich an, dass du bei der konkreten Umsetzung etwas verkehrt gemacht hast.

SeppJ schrieb:

Im Prinzip ist das richtig (sofern dein Mittelpunkt (0,0) ist, ansonsten musst du den Mittelpunkt nochmal addieren). Daher nehme ich an, dass du bei der konkreten Umsetzung etwas verkehrt gemacht hast.

Genau das hatte gefehlt!
Ich danke dir!

Dann hätte ich zu diesem ganzen noch eine Frage, bzw. ein Problem!
Wenn ich jetzt hinzufügen möchte, dass die man noch um die Z-Koordinate rotieren kann, geht das so einfach ?

D.h. auf der genannten Seite finde ich dann Rotationsmatrizen für Rotationen um eine bestimmte Achse.
Ist es denn jetzt einfach so möglich, eine weitere Achse, oder eine weitere Berechnung zu dieser oben beschriebenen hinzuzufügen ?

Soweit ich dass jetzt verstanden habe, ist in der Berechnung die ich ausgeführt habe die X- und Y-Koordinate enthalten.

Wenn ich einen weiteren Winkel besitze, der nun für den Zielpkt. die Z-Koordinate bestimmt, muss ich dann nun Y nochmal bestimmen und Z komplett neu rechnen ?

Liebe Grüße,
Maab.

Also ich habe nochmal etwas gesucht und bin über einen Beitrag gestoßen, welcher die Drehung in R3 mit beliebigen Einheitsvektoren als Drehmatrix beschreibt.

Dort wurde gesagt, dass man erst die Einheitsvektoren bilden muss, d.h. veceinheit = vector / betrag(vector), anschließend daraus die Drehmatrix bildet, wie beim obrigen Link beschrieben und nachträglich noch einen Verschiebungsvektor benötigt.

Kann ich somit die Rotation des Standortpunktes im R3 gewährleisten ?
Ist in diesem Fall der Verschiebungsvektor nicht mein Mittelpunkt ?

D.h. doch, dass ich im Endeffekt die beschriebene Formel nutzen muss und anschließend wieder den Mittelpunkt hinzuaddieren muss, oder ?

Grüße und danke nochmals,
Maab.

SeppJ

Im Prinzip funktioniert die Drehung in 3D genauso wie in 2D mit der schon beschriebenen Verkomplizierung, dass man zusätzlich noch eine Drehachse angeben muss (mach dir mal an einem Objekt auf deinem Schreibtisch klar, warum das so ist, dann hast du das wichtigste verstanden). Du musst wieder die Drehmatrix berechnen, in die dann neben dem Winkel auch die Drehachse eingeht und diese Matrix wieder mit den zu transformierenden Vektoren multiplizieren. Der Mittelpunkt wird dabei genauso behandelt wie in 2D.

Je nach Anwendung gibt es auch noch ein paar andere Möglichkeiten Drehungen in 3D zu beschreiben als mit Drehachse und Winkel. Überdies gibt es für bestimmte Drehachsen (x, y und z Achse) besonders einfache Formeln für die Drehmatrix.

SeppJ schrieb:

Im Prinzip funktioniert die Drehung in 3D genauso wie in 2D mit der schon beschriebenen Verkomplizierung, dass man zusätzlich noch eine Drehachse angeben muss (mach dir mal an einem Objekt auf deinem Schreibtisch klar, warum das so ist, dann hast du das wichtigste verstanden). Du musst wieder die Drehmatrix berechnen, in die dann neben dem Winkel auch die Drehachse eingeht und diese Matrix wieder mit den zu transformierenden Vektoren multiplizieren. Der Mittelpunkt wird dabei genauso behandelt wie in 2D.

Je nach Anwendung gibt es auch noch ein paar andere Möglichkeiten Drehungen in 3D zu beschreiben als mit Drehachse und Winkel. Überdies gibt es für bestimmte Drehachsen (x, y und z Achse) besonders einfache Formeln für die Drehmatrix.

Okay verständlich, jetzt habe ich wieder das selbe Problem mit dem Radius wie ich es auch schon im 2D-Raum hatte.

Folgendes berechne ich:
RichtungsMatrixX, RichtungsMatrixY und RichtungsMatrixZ wie auf der geposteten Seite, nacheinander.

DirectionMatrixX =

[
[1, 0, 0], 
[0,cos(this.offset.y),-sin(this.offset.y)],												[0, Math.sin(this.offset.y), Math.cos(this.offset.y)]	
];

DirectionMatrixY =	

[	
[Math.cos(this.offset.y),0,Math.sin(this.offset.y)],												[0,1,0],												[-Math.sin(this.offset.y),0,Math.cos(this.offset.y)]	
];

Die einzige Abweichung hier, dass ist Z-Achse auf die Mausbewegung in X reagieren soll.
Deswegen habe ich hier bei der Berechnung die Y-Verschiebung genutzt.

DirectionMatrixZ =	
[
[Math.cos(this.offset.x),-Math.sin(this.offset.x),0],							[Math.sin(this.offset.x),Math.cos(this.offset.x),0],											[0,0,1]												];

Anschließend berechne ich den Richtungsvektor wie schonmal beschrieben, zusätzlich kommt hier hinzu die Z-Achse.

direction = [ TargetX - EyeX, //das selbe für Y und Z ];

Dann den Rotations Vektor für X, Y und Z nacheinander, in dem ich die RichtungsMatrix mit dem Richtungs-Vektor ,je Achse, multipliziere.

rotationX = directionMatrixX * direction
rotationY = directionMatrixY * direction
rotationZ = directionMatrixZ * direction

Anschließend berechne ich den Zielpunkt für X, Y und Z so, dass ich bspw. die Rotation für X mit jeden X-Vektor der einzelnen Achsen aufsummiere und anschließend den Mittelpunkt hinzuaddiere.

TargetX = rotationX[0] + rotationY[0] + rotation[Z] + MittelpunktX
//Das selbe dann halt für TargetY und TargetZ

Das müsste es gewesen sein ... ich hoffe ich berechne das so richtig, wobei irgendetwas muss ja falsch sein, wenn der Radius wieder nicht stimmt ...

SeppJ

Kannst du das bitte etwas besser formatieren? Die Matrizen kann ich so nicht lesen. In dem lesbaren Teil habe ich diesen Fehler gefunden:

Maab schrieb:

Anschließend berechne ich den Zielpunkt für X, Y und Z so, dass ich bspw. die Rotation für X mit jeden X-Vektor der einzelnen Achsen aufsummiere und anschließend den Mittelpunkt hinzuaddiere.
TargetX = rotationX[0] + rotationY[0] + rotation[Z] + MittelpunktX
//Das selbe dann halt für TargetY und TargetZ

Hier addierst du x-, y- und z-Koordinaten aufeinander. Ein sicheres Zeichen, dass es falsch ist.

Also ich glaube ich habe die Geschichte doch noch nicht so verstanden, wie ich dachte.

Bei der 2D Berechnung bestimme ich die Rotationsmatrix, bzw. die neue Position für das Ziel, um den Standort (in einen Kreis) drumherum.

Theoretisch wäre das doch nun auch für das hoch und runterschauen möglich.
Bisher habe ich es ermöglicht am gleichen Standort nach links oder rechts zu schauen, wenn ich jetzt nach oben oder unten schauen möchte, muss ich doch eine Rotationsmatrix für Y und Z bestimmen, oder ?

Also die Rotationsmatrize müsste dann so aussehen:

//  direction = Richtungsvektor, welcher die Form [x, y, z] besitzt

rotationsMatrixYZ[0] = (cos(VerschiebungsfaktorY) * directionXY[1]) + (-sin(VerschiebungsfaktorY) * directionXY[2])
rotationsMatrixYZ[1] = (sin(VerschiebungsfaktorY) * directionXY[1]) + ( cos(VerschiebungsfaktorY) * directionXY[2])

So brauch ich mir doch nicht erneut die Arbeit machen eine weitere Formel zu errechnen, wenn sich die Kopfbewegung von links nach rechts um einen VerschiebuungsfaktorX berechnet und die Kopfbewegung von oben nach unten um einen VerschiebuungsfaktorY berechnet.

Oder entstehen so Fehler ?
Bzw. ist das nicht korrekt ?

Was das Post davor angeht:
Die Richtungsmatrizen bilden sich wie auf der Seite des genannten Links.
X und Y-Richtungsmatrizen enthalten hierbei als Winkel die Verschiebung in X Richtung, bei der Z-Richtungsmatrix die Verschiebung in Y Richtung.

DirectionMatrixX[0] = [1, 0, 0]
DirectionMatrixX[1] = [0, cos(VerschiebungX), -sin(VerschiebungX)]
DirectionMatrixX[2] = [0, sin(VerschiebungX),  cos(VerschiebungX)]

DirectionMatrixY[0] = [cos(VerschiebungX), 0, -sin(VerschiebungX)]
DirectionMatrixY[1] = [0, 1, 0]
DirectionMatrixY[2] = [sin(VerschiebungX), 0,  cos(VerschiebungX)]

DirectionMatrixZ[0] = [cos(VerschiebungY), -sin(VerschiebungY), 0]
DirectionMatrixZ[1] = [cos(VerschiebungY), -sin(VerschiebungY), 0]
DirectionMatrixZ[2] = [0, 0, 1]

Richtungsvektor

Direction[0] = TargetX - EyeX;
//das nochmal für Y und Z

Rotationsvektor

RotationX[0] = DirectionMatrixX * Direction
//das nochmal für Y und Z

Anpassung der eigentlich Koordianten

TargetX = RotationX[0] + RotationY[0] + RotationZ[0] + MittelpunktX
//das nochmal für Y und Z

Ich hoffe jetzt ist es lesbarer

SeppJ

Maab schrieb:

Also ich glaube ich habe die Geschichte doch noch nicht so verstanden, wie ich dachte.

Bei der 2D Berechnung bestimme ich die Rotationsmatrix, bzw. die neue Position für das Ziel, um den Standort (in einen Kreis) drumherum.

Theoretisch wäre das doch nun auch für das hoch und runterschauen möglich.
Bisher habe ich es ermöglicht am gleichen Standort nach links oder rechts zu schauen, wenn ich jetzt nach oben oder unten schauen möchte, muss ich doch eine Rotationsmatrix für Y und Z bestimmen, oder ?

Ja, kann man so machen.

Also die Rotationsmatrize müsste dann so aussehen:

//  direction = Richtungsvektor, welcher die Form [x, y, z] besitzt

rotationsMatrixYZ[0] = (cos(VerschiebungsfaktorY) * directionXY[1]) + (-sin(VerschiebungsfaktorY) * directionXY[2])
rotationsMatrixYZ[1] = (sin(VerschiebungsfaktorY) * directionXY[1]) + ( cos(VerschiebungsfaktorY) * directionXY[2])

Verstehe nicht, warum du jetzt auf einmal mit 2D Matrizen kommst. Was willst du in diesem Zusammenhang damit sagen?

So brauch ich mir doch nicht erneut die Arbeit machen eine weitere Formel zu errechnen, wenn sich die Kopfbewegung von links nach rechts um einen VerschiebuungsfaktorX berechnet und die Kopfbewegung von oben nach unten um einen VerschiebuungsfaktorY berechnet.

Oder entstehen so Fehler ?
Bzw. ist das nicht korrekt ?

Das kommt ganz darauf an, wie die Bewegung genau aussehen soll. Eine mögliche Fehlerquelle die bei dieser Art des Vorgehens auftauchen kann, ist, dass es einen Unterschied macht, in welcher Reihenfolge die Rotationen um verschiedene Achsen durchgeführt werden.

Was das Post davor angeht:
Die Richtungsmatrizen bilden sich wie auf der Seite des genannten Links.
X und Y-Richtungsmatrizen enthalten hierbei als Winkel die Verschiebung in X Richtung, bei der Z-Richtungsmatrix die Verschiebung in Y Richtung.
DirectionMatrixX[0] = [1, 0, 0]
DirectionMatrixX[1] = [0, cos(VerschiebungX), -sin(VerschiebungX)]
DirectionMatrixX[2] = [0, sin(VerschiebungX),  cos(VerschiebungX)]
	
DirectionMatrixY[0] = [cos(VerschiebungX), 0, -sin(VerschiebungX)]
DirectionMatrixY[1] = [0, 1, 0]
DirectionMatrixY[2] = [sin(VerschiebungX), 0,  cos(VerschiebungX)]

DirectionMatrixZ[0] = [cos(VerschiebungY), -sin(VerschiebungY), 0]
DirectionMatrixZ[1] = [cos(VerschiebungY), -sin(VerschiebungY), 0]
DirectionMatrixZ[2] = [0, 0, 1]

Die sehen soweit richtig aus.

Richtungsvektor

Direction[0] = TargetX - EyeX;
//das nochmal für Y und Z

ok.

Rotationsvektor

RotationX[0] = DirectionMatrixX * Direction
//das nochmal für Y und Z

Schreib das mal bitte ganz aus, damit man sehen kann, ob du Matrixmultiplikation richtig beherrscht.

Anpassung der eigentlich Koordianten

TargetX = RotationX[0] + RotationY[0] + RotationZ[0] + MittelpunktX
//das nochmal für Y und Z

Nein, siehe vorheriger Post von mir. Diese Formel deutet sehr darauf hin, dass du vorher schon Quatsch gemacht hast. Ich schreib nochmal richtig hin, wie man mehrere Drehungen durchführen kann:

Sei Mittelpunkt $\vec{m}$, darum zu drehender Punkte $\vec{t}$. Dann ist der zu drehende Richtungsvektor $\vec{d}=\vec{t}-\vec{m}$. Gegeben eine Rotationsmatrix $\hat{X}(\alpha)$ um die x-Achse um einem Winkel $\alpha$ und entsprechend Rotationsmatrizen $\hat{Y}(\beta)$ und $\hat{Z}(\gamma)$ um y und z. Angenommen man möchte diese nacheinander auf $\vec{d}$ anwenden (siehe oben, warum das möglicherweise Probleme macht). Dazu rechnet man: \begin{equation*} \vec{d}_{neu}= \hat{Z}(\gamma) \cdot \hat{Y}(\beta) \cdot \hat{X}(\alpha) \cdot \vec{d}\end{equation*} Der Punkt $\cdot$ bedeutet dabei jeweils eine Matrixmultiplikation, je nach Zusammenhand zwischen 3x3 Matrizen bzw. 3x3 Matrix und 3d-Vektor. Die Klammerung der Rechnung ist dabei egal, die Reihenfolge der Matrizen beeinflusst jedoch das Ergebnis. Der transformierte t-Vektor ist dann $\vec{t}_{neu}=\vec{m}+\vec{d}_{neu}$

Also wie soll das nun genau aussehen:
Hier erstmal ein Bild

Was passiert da nun:
Links erstmal eine 3D-Darstellung der Umgebung.
Der Kreis signalisiert eigentlich nur, den Radius des Zielpunktes, d.h. auf dem der Zielpunkt sich bewegt.

Standort ist der Standort, also die Position, der Kamera
Ziel ist jeweils der Zielpunkt (Bei der Grafik sieht es so aus, als würde der Punkt im Kreis liegen, der liegt jedoch auf dem Kreis, also egal wo ich ihn nun gezeichnet hätte, er hätte immer den gleichen Abstand zum Mittelpunkt).

Oben rechts siehst du die Draufsicht.
Hier wird der Zielpunkt auf dem Kreis verschoben, wenn die Maus nach links oder rechts bewegt wird.
Der daraus entstehende Faktor, von neuer und alter Position der Maus, entspicht den Verschiebungswinkel!

Diese Draufsicht kannst du dir vorstellen wie du selbst siehst, d.h. du kannst deinen Kopf nach links uns rechts bewegen ohne deine eigetnliche Position (die deines Körpers) zu verädern. Kurz gesagt du schaust dich um _OHNE_ den Kopf zu knicken d.h. die Z-Höhe ist die selbe!

Die Position des alten Ziels und des neuen Ziels ist jeweils immer auf dem Kreis, d.h. die Länge beider Vektoren ist gleich.

Darunter siehst du die Rotation für die Z-Achse, diese soll das nicken deines Kopfes realisieren, d.h. du darfst nun auch nach oben und nach unten gucken, ohne deinen Körper zu bewegen.

Der Faktor entsteht bei der Verschiebung der Maus, wenn du sie nach oben oder nach unten bewegst.

Das ist eigentlich alles.
Ersteres funktioniert mit den angegeben Berechnungen im 2D Bereich.
Jedoch weiss ich nicht, wie ich das Kopf nicken implementieren soll, weil ich ja dann eine weitere Matrix rausbekomme.

// Zu deine Post

Die Matrixmultiplikation ist Zeile * Spalte.
In diesem genannten Fall heißt dass ich Multipliziere alle Faktoren der ersten Zeile der Matrix mit der erten Spalte des Vektors (dieser hat ja nur einen), anschließend Summiere ich die Multiplikationsergebnisse auf und komme auf die erste Dimension des Ergebnisvektors.

D.h. grob

EV[0] = M[0][0] * V[0] + M[0][1] * V[1] + M[0][2] * V[2]
EV[1] = M[1][0] * V[0] + M[1][1] * V[1] + M[1][2] * V[2]
EV[2] = M[2][0] * V[0] + M[2][1] * V[1] + M[2][2] * V[2]

Somit habe ich den Ergebnisvektor, der ja nun x,y und z enthält.

In unseren Fall heißt das:
RotationX[0] = DirectionMatrixX[0][0] * Direction[0] + DirectionMatrixX[0][1]...
RotationX[1] = DirectionMatrixX[1][0] * Direction[0] + DirectionMatrixX[1][1]...
RotationX[2] = DirectionMatrixX[2][0] * Direction[0] + DirectionMatrixX[2][1]...

RotationY[0] = DirectionMatrixY[0][0] * Direction[0] + DirectionMatrixY[0][1]...
RotationY[1] = DirectionMatrixY[1][0] * Direction[0] + DirectionMatrixY[1][1]...
RotationY[2] = DirectionMatrixY[2][0] * Direction[0] + DirectionMatrixY[2][1]...

RotationZ[0] = DirectionMatrixZ[0][0] * Direction[0] + DirectionMatrixZ[0][1]...
RotationZ[1] = DirectionMatrixZ[1][0] * Direction[0] + DirectionMatrixZ[1][1]...
RotationZ[2] = DirectionMatrixZ[2][0] * Direction[0] + DirectionMatrixZ[2][1]...

Dann habe ich drei Rotationsmatrizen!
Und hier hängt es dann irgendwie bei mir, jedenfalls was das R3 angeht.

So hatte ich es mir gedacht.

Was du mir jetzt geschrieben hast, bringt wieder etwas Licht ins Dunkle, jedoch kann ich das heute nicht mehr anwenden, da ich nicht mehr auf Arbeit bin, sondern werde das morgen tun.

Aber nochmal eine Frage zu deiner Erklärung:
Wenn ich den Punkt jetzt bei Mausbewegung von links nach rechts und umgekehrt wie im Bild besprochen um den Mittelpunkt rotieren lassen möchte, dann muss ich doch aus den genannten Rotationsmatrizen nur die MatrixX und MatrixY nutzen, oder ?

D.h. bei den beiden Matrizen wäre der Winkel (d.h. der Bewegungsfaktor der Maus) doch der selbe, damit ich mich mehrmals um meine eigene Achse drehen kann, oder ?

Mir fehlt irgendwie noch der letzte Funken der das Eis bricht, ich bin irgendwie kurz davor, aber so richtig habe ich die Brücke noch nicht entdeckt.

Liebe Grüße und danke für deine Nerven!

Maab.

Guten Morgen,

also soweit funktioniert das mit der Bewegung von links nach rechts, wie ich das möchte, der Radius bleibt auch der selbe.

Was nun noch nicht funktioniert ist die Bewegung von oben nach unten.
Da rotiert er, bei der Mausbewegung im Kreis, nicht über sich selbst drüber.
Schwer zu beschreiben, aber laut meinem Bild müsste die Kamera an der gleichen Position immer nach oben oder unten rotieren, dass macht sie in diesem Fall nicht.

Kann es sein, dass ich für die Bewegung von links nach rechts und umgekehrt, zwei Richtungsmatrizen brauche und für die Bewegung von oben nach unten und umgekehrt, ebenfalls zwei ?

Grüße,
Maab.

SeppJ

Maab schrieb:

Guten Morgen,

also soweit funktioniert das mit der Bewegung von links nach rechts, wie ich das möchte, der Radius bleibt auch der selbe.

Was nun noch nicht funktioniert ist die Bewegung von oben nach unten.
Da rotiert er, bei der Mausbewegung im Kreis, nicht über sich selbst drüber.
Schwer zu beschreiben, aber laut meinem Bild müsste die Kamera an der gleichen Position immer nach oben oder unten rotieren, dass macht sie in diesem Fall nicht.

Kann es sein, dass ich für die Bewegung von links nach rechts und umgekehrt, zwei Richtungsmatrizen brauche und für die Bewegung von oben nach unten und umgekehrt, ebenfalls zwei ?

Grüße,
Maab.

Ich bin mir nicht ganz sicher was du beschreibst, vermute aber mal, dass du Probleme mit den richtigen Drehachsen hast. Schnapp dir mal eine Kugel, markiere einen Punkt auf der Oberfläche und mal dir ein Koordinatensystem hin. Dann machst du genau die Sachen, die du dir von deinem Programm wünscht und achtest dabei darauf, um welche Achsen du deine Kugel drehst.

SeppJ schrieb:

Ich bin mir nicht ganz sicher was du beschreibst, vermute aber mal, dass du Probleme mit den richtigen Drehachsen hast. Schnapp dir mal eine Kugel, markiere einen Punkt auf der Oberfläche und mal dir ein Koordinatensystem hin. Dann machst du genau die Sachen, die du dir von deinem Programm wünscht und achtest dabei darauf, um welche Achsen du deine Kugel drehst.

Also so richtig weiss ich jetzt eigentlich auch nicht mehr, wie ich das erklären soll.

Eigentlich ist es einfach erklärt wenn ich sage: "Wie als würde man einen Egoshooter spielen und sich umgucken!".

D.h. Umschauen tut man sich ja, indem man sich nicht bewegt sondern nur seinen Kopf.
Hierbei funktiniert das umschauen von rechts nach links und links nach rechts, aber das umschauen von oben nach unten und unten nach oben nicht.

Beim hochschauen zieht die Sicht nach links oder rechts, nicht gerade hoch.
Ich weiss nicht recht, was ich da falsch gemacht habe.

Ich werde evtl. gleich mal versuchen das per Hand zu berechnen, wobei ich denke, dass mir das wahrscheinlich mehr Arbeit macht als es mir wirklich nützt.

Grüße,
Maab.

SeppJ

Das hört sich so an, als würdest du das 'Kopfnicken' durch Drehen um eine bestimmte Koordinatenachse versuchen. Realistischer als Drehachse wäre doch wohl eine Achse die orthogonal zu Blickrichtung in der Bewegungsebene liegt.

Okay also ich habe es nochmal etwas eindeutiger gemacht.

Schau mal HIER

Die Rotation um die Z-Achse (Rotationskreis = Dunkelgrau) simuliert das nach links und rechts schauen im Raum. Hier bei rotiert der Punkt (grün auf der Z-Achse) auf dieser Achse.
D.h. die Kamera schaut (Koordinatenursprung = Kamerastandort) in Richtung dieses Punktes.

Da existiert jedoch noch ein Punkt (rot) mitten im Raum der das nach oben und unten sehen simuliert.

Hierbei kann ich diesen Punkt um keiner der Achsen rotieren lassen, da die Rotation (Winkel = gelb) nicht korrekt sein würde.
D.h der Punkt (rot) soll für die auf und Auf- und Abewegung auf diesen Rotationskreis (türkis) hin und her fahren.

Ich habe die ganze Geschichte jetzt nur für diesen einen Quadranten gezeichnet, jedoch soll die Rotation in den anderen Quadranten (wenn man den Rotationskreis vervollständigt) weitergeführt werden können.

Also dazu finde ich im Netz auch irgendwie gar nichts, zumal ich auch nicht weiss unter was man da nun genau suchen sollte.

Grüße,
Maab.

SeppJ

Dann lag ich mit meinem letzten Beitrag richtig, dort steht auch schon die Lösung. Deine Rotationsachse steht orthogonal zu der Verbindung zwischen dem Ursprung und dem roten Punkt und sie liegt in der XY-Ebene. Oder anders ausgedrückt:
Rotationsachse = Kreuzprodukt(Ortsvektor roter Punkt, Z-Achse)

SeppJ schrieb:

Dann lag ich mit meinem letzten Beitrag richtig, dort steht auch schon die Lösung. Deine Rotationsachse steht orthogonal zu der Verbindung zwischen dem Ursprung und dem roten Punkt und sie liegt in der XY-Ebene. Oder anders ausgedrückt:
Rotationsachse = Kreuzprodukt(Ortsvektor roter Punkt, Z-Achse)

Was bedeutet hier "Z-Achse" ?
Die Koordinaten des Punktes auf der Z-Achse ?

Grüße,
Maab.