Tutorial Kollision1 - Versionsgeschichte

Glawesome: /* Nun zur Kollision */ Rechtschreibfehler korrigiert, Ebene verlinkt

2013-10-12T22:38:32Z

‎Nun zur Kollision: Rechtschreibfehler korrigiert, Ebene verlinkt

Openglerf: Rechtschreibfehler ausgebessert

2013-09-25T14:33:22Z

Rechtschreibfehler ausgebessert

DGLBot: Der Ausdruck ''(.*?)'' wurde ersetzt mit ''$1''.

2009-03-10T18:47:30Z

Der Ausdruck ''<cpp>(.*?)</cpp>'' wurde ersetzt mit ''<source lang="cpp">$1</source>''.

Flash: /* Nun doch noch der wichtige Gedanke */

2008-04-08T19:03:55Z

‎Nun doch noch der wichtige Gedanke

Flash: /* Geht noch mehr? */

2008-02-08T09:58:44Z

‎Geht noch mehr?

Flash: Pascaltags ->CppTags

2008-02-08T09:56:39Z

Pascaltags ->CppTags

Flash: Pascaltags -> Cpp Tags

2008-02-08T09:55:59Z

Pascaltags -> Cpp Tags

Flash: /* ... und lassen die Kugel rollen */ pascal tags durch cpp tags ersetzt

2008-02-08T09:55:09Z

‎... und lassen die Kugel rollen: pascal tags durch cpp tags ersetzt

Flash: Neues Tutorial

2008-02-07T22:59:12Z

Neues Tutorial

Änderungen zeigen

@@ Zeile 155: / Zeile 155: @@
 Was ist zu tun? Genauer: Wo müssen wir die Kugel abfangen und ihr mitteilen, dass es beim nächsten Mal in anderer Richtung weitergeht? Wir können das erledigen, nachdem die Kugel die Grenzlinie überschritten hat, oder wir machen das vorher, indem wir den anstehenden Bewegungsschritt nur probehalber durchführen und ggfs. unterlassen? Beides ist nicht ganz sauber, und nur, wenn die Kugel sehr langsam rollt und die Bewegungsschritte entsprechend klein sind, fällt es nicht auf. Wenn wir genau sein wollen, müssen wir ein wenig weiter ausholen und den Berührungspunkt auf der weißen Linie finden. Nennen wir ihn '''Intersektionspunkt''', obwohl der eigentliche Intersektionspunkt direkt an der Bande liegt.
-Damit sind wir schon mitten drin im Kollisionszirkel. Es geht daraum, den Schnittpunkt eines Strahls mit einer Ebene zu berechnen ''(ray-plane intersection)''. Der Strahl ist nichts anderes als der Bewegungsvektor der Kugel, der von der Kugelposition wegzeigt. Und die Ebene müssen wir uns senkrecht auf der weißen Linie vorstellen, wie eine unsichtbare Wand.
+Damit sind wir schon mitten drin im Kollisionszirkel. Es geht darum, den Schnittpunkt eines Strahls mit einer [[Ebene]] zu berechnen ''(ray-plane intersection)''. Der Strahl ist nichts anderes als der Bewegungsvektor der Kugel, der von der Kugelposition wegzeigt. Und die Ebene müssen wir uns senkrecht auf der weißen Linie vorstellen, wie eine unsichtbare Wand.
 Die mathematischen Hintergründe wollen wir uns ersparen, hier die Funktion, die den Intersektionspunkt ausrechnet:

@@ Zeile 257: / Zeile 257: @@
 <br>
-Viel Spass beim Experimentieren mit Kollisionen.
+Viel Spaß beim Experimentieren mit Kollisionen.
 '''Reinhard'''

@@ Zeile 123: / Zeile 123: @@
 Wir brauchen also zwei Vektor-Variablen, die wir nach dem Programmstart auf geeignete Anfangswerte setzen:
-<cpp>
+<source lang="cpp">
 TVector position;
 TVector velocity;
@@ Zeile 133: / Zeile 133: @@
 velocity.y = 0.0 // bleibt immer 0, zweidimensional
 velocity.z = -0.5 // Vorwärtsbewegung
-</cpp>
+</source>
 Die Werte müssen wir natürlich anpassen. Vor dem Zeichnen der Kugel wird in jedem Frame die Position aktualisiert:
-<cpp>
+<source lang="cpp">
 position = AddVectors (position, ScaleVector (timestep, velocity));
-</cpp>
+</source>
 Wenn wir das Programm starten, rollt die Kugel, lässt sich aber von der Bande nicht aufhalten und verschwindet in der unendlichen Weite. Vielleicht wird sie irgendwann den Mars umkreisen oder in der Sonne verglühen, wobei wir dafür erst den passenden Code schreiben müssten.  ;)
@@ Zeile 159: / Zeile 159: @@
 Die mathematischen Hintergründe wollen wir uns ersparen, hier die Funktion, die den Intersektionspunkt ausrechnet:
-<cpp>
+<source lang="cpp">
 double PlaneIntersect (TVector pOrigin, TVector pNormal, TVector sPosition, TVector sDir)
+{
@@ Zeile 167: / Zeile 167: @@
 	return -(num / denom);
+}
-</cpp>
+</source>
 ''pOrigin'' ist irgendein Punkt auf der Ebene und damit auf der weißen Hilfslinie. Es dürfte kein Problem sein, irgendeinen geeigneten Punkt zu finden. ''pNormal'' ist die Normale der Ebene, ein Vektor, den wir ganz einfach im Kopf ausrechnen können. Nehmen wir dazu die linke Begrenzungsebene. Aus der Sicht der Kugel zeigt die Normale nach rechts, also ist der Vektor (1, 0, 0). Ähnliches gilt für die anderen drei Ebenen.
@@ Zeile 179: / Zeile 179: @@
 An der Bande lassen wir die Kugel zunächst liegen, versäumen aber nicht, die Richtung so zu verändern, dass der Aufprallwinkel gleich dem Rückprallwinkel ist. Auch das ist kein Problem, schauen wir wieder auf die linke Bande. Es ändert sich hier nur die x-Richtung, während die Fortbewegung in z-Richtung gleich bleibt. Also stülpen wir den x-Wert des Bewegungsvektors um:
-<cpp>
+<source lang="cpp">
 velocity.x = - velocity.x;
-</cpp>
+</source>
 Mit den anderen Banden verfahren wir analog. Es ist aber wichtig, dass wir immer '''alle vier Banden''' überprüfen. Es kann nämlich sein, dass die Kugel auf eine Ecke zusteuert und gleichzeitig mit zwei Banden in Konflikt gerät. Dann müssen in ein- und demselben Frame zwei Richtungen umgedreht werden. Wenn wir feststellen, dass die Kugel gelegentlich außerhalb des Käfigs hin- und herzittert und nicht wieder hinein will, haben wir diesen Punkt nicht beachtet.
@@ Zeile 195: / Zeile 195: @@
 In der Abbildung steckt alles, was wir zur Lösung des Problems brauchen. Wieder haben wir die weiße Linie, die uns erlaubt, mit dem Mittelpunkt der Kugel zu rechnen, und natürlich ist der äußere Kreis um den Radius der Kugel größer als der eigentliche Kollisionskörper. Wir sehen die gelb eingezeichnete Tangente, an der wir die Reflexion vornehmen. Doch vorher müssen wir wieder den Intersektionspunkt haben, worauf der blaue Pfeil zeigt. Hier nun die Funktion, die uns den Punkt liefert:
-<cpp>
+<source lang="cpp">
 double CircleIntersect (TVector center, double radius,
 					   TVector sPosition, TVector sDir)
@@ Zeile 208: / Zeile 208: @@
 	return v - sqrt (d);
+}
-</cpp>
+</source>
 Die ersten beiden Parameter beschreiben den Kollisionskreis (oder Zylinder) und dürften selbsterklärend sein; die beiden anderen Parameter sind dieselben wie bei der Funktion weiter oben. Auch das Ergebnis wird in gleicher Weise verwendet. Halt, eines ist zu beachten: '''sDir muss nun auf jeden Fall normalisiert sein!'''
@@ Zeile 216: / Zeile 216: @@
 Der '''Reflexionswinkel''' lässt sich leider nicht mehr ganz so einfach berechnen wie bei der Kollision an der Bande. Die Tangente ist ja nicht nach x oder z ausgerichtet, sondern kann irgendwie liegen. Aber auch hierfür gibt es eine praktische Funktion:
-<cpp>
+<source lang="cpp">
 TVector ReflectVector (TVector a, TVector norm)
+{
@@ Zeile 228: / Zeile 228: @@
 	return res;
+}
-</cpp>
+</source>
 ''a'' ist der normalisierte Bewegungsvektor, der auf den Intersektionspunkt zeigt, und ''norm'' ist die Normale der Tangente bzw. der Ebene, die sie repräsentiert. Diese Normale lässt sich schnell aus dem Mittelpunkt des Kreises und dem Intersektionspunkt ableiten (blauer Pfeil). Das Ergebnis ist die Richtung des neuen Bewegungsvektors, der dann noch auf die ursprüngliche Länge gebracht werden muss.

@@ Zeile 261: / Zeile 261: @@
 '''Reinhard'''
-{{TUTORIAL_NAVIGATION|[[Tutorial Separating Axis Theorem]]|-}}
+{{TUTORIAL_NAVIGATION|[[Tutorial Separating Axis Theorem]]|[[Tutorial Kollision2]]}}
 [[Kategorie:Tutorial|Kollision1]]

@@ Zeile 230: / Zeile 230: @@
 </cpp>
-a ist der normalisierte Bewegungsvektor, der auf den Intersektionspunkt zeigt, und norm ist die Normale der Tangente bzw. der Ebene, die sie repräsentiert. Diese Normale lässt sich schnell aus dem Mittelpunkt des Kreises und dem Intersektionspunkt ableiten (blauer Pfeil). Das Ergebnis ist die Richtung des neuen Bewegungsvektors, der dann noch auf die ursprüngliche Länge gebracht werden muss.
+''a'' ist der normalisierte Bewegungsvektor, der auf den Intersektionspunkt zeigt, und ''norm'' ist die Normale der Tangente bzw. der Ebene, die sie repräsentiert. Diese Normale lässt sich schnell aus dem Mittelpunkt des Kreises und dem Intersektionspunkt ableiten (blauer Pfeil). Das Ergebnis ist die Richtung des neuen Bewegungsvektors, der dann noch auf die ursprüngliche Länge gebracht werden muss.
 Für den Fall, dass einer der beiden Parameter in nicht-normalisierter Form übergeben werden soll, lässt sich das in der Funktion nachholen. Dazu dienen die beiden auskommentierten Zeilen.