Vektor Problem (3D)

[MR321]

Ich hab da ein Problem mit Vektoren:

Code:

^
|     P2
|    /
|   /
|  /
| /
|/--------P1
+------------------>

Das soll ein Koordinatensystem sein :-D
P1 und P2 sind Vektoren. Sie kommen beide aus dem Ursprung des Koordinatensystems.
Das ganze soll in 3D sein.
Wenn ich jetzt P1 bewege, dann soll sich P2 entsprechend mitbewegen.
Wie kann ich das realisieren? In 2D wäre das ja noch entsprechend einfach. Aber wie geht das in 3D?

[OregonGhost]

Wo ist das Problem?
Um P1 zu bewegen, musst du einen Vektor hinzuaddieren. Addierst du denselben zu P2, bewegen sich beide gleich, also um denselben Betrag in dieselbe Richtung.

Und ob es in 2D oder 3D ist, ist bei Vektoren doch auch egal?!

Entweder ist dein Problem kein Problem oder ich hab's einfach nicht kapiert, was du machen willst ;c)
Also sag's noch mal genauer...

[MR321]

Ähm, das meine ich nicht!
Das Verhältnis zu P1 und P2 soll immer gleich sein!
OK, Beispiel:

Code:

    1      0     P2| /P1
P1: 1  P2: 1       |/    
    0      0       |       Schlecht zu sehen, aber zwischen P1 und P2 soll ein 45° Winkel sein.

So, jetzt verschiebe ich P1, und dann soll das so aussehen:

Code:

    1     -1    P1\
P1:-1  P2: 0       \
    0      0    P2--\      Und der soll sich mitdrehen.

Also P2 soll sich mit P1 immer entsprechend mitdrehen.
Wie gesagt, in 2D ist das kein Problem, kann man einfach mit sin und cos machen. Aber wie macht man das in 3D?

[Jelly]

Sollte so gehen... Omega, phi und kappa sind die 3 Drehwinkel.

[MR321]

Also ich kapier das überhaupt nicht.
Diese mathematischen Ausdrücke sagen mir überhaupt nichts.
Und was für 3 Drehwinkel?
Und wie sehen Omega, phi und kappa aus?

Also ich brauch nur ne ganz einfache (*g*) Funktion, die als Eingabe 3 Punkte erwartet und einen Punkt ausgibt.
Also nach diesem Schema:

Delphi-Quellcode:

T3DPunkt = record
  X,Y,Z: Double
end;

...

function anpassen (P1alt, P1neu, P2alt: T3DPunkt): T3DPunkt;
begin
  ...
  Result := P2neu;
end;

[edit=Daniel B]Delphi-Tags korrigiert. Mfg, Daniel B[/edit]

[MR321]

Am besten wäre es, wenn der "Unterschied" zwischen P1 und P2 in einer seperaten Variable gespeichert werden kann, denn von P2 gibt es mehrere, und damit nicht jedesmal der "Unterschied" ausgerechnet werden muss. Spart CPU Zeit. Denn es gibt sehr sehr viele von P2. Und die Berechnung muss in Echtzeit stattfinden.

[Jelly]

Zitat:

Zitat von MR321

Also ich kapier das überhaupt nicht.
Diese mathematischen Ausdrücke sagen mir überhaupt nichts.
Und was für 3 Drehwinkel?
Und wie sehen Omega, phi und kappa aus?

Das Ganze ist eine Matrix Multiplikation. Du gibst dir einen Vektor r_1 vor, wo du die 3 Koordinanten vorliegen hast. Daraud wendest du die angegebene Matrix M an, und kriegst dadurch die 3 Komponenten von vom Vektor r_2 raus... Die 3 Winkel sind die Drehwinkel (in rad angegeben) um deine 3 Raumachsen.

Gruß,
Tom

[MR321]

Was für eine Matrix M? In der pdf-Datei steht nirgendwo was davon. Da steht nur eine einzige Formel einfach so dahin geschrieben.
Und was musst du hier schon wieder neue Bezeichner einführen? Ich hab doch vohrin versucht einheitliche Bezeichner zu machen. Ich weis schon wieder nicht wofür die ganzen Bezeichner stehen.

Ich hab von Vektorrechnug überhaupt keinen Plan. Das einzige was ich weis, ist, dass Vektoren in eine Richtung gehen, und dass man die einzelnen Koordinaten übereinanderschreibt. :wall:


Also ich hoffe, dass ich das jetzt richtig verstanden habe, die 3 Drehwinkel sind der Unterschied zwischen P1alt und P2alt? (Bzw. P1neu und P2neu)
Wie bekomme ich nun diese Drehwinkel aus P1alt & P2alt, und wie wende ich sie auf P1neu an, um P2neu herauszubekommen?

[Dagon]

@MR321: Hier ein kleiner Tipp: Wenn du 3D-Spiele schreiben willst, solltest du schon mit der Vektorgeometrie vertraut sein.

[MR321]

Ja, weis ich...
Wir sind aber noch nicht so weit in der Schule.
Wir sind gerade erst bei Differenzialrechnung.

Aber ich brauche das nunmal.
Sonst funktioniert auch alles soweit in meiner 3D-Engine. Nur das Animationssystem funktioniert noch nicht.

[Mirilin]

:hi:

Viel spass beim LESEN

[Dagon]

Hier hast du noch mehr Spass! :mrgreen:

[MR321]

Ach nö, das wollt ihr mir doch nicht antun.
Ich soll den Stoff eines ganzen Schuljahres und nochmehr mal eben so mir aneignen. :pale:

Ich brauch das Animationssystem jetzt. Sind doch nur 2 Funktionen. (Soweit ich das jetzt verstanden habe)

Delphi-Quellcode:

T3DPunkt = record
  X,Y,Z: Double
end;

...

function getdrehwinkel (P1alt,P1neu: T3DPunkt): T3DPunkt;
begin
  ...
  Result := Die_3_Drehwinkel;
  // Hier verwenden wir den T3DPunkt um darin die 3 Drehwinkel zu speichern
end;

function drehevektor (P2alt,Drehwinkel: T3DPunkt): T3DPunkt;
begin
  ...
  Result := Der_Gedrehte_P; // (P2neu)
end;

Wär echt super, wenn mir jemand die ... in den Funktionen mit Code füllen könnte! :zwinker:

[edit=Daniel B]Delphi-Tags korrigiert. Mfg, Daniel B[/edit]

[MR321]

Ist das jetzt ein ganz falscher Lösungsansatz, oder warum antwortet mir jetzt keiner? :gruebel:

[Jelly]

Die Sache mit dem Drehen ist im 3D nicht so trivial. Anschaulich bleibts im 2D, wo du deinen Vektor einfach um einen Winkel drehst, so ähnlich wie die Zeiger einer Uhr. Im 3D hast du aber weitere Drehmöglichkeiten. stell die ne Kugel vor, und einem Vektor vom Mittelpunkt irgendwo bis zum Rand. Jetzt kannst du, im Gegensatz zum 2D Fall, den Vekor in 3 Richtungen drehen. Ich hoff so wirds anschaulicher.

Um die Sache noch etwas zu verkomplizieren. Meist hast du sogar mehrere Möglichkeiten, deine Drehung darzustellen. Bsp: Ein Vektor soll durch Drehung vom Südpol zum Nordpol werden. Jetzt hast du 2 Möglichkeiten, dies zu erzielen. Entweder durch 180° Drehung um die x-Achse oder durch 180° Drehung um die y-Achse. Beidesmal hast du nachher einen Vektor der zum Nordpol zeigt.

Und somit dürfte jetzt auch klarer sein, was die 3 Winkel bedeuten, eben genau jeweils der Drehwinkel um die x-, y- bzw. z-Achse.

Lange Rede kurzer Sinn: ist alles nicht so ohne. :cyclops:

gruß,
Tom

[Dagon]

Ich an deiner Stelle, würde mich noch mit der analytischen Geometrie auseinandersetzen. Das wird dir auf jeden Fall weiterhelfen.

[MR321]

Hab ich mir schon gedacht, dass das nicht so einfach ist. Ich hab die Frage inzwischen schon in 3 Foren gestellt - ohne Ergebnis.

Das ist mir inzwischen schon fast egal, wie das Teil das ausrechnet, Hauptsache es funzt.
Ich bräuchte nur irgendeine Formel (bzw. Algorhytmus) die mir den Unterschied zwischen 2 Vektoren in Drehwinkeln ausgibt. Egal wie.
Und da ich von sowas noch gar keine Ahnung habe, bin ich auf eure Hilfe angewiesen.

[OregonGhost]

Es gibt da noch ein Problem. Wenn du tatsächlich allen Ernstes deine Vektoren über drei Drehwinkel drehst (was durchaus möglich ist), landest du möglicherweise beim so genannten Gimbal Lock Problem. Die Drehungen sind nämlich nicht ganz unabhängig voneinander.
Ein sehr eleganter Weg, Vektoren zu drehen, sind daher Quaternionen, mit denen man das Problem durch Hinzufügen einer vierten Dimension umgeht. Unter diesem Stichwort wirst du sicherlich u.a. bei gamedev.net oder auch im DirectX SDK einige Artikel oder Tutoriale finden.

Ansonsten ist etwas mehr Hintergrundwissen vielleicht angebracht. Im Buch "Direct3D Spieleprogrammierung" gibt es im Anhang eine Einführung in dieses Thema, die du auch ohne Vorwissen verstehen kannst, wie auch in den meisten anderen Büchern zur 3D-Programmierung.

Außerdem findest du auf gamedev.net unter Articles & Resources -> Programming -> Math & Physics zu allen bisher genannten Vorschlägen Tutoriale, darunter 3D-Vektoren, Quaternionen und Matrizen. Schau dir die mal ein wenig an, da sollte was für dein Problem dabei sein. Insbesondere der Artikel "Mathematics of 3D Graphics" sollte für dich interessant sein, zumal sich die meisten Artikel dort halt nicht nur auf den Hintergrund, sondern auch auf die praktische Programmierumsetzung konzentrieren.

[MR321]

Die 4. Dimension ist mir durchaus bekannt. Aber auf der Seite weis man gar nicht wo man anfangen soll zu lesen.

OK, da mein Problem anscheinend so nicht lösbar ist, erkläre ich mal den Zusammenhang:
Mein Animationssystem arbeitet mit sozusagen mit einem Skelett. Und man animiert Objekte indem man die Knochen im Skelett bewegt.
Nun zum Zusammenhang mit der Aufgabe: Ein Knochen im Skelett ist hier P1. Die Sachen um den Knochen herum, die sich mitbewegen sollen, sind jeweils P2.
Ein Knochen geht immer von einem Gelenk zu einem anderen. Die Herkunft von P1 ist immer im übergeordneten Gelenk, und er geht zum untergeodneten Gelenk. Am unteren Gelenk ist auch P2 "befestigt", also hat dort seinen Ursprung.
Ich hoffe das war verständlich.

Also, wie könnte ich mein Problem sonst noch lösen, dass sich das Objekt mitbewegt, wenn man seine Knochen bewegt?

[OregonGhost]

Siehst du, hättest du das mal gleich gesagt. Die Antwort lautet:

Matrixmultiplikation.

Schon mal gehört, oder? Nämlich auf Seite 1 ;c)

Und das geht so. Irgendwo musst du die Bewegung der Knochen ja definieren. Das geht letztendlich über Matrixmultiplikation, das X-Format von DirectX beispielsweise speichert hierzu direkt die Matrizen. Und jetzt kommt der Witz: Wenn du z.B. deine Torso-Matrix multiplizierst mit der Oberarm-Matrix, die du mit der Unterarmmatrix multiplizierst etc. (Handmatrix, Fingermatrix), musst du nämlich nur relative Matrizen speichern und erhältst jeweils die "End-"Matrix, die du direkt auf den Vertices anwenden kannst. Zu diesem Konzept gehört auch der Matrix-Stack, den es z.B. für DirectX als ID3DXMatrixStack gibt.
Du definierst die Bewegung des Knochen als Matrix. Diese speicherst du für den Knochen, und dann kannst du sie sowohl auf den zu dem Knochen gehörigen Vertices, als auch auf allen in der Hierarchie untergeordneten Knochen anwenden.

Gewöhnlich führst du die letztendliche Multiplikation der Vektoren mit den Matrizen jedoch nicht selbst durch, sondern lässt das die Grafikkarte machen, indem du die Matrix als Transformationsmatrix (in diesem Fall als Welttransformationsmatrix) der Karte übermittelst. Du kannst es natürlich trotzdem von Hand machen.

Aber mal ehrlich, du willst also ein Knochensystem basteln, ohne von Vektoren eine Ahnung zu haben?
Wie dem auch sei, die Stichworte Matrix, Matrixmultiplikation, Matrixstack sollten eigentlich als Suchgrundlage reichen. Auch auf gamedev.net oder gamasutra.com gibt es zu diesen Themen mehrere Artikel, wenn ich nicht irre sogar exakt zu deinem Problem (wie baue ich ein Knochensystem).

Ach ja, um es nicht zu vergessen: Wenn du Winkel zwischen Vektoren benötigst, ist generell das Punktprodukt (Dot Product) oder Skalarprodukt die richtige Wahl. Ich hab' auch noch einen Artikel gefunden, der das ganze etwas erläutert: http://www.jtl-software.de/3d_grund.html

[MR321]

Ja, Matrixmultiplikationen kann OpenGL, genauso wie man sie auch auf einem Stack speichern kann. (Und jetzt das beste: Ich weis sogar wie man das macht :mrgreen:)
Aber trotzdem muss ich die Werte für die Matrixmultiplikation erstmal rausbekommen. Denn ich hab ja nur die Koordinaten der einzelnen Gelenkpunkte. Und die neuen Koordinaten, wenn sich das Teil bewegt.

Und zum Knochensystem: Mir ist kein anderes System eingfallen, was man zur Animation benutzen könnte. :zwinker:

//Edit: Ach ja, jetzt hab ich doch glatt die Frage vergessen: Wie bekomme ich die Werte für die Matrixmultiplikation? Und da sind wir wieder beim Thema... :(

[OregonGhost]

Ich glaube, das ist nicht so pauschal zu beantworten. Können die Knochen sich denn beliebig bewegen, oder anders gefragt, wer bewegt sie, wenn nicht du? Können sie NUR gedreht oder bewegt werden oder beides?

Normalerweise bewegst du bereits die Knochen selbst per Matrixmultiplikation, so dass du die Matrix somit automatisch zur Verfügung hast. Also: Wie bewegst du denn nun deine Knochen? Bitte detailliert ;c)

[MR321]

Meine Knochen werden bewegt, indem man einem Gelenk einfach einen anderen Punkt zuweist. Die Zuweisung betrifft nur das eine Gelenk. Alle untergeordneten Gelenke bleiben an der selben Stelle. Alle übergeordneten auch. Man kann den Gelenken belibige Koordinaten zuweisen.

Die Knochen werden bewegt durch Keyframes, in denen jeweils alle Positionen der Gelenke gespeichert sind. In den Frames dazwischen werden die Gelenke dynamisch berechnet. Also wir haben die aktuellen Knochenpostitionen für den aktuellen Frame vorliegen (Habe ich sogar selbst geschafft zu berechnen :mrgreen:).

Aber mal ne Frage so nebenbei: Wie würde man das ganze mit Matrixmultiplikationen machen? Also so, dass es auch hinterher anwenderfreundlich ist.

[OregonGhost]

Du setzt die Transformationsmatrix als Weltmatrix und renderst einfach die betreffenden Vertices, Rest erledigt 3D-Api bzw. Grafikkarte ;c)

Ich würde dir empfehlen, einfach die Punkte in Matrizen umzurechnen. Wie ich weiter oben schon erwähnte, bekommst du den Winkel (und somit die Rotation) über das Skalarprodukt und die Translation kannste ja direkt ausrechnen, davon ausgehend, dass du für jeden Knochen zwei Punkte hast (nämlich seinen Startpunkt und den Startpunkt des nächsten). Aus dem Winkel errechnest du die Rotationsmatrix und aus der Translation halt die Translationsmatrix, und dann multiplizierst du die beiden (aber bitte in der richtigen Reihenfolge, die ich gerade nicht im Kopf habe :roll: ) und setzt sie als Weltmatrix. Bei D3D also IDirect3DDevice9::SetTransform(D3DTS_WORLDMATRIX, &Matrix) oder so. Und dann renderst du die Vertices, die zu dem Knochen gehören -> Grafikkarte transformiert sie alle so wie den Knochen. Die Transformationsmatrizen berechnen kannst du z.B. mit den D3DXMatrixTranslation und D3DXMatrixRotationAxis Funktionen, im DirectX SDK steht aber auch, wie du die Matrizen ganz einfach von Hand berechnest. In dem Artikel, zu dem ich oben verlinkt habe, glaube ich auch ;c)
Ach, und ich glaube, eine Skalierung ist nicht mit dieser Methode zu erkennen -> einfacher wäre die Speicherung mit Matrizen wie z.B. das X-Format es macht.

So, und was meinst du jetzt mit ANWENDERFREUNDLICH? ;c)

[MR321]

Ich arbeite mit OpenGL. Aber dort kenne ich die Befehle dafür.

Delphi-Quellcode:

glTranslate3f(X,Y,Z); // Verschieben
glRotate4f(Winkel,1,0,0) // Um X-Achse drehen
glRotate4f(Winkel,0,1,0) // Um Y-Achse drehen
glRotate4f(Winkel,0,0,1) // Um Z-Achse drehen

OK, und wie genau berechne ich das jetzt? Nehmen wir an ich habe jetzt den Punkt vom übergeordneten Gelenk: P1neu. Und den vom untergeordneten suche ich: P2neu. Und die Grundposition von den beiden: P1alt,P2alt habe ich auch.
Wie berechne ich das nun?

[edit=Daniel B]Delphi-Tags eingefügt. Mfg, Daniel B[/edit]

[OregonGhost]

Tja, das ist halt das Problem. Wenn du aus deinen zwei Vektoren drei Winkel berechnen willst, ist das nicht ganz einfach.
Ich habe oben schon eine einfachere Methode beschrieben, die ich daher empfehlen würde: Den Winkel per Skalarprodukt berechnen, per Kreuzprodukt eine zur Rotationsbewegung senkrechte Achse berechnen und dann eine Matrix erzeugen bzw. eine Drehung ausführen, die um den Winkel um die berechnete Achse dreht. In D3D nimmste da halt einfach D3DXMatrixRotationAxis, unter OpenGL weiß ich nicht ob es da ein direktes Äquivalent gibt, und wie gesagt, ist es nicht ganz einfach, wenn auch nicht unmöglich, es mit drei Winkeln zu machen.

Dazu musst du halt neue Vektoren erzeugen, für jede achsenparellele Ebene einen (also für die xy-Ebene, indem du die Z-Koordinate auf 0 setzt). Jetzt berechnest du innerhalb dieser Ebene den Winkel zwischen den Vektoren per Skalarprodukt, und das machst du für die anderen Ebenen auch. Dadurch bekommst du deine drei Winkel. Naja, die Translation ist dann ja wieder trivial, einfach den alten Anfangspunkt des Knochens vom neuen Anfangspunkt subtrahieren. Leider landest du damit wiederum beim noch weiter oben von mir erwähnten Gimbal-Lock-Problem, das aber für deine Animationen vermutlich nicht so drastisch ist.

[MR321]

Bahnhof! :wiejetzt:
Ich habe nicht den blassesten Schimmer wovon du da gerade redest.
Kannst du das auch irgendwie als Formeln aufschreiben, die ich dann in Delphi auch benutzen kann?

(Oder falls du keine Lösung findest eine Alternative, die besser zu meinem jetzigen Animationssystem ist...)

//Edit: Man kann auch in OpenGL direkt eine Matrix eingeben, mit der man die aktuelle Matrix multipliziert.

[OregonGhost]

Aber OpenGL bietet meines Wissens keine Funktion, die eine Matrix erzeugt, die eine Rotation um eine beliebige Achse durchführt! Das wäre daher von Hand zu erledigen, wiederum nicht ganz trivial.

Die Alternative zu deinem Animationssystem (abgesehen von der Möglichkeit, die Matrizen mit den Vertexdaten zu speichern) liegt doch auf der Hand: Anstatt Knochen-Keyframes zu speichern, speicherst du Keyframes des gesamten Models. Macht zum Beispiel Quake 3 so. Dann schenkst du dir den ganzen Knochenkram, der ohne analytische Geometrie wie du siehst nicht ganz einfach ist. Da das sehr aufwändig ist, werde ich dir auch keine fertigen Formeln geben (weil ich keine hab' (c; ), so dass du entweder die Formeln selbst erarbeiten musst (der Link oben von mir gibt da wie gesagt reichlich Hilfe, ebenso jede mathematische Formelsammlung), ein vorgefertigtes Animationssystem verwendest (wie z.B. das md3-Format oder das X-Format, die du überall erklärt findest) oder dir ein eigenes neues überlegst. Ansonsten, wenn du es weiterhin so machen willst wie bisher, dann:

Lerne was ein Skalarprodukt ist.
Lerne was ein Kreuzprodukt ist.

Mit etwas Nachdenken kommst du dann schon zu den Formeln, aber diese beiden Teile sind so elementar, dass keine 3D-Engine ohne auskommt. Selbst wenn du sie nicht aktiv benutzt, denn z.B. die Lichtberechnung ist nichts weiter als ein Skalarprodukt des Lichtvektors mit dem Normalenvektor der Oberfläche.

Weil du's bist, gebe ich dir nochmal den Link: http://www.jtl-software.de/3d_grund.html
Da steht was ein Kreuzprodukt ist, was ein Skalarprodukt ist und wie du einfache Matrizen erzeugst. Und es ist auch für jemanden verständlich, der von Tuten und Blasen (oder vielmehr Vektoren) keinen blassen Schimmer hat. Also bitte ich dich nochmal, lies diesen Text durch, verstehe ihn und dann kannst du wiederkommen :mrgreen:
Es steht wirklich alles drin, was du für die besagten drei Drehwinkel brauchst, wie ich es etwas weiter oben beschrieben habe, aber ohne diese Grundbegriffe werde ich es dir kaum näher erklären können.