Quelltext der Seite AS3-Tutorium:Physics:Grundlagen

= Überblick =

Dieser Artikel erklärt die Grundlagen der rechnergesteuerten Simulation von physikalischen Vorgängen.

= Anmerkungen =

Um die im Artikel enthaltenen Beispiel auszuführen werden Grundkenntnisse in [[Flex]] benötigt. Eine einfache Einführung bietet dieses [http://www.webmasterpro.de/coding/news/2008/04/04/flex-builder-kostenlos-fuer-studenten.html Tutorial]. Die Theorie des Artikels ist jedoch in jeder Programmiersprache realisierbar. 

Basis aller Code-Beispiele ist folgende Klasse:

 package 
 {	
     import flash.display.MovieClip;
     import flash.display.Sprite;
     import flash.events.Event;
 
     [ SWF( backgroundColor = '0xFFFFFF', width = '500', height = '400' ) ]
     public class Main extends Sprite
     {	
         public function Main()
         {
             addEventListener( Event.ENTER_FRAME, on_enter_frame );
         }
 		
         public function on_enter_frame( event: Event ): void
 	 {
             trace( "enter frame" );
         }
     }
 }

= Definition =

<blockquote>Eine Physik-Engine ist ein meist separater Teil eines Computerprogramms, welcher zur Simulation physikalischer Prozesse dient. Ziele sind eine Vereinfachung der Programmierung und die Vermittlung von realistischer Umgebung. Hauptanwendungsgebiete sind moderne Computerspiele und Simulationssoftware.
Anders als es die Bezeichnung vermuten lässt, muss dabei nicht zwangsläufig ein physikalisches Konzept zu Grunde liegen. Dies liegt oft an der immensen Komplexität der auf physikalischen Prozessen basierenden Berechnungen. Da in solchen Fällen meist ein Anspruch auf Echtzeitfähigkeit besteht, geht Effizienz vor Exaktheit. <cite>(Quelle: Wikipedia)</cite></blockquote> 

= Einsatzgebiete =

Physics-Engines werden in der Regel in der Spielebranche häufig eingesetzt. Für Simulationen eignen sich diese nur bedingt, da sie oft keinen Fokus auf Exaktheit legen. Es folgen einige Beispiele für mögliche Anwendungsfälle:

* Spiele
** [http://www.sideroller.com/ Sideroller]
** [http://magic.pen.fizzlebot.com/magic-pen.swf Magic Pen]
** [http://www.flashphysicsgames.com/do-not-hotlink/ragdollcannon15.swf Ragdoll Cannon]
* Simulationen
** [http://cove.org/ape/demo2.htm APE Demo]
** [http://lab.polygonal.de/files/AS3/verletblob.swf Verlet Blob]
** [http://www.nulldesign.de/exp/f9_particle2.swf Fireflies]

= Grundlagen =

Dieser Abschnitt behandelt die mathematischen und physikalischen Grundlagen für eine einfache Physics-Simulation. Ein grundsätzliches Verständnis folgender Gebiete wird vorausgesetzt:  [[Wikipedia:Vektoralgebra|Vektoralgebra]], [[Wikipedia:Newtonsche_Mechanik|Newtonsche Mechanik]], [[Wikipedia:Hooksches_Gesetz|Hooksches Gesetz]]

== Ort ==

<blockquote>Typischerweise spricht man in der Mechanik von Massenpunkten. Jeder Massenpunkt besitzt eine endliche, von null verschiedene Masse m. Jedem Massenpunkt ist zu jeder Zeit t ein eindeutiger Ort q = q(t)  zugeordnet. <cite>(Quelle: Wikipedia)</cite></blockquote>

Im einem zweidimensionalen Raum wird ein Ort durch einen Vektor v(x,y) beschrieben. Bei Bildschirmkoordinaten ist wichtig zu beachten, dass der Ursprung links oben liegt und nach rechts unten ins Positive verläuft.

Die einfachste Form von Bewegung erfolgt über eine direkte Positionsänderung zu jedem beliebigen Zeitpunkt t (im Falle von Actionscript oder vergleichbaren Sprachen in jedem Frame bzw. bei jeder draw()-Methode).

 package 
 {	
     import flash.display.MovieClip;
     import flash.display.Sprite;
     import flash.events.Event;
 
     [ SWF( backgroundColor = '0xFFFFFF', width = '500', height = '400' ) ]
     public class Main extends Sprite
     {
         public var circle: MovieClip;
     	
         public function Main()
         {
             circle = new MovieClip();
             circle.graphics.lineStyle( 1, 0 );
             circle.graphics.drawCircle( 0, 0, 20 );
             addChild( circle );
             addEventListener( Event.ENTER_FRAME, on_enter_frame );
         }
             
         public function on_enter_frame( event: Event ): void
         {
             circle.x = Math.random() * 500;
             circle.y = Math.random() * 400;
         }
     }
 }

Beispiel: http://glossar.hs-augsburg.de/beispiel/tutorium/physics/Lawrence_Physics/swf/TutoriumPhysics-01-Ort.swf

== Geschwindigkeit ==

<blockquote>Unter der Geschwindigkeit eines Objekts versteht man die von ihm zurückgelegte Wegstrecke s pro Zeit t. Mathematisch entspricht die Geschwindigkeit der Ableitung des Ortes nach der Zeit. <cite>(Quelle: Wikipedia)</cite></blockquote>

Betrachtet man also den Ort x zu zwei verschiedenen diskreten Zeitpunkten t0 und t1, ergibt sich aus der Differenz der beiden Orte die Geschwindigkeit zum Zeitpunkt t1.

 t0: x0 = 0
 t1: x1 = 1
 
 v = x1 - x0 = 1

Wenn man also nicht den Ort direkt, sondern die Geschwindigkeit ändert, welche man pro Zeitintervall auf den Ort addiert, erhält man lineare Bewegungen.

 package 
 {	
     import flash.display.MovieClip;
     import flash.display.Sprite;
     import flash.events.Event;
     
     [ SWF( backgroundColor = '0xFFFFFF', width = '500', height = '400' ) ]
     public class Main extends Sprite
     {
         public var circle: MovieClip;
         public var vx: Number = 0;
         public var vy: Number = 0;
         	
         public function Main()
         {
             circle = new MovieClip();
             circle.graphics.lineStyle( 1, 0 );
             circle.graphics.drawCircle( 0, 0, 20 );
             circle.x = 250;
             circle.y = 200;
             addChild( circle );
             addEventListener( Event.ENTER_FRAME, on_enter_frame );
         }
             
         public function on_enter_frame( event: Event ): void
         {
             vx = 1 - Math.random() * 2;
             vy = 1 - Math.random() * 2;
             circle.x += vx;
             circle.y += vy;
         }
     }
 }

Beispiele:
* [[Medium:TutoriumPhysics-02-Geschwindigkeit.swf]]
* [[Medium:TutoriumPhysics-03-Geschwindigkeit.swf]]

== Masse ==

<blockquote>Die Masse ist eine Ursache von Gravitation („schwere Masse“) und ein Maß für die Trägheit eines Körpers, das heißt seinen Widerstand gegenüber Änderungen seines Bewegungszustands („träge Masse“). <cite>(Quelle: Wikipedia)</cite></blockquote>

Das heißt, die Masse bestimmt wie stark Körper unterschiedlicher Masse von Kräften beeinflusst werden.

== Kräfte ==

<blockquote>Die Kraft ist eine physikalische Größe und ein grundlegender Begriff insbesondere der Mechanik, die die Beschleunigung von Massen oder die Verformung von Körpern verursacht. <cite>(Quelle: Wikipedia)</cite></blockquote>

Im Fall von "Rigid Body Physics" (Physik der starren Körper) interessiert die Beschleunigung von Massen, nicht aber die Verformung. Es gilt also:

 Kraft = Masse * Beschleunigung
 F = m * a
 a = F / m

== Beschleunigung ==

<blockquote>Beschleunigung ist die Änderung der Geschwindigkeit eines Körpers. <cite>(Quelle: Wikipedia)</cite></blockquote>

Die Beschleunigung ist somit die erste Ableitung der Geschwindigkeit und die zweite Ableitung des Ortes. Um natürlich wirkende Bewegungen zu erzielen, arbeitet man mit Beschleunigungen anstatt nur mit Geschwindigkeit (Vergleich: Ease-In/Ease-Out in Flash oder After Effects). 

 t0: x0 = 0, v0 = 1
 t1: x1 = 1, v1 = 2
 t3: x2 = 3, v2 = 3
 t4: x3 = 6, v3 = 4

 a = v3 - v2 = v2 - v1 = v1 - v0 = 1

 package 
 {	
     import flash.display.MovieClip;
     import flash.display.Sprite;
     import flash.events.Event;
     
     [ SWF( backgroundColor = '0xFFFFFF', width = '500', height = '400' ) ]
     public class Main extends Sprite
     {
         public var circle: MovieClip;
         public var vx: Number = 0;
         public var vy: Number = 0;
         public var ax: Number = 0;
         public var ay: Number = 0;
         		
         public function Main()
         {
             circle = new MovieClip();
             circle.graphics.lineStyle( 1, 0 );
             circle.graphics.drawCircle( 0, 0, 20 );
             circle.x = 50;
             circle.y = 200;
             ax = .2;
             addChild( circle );
             addEventListener( Event.ENTER_FRAME, on_enter_frame );
         }
         		
         public function on_enter_frame( event: Event ): void
         {
             vx += ax;
             vy += ay;
             circle.x += vx;
             circle.y += vy;
         }
     }
 }

Beispiele:
* [[Medium:TutoriumPhysics-04-Beschleunigung.swf]]
* [[Medium:TutoriumPhysics-05-Beschleunigung.swf]]

== Gravitation ==

<blockquote>Die Gravitation (v. lat. gravitas „Schwere“) ist eine der vier Grundkräfte der Physik. Sie bezeichnet die gegenseitige Anziehung von Massen. Sie bewirkt damit beispielsweise, dass Gegenstände zu Boden fallen (sie werden von beispielsweise der Erde angezogen und ziehen diese im Gegenzug an). <cite>(Quelle: Wikipedia)</cite></blockquote>

Bei einer Gravitation ziehen sich also zwei Körper immer gegenseitig. Wenn man allerdings Kräfte von sehr großen Körpern simulieren will (wie zum Beispiel die Erdanziehungskraft), so kann man die Kraft vernachlässigen, welche vom kleineren auf den größeren Körper wirkt. Desweiteren können Objekte unter einer bestimmten Größe als massengleich angesehen werden. Solche Kräfte werden in Physics-Simulationen als massenunabhängig betrachtet.

Beispiel: [[Medium:TutoriumPhysics-06-Gravitation.swf]]

== Federn (Hooksches Gesetz) ==

<blockquote>Das Hooke'sche Gesetz (nach Sir Robert Hooke) beschreibt das elastische Verhalten von Festkörpern, deren elastische Verformung annähernd proportional zur einwirkenden Belastung ist, durch einen streng linearen Zusammenhang (linear-elastisches Verhalten). [..] Das Hookesche Gesetz kann also dort zur Anwendung kommen, wo die wirkende Kraft nahezu linear von der Auslenkung oder Ausdehnung abhängt. Das kann für sehr kleine Δl der Fall sein oder beispielsweise auch für einen großen Dehnungsbereich bei Zug- und Druckfedern. <cite>(Quelle: Wikipedia)</cite></blockquote>

Im Bereich der Physics werden Federn oft benutzt um aus einer Menge von verbundenen Massepunkten einen Körper zu simulieren. Der große Vorteil hierbei ist, dass die Rotation komplexer Körper nicht berechnet werden muß. Für exakte und komplexere Simulationen reicht ein Netzt von Massepunkten allerdings nicht aus. Die Simulation von Federn ist sehr einfach zu implementieren und wirkt bei ausreichenden kleinen Zeitintervallen sehr realistisch.

 (1) F = k * x
 (2) F = k * ( xn - x0 )
 (3) F1 = k * ( xn - x0 ) * m2 / ( m1 + m2 )
 (4) F2 = k * ( xn - x0 ) * m1 / ( m1 + m2 ) * -1

 ...
 spring.object_a.vx += ( f * dx * ( spring.object_b.mass / m12 ) );
 spring.object_a.vy += ( f * dy * ( spring.object_b.mass / m12 ) );
 				
 spring.object_b.vx -= ( f * dx * ( spring.object_a.mass / m12 ) );
 spring.object_b.vy -= ( f * dy * ( spring.object_a.mass / m12 ) );
 ...

Beispiele:
* [[Medium:TutoriumPhysics-07-Federn.swf]]
* [[Medium:TutoriumPhysics-08-Federn.swf]]
* [[Medium:TutoriumPhysics-09-Federn.swf]] (dieses Beispiel implementiert bereits Kollisionserkennung und -lösung)

== Kollsionen mit den Bildschirmgrenzen ==

Bei Grenzen im 2D-Raum, welche parallel zur X- oder Y-Achse verlaufen, kann der entsprechende Geschwindigkeitsanteil eines Objekts einfach umgedreht werden (v *= -1). Außerdem wird das Objekt wieder so weit zurückgeschoben, sodass es nicht mehr mit den Grenzen kollidiert. Hiermit wird eine einfache Kollsionsabfrage simuliert. 

 ...
 if ( 	( object.x - object.radius < 0 )
     && ( object.vx < 0 ) )
 {
     object.vx *= -1;
     object.x = object.radius;
 }			
 ...

Beispiele: [[Medium:TutoriumPhysics-10-Bounds.swf]]

== Kollisionen zwischen kreisförmigen Objekten ==

Die Grundlage hierfür der zentrale, unelastische [http://de.wikipedia.org/wiki/Sto%C3%9F_(Physik) Stoß]. Das Prinzip des zentralen Stoßes dient zur einfachen Kollsionserkennung und -lösung zwischen zwei kreisförmigen Objekten, deren Massenschwerpunkte im Zentrum liegen. Für komplexere Objekte und Berechnungen von Rotationen ist dieses Prinzip nicht geeignet.

<blockquote>[..] Im folgenden wird nur der Fall des zentralen Stoßes betrachtet. Wird hierbei freie Beweglichkeit der Stoßpartner vorausgesetzt, so bleiben die Geschwindigkeitskomponenten beider Stoßpartner normal zur Stoßlinie unverändert: vn = vn, da die Stoßkräfte nur entlang der Stoßlinie wirken können. Da die Schwerpunkte auf der Stoßlinie liegen, erfahren die Körper nach dem Stoß keine Rotationsbewegung. Im folgenden bezeichnen darum v1 und v2 die (skalaren) Geschwindigkeitskomponenten parallel zur Stoßlinie. <cite>Quelle: Wikipedia</cite></blockquote>

=== Kollsionserkennung ===

In den meisten Physics-Engines werden Kollision erst erkannt, nachdem sie bereits geschehen sind. Es ist in jedem Fall möglich eine Kollision mithilfe von Projektionen der Körper entlang der Geschwindigkeiten vorherzusagen, der erhöhte Rechenaufwand für dieses Verfahren lohnt sich in den meisten Fällen jedoch nicht, da Effizienz vor Exaktheit geht.

Da ein Kreis vom Mittelpunkt zu einem Punkt auf seiner Oberfläche unabhängig von der Richtung immer denselben Abstand hat, liegt eine Kollision zwischen zwei Kreisen vor, sobald der Abstand der Mittelpunkte kleiner ist als die Summe der Radien der beiden Kreise.

 d12 = |m1 - m2|
 d12 < r1 + r2

Um eine Kollision korrekt verarbeiten zu können werden folgende Nenngrößen benötigt:
* Tiefe der Kollision, in Physics-Simulation oft MTD genannt (Minimum Translation Distance) - im Falle von Kreisen die Differenz von Abstand und Summe der Radien
* Die Kollisionsnormale - im Falle von Kreisen der normierte Vektor von Mittelpunkt m1 nach m2
* Die Massen der beiden Objekte
* Die Geschwindigkeiten der beiden Objekte

=== Kollisionslösung ===

Bei einer Kollisionslösung von bereits geschehenen Kollisionen spricht man meistens vom "Collision Resolving". 
Es werden folgende Schritte durchgeführt:
* Die Objekte werden entlang der Kollisionsnormale massenabhängig insgesamt um die Tiefe der Kollision auseinandergezogen
* Die Geschwindigkeiten der Objekte werden in einen Normalen- und einen Tangentenanteil aufgeteilt (die Normale ist hier die Kollisionsnormale)
* Die Tangentenanteile der Geschwindigkeiten der Objekte werden unverändert übernommen, die Normalenanteile gespiegelt und massenabhängig verrechnet

Beispiele:
* [[Medium:TutoriumPhysics-11-Stoss.swf]]
* [[Medium:TutoriumPhysics-12-Stoss.swf]]

== Lebenszeit ==

In Partikelsystemen (vereinfachte Physik-Simulation ohne Kollisionen, werden benutzt um z.B. Rauch, Feuer, Flüssigkeit zu simulieren) werden allen Objekten Lebenszeiten zugeordnet. Dieser werden über die Zeit verringert und führen dazu, dass das Objekt "stirbt", wenn die Lebenszeit abgelaufen ist.

 ...
 if ( object.lifetime > 0 )
 {
     object.lifetime--;
     object.alpha = ( object.lifetime / lifetime_maximum );
     if ( object.lifetime == 0 )
     {
         dead_objects.push( object );
     }
 }
 ...

Beispiel: [[Medium:TutoriumPhysics-13-Lebenszeit.swf]]

== Weitere Beispiele ==

* [[Medium:TutoriumPhysics-14-Partikel.swf]]
* [[Medium:TutoriumPhysics-15-Partikel.swf]]
* [[Medium:TutoriumPhysics-16-Physics.swf]]
* [[Medium:TutoriumPhysics-17-Physics.swf]]
  
[[Kategorie:Spielephysik]]
[[Kategorie: AS3-Tutorium: Physics]]