Hi Leute,

ich habe mal wieder eine spannende Frage. Meine Situation: In meinem Source-Code existieren zwei Körper die ich auf den Bildschirm klatsche.
Jeder dieser Körper wird mit Hilfe des Ursprünglichen Modelview - Koordinatensystems an eine bestimmte Position verschoben:

Pseudocode:


Somit wird ja das Koordinatensystem an eine Position verschoben, der Körper dort gezeichnet und das Ursprüngliche wieder geladen.
Nun befinden sich ja beide Körper an der gewünschten Position. Die Körper werden, in meinem Fall mit Vector3d - Listen beschrieben
und gezeichnet. Da ich nun einen der beiden Körper rotieren lasse, um seine Z-Achse, und diesen nach jeder Rotation verschieben möchte,
in Abhängigkeit davon wie nah seine Kanten dem anderen Körper kommen, benötige ich die Vector3d - Listen nun in Abhängigkeit von meinem
aktuellen Koordinatensystem, das nicht verschoben wurde! Die müssten ja dann bereits die Rotation und Translation beinhalten!?

Schlussendlich die Frage: Wie komme ich da ran!?

_________________
_______________________________________
Lets move over mountains and through valleys:
GL.Map2(,,,,,,,,,)
GL.MapGrid2(,,,,,,,,,)
GL.EvalMesh2(,,,,,,,,,)

Ich kann mir noch nicht genau vorstellen, was du im Endeffekt vorhast. Willst du die Rotation und Translation der Vertices deiner Objekte selbst berechnen?
In dem Fall kannst du ja jeden Vertex einzeln mit der Modelviewmatrix des entsprechenden Objektes "händisch" multiplizieren um die endgültige Position im Eyespace zu erhalten. Machst du das für alle Objekte hast du so automatisch ihre Konstellationen zueinander.
Sollte es nur darum gehen, grob dafür zu sorgen, dass sich die Objekte aus dem weg gehen, dann ist es vielleicht einfacher nur (wie oben beschrieben) die Objekt-Mittelpunkte zu transformieren und zu überprüfen, ob sich die Boundingspheres der Objekte schneiden und notfalls zu verschieben.

_________________
Flummi: Projektseite und Projektthread

Wenn sich die einzelnen Vertices unterschiedlich schnell drehen sollen, dann musst du das entweder selber berechnen, d.h. einfach das ganze glTranslate weglassen und die Vertices dann mit sin und cos zu setzen, was schwierig wird, wenn du um mehr als eine Achse drehst, aber bei reiner Rotation um die Z-Achse möglichen seien sollte. ODER: Du brauchst für jeden einzelnen Vertice eine eigene ModelviewMatrix, damit das mit dem rotieren hin kommt. Da aber leider zwischen glBegin und glEnd keine Transformationsbefehle stehen dürfen wird sich das trotzdem als schwierig rausstellen.

Was dir noch vielleicht weiterhelfen könnte ist
Damit bekommst du die momentante Modelmatrix und die Elemente 12,13,14 geben die x,y,z koordinate an, was für eine Distanzberechnung reichen müsste.

P.S. Hoffe ich konnte dir weiterhelfen, hab auch nicht 100%tig verstanden was genau dein Problem ist.

Okay ich versuche es noch einmal zu beschreiben:

Ich habe zwei Körper - ein Kreissegment frei wählbarer Größe - und einen Quader mit abgerundeten Ecken - beide gehen noch ein Stück in den Raum hinein, was aus den beiden jeweils einen 3D - Körper macht. Nun ist die Position des Kreissegments im Raum fest und verändert sich nicht. Der Quader steht auf dem höchsten Punkt des Kreissegments. Der Quader soll nun um seine Z-Achse rotieren und permanenten Kontakt zum höchsten Punkt des Kreissegments halten.
Das bedeutet, dass ich bei jedem Programmdurchlauf bestimmen muss wie weit der Body des Quaders in den des Kreissegments hineinragt oder wie weit sich seine, dem Kreissegment zugewandte Seite, vom Kreissegment entfernt befindet, damit ich das Koordinatensystem des Quaders über Translate(); an die richtige Y-Position verschieben kann.

_________________
_______________________________________
Lets move over mountains and through valleys:
GL.Map2(,,,,,,,,,)
GL.MapGrid2(,,,,,,,,,)
GL.EvalMesh2(,,,,,,,,,)

Mhh ja da muesstest du dir nochmal Ebenen anschauen, der allgemeine Fall waere wohl in etwa so:


In deinen Fall koenntest du das ganze aber wohl noch nen bissl kuerzen. (die naechste Ebene koennte zum Beispiel schon bekannt sein usw....). Ansonsten koennte noch das hier
interessant werden:


(copy & paste aus SVG projekt )

_________________
Meine Homepage

Ebenen.. okay muss ich mir mal anschauen. Meine Idee wäre jetzt gewesen, dass ich eine Art Hitbox um beide Körper generiere
und diese dann mit einer Rotationsmatrix multipliziere sowie die Tranlsation mit einbeziehe um die Koordinaten der Hitbox, auf das
ursprüngliche Koordinatensystem bezogen, zu erhalten. Danach hätte ich die Positionen der Hitboxen zueinander ausgewertet.

Aber so wie das in deinem Beispielcode aussieht kann man anscheinend seine Flächen, die den Körper bilden, in ein Objekt packen.

@yunharla: Ich glaub zukünftig wende ich mich direkt an dich, so oft wie du in meine Themen Hilfreiches postest

_________________
_______________________________________
Lets move over mountains and through valleys:
GL.Map2(,,,,,,,,,)
GL.MapGrid2(,,,,,,,,,)
GL.EvalMesh2(,,,,,,,,,)

Ich hab mal kurz skizziert, wie ich jetzt deine Beschreibung verstanden habe. Kommt das so ungefähr hin?
Der Vorschlag von yunharla ist schonmal nicht schlecht, allerdings kann es meiner Meinung nach trotzdem noch zum Überschneiden der beiden Objekte kommen (im Bild ganz rechts dargestellt).
Was du prinzipiell suchst, scheint mir einfach eine Kollisionsdetektion zu sein, bzw. genauer gesagt die Bestimmung der Kontaktpunkte, allerdings mit der Nebenbedingung, dass das eine Objekt fest ist, und das andere sich nur entlang einer Achse bewegen darf (hier die y-Achse). Das macht es dann knifflig.

_________________
Flummi: Projektseite und Projektthread

Genau so stell ich mir das vor!

Gut, der Bezugspunkt auf dem Kreissegment ist ja immer fest und bekannt. Da bei mir der rotierende Körper mit so wenig Punkten wie nötig
gezeichnet wird, versuche ich jetzt eine Art Hitbox, welche am Körper anliegt, zu erzeugen. Meine Idee wäre dann gewesen zu vergleichen,
welcher Punkt des Körpers nun am niedrigsten liegt im Bezug auf sein eigenes Koordinatensystem und dann auszuwerten ob eine Korrektur
mittels Translation nötig ist. An sich kein Problem, nur das gemeine ist, dass ich die Hitbox auf das Koordinatensystem des rotierenden Körpers
setzen muss und im Bezug auf das ursprüngliche Koordinatensystem die Koordinaten der Hitbox dann entsprechend der rotation des Körpers
mittels Rotationsmatrix, welche sich dann auf das ursprüngliche Koordinatensystem bezieht, ermitteln. Danach könnte ich dann die Auswertung
machen und müsste entsprechend dieser das Koordinatensystem des rotierenden Körpers verschieben!

Ein Vorteil der mir bei dieser Lösung einfällt: Ich kann beliebig genau werden, je nach dem wie fein ich die Hitbox gestalte.

Klingt ein wenig kompliziert aber vllt. gibt es ja eine schönere Möglichkeit.



PS: Ich hoffe der Text ist verständlich ^^

_________________
_______________________________________
Lets move over mountains and through valleys:
GL.Map2(,,,,,,,,,)
GL.MapGrid2(,,,,,,,,,)
GL.EvalMesh2(,,,,,,,,,)

joa... dann kuck mal nach Herrn Hausdorff

_________________
Meine Homepage

Alles klar, mach ich. Mal unter uns,.. wisst ihr das alles (das Mathematische Zeugs), sind das Erfahrungswerte
oder müsst ihr auch jedes mal suchen!?

_________________
_______________________________________
Lets move over mountains and through valleys:
GL.Map2(,,,,,,,,,)
GL.MapGrid2(,,,,,,,,,)
GL.EvalMesh2(,,,,,,,,,)

Vielen Dank für eure Antworten. Das Problem habe ich mittlerweile gelöst, und zwar per Hitbox.
War für mich dann doch die beste Idee. Hausdorff wäre auch sehr nützlich nur leider schwer in
Quellcode zu fassen.

Wen es interessiert hier die Beschreibung meiner Lösung:

Als erstes habe ich eine Art "Hitbox" um meinen Körper herumgebaut, welcher sozusagen wie eine
zweite Haut am Körper anliegt. Die "Hitbox" (ich schreibs mal lieber zwischen Anführungszeichen, da
viele eine richtige Hitbox vllt. anders definieren) ist bei mir nichts anderes als eine Liste von Vectoren
die die Form des Körpers beschreiben. Diese liegt auf dem selben Koordinatensystem wie der Körper
selbst. Es ist recht einfach diese zu erstellen.

Grund für die "Hitbox":

Da der Körper mit recht wenigen Punkten bzw. Vektoren gezeichnet wird und ich beliebig
genau die Bewegung durchführen möchte benötige ich diese. Außerdem ist die Vorgabe,
die Bewegung unabhängig vom Zeichnen des Körpers zu berechnen. Sprich die Vertices, welche
zum Zeichnen des Körpers berechnet wurden dürfen nicht verwendet werden.

Nun zum Ablauf meines Algorithmus`s:

Ich rotiere in jedem Programmdurchlauf den Körper um einen festen Winkel und multipliziere die Hitbox mit einer Rotationsmatrix entsprechend
der Rotationsachse und dem Winkel. Dann lege ich einen Kontaktpunkt fest und ermittele die (in meinem Fall) Y - Distanz vom Koordinatenursprung
des Körpers zu diesem und den Y - Abschnitt des niedrigsten Punktes der Hitbox mit, in etwa, dem selben X - Achsen - Abschnitt des Kontaktpunktes.
Um die Differenz dieser beiden Abschnitte muss der Körper in Y - Richtung verschoben werden, ob negativ oder positiv hängt davon ab ob die
Y - Koordinate des niedrigsten Punktes größer oder kleiner der Distanz zum Kontaktpunkt ist.

Nun muss, um Kollisionen der beiden Körper zu vermeiden, der Kontakpunkt am Kreissegment entsprechend verschoben werden und der Körper um die
selbe X - Distanz ebenfalls. Insgesamt wandert der Kontaktpunkt am Kreissegment vom höchsten Punkt am Kreissegment entlang und wieder zurück.
Das Ganze geschieht pro Umdrehung des Körpers 2mal.

_________________
_______________________________________
Lets move over mountains and through valleys:
GL.Map2(,,,,,,,,,)
GL.MapGrid2(,,,,,,,,,)
GL.EvalMesh2(,,,,,,,,,)