GlossarWiki - Benutzerbeiträge [de-formal]

CRUD

2009-07-17T08:42:04Z

Jakobw: /* CRUD-Frameworks */

{{In Bearbeitung}}

=Definition=
'''CRUD''' ist ein Akronym für die grundlegenden Datenbankoperationen
*'''C'''reate(Datensatz anlegen),
*'''I'''nsert(Datensatz lesen),
*'''U'''pdate(Datensatz aktualisieren) und
*'''D'''elete(Datensatz löschen).

=Alternative Definitionen=

Alternative Ausführungen des Akronyms '''CRUD''':
*'''R'''etrieve an Stelle von '''R'''ead
*'''D'''estroy an Stelle von '''D'''elete

Alternative Akronyme sind
*'''RUDI''' (Insert an Stelle von Create)
*'''CDUR''' (in Anlehnung an die Tonart)

=Beispiele=
*'''C'''reate: INSERT INTO haendler (name) VALUES ('lisa')
*'''R'''ead: SELECT * FROM haendler WHERE name='lisa'
*'''U'''pdate: UPDATE haendler SET name=‘lina' WHERE name='lisa'
*'''D'''elete: DELETE FROM haendler WHERE name='lina'

=CRUD-Frameworks=

Man spricht von einem CRUD-Framework, wenn man mithilfe einer grafischen Oberfläche die in der Persistenzschicht gespeicherten Datensätze mithilfe von CRUD-Operationen bearbeiten kann. Weiterhin gibt es eine Entsprechung von relationalen Datensätzen auf Persistenzebene zu Objekten in der Anwendungsschicht, man arbeitet also stetig objektorientiert. CRUD-Frameworks unterstützen Transaktionen, eine CRUD-Operation ist ein atomarer Vorgang.

Bekannte CRUD-Frameworks sind z.B. Ruby on Rails oder Django.

=Quellen=
*[[Wikipedia:CRUD ]]

[[Kategorie:Glossar]]
[[Kategorie:Informatik]]
[[Kategorie:Daten-Management]]

Vererbung in Datenbanken

2009-07-17T07:06:01Z

Jakobw:

{{In Bearbeitung}}

Es gibt verschiedene Möglichkeiten wie man Vererbungen, sogenannte IS-A-Beziehungen, in Datenbanken realisieren kann. Die unterschiedlichen Implementierungsmöglichkeiten bringen jeweils Vor- und Nachteile, insbesondere beim Zugriff auf die jeweiligen Tabellen, mit sich.

=Manuelle Definition=
==Implementierungsvarianten Relationenschema==

'''1. Möglichkeit'''
e: id, e1, e2
f: id, e1, e2, f1, f2 (id -> E: id)

[...]

'''2. Möglichkeit'''
e: id, e1, e2
f: id, f1, f2 (id -> E: id)

Hierbei ist die Auflistung aller Objekte der Tabelle e einfacher, für alle Objekte und f und deren zugehörigen von e geerbten Attribute ist ein einfacher Join möglich. Die zweite Variante ist die sauberste aller Implementierungsmöglichkeiten und wird empfohlen.

3. Möglichkeit(nicht empfohlen)
e: id, e1, e2, f1*, f2*

Es ist theoretisch möglich für die gesamte Vererbungs-Hierachie nur eine einzige Tabelle zu definieren. Diese enthält dann alle Attribute der Basisklasse sowie aller Subklassen. Die Attribute der Subklassen dürfen NULL werden.

Der große Nachteil dieser Variante: Es können Inkonsistenzen auftreten. Attribute wie f1 und f2, welche bei einem Objekt der Klasse f nicht undefiniert sein dürften; können nun den WERT NULL annehmen. Denkbar wäre z.B. dass f1 mit einem richtigen Wert initialisiert wird, während f2 leer bleibt.

==Zugriff==

'''1. Möglichkeit'''

Alle Objekte der Art e:
SELECT id, e1, e2 FROM e
UNION
SELECT id, e1, e2 FROM F

Alle Informationen über f-Objekte:
SELECT id, e1, e2, f1, f2 FROM f

'''2. Möglichkeit'''

Alle Objekte der Art e:
SELECT id, e1, e2 FROM e

Alle Informationen über f-Objekte:
SELECT id, e1, e2, f1, f2 FROM e, f
WHERE e.id = f.id

=Direkte Vererbung in SQL=

Seit SQL:1999 wird einfache Attributvererbung auch direkt unterstützt. Man muss sich nicht mehr darum kümmern welche Attribute in welche Tabelle gehören. Auch ist der Zugriff ohne zusätzliche JOIN- oder UNION-Operationen möglich.

Jedoch unterstützen einige Datenbank-Management-Systeme Vererbung gar nicht oder nicht standard-konform. Im Folgenden wird deshalb der SQL-Standard sowie PostgreSQL behandelt.

==Erstellung==

'''SQL-Standard:'''
CREATE TABLE e(...);
CREATE TABLE f UNDER e(...);

'''PostgreSQL:'''
CREATE TABLE e(...);
CREATE TABLE f(...) inherits (e)

Hierbei erbt f alle Attribute und Integritätsbedingungen von e, auch den Primärschlüssel.
f kann, abgesehen vom Primärschlüssel, weitere Attribute und Integritätsbedingungen definieren.

==Zugriff==

SELECT * FROM e

Auf diese Art und Weise werden alle Tupel von e einschließlich der Tupel von f(reduziert auf die geerbten Attribute von e) selektiert.

SELECT * FROM ONLY(e)

Hierbei erhält man ausschließlich die Tupel von e, nicht aber Tupel von Subklassen wie f.

=Quellen=

*Kowarschick, "Multimedia-Datenbanksysteme", Sommersemester 2009, Hochschule Augsburg

[[Kategorie:HowTo]]
[[Kategorie:Informatik]]
[[Kategorie:SQL]]
[[Kategorie:Daten-Management]]

Vererbung in Datenbanken

2009-07-17T06:56:49Z

Jakobw: Die Seite wurde neu angelegt: {{In Bearbeitung}} Es gibt verschiedene Möglichkeiten wie man Vererbungen, sogenannte IS-A-Beziehungen, in Datenbanken realisieren kann. Die unterschiedlichen Impleme...

{{In Bearbeitung}}

Es gibt verschiedene Möglichkeiten wie man Vererbungen, sogenannte IS-A-Beziehungen, in Datenbanken realisieren kann. Die unterschiedlichen Implementierungsmöglichkeiten bringen jeweils Vor- und Nachteile, insbesondere beim Zugriff auf die jeweiligen Tabellen, mit sich.

=Manuelle Definition=
==Implementierungsvarianten Relationenschema==

'''1. Möglichkeit'''
e: id, e1, e2
f: id, e1, e2, f1, f2 (id -> E: id)

[...]

'''2. Möglichkeit'''
e: id, e1, e2
f: id, f1, f2 (id -> E: id)

Hierbei ist die Auflistung aller Objekte der Tabelle e einfacher, für alle Objekte und f und deren zugehörigen von e geerbten Attribute ist ein einfacher Join möglich. Die zweite Variante ist die sauberste aller Implementierungsmöglichkeiten und wird empfohlen.

3. Möglichkeit(nicht empfohlen)
e: id, e1, e2, f1*, f2*

Es ist theoretisch möglich für die gesamte Vererbungs-Hierachie nur eine einzige Tabelle zu definieren. Diese enthält dann alle Attribute der Basisklasse sowie aller Subklassen. Die Attribute der Subklassen dürfen NULL werden.

Der große Nachteil dieser Variante: Es können Inkonsistenzen auftreten. Attribute wie f1 und f2, welche bei einem Objekt der Klasse f nicht undefiniert sein dürften; können nun den WERT NULL annehmen. Denkbar wäre z.B. dass f1 mit einem richtigen Wert initialisiert wird, während f2 leer bleibt.

==Zugriff==
'''1. Möglichkeit'''

Alle Objekte der Art e:
SELECT id, e1, e2 FROM e
UNION
SELECT id, e1, e2 FROM F

Alle Informationen über f-Objekte:
SELECT id, e1, e2, f1, f2 FROM f

'''2. Möglichkeit'''

Alle Objekte der Art e:
SELECT id, e1, e2 FROM e

Alle Informationen über f-Objekte:
SELECT id, e1, e2, f1, f2 FROM e, f
WHERE e.id = f.id

=Direkte Vererbung in SQL=

=Quellen=
Wenn die Definitionen und/oder die Anmerkungen nicht von einem selbst stammen, sollte man die Quellen angeben
(das sind natürlich nur Beispiele, keine echten Quellen dieses Artikels :-) ):

*Hinz und Kunz, "Der Bau einer Musterseite", 7. Auflage, Wiki-Verlag, 1931

Besser ist es spezielle Quellendokumente zu erstellen (und diese dann auch mit Inhalt zu füllen):

*[[Kowarschick, W. et al. (2005): Musterquelle (Buch)]]
*[[Goldratt, E.; Cox , J. (2004): The Goal]]
*[[Leach, L. (2005): Critical Chain Project Management]]

Auch externe Quellen können zitiert werden.

*[http://kowa.fh-augsburg.de Kowarschicks gesammelte Werke] (besser als eigenes Quellen-Dokument, basierend auf der [[Vorlage:Quelle:URL]])
*[http://de.wikipedia.org/ Wikipedia] ('''so nicht''', da zu allgemein und außerdem nicht der Wikipedia-Verweis benutzt wurde)
*[[Wikipedia:Vorlage (Datenverarbeitung)]] (sondern eher so, aber noch besser auch als eigenes Quellen-Dokument)

=Siehe auch=
Zu guter letzt kann Sekundärliteratur angegeben werden, die zwar im Artikel nicht direkt verwendet, aber doch irgendwie interessant ist.
Außerdem sollten eine oder mehrere Kategorien angegeben werden sowie ein Verweis auf den zugehörigen englischen Artikel
in [[GlossaryWiki:Main Page|GlossaryWiki]], auch wenn es diesen noch gar nicht gibt.

*[[Theory of Constraints (Quellen)]] (eine ganze Sammlung von Quellen in einem Quellen-Dokument)
*[[Wikipedia:Wikipedia:Formatvorlagen|Wikipedia: Formatvorlagen]]

[[Kategorie:Glossar]]
[[Kategorie:GlossarWiki]]
[[en:GlossaryWiki:Sample Page]]

AS3-Tutorium:Physics:3D-Physics-Engines

2009-07-17T06:52:23Z

Jakobw: /* flashjiglib */

{{In Bearbeitung}}

Im Folgenden erfahren Sie, welche Möglichkeiten Ihnen für die Arbeit mit vorhandenen 3D-Physics-Engines in Actionscript 3 gegeben sind. Wer sich die Grundlagen der Physik aneignen will oder gar eine eigene (2D)Physics-Engine bauen will wird der Artikel [[AS3-Tutorium:Physics:Grundlagen]] empfohlen.

=Grundlegendes Prinzip=
Physics-Engines stellen lediglich Algorithmen für die physikalische Berechnung, jedoch keine Routinen zur Darstellung von Objekten, zur Verfügung! Da Flex oder Flash selber auch keine echten 3D-Engines besitzen, brauchen Sie für die Darstellung eine zusätzliche Bibliothek. Im Code müssen Sie selbständig die physikalische Objekte mit den darstellenden Objekten verbinden, da beide sonst unabhängig voneinander agieren würden. Weiterhin müssen sie beachten, dass die physikalische Berechnung so kompliziert ist, dass nicht alle Objekte die Sie darstellen können, auch physikalisch in ihrer ganzen Komplexität berücksichtigen können. Auf den Umgang mit den Libraries in AS3 wird später genauer eingegangen.

=3D-Engines=

==Papervision3D==
Papervision3D eine sehr populäre 3D-Engine für Actionscript. Sie kann alle wichtigen primitive Objekte wie Quader, Kugeln, Ebenen und Zylinder darstellen. Auch komplexe Objekte, beispielsweise 3D-Models aus Maya sind mit einer Hilfsklasse, dem Collada, sehr einfach einzubinden. Man kann koordinatengenau Punktlichter setzen und verschiedene Materialen, wie beispielweise das einfache FlatShadeMaterial oder das WireFrameMaterial auf seine Objekte anwenden. Und auch sonst ist Papervision eine recht mächtige Engine. Sie unterstützt beispielsweise die komplexe Rechnung mit Matrizen und stellt uns mit der Matrix3D eine Klasse mit vielen nützlichen Methoden zur Verfügung.

Die Dokumentation von Papervision3D fällt etwas spärlich aus und verzichtet auf eine ausführliche Beschreibung der Methoden. Da aber einige gute Tutorials im Web zu finden sind fällt der Einstieg nicht schwer.Insgesamt ist die Arbeit mit Papervision sehr simpel und effektiv: Man erstellt seine Objekte; fügt diese der Szene hinzu, konfiguriert den Renderer, und los geht’s.

==Sonstige Engines==

Sandy3D

Away3D

Alternativa

=3D-Physics-Engines=

==WOW-Engine==

WOW, nicht zu verwechseln mit World of Warcraft, ist die verbreitetste aller 3D-Physics-Engines für Actionscript. Man stößt bei der Internet-Recherche fast nur auf Beispiele mit der WOW-Engine, was nicht ganz verständlich ist.

Die Arbeit mit der WOW-Engine ist durchweg intuitiv und komfortabel. Man erstellt seine Objekte, modifiziert ggbf. die Elastizität o.ä., verbindet sie mit der Darstellung und aktualisiert sie jedes Frame.

Die Engine hat jedoch einige große Nachteile:

1. Die Performance lässt zu wünschen übrig. Schon nicht allzu viele gleichzeitig zu berechnende Objekten zwingen die Physics-Engine in die Knie.

2. Es gibt keine Kollisionsberechnung von Quader, Würfeln.

3. Auch sonstige Feinheiten wie Federn o.ä. fehlen.

Was dann überhaupt noch übrig bleibt: Die Kollision von Kugeln sowie einfache Gravitation; bei schlechter Performance. Es ist daher unverständlich, warum die WOW-Engine einen solchen Status erlangt hat. Eine bessere Alternative wird im Folgenden dargestellt.

==flashjiglib==

Die flashjiglib ist aus unerklärchlich Gründen in den Weiten des World Wide Webs sehr schwer zu entdecken. Sie ist eine Portierung der jiglib aus C++ und deutlich ausgereifter als die WOW-Engine:

Die Arbeit mit der flashjiglib ist ebenso intuitiv, die Performance deutlich besser. Die jiglib unterstützt die Kollision von Kugeln, Quadern, begrenzten Ebenen und Kapseln. Die physikalische Berechnung von Federn ist ebenfalls möglich. Last but not least bringt die flashjiglib Komfortfunktionen mit sich, die es beispielsweise erlauben, die Arbeit mit den 3D-Render-Engines zu erleichtern. Eine Demo können sie [http://www.flashbookmarks.com/demos/jiglibtimestep/ hier] ausprobieren.

=Tutorial=

Im Folgenden werden wir eine einfache 3D-Physics-Szene mit Papervision3D und flashjiglib bauen.

<source lang="actionscript">
package {
import flash.display.Sprite;
import flash.events.Event;

import jiglib.geometry.JBox;
import jiglib.math.JNumber3D;
import jiglib.physics.RigidBody;
import jiglib.plugin.papervision3d.Papervision3DPhysics;
import jiglib.plugin.papervision3d.Pv3dMesh;

import org.papervision3d.cameras.Camera3D;
import org.papervision3d.lights.PointLight3D;
import org.papervision3d.materials.WireframeMaterial;
import org.papervision3d.materials.shadematerials.FlatShadeMaterial;
import org.papervision3d.materials.utils.MaterialsList;
import org.papervision3d.objects.primitives.Cube;
import org.papervision3d.render.LazyRenderEngine;
import org.papervision3d.scenes.Scene3D;
import org.papervision3d.view.Viewport3D;

public class Physics3DTutorial extends Sprite
{
private var physics:Papervision3DPhysics;

private var camera3D:Camera3D;
private var viewport3D:Viewport3D;
private var renderEngine:LazyRenderEngine;
private var scene3D:Scene3D;

public function Physics3DTutorial()
{
initPapervision();
initJiglib();

initObjects();
}
</source>

Man kann den Programmfluß in 4 wichtige Schritte aufteilen. Drei davon sind Initialisierungsschritte und werden direkt im Konstruktor aufgerufen. (( Der vierte Schritt, die Aktualisierung der Engines pro Frame, wird über einen EventListener auf ENTER_FRAME aufgerufen. Der EventListener wird bei erfolgreicher Initalisierung, also nach der Erzeugung aller Objekte hinzugefügt. ))

<source lang="actionscript">
private function initPapervision () :void {
this.camera3D = new Camera3D();
this.viewport3D = new Viewport3D(640, 480);
this.scene3D = new Scene3D();
this.renderEngine = new LazyRenderEngine(this.scene3D, this.camera3D, this.viewport3D);
this.addChild(this.viewport3D);
}
</source>

Hier wird die Papervision3D-Engine zur Darstellung von dreidimensionalen Objekten intialisiert. Dafür braucht man folgende Elemente:
*Die Kamera. Sie ist der Blickpunkt auf die Szene. Du kannst es dir also genau so vorstellen wie eine Filmkamera. Man sie beispielsweise nach oben verschieben um eine „Draufsicht“ auf die Szene zu erreichen.
*Die Szene. Sie enthält alle zu renderenden Objekte. Wenn du später ein Objekt erzeugst musst du es der Szene per addChild() übergeben.
*Der Viewport ist die Zeichenfläche für die Darstellung. Den Viewport musst du immer deiner darstellenden Klassen mitt addChild übergeben. In unserem Falle ist dies das eigene Objekt.
*Der Renderer. Ihm musst die restlichen Elemente übergeben damit er weiß was er wie rendern muss. Außerdem musst du ihn später pro Schritt updaten.

<source lang="actionscript">
private function initJiglib():void
{
physics = new Papervision3DPhysics(this.scene3D, 7);
physics.engine.setGravity(new JNumber3D(0, -1, 0));

}
</source>

Die Initialisierung der Physics-Engine ist recht einfach; wir müssen lediglich ein Papervision3DPhysics-Objekt erzeugen. Dieses Objekt muss wissen auf welche Szene sie einen Einfluss hat, in unserem Falle „scene3D“. Anschließend können wir noch Einstellungen vornehmen und so z.B. die Gravitation verändern.

<source lang="actionscript">
private function initObjects():void
{
var pointLight3D:PointLight3D = new PointLight3D();
pointLight3D.x = 1000;
pointLight3D.y = 1000;
pointLight3D.z = -1000;

var materialsList1 :MaterialsList = new MaterialsList({all: new FlatShadeMaterial(pointLight3D)});
var boxPV:Cube = new Cube(materialsList1, 100, 10, 40 );
var boxJL:JBox = new JBox(new Pv3dMesh(boxPV), 100, 10, 40);

boxJL.y = 30;
boxJL.rotationY = 20;
boxJL.rotationZ = 20;

this.scene3D.addChild(boxPV);
this.physics.addBody(boxJL);

var ground:RigidBody = physics.createGround(new FlatShadeMaterial(pointLight3D), 300, 2);
ground.y = - 100;

var sphere:RigidBody = physics.createSphere(new WireframeMaterial(0xFF44FF), 20);

this.addEventListener(Event.ENTER_FRAME, this.onEnterFrame);
}
</source>

Zunächst erzeugen wir ein Objekt auf einem vergleichsweise komplizierten Weg. Dieser Weg eignet sich z.b. wenn noch andere Routinen in den Worflow eingebaut werden müssen.

Zunächst erzeugen wir ein Punktlicht der Klasse PointLight3D, das wir im Raum platzieren und eine MaterialsList, welche wir für die Darstellung eines Quaders brauchen. Als nächstes erzeugen wir die zwei grundlegenden Objekte.
*Das von Papervision3D darzustellende Objekt, welches immer von DisplayObject3D ableitet. In unserem Falle ist es ein „Cube“.
*Der dem darstellenden Objekt entsprechende physikalische Körper, immer eine Subklasse von RigidBody. Der RigidBody muss wissen, welches Darstellungs-Objekt er beeinflusst. In unserem Falle entspricht dem Cube die JBBox; sie sollte auch die selben Maße haben.
Da wir zwei getrennte Libraries haben wird grundsätzlich immer mit diesen beiden Objekten gearbeitet. Da es aber etwas umständlich ist, beide Objekte einzeln zu erzeugen, lernen wir im folgenden noch eine verkürzte Schreibweise, bei dir die Erzeugung und Verknüpfung beider Objekte im Hintergrund abläuft.

Wir können jetzt noch die Rotation oder Position des Quaders verändern. Beachte, dass die Koordinatenachsen nicht wie in der Informatik üblich von links oben nach rechts unten verlaufen. Stattdessen beginnen sie in der Mitte. Y-Werte werden nach oben und X-Werte nach rechts größer.

Wie bereits erwähnt stellt uns das Papervision3DPhysics-Objekt Komfortfunktionen zur Verfügung mit der wir die Erzeugung von Objekten vereinfachen können. Mit physics.createGround() erzeugen wir einen begrenzte Ebene und mit createSphere() eine Kugel. Das Objekt kümmert sich darum das flashjiglib-Objekt als auch das enstprechende Papervision-Objekt zu erzeugen und es zur Szene hinzuzufügen.

Zuletzt fügen wir einen EventListener auf ENTER_FRAME hinzu.

<source lang="actionscript">
private function onEnterFrame(evt: Event):void
{
this.physics.step();
this.renderEngine.render();
}

}
}
</source>

Alles war wir jetzt noch tun müssen ist den Renderer sowie die Physics-Engine jeden Schritt zu aktualisieren.

=Quellen=
*[http://www.papervision3d.org/docs/as3/ Papervision3D API Documentation]
*[http://as3.miguelmoraleda.com/2009/04/24/flash/jiglibflash/tutorial-jiglibflash-how-to-create-basic-physics-3d-scenetutorial-jiglibflash-como-crear-una-scena-en-3d-con-fisica/ Tutorial JigLibFlash – How to create basic physics 3d scene.]
*[http://blog.zupko.info/?p=96 BasicView - Making Life In Papervision a Little Easier]

[[Kategorie:HowTo]]
[[Kategorie:Informatik]]
[[Kategorie:Spielephysik]]
[[Kategorie:Flex]]
[[Kategorie:Flash]]
[[Kategorie:Flash-HowTo]]

Verbundoperatoren (Join)

2009-07-12T14:39:32Z

Jakobw: /* Quellen */

=Definition=

Verbundoperatoren (auch Joins genannt) verbinden die Spalten zweier Tabellen zu einer Tabelle.

=Beschreibung=

Es existieren verschiedene Verbundoperatoren:

*Cross Join
*Inner Join, Equivalent Join
*Natural Join
*Left Join, Left Outer Join
*Right Outer Join, Right Join
*Full Outer Join, Full Join
*Union Join
*Theta Join
*Self Join

== Cross Join ==
Der Cross Join (auch als Kartesisches Produkt oder Kreuzprodukt bezeichnet)verbindet jede Zeile der ersten Tabelle mit jeder Zeile der Zweiten Tabelle. Die Ergebnistabelle eines Cross Joins kann sehr groß werden und ist häufig nutzlos.

SELECT * FROM TabelleA CROSS JOIN TabelleB

== Inner Join ==
Der Inner Join verbindet Datensätze aus zwei Tabellen, welche in beiden Tabellen denselben Werte enthalten. Die Spalten die in beiden Tabellen verglichen werden sollen, muß explizit angegeben werden.

SELECT * FROM TabelleA INNER JOIN TabelleB ON TabelleA.Index = TabelleB.Index

== Natural Join ==
Der Natural Join verknüpft die beiden Tabellen über die gleichheit der Felder, in Spalten mit gleichem Namen.
Spalten mit gleichem Namen werden im Ergebnis nur einmal angezeigt. Haben die Tabellen keine Spalten mit gleichem Namen, wird der Natural Join automatisch zum Cross Join.

SELECT * FROM TabelleA NATURAL JOIN TabelleB

== Left Join ==
Der Left Join (auch Left Outer Join genannt) erstellt eine so genannte linke Inklusionsverknüpfung. Diese schließt alle Datensätze aus der ersten (linken) Tabelle ein, auch wenn keine entsprechenden Werte für die Datensätze in der zweiten (rechten) Tabelle existieren. Die zu vergleichenden Spalten müssen explizit Angegeben werden.

SELECT * FROM TabelleA LEFT JOIN TabelleB ON TabelleA.Index = TabelleB.Index

== Right Join ==
Der Right Join (auch Right Outer Join genannt) erstellt eine so genannte rechte Inklusionsverknüpfung. Diese schließt alle Datensätze aus der zweiten (rechten) Tabelle ein, auch wenn keine entsprechenden Werte für die Datensätze in der ersten (linken) Tabelle existieren. Die zu vergleichenden Spalten müssen explizit Angegeben werden.

SELECT * FROM TabelleA RIGHT JOIN TabelleB ON TabelleA.Index = TabelleB.Index

== Full Join ==
Der Full Join (auch Full Outer Join genannt) ist eine Kombination von Left Join und Right Join. Die zu vergleichenden Spalten müssen explizit Angegeben werden.

SELECT * FROM TabelleA FULL JOIN TabelleB ON TabelleA.Index = Tabelle.Index

==Union Join==
Der Union Join nimmt die Datensätze beider Tabellen auf und gibt sie in einer Tabelle aus.
Der Union Join steht nicht immer zur Verfügung, da er zum SQL 92 Intermediate Level gehört.
In PostgreSQL steht der Union Join nicht zur Verfügung.

SELECT * FROM TabelleA UNION JOIN TabelleB

==Theta Join==
Der Theta Join ist eine Verallgemeinerung des Inner Join. Beim Inner Join wird die Gleichheit des Inhalts zweier Attribute verglichen und beim Theta Join wird der Inhalt der Attribute x und y mit einer beliebigen Formel, zum Beispiel "<", "<=", ">", ">=", "<>" verglichen.
SELECT * FROM TabelleA INNER JOIN TabelleB ON TabelleA.x <= TabelleB.y

==Self Join==
Der Self Join dient dazu, um in bestimmten Situationen einen Verbund innerhalb einer einzigen Tabelle bilden zu können. Dazu muss man der Tabelle zwei verschiedene Aliasnamen geben. Self Joins können mit allen Joins durchgeführt werden. Ein Beispiel für den Gebrauch eines Self Joins ist zum Beispiel ein Vergleich innerhalb einer Tabelle.

=Beispiele=
==Cross Join==
SELECT * FROM TabelleA CROSS JOIN TabelleB

'''TabelleA''' '''TabelleB''' '''Ergebnis'''
Index | Name Index | Geb.Datum TabelleA.Index | Name | TabelleB.Index | Geb.Datum
1 Jan 1 16.05.1976 1 Jan 1 16.05.1976
2 Tom 2 29.07.1985 1 Jan 2 29.07.1985
3 Anne 5 08.11.2001 1 Jan 5 08.11.2001
2 Tom 1 16.05.1976
2 Tom 2 29.07.1985
2 Tom 5 08.11.2001
3 Anne 1 16.05.1976
3 Anne 2 29.07.1985
3 Anne 5 08.11.2001

== Inner Join ==
SELECT * FROM TabelleA INNER JOIN TabelleB ON TabelleA.Index = TabelleB.Liste

'''TabelleA''' '''TabelleB''' '''Ergebnis'''
Index | Name Index | Geb.Datum TabelleA.Index | Name | TabelleB.Index | Geb.Datum
1 Jan 1 16.05.1976 1 Jan 1 16.05.1976
2 Tom 2 29.07.1985 2 Tom 2 29.07.1985
3 Anne 5 08.11.2001

== Natural Join ==
SELECT * FROM TabelleA NATURAL JOIN TabelleB

'''TabelleA''' '''TabelleB''' '''Ergebnis'''
Index | Name Index | Geb.Datum Index | Name | Geb.Datum
1 Jan 1 16.05.1976 1 Jan 16.05.1976
2 Tom 2 29.07.1985 2 Tom 29.07.1985
3 Anne 5 08.11.2001

== Left Join ==
SELECT * FROM TabelleA LEFT JOIN TabelleB ON TabelleA.Index = TabelleB.Index

'''TabelleA''' '''TabelleB''' '''Ergebnis'''
Index | Name Index | Geb.Datum TabelleA.Index | Name | TabelleB.Index | Geb.Datum
1 Jan 1 16.05.1976 1 Jan 1 16.05.1976
2 Tom 2 29.07.1985 2 Tom 2 29.07.1985
3 Anne 5 08.11.2001 3 Anne NULL NULL

== Right Join ==
SELECT * FROM TabelleA RIGHT JOIN TabelleB ON TabelleA.Index = TabelleB.Index

'''TabelleA''' '''TabelleB''' '''Ergebnis'''
Index | Name Index | Geb.Datum TabelleA.Index | Name | TabelleB.Index | Geb.Datum
1 Jan 1 16.05.1976 1 Jan 1 16.05.1976
2 Tom 2 29.07.1985 2 Tom 2 29.07.1985
3 Anne 5 08.11.2001 NULL NULL 5 08.11.2001

== Full Join ==
SELECT * FROM TabelleA FULL JOIN TabelleB ON TabelleA.Index = Tabelle.Index

'''TabelleA''' '''TabelleB''' '''Ergebnis'''
Index | Name Index | Geb.Datum TabelleA.Index | Name | TabelleB.Index | Geb.Datum
1 Jan 1 16.05.1976 1 Jan 1 16.05.1976
2 Tom 2 29.07.1985 2 Tom 2 29.07.1985
3 Anne 5 08.11.2001 3 Anne NULL NULL
NULL NULL 5 08.11.2001
== Union Join ==
SELECT * FROM Mitarbeiter UNION JOIN Projekte

'''TabelleA''' '''TabelleB''' '''Ergebnis'''
Index | Name Index | Geb.Datum TabelleA.Index | Name | TabelleB.Index | Geb.Datum
1 Jan 1 16.05.1976 1 Jan NULL NULL
2 Tom 2 29.07.1985 2 Tom NULL NULL
3 Anne 5 08.11.2001 3 Anne NULL NULL
NULL NULL 1 16.05.1976
NULL NULL 2 29.07.1985
NULL NULL 5 08.11.2001

== Theta Join ==
Sie haben eine Tabelle mit Mannschaften und möchten diese im Weltmeisterschaftsmodus (Für Hin- und Rückspiel müssen Sie einfach den Operator "<>" verwenden) gegeneinander antreten lassen:
SELECT x.Team AS Heim, y.Team AS Gast FROM Mannschaften AS x INNER JOIN Mannschaften AS y ON h.m_id > g.m_id

'''Mannschaften''' '''Ergebnis'''
m_id | Team Heim | Gast
1 Deutschland Spanien Deutschland
2 Spanien Holland Deutschland
3 Holland Italien Deutschland
4 Italien Holland Spanien
Italien Spanien
Italien Holland
== Self Join ==
Sie haben eine Tabelle mit Namen, Personalnummer und der Personalnummer des Vorgesetzten. Es soll zu jedem Mitarbeiter der Name des Vorgesetzten ermittelt werden:
SELECT x.Name, x.Personalnummer, y.Name "Chef" FROM Mitarbeiter x, Mitarbeiter y WHERE x.ChefsPersonalnummer = y.Personalnummer

'''Mitarbeiter''' '''Ergebnis'''
Personalnummer | Name | ChefsPersonalnummer Name | Personalnummer | Chef
1 Maier 2 Maier 1 Mueller
2 Mueller 3 Mueller 2 Kuenstler
3 Kuenstler 1 Kuenstler 3 Maier

=Quellen=
*http://v.hdm-stuttgart.de/~riekert/lehre/db-kelz/chap7.htm
*http://www.thomaskaelin.ch/media/archive1/zusammenfassungen/db1.pdf
*http://www.postgresql.org/docs/8.3/interactive/queries-table-expressions.html
*http://www.tinohempel.de/info/info/datenbank/operation.htm
*http://aktuell.de.selfhtml.org/artikel/datenbanken/
* http://rowa.giso.de/oracle/latex/Komplexere_SQL_Abfragen.html

[[Kategorie:Glossar]]
[[Kategorie:Informatik]]
[[Kategorie:Daten-Management]]
[[Kategorie:SQL]]

SQL Unterabfragen

2009-07-12T14:37:41Z

Jakobw: /* Quellen */

=Definition=
Unterabfragen, die auch Sub-Selects oder Sub-Querys genannt werden, können verwendet werden, um andere SQL-Anweisungen mit einzubinden.
Dadurch können Ergebnisse einer Abfrage sofort in einer neuen Abfrage verwendet werden.

<pre>
SELECT kundennr, bestelldatum, rechnungsbetrag
FROM bestellung
WHERE rechnungsbetrag =
(
SELECT max(rechnungsbetrag) FROM bestellung
);
</pre>

Hier wird in der WHERE-Bedingung eine SELECT-Abfrage formuliert, die sich komplett in runden Klammern befindet. Das Ergebnis dieser Abfrage gibt genau einen Wert zurück, der mit dem Rechnungsbetrag verglichen wird. Der Rückgabewert muss folglich zum Selektionskriterium passen.

Grundsätzlich gibt es zwei Varianten, die Unterabfragen liefern können. Entweder liefern sie einen Wert, also eine Zeile zurück oder mehrere Zeilen.
Dabei können die Abfragen eigenständig ausgeführt werden, ohne Beeinflussung durch die Hauptabfrage oder umgekehrt.
Sie lassen sich auch in DELETE-, UPDATE- und INSERT-Anweisungen verwenden.

=Unterabfragen mit einem Rückgabewert=
Hier gelten folgende Bedingungen:
Die Unterabfrage gibt genau einen Wert zurück.
Die Unterabfrage gibt genau eine Spalte zurück.

Bei dieser Art von Abfrage wird hauptsächlich mit Vergleichsoperatoren wie =, >, >=, < oder <= gearbeitet.
Man kann diese Unterabfragen auch gut für Aggregatfunktionen wie MAX oder AVG verwenden.

<pre>
SELECT bestellnr
FROM bestellung
WHERE rechnungsbetrag >
(
SELECT AVG(rechnungsbetrag) FROM bestellung
);
</pre>

Hier wird mit SELECT AVG(rechnungsbetrag) der durchschnittliche Rechnungsbetrag ermittelt.

=Unterabfragen mit mehreren Rückgabewerten=
Nun ist der Einsatz von Mengenoperatoren (vo ALL, vo ANY, IN, EXISTS) notwendig, da jetzt mit mehreren Werten verglichen wird.

<pre>
SELECT name, gehalt, abteilung
FROM mitarbeiter
WHERE gehalt < ALL
(
SELECT gehalt FROM mitarbeiter WHERE abteilung = 5
);
</pre>

Die Unterabfrage gibt nun alle Gehälter aus der Abteilung 5 aus. ALL vergleicht, ob die Bedingung auf alle Zeilen der Unterabfrage zutrifft. Ob es also ein Gehalt gibt, das kleiner ist als alle Gehälter aus der Abteilung 5.

=Regeln für Unterabfragen=
#die Unterabfrage wird in runden Klammer gesetzt
#wird als rechtsseitiger Ausdruck, Vergleich oder EXISTS-Bedingung eingesetzt
#ein einzelner Datensatz als Rückgabewert kann mit Vergleichsoperatoren verwendet werden
#bei mehreren Datensätzen verwendet man Mengenoperatoren
#ORDER BY und UNION ist in einer Unterabfrage unzulässig

=Quellen=
*[[Throll, M.; Bartosch, O. (2005): Einstieg in SQL]]

[[Kategorie:Glossar]]
[[Kategorie:Informatik]]
[[Kategorie:Daten-Management]]

AS3-Tutorium:Physics:3D-Physics-Engines

2009-07-12T14:11:41Z

Jakobw: /* Quellen */

{{In Bearbeitung}}

Im Folgenden erfahren Sie, welche Möglichkeiten Ihnen für die Arbeit mit vorhandenen 3D-Physics-Engines in Actionscript 3 gegeben sind. Wer sich die Grundlagen der Physik aneignen will oder gar eine eigene (2D)Physics-Engine bauen will wird der Artikel [[AS3-Tutorium:Physics:Grundlagen]] empfohlen.

=Grundlegendes Prinzip=
Physics-Engines stellen lediglich Algorithmen für die physikalische Berechnung, jedoch keine Routinen zur Darstellung von Objekten, zur Verfügung! Da Flex oder Flash selber auch keine echten 3D-Engines besitzen, brauchen Sie für die Darstellung eine zusätzliche Bibliothek. Im Code müssen Sie selbständig die physikalische Objekte mit den darstellenden Objekten verbinden, da beide sonst unabhängig voneinander agieren würden. Weiterhin müssen sie beachten, dass die physikalische Berechnung so kompliziert ist, dass nicht alle Objekte die Sie darstellen können, auch physikalisch in ihrer ganzen Komplexität berücksichtigen können. Auf den Umgang mit den Libraries in AS3 wird später genauer eingegangen.

=3D-Engines=

==Papervision3D==
Papervision3D eine sehr populäre 3D-Engine für Actionscript. Sie kann alle wichtigen primitive Objekte wie Quader, Kugeln, Ebenen und Zylinder darstellen. Auch komplexe Objekte, beispielsweise 3D-Models aus Maya sind mit einer Hilfsklasse, dem Collada, sehr einfach einzubinden. Man kann koordinatengenau Punktlichter setzen und verschiedene Materialen, wie beispielweise das einfache FlatShadeMaterial oder das WireFrameMaterial auf seine Objekte anwenden. Und auch sonst ist Papervision eine recht mächtige Engine. Sie unterstützt beispielsweise die komplexe Rechnung mit Matrizen und stellt uns mit der Matrix3D eine Klasse mit vielen nützlichen Methoden zur Verfügung.

Die Dokumentation von Papervision3D fällt etwas spärlich aus und verzichtet auf eine ausführliche Beschreibung der Methoden. Da aber einige gute Tutorials im Web zu finden sind fällt der Einstieg nicht schwer.Insgesamt ist die Arbeit mit Papervision sehr simpel und effektiv: Man erstellt seine Objekte; fügt diese der Szene hinzu, konfiguriert den Renderer, und los geht’s.

==Sonstige Engines==

Sandy3D

Away3D

Alternativa

=3D-Physics-Engines=

==WOW-Engine==

WOW, nicht zu verwechseln mit World of Warcraft, ist die verbreitetste aller 3D-Physics-Engines für Actionscript. Man stößt bei der Internet-Recherche fast nur auf Beispiele mit der WOW-Engine, was nicht ganz verständlich ist.

Die Arbeit mit der WOW-Engine ist durchweg intuitiv und komfortabel. Man erstellt seine Objekte, modifiziert ggbf. die Elastizität o.ä., verbindet sie mit der Darstellung und aktualisiert sie jedes Frame.

Die Engine hat jedoch einige große Nachteile:

1. Die Performance lässt zu wünschen übrig. Schon nicht allzu viele gleichzeitig zu berechnende Objekten zwingen die Physics-Engine in die Knie.

2. Es gibt keine Kollisionsberechnung von Quader, Würfeln.

3. Auch sonstige Feinheiten wie Federn o.ä. fehlen.

Was dann überhaupt noch übrig bleibt: Die Kollision von Kugeln sowie einfache Gravitation; bei schlechter Performance. Es ist daher unverständlich, warum die WOW-Engine einen solchen Status erlangt hat. Eine bessere Alternative wird im Folgenden dargestellt.

==flashjiglib==

Die flashjiglib ist aus unerklärchlich Gründen in den Weiten des World Wide Webs sehr schwer zu entdecken. Sie ist eine Portierung der jiglib aus C++ und deutlich ausgereifter als die WOW-Engine:

Die Arbeit mit der flashjiglib ist ebenso intuitiv, die Performance um Welten besser( durch zahlreiche Demos bewiesen, siehe[...Link..]). Die jiglib unterstützt die Kollision von Kugeln, Quadern, begrenzten Ebenen und Kapseln. Die physikalische Berechnung von Federn ist ebenfalls möglich. Last but not least bringt die flashjiglib Komfortfunktionen mit sich; die es beispielsweise erlauben, die Papervision-Initialisierung zu verkürzen.

=Tutorial=

Im Folgenden werden wir eine einfache 3D-Physics-Szene mit Papervision3D und flashjiglib bauen.

<source lang="actionscript">
package {
import flash.display.Sprite;
import flash.events.Event;

import jiglib.geometry.JBox;
import jiglib.math.JNumber3D;
import jiglib.physics.RigidBody;
import jiglib.plugin.papervision3d.Papervision3DPhysics;
import jiglib.plugin.papervision3d.Pv3dMesh;

import org.papervision3d.cameras.Camera3D;
import org.papervision3d.lights.PointLight3D;
import org.papervision3d.materials.WireframeMaterial;
import org.papervision3d.materials.shadematerials.FlatShadeMaterial;
import org.papervision3d.materials.utils.MaterialsList;
import org.papervision3d.objects.primitives.Cube;
import org.papervision3d.render.LazyRenderEngine;
import org.papervision3d.scenes.Scene3D;
import org.papervision3d.view.Viewport3D;

public class Physics3DTutorial extends Sprite
{
private var physics:Papervision3DPhysics;

private var camera3D:Camera3D;
private var viewport3D:Viewport3D;
private var renderEngine:LazyRenderEngine;
private var scene3D:Scene3D;

public function Physics3DTutorial()
{
initPapervision();
initJiglib();

initObjects();
}
</source>

Man kann den Programmfluß in 4 wichtige Schritte aufteilen. Drei davon sind Initialisierungsschritte und werden direkt im Konstruktor aufgerufen. (( Der vierte Schritt, die Aktualisierung der Engines pro Frame, wird über einen EventListener auf ENTER_FRAME aufgerufen. Der EventListener wird bei erfolgreicher Initalisierung, also nach der Erzeugung aller Objekte hinzugefügt. ))

<source lang="actionscript">
private function initPapervision () :void {
this.camera3D = new Camera3D();
this.viewport3D = new Viewport3D(640, 480);
this.scene3D = new Scene3D();
this.renderEngine = new LazyRenderEngine(this.scene3D, this.camera3D, this.viewport3D);
this.addChild(this.viewport3D);
}
</source>

Hier wird die Papervision3D-Engine zur Darstellung von dreidimensionalen Objekten intialisiert. Dafür braucht man folgende Elemente:
*Die Kamera. Sie ist der Blickpunkt auf die Szene. Du kannst es dir also genau so vorstellen wie eine Filmkamera. Man sie beispielsweise nach oben verschieben um eine „Draufsicht“ auf die Szene zu erreichen.
*Die Szene. Sie enthält alle zu renderenden Objekte. Wenn du später ein Objekt erzeugst musst du es der Szene per addChild() übergeben.
*Der Viewport ist die Zeichenfläche für die Darstellung. Den Viewport musst du immer deiner darstellenden Klassen mitt addChild übergeben. In unserem Falle ist dies das eigene Objekt.
*Der Renderer. Ihm musst die restlichen Elemente übergeben damit er weiß was er wie rendern muss. Außerdem musst du ihn später pro Schritt updaten.

<source lang="actionscript">
private function initJiglib():void
{
physics = new Papervision3DPhysics(this.scene3D, 7);
physics.engine.setGravity(new JNumber3D(0, -1, 0));

}
</source>

Die Initialisierung der Physics-Engine ist recht einfach; wir müssen lediglich ein Papervision3DPhysics-Objekt erzeugen. Dieses Objekt muss wissen auf welche Szene sie einen Einfluss hat, in unserem Falle „scene3D“. Anschließend können wir noch Einstellungen vornehmen und so z.B. die Gravitation verändern.

<source lang="actionscript">
private function initObjects():void
{
var pointLight3D:PointLight3D = new PointLight3D();
pointLight3D.x = 1000;
pointLight3D.y = 1000;
pointLight3D.z = -1000;

var materialsList1 :MaterialsList = new MaterialsList({all: new FlatShadeMaterial(pointLight3D)});
var boxPV:Cube = new Cube(materialsList1, 100, 10, 40 );
var boxJL:JBox = new JBox(new Pv3dMesh(boxPV), 100, 10, 40);

boxJL.y = 30;
boxJL.rotationY = 20;
boxJL.rotationZ = 20;

this.scene3D.addChild(boxPV);
this.physics.addBody(boxJL);

var ground:RigidBody = physics.createGround(new FlatShadeMaterial(pointLight3D), 300, 2);
ground.y = - 100;

var sphere:RigidBody = physics.createSphere(new WireframeMaterial(0xFF44FF), 20);

this.addEventListener(Event.ENTER_FRAME, this.onEnterFrame);
}
</source>

Zunächst erzeugen wir ein Objekt auf einem vergleichsweise komplizierten Weg. Dieser Weg eignet sich z.b. wenn noch andere Routinen in den Worflow eingebaut werden müssen.

Zunächst erzeugen wir ein Punktlicht der Klasse PointLight3D, das wir im Raum platzieren und eine MaterialsList, welche wir für die Darstellung eines Quaders brauchen. Als nächstes erzeugen wir die zwei grundlegenden Objekte.
*Das von Papervision3D darzustellende Objekt, welches immer von DisplayObject3D ableitet. In unserem Falle ist es ein „Cube“.
*Der dem darstellenden Objekt entsprechende physikalische Körper, immer eine Subklasse von RigidBody. Der RigidBody muss wissen, welches Darstellungs-Objekt er beeinflusst. In unserem Falle entspricht dem Cube die JBBox; sie sollte auch die selben Maße haben.
Da wir zwei getrennte Libraries haben wird grundsätzlich immer mit diesen beiden Objekten gearbeitet. Da es aber etwas umständlich ist, beide Objekte einzeln zu erzeugen, lernen wir im folgenden noch eine verkürzte Schreibweise, bei dir die Erzeugung und Verknüpfung beider Objekte im Hintergrund abläuft.

Wir können jetzt noch die Rotation oder Position des Quaders verändern. Beachte, dass die Koordinatenachsen nicht wie in der Informatik üblich von links oben nach rechts unten verlaufen. Stattdessen beginnen sie in der Mitte. Y-Werte werden nach oben und X-Werte nach rechts größer.

Wie bereits erwähnt stellt uns das Papervision3DPhysics-Objekt Komfortfunktionen zur Verfügung mit der wir die Erzeugung von Objekten vereinfachen können. Mit physics.createGround() erzeugen wir einen begrenzte Ebene und mit createSphere() eine Kugel. Das Objekt kümmert sich darum das flashjiglib-Objekt als auch das enstprechende Papervision-Objekt zu erzeugen und es zur Szene hinzuzufügen.

Zuletzt fügen wir einen EventListener auf ENTER_FRAME hinzu.

<source lang="actionscript">
private function onEnterFrame(evt: Event):void
{
this.physics.step();
this.renderEngine.render();
}

}
}
</source>

Alles war wir jetzt noch tun müssen ist den Renderer sowie die Physics-Engine jeden Schritt zu aktualisieren.

=Quellen=
*[http://www.papervision3d.org/docs/as3/ Papervision3D API Documentation]
*[http://as3.miguelmoraleda.com/2009/04/24/flash/jiglibflash/tutorial-jiglibflash-how-to-create-basic-physics-3d-scenetutorial-jiglibflash-como-crear-una-scena-en-3d-con-fisica/ Tutorial JigLibFlash – How to create basic physics 3d scene.]
*[http://blog.zupko.info/?p=96 BasicView - Making Life In Papervision a Little Easier]

[[Kategorie:HowTo]]
[[Kategorie:Informatik]]
[[Kategorie:Spielephysik]]
[[Kategorie:Flex]]
[[Kategorie:Flash]]
[[Kategorie:Flash-HowTo]]

CRUD

2009-07-12T14:08:58Z

Jakobw: /* Beispiele */

{{In Bearbeitung}}

=Definition=
'''CRUD''' ist ein Akronym für die grundlegenden Datenbankoperationen
*'''C'''reate(Datensatz anlegen),
*'''I'''nsert(Datensatz lesen),
*'''U'''pdate(Datensatz aktualisieren) und
*'''D'''elete(Datensatz löschen).

=Alternative Definitionen=

Alternative Ausführungen des Akronyms '''CRUD''':
*'''R'''etrieve an Stelle von '''R'''ead
*'''D'''estroy an Stelle von '''D'''elete

Alternative Akronyme sind
*'''RUDI''' (Insert an Stelle von Create)
*'''CDUR''' (in Anlehnung an die Tonart)

=Beispiele=
*'''C'''reate: INSERT INTO haendler (name) VALUES ('lisa')
*'''R'''ead: SELECT * FROM haendler WHERE name='lisa'
*'''U'''pdate: UPDATE haendler SET name=‘lina' WHERE name='lisa'
*'''D'''elete: DELETE FROM haendler WHERE name='lina'

=CRUD-Frameworks=

Man spricht von einem CRUD-Framework, wenn man mithilfe einer grafischen Oberfläche die in der Persistenzschicht gespeicherten Datensätze mithilfe von CRUD-Operationen bearbeiten kann. Weiterhin gibt es eine Entsprechung von relationalen Datensätzen auf Persistenzebene zu Objekten in der Anwendungsschicht, man arbeitet also stetig objektorientiert. CRUD-Frameworks unterstützen Transaktionen, eine CRUD-Operation ist ein atomarer Vorgang.

Bekannte CRUD-Frameworks sind unter z.B. Ruby on Rails oder Django.

=Quellen=
*[[Wikipedia:CRUD ]]

[[Kategorie:Glossar]]
[[Kategorie:Informatik]]
[[Kategorie:Daten-Management]]

CRUD

2009-07-12T14:07:59Z

Jakobw: Die Seite wurde neu angelegt: {{In Bearbeitung}} =Definition= '''CRUD''' ist ein Akronym für die grundlegenden Datenbankoperationen *'''C'''reate(Datensatz anlegen), *'''I'''nsert(Datensatz lese...

{{In Bearbeitung}}

=Definition=
'''CRUD''' ist ein Akronym für die grundlegenden Datenbankoperationen
*'''C'''reate(Datensatz anlegen),
*'''I'''nsert(Datensatz lesen),
*'''U'''pdate(Datensatz aktualisieren) und
*'''D'''elete(Datensatz löschen).

=Alternative Definitionen=

Alternative Ausführungen des Akronyms '''CRUD''':
*'''R'''etrieve an Stelle von '''R'''ead
*'''D'''estroy an Stelle von '''D'''elete

Alternative Akronyme sind
*'''RUDI''' (Insert an Stelle von Create)
*'''CDUR''' (in Anlehnung an die Tonart)

=Beispiele=
*'''C'''reate: INSERT INTO haendler (name) VALUES ('lisa')
*'''R'''ead: SELECT * FROM haendler WHERE name='lisa'
*'''U'''pdate: UPDATE haendler SET name=‘lina' WHERE name='lisa'
*'''D'''elete: DELETE haendler WHERE name='lina'

=CRUD-Frameworks=

Man spricht von einem CRUD-Framework, wenn man mithilfe einer grafischen Oberfläche die in der Persistenzschicht gespeicherten Datensätze mithilfe von CRUD-Operationen bearbeiten kann. Weiterhin gibt es eine Entsprechung von relationalen Datensätzen auf Persistenzebene zu Objekten in der Anwendungsschicht, man arbeitet also stetig objektorientiert. CRUD-Frameworks unterstützen Transaktionen, eine CRUD-Operation ist ein atomarer Vorgang.

Bekannte CRUD-Frameworks sind unter z.B. Ruby on Rails oder Django.

=Quellen=
*[[Wikipedia:CRUD ]]

[[Kategorie:Glossar]]
[[Kategorie:Informatik]]
[[Kategorie:Daten-Management]]

AS3-Tutorium:Physics:3D-Physics-Engines

2009-07-11T08:45:32Z

Jakobw: /* Quellen */

{{In Bearbeitung}}

Im Folgenden erfahren Sie, welche Möglichkeiten Ihnen für die Arbeit mit vorhandenen 3D-Physics-Engines in Actionscript 3 gegeben sind. Wer sich die Grundlagen der Physik aneignen will oder gar eine eigene (2D)Physics-Engine bauen will wird der Artikel [[AS3-Tutorium:Physics:Grundlagen]] empfohlen.

=Grundlegendes Prinzip=
Physics-Engines stellen lediglich Algorithmen für die physikalische Berechnung, jedoch keine Routinen zur Darstellung von Objekten, zur Verfügung! Da Flex oder Flash selber auch keine echten 3D-Engines besitzen, brauchen Sie für die Darstellung eine zusätzliche Bibliothek. Im Code müssen Sie selbständig die physikalische Objekte mit den darstellenden Objekten verbinden, da beide sonst unabhängig voneinander agieren würden. Weiterhin müssen sie beachten, dass die physikalische Berechnung so kompliziert ist, dass nicht alle Objekte die Sie darstellen können, auch physikalisch in ihrer ganzen Komplexität berücksichtigen können. Auf den Umgang mit den Libraries in AS3 wird später genauer eingegangen.

=3D-Engines=

==Papervision3D==
Papervision3D eine sehr populäre 3D-Engine für Actionscript. Sie kann alle wichtigen primitive Objekte wie Quader, Kugeln, Ebenen und Zylinder darstellen. Auch komplexe Objekte, beispielsweise 3D-Models aus Maya sind mit einer Hilfsklasse, dem Collada, sehr einfach einzubinden. Man kann koordinatengenau Punktlichter setzen und verschiedene Materialen, wie beispielweise das einfache FlatShadeMaterial oder das WireFrameMaterial auf seine Objekte anwenden. Und auch sonst ist Papervision eine recht mächtige Engine. Sie unterstützt beispielsweise die komplexe Rechnung mit Matrizen und stellt uns mit der Matrix3D eine Klasse mit vielen nützlichen Methoden zur Verfügung.

Die Dokumentation von Papervision3D fällt etwas spärlich aus und verzichtet auf eine ausführliche Beschreibung der Methoden. Da aber einige gute Tutorials im Web zu finden sind fällt der Einstieg nicht schwer.Insgesamt ist die Arbeit mit Papervision sehr simpel und effektiv: Man erstellt seine Objekte; fügt diese der Szene hinzu, konfiguriert den Renderer, und los geht’s.

==Sonstige Engines==

Sandy3D

Away3D

Alternativa

=3D-Physics-Engines=

==WOW-Engine==

WOW, nicht zu verwechseln mit World of Warcraft, ist die verbreitetste aller 3D-Physics-Engines für Actionscript. Man stößt bei der Internet-Recherche fast nur auf Beispiele mit der WOW-Engine, was nicht ganz verständlich ist.

Die Arbeit mit der WOW-Engine ist durchweg intuitiv und komfortabel. Man erstellt seine Objekte, modifiziert ggbf. die Elastizität o.ä., verbindet sie mit der Darstellung und aktualisiert sie jedes Frame.

Die Engine hat jedoch einige große Nachteile:

1. Die Performance lässt zu wünschen übrig. Schon nicht allzu viele gleichzeitig zu berechnende Objekten zwingen die Physics-Engine in die Knie.

2. Es gibt keine Kollisionsberechnung von Quader, Würfeln.

3. Auch sonstige Feinheiten wie Federn o.ä. fehlen.

Was dann überhaupt noch übrig bleibt: Die Kollision von Kugeln sowie einfache Gravitation; bei schlechter Performance. Es ist daher unverständlich, warum die WOW-Engine einen solchen Status erlangt hat. Eine bessere Alternative wird im Folgenden dargestellt.

==flashjiglib==

Die flashjiglib ist aus unerklärchlich Gründen in den Weiten des World Wide Webs sehr schwer zu entdecken. Sie ist eine Portierung der jiglib aus C++ und deutlich ausgereifter als die WOW-Engine:

Die Arbeit mit der flashjiglib ist ebenso intuitiv, die Performance um Welten besser( durch zahlreiche Demos bewiesen, siehe[...Link..]). Die jiglib unterstützt die Kollision von Kugeln, Quadern, begrenzten Ebenen und Kapseln. Die physikalische Berechnung von Federn ist ebenfalls möglich. Last but not least bringt die flashjiglib Komfortfunktionen mit sich; die es beispielsweise erlauben, die Papervision-Initialisierung zu verkürzen.

=Tutorial=

Im Folgenden werden wir eine einfache 3D-Physics-Szene mit Papervision3D und flashjiglib bauen.

<source lang="actionscript">
package {
import flash.display.Sprite;
import flash.events.Event;

import jiglib.geometry.JBox;
import jiglib.math.JNumber3D;
import jiglib.physics.RigidBody;
import jiglib.plugin.papervision3d.Papervision3DPhysics;
import jiglib.plugin.papervision3d.Pv3dMesh;

import org.papervision3d.cameras.Camera3D;
import org.papervision3d.lights.PointLight3D;
import org.papervision3d.materials.WireframeMaterial;
import org.papervision3d.materials.shadematerials.FlatShadeMaterial;
import org.papervision3d.materials.utils.MaterialsList;
import org.papervision3d.objects.primitives.Cube;
import org.papervision3d.render.LazyRenderEngine;
import org.papervision3d.scenes.Scene3D;
import org.papervision3d.view.Viewport3D;

public class Physics3DTutorial extends Sprite
{
private var physics:Papervision3DPhysics;

private var camera3D:Camera3D;
private var viewport3D:Viewport3D;
private var renderEngine:LazyRenderEngine;
private var scene3D:Scene3D;

public function Physics3DTutorial()
{
initPapervision();
initJiglib();

initObjects();
}
</source>

Man kann den Programmfluß in 4 wichtige Schritte aufteilen. Drei davon sind Initialisierungsschritte und werden direkt im Konstruktor aufgerufen. (( Der vierte Schritt, die Aktualisierung der Engines pro Frame, wird über einen EventListener auf ENTER_FRAME aufgerufen. Der EventListener wird bei erfolgreicher Initalisierung, also nach der Erzeugung aller Objekte hinzugefügt. ))

<source lang="actionscript">
private function initPapervision () :void {
this.camera3D = new Camera3D();
this.viewport3D = new Viewport3D(640, 480);
this.scene3D = new Scene3D();
this.renderEngine = new LazyRenderEngine(this.scene3D, this.camera3D, this.viewport3D);
this.addChild(this.viewport3D);
}
</source>

Hier wird die Papervision3D-Engine zur Darstellung von dreidimensionalen Objekten intialisiert. Dafür braucht man folgende Elemente:
*Die Kamera. Sie ist der Blickpunkt auf die Szene. Du kannst es dir also genau so vorstellen wie eine Filmkamera. Man sie beispielsweise nach oben verschieben um eine „Draufsicht“ auf die Szene zu erreichen.
*Die Szene. Sie enthält alle zu renderenden Objekte. Wenn du später ein Objekt erzeugst musst du es der Szene per addChild() übergeben.
*Der Viewport ist die Zeichenfläche für die Darstellung. Den Viewport musst du immer deiner darstellenden Klassen mitt addChild übergeben. In unserem Falle ist dies das eigene Objekt.
*Der Renderer. Ihm musst die restlichen Elemente übergeben damit er weiß was er wie rendern muss. Außerdem musst du ihn später pro Schritt updaten.

<source lang="actionscript">
private function initJiglib():void
{
physics = new Papervision3DPhysics(this.scene3D, 7);
physics.engine.setGravity(new JNumber3D(0, -1, 0));

}
</source>

Die Initialisierung der Physics-Engine ist recht einfach; wir müssen lediglich ein Papervision3DPhysics-Objekt erzeugen. Dieses Objekt muss wissen auf welche Szene sie einen Einfluss hat, in unserem Falle „scene3D“. Anschließend können wir noch Einstellungen vornehmen und so z.B. die Gravitation verändern.

<source lang="actionscript">
private function initObjects():void
{
var pointLight3D:PointLight3D = new PointLight3D();
pointLight3D.x = 1000;
pointLight3D.y = 1000;
pointLight3D.z = -1000;

var materialsList1 :MaterialsList = new MaterialsList({all: new FlatShadeMaterial(pointLight3D)});
var boxPV:Cube = new Cube(materialsList1, 100, 10, 40 );
var boxJL:JBox = new JBox(new Pv3dMesh(boxPV), 100, 10, 40);

boxJL.y = 30;
boxJL.rotationY = 20;
boxJL.rotationZ = 20;

this.scene3D.addChild(boxPV);
this.physics.addBody(boxJL);

var ground:RigidBody = physics.createGround(new FlatShadeMaterial(pointLight3D), 300, 2);
ground.y = - 100;

var sphere:RigidBody = physics.createSphere(new WireframeMaterial(0xFF44FF), 20);

this.addEventListener(Event.ENTER_FRAME, this.onEnterFrame);
}
</source>

Zunächst erzeugen wir ein Objekt auf einem vergleichsweise komplizierten Weg. Dieser Weg eignet sich z.b. wenn noch andere Routinen in den Worflow eingebaut werden müssen.

Zunächst erzeugen wir ein Punktlicht der Klasse PointLight3D, das wir im Raum platzieren und eine MaterialsList, welche wir für die Darstellung eines Quaders brauchen. Als nächstes erzeugen wir die zwei grundlegenden Objekte.
*Das von Papervision3D darzustellende Objekt, welches immer von DisplayObject3D ableitet. In unserem Falle ist es ein „Cube“.
*Der dem darstellenden Objekt entsprechende physikalische Körper, immer eine Subklasse von RigidBody. Der RigidBody muss wissen, welches Darstellungs-Objekt er beeinflusst. In unserem Falle entspricht dem Cube die JBBox; sie sollte auch die selben Maße haben.
Da wir zwei getrennte Libraries haben wird grundsätzlich immer mit diesen beiden Objekten gearbeitet. Da es aber etwas umständlich ist, beide Objekte einzeln zu erzeugen, lernen wir im folgenden noch eine verkürzte Schreibweise, bei dir die Erzeugung und Verknüpfung beider Objekte im Hintergrund abläuft.

Wir können jetzt noch die Rotation oder Position des Quaders verändern. Beachte, dass die Koordinatenachsen nicht wie in der Informatik üblich von links oben nach rechts unten verlaufen. Stattdessen beginnen sie in der Mitte. Y-Werte werden nach oben und X-Werte nach rechts größer.

Wie bereits erwähnt stellt uns das Papervision3DPhysics-Objekt Komfortfunktionen zur Verfügung mit der wir die Erzeugung von Objekten vereinfachen können. Mit physics.createGround() erzeugen wir einen begrenzte Ebene und mit createSphere() eine Kugel. Das Objekt kümmert sich darum das flashjiglib-Objekt als auch das enstprechende Papervision-Objekt zu erzeugen und es zur Szene hinzuzufügen.

Zuletzt fügen wir einen EventListener auf ENTER_FRAME hinzu.

<source lang="actionscript">
private function onEnterFrame(evt: Event):void
{
this.physics.step();
this.renderEngine.render();
}

}
}
</source>

Alles war wir jetzt noch tun müssen ist den Renderer sowie die Physics-Engine jeden Schritt zu aktualisieren.

=Quellen=
*[http://www.papervision3d.org/docs/as3/ Papervision3D API Documentation]
*[http://as3.miguelmoraleda.com/2009/04/24/flash/jiglibflash/tutorial-jiglibflash-how-to-create-basic-physics-3d-scenetutorial-jiglibflash-como-crear-una-scena-en-3d-con-fisica/ Tutorial JigLibFlash – How to create basic physics 3d scene.]
*[http://blog.zupko.info/?p=96 BasicView - Making Life In Papervision a Little Easier]

[[Kategorie:Spielephysik]]
[[Kategorie:Flex]]
[[Kategorie:Flash]]
[[Kategorie:Flash-HowTo]]

AS3-Tutorium:Physics:3D-Physics-Engines

2009-07-11T08:43:21Z

Jakobw:

{{In Bearbeitung}}

Im Folgenden erfahren Sie, welche Möglichkeiten Ihnen für die Arbeit mit vorhandenen 3D-Physics-Engines in Actionscript 3 gegeben sind. Wer sich die Grundlagen der Physik aneignen will oder gar eine eigene (2D)Physics-Engine bauen will wird der Artikel [[AS3-Tutorium:Physics:Grundlagen]] empfohlen.

=Grundlegendes Prinzip=
Physics-Engines stellen lediglich Algorithmen für die physikalische Berechnung, jedoch keine Routinen zur Darstellung von Objekten, zur Verfügung! Da Flex oder Flash selber auch keine echten 3D-Engines besitzen, brauchen Sie für die Darstellung eine zusätzliche Bibliothek. Im Code müssen Sie selbständig die physikalische Objekte mit den darstellenden Objekten verbinden, da beide sonst unabhängig voneinander agieren würden. Weiterhin müssen sie beachten, dass die physikalische Berechnung so kompliziert ist, dass nicht alle Objekte die Sie darstellen können, auch physikalisch in ihrer ganzen Komplexität berücksichtigen können. Auf den Umgang mit den Libraries in AS3 wird später genauer eingegangen.

=3D-Engines=

==Papervision3D==
Papervision3D eine sehr populäre 3D-Engine für Actionscript. Sie kann alle wichtigen primitive Objekte wie Quader, Kugeln, Ebenen und Zylinder darstellen. Auch komplexe Objekte, beispielsweise 3D-Models aus Maya sind mit einer Hilfsklasse, dem Collada, sehr einfach einzubinden. Man kann koordinatengenau Punktlichter setzen und verschiedene Materialen, wie beispielweise das einfache FlatShadeMaterial oder das WireFrameMaterial auf seine Objekte anwenden. Und auch sonst ist Papervision eine recht mächtige Engine. Sie unterstützt beispielsweise die komplexe Rechnung mit Matrizen und stellt uns mit der Matrix3D eine Klasse mit vielen nützlichen Methoden zur Verfügung.

Die Dokumentation von Papervision3D fällt etwas spärlich aus und verzichtet auf eine ausführliche Beschreibung der Methoden. Da aber einige gute Tutorials im Web zu finden sind fällt der Einstieg nicht schwer.Insgesamt ist die Arbeit mit Papervision sehr simpel und effektiv: Man erstellt seine Objekte; fügt diese der Szene hinzu, konfiguriert den Renderer, und los geht’s.

==Sonstige Engines==

Sandy3D

Away3D

Alternativa

=3D-Physics-Engines=

==WOW-Engine==

WOW, nicht zu verwechseln mit World of Warcraft, ist die verbreitetste aller 3D-Physics-Engines für Actionscript. Man stößt bei der Internet-Recherche fast nur auf Beispiele mit der WOW-Engine, was nicht ganz verständlich ist.

Die Arbeit mit der WOW-Engine ist durchweg intuitiv und komfortabel. Man erstellt seine Objekte, modifiziert ggbf. die Elastizität o.ä., verbindet sie mit der Darstellung und aktualisiert sie jedes Frame.

Die Engine hat jedoch einige große Nachteile:

1. Die Performance lässt zu wünschen übrig. Schon nicht allzu viele gleichzeitig zu berechnende Objekten zwingen die Physics-Engine in die Knie.

2. Es gibt keine Kollisionsberechnung von Quader, Würfeln.

3. Auch sonstige Feinheiten wie Federn o.ä. fehlen.

Was dann überhaupt noch übrig bleibt: Die Kollision von Kugeln sowie einfache Gravitation; bei schlechter Performance. Es ist daher unverständlich, warum die WOW-Engine einen solchen Status erlangt hat. Eine bessere Alternative wird im Folgenden dargestellt.

==flashjiglib==

Die flashjiglib ist aus unerklärchlich Gründen in den Weiten des World Wide Webs sehr schwer zu entdecken. Sie ist eine Portierung der jiglib aus C++ und deutlich ausgereifter als die WOW-Engine:

Die Arbeit mit der flashjiglib ist ebenso intuitiv, die Performance um Welten besser( durch zahlreiche Demos bewiesen, siehe[...Link..]). Die jiglib unterstützt die Kollision von Kugeln, Quadern, begrenzten Ebenen und Kapseln. Die physikalische Berechnung von Federn ist ebenfalls möglich. Last but not least bringt die flashjiglib Komfortfunktionen mit sich; die es beispielsweise erlauben, die Papervision-Initialisierung zu verkürzen.

=Tutorial=

Im Folgenden werden wir eine einfache 3D-Physics-Szene mit Papervision3D und flashjiglib bauen.

<source lang="actionscript">
package {
import flash.display.Sprite;
import flash.events.Event;

import jiglib.geometry.JBox;
import jiglib.math.JNumber3D;
import jiglib.physics.RigidBody;
import jiglib.plugin.papervision3d.Papervision3DPhysics;
import jiglib.plugin.papervision3d.Pv3dMesh;

import org.papervision3d.cameras.Camera3D;
import org.papervision3d.lights.PointLight3D;
import org.papervision3d.materials.WireframeMaterial;
import org.papervision3d.materials.shadematerials.FlatShadeMaterial;
import org.papervision3d.materials.utils.MaterialsList;
import org.papervision3d.objects.primitives.Cube;
import org.papervision3d.render.LazyRenderEngine;
import org.papervision3d.scenes.Scene3D;
import org.papervision3d.view.Viewport3D;

public class Physics3DTutorial extends Sprite
{
private var physics:Papervision3DPhysics;

private var camera3D:Camera3D;
private var viewport3D:Viewport3D;
private var renderEngine:LazyRenderEngine;
private var scene3D:Scene3D;

public function Physics3DTutorial()
{
initPapervision();
initJiglib();

initObjects();
}
</source>

Man kann den Programmfluß in 4 wichtige Schritte aufteilen. Drei davon sind Initialisierungsschritte und werden direkt im Konstruktor aufgerufen. (( Der vierte Schritt, die Aktualisierung der Engines pro Frame, wird über einen EventListener auf ENTER_FRAME aufgerufen. Der EventListener wird bei erfolgreicher Initalisierung, also nach der Erzeugung aller Objekte hinzugefügt. ))

<source lang="actionscript">
private function initPapervision () :void {
this.camera3D = new Camera3D();
this.viewport3D = new Viewport3D(640, 480);
this.scene3D = new Scene3D();
this.renderEngine = new LazyRenderEngine(this.scene3D, this.camera3D, this.viewport3D);
this.addChild(this.viewport3D);
}
</source>

Hier wird die Papervision3D-Engine zur Darstellung von dreidimensionalen Objekten intialisiert. Dafür braucht man folgende Elemente:
*Die Kamera. Sie ist der Blickpunkt auf die Szene. Du kannst es dir also genau so vorstellen wie eine Filmkamera. Man sie beispielsweise nach oben verschieben um eine „Draufsicht“ auf die Szene zu erreichen.
*Die Szene. Sie enthält alle zu renderenden Objekte. Wenn du später ein Objekt erzeugst musst du es der Szene per addChild() übergeben.
*Der Viewport ist die Zeichenfläche für die Darstellung. Den Viewport musst du immer deiner darstellenden Klassen mitt addChild übergeben. In unserem Falle ist dies das eigene Objekt.
*Der Renderer. Ihm musst die restlichen Elemente übergeben damit er weiß was er wie rendern muss. Außerdem musst du ihn später pro Schritt updaten.

<source lang="actionscript">
private function initJiglib():void
{
physics = new Papervision3DPhysics(this.scene3D, 7);
physics.engine.setGravity(new JNumber3D(0, -1, 0));

}
</source>

Die Initialisierung der Physics-Engine ist recht einfach; wir müssen lediglich ein Papervision3DPhysics-Objekt erzeugen. Dieses Objekt muss wissen auf welche Szene sie einen Einfluss hat, in unserem Falle „scene3D“. Anschließend können wir noch Einstellungen vornehmen und so z.B. die Gravitation verändern.

<source lang="actionscript">
private function initObjects():void
{
var pointLight3D:PointLight3D = new PointLight3D();
pointLight3D.x = 1000;
pointLight3D.y = 1000;
pointLight3D.z = -1000;

var materialsList1 :MaterialsList = new MaterialsList({all: new FlatShadeMaterial(pointLight3D)});
var boxPV:Cube = new Cube(materialsList1, 100, 10, 40 );
var boxJL:JBox = new JBox(new Pv3dMesh(boxPV), 100, 10, 40);

boxJL.y = 30;
boxJL.rotationY = 20;
boxJL.rotationZ = 20;

this.scene3D.addChild(boxPV);
this.physics.addBody(boxJL);

var ground:RigidBody = physics.createGround(new FlatShadeMaterial(pointLight3D), 300, 2);
ground.y = - 100;

var sphere:RigidBody = physics.createSphere(new WireframeMaterial(0xFF44FF), 20);

this.addEventListener(Event.ENTER_FRAME, this.onEnterFrame);
}
</source>

Zunächst erzeugen wir ein Objekt auf einem vergleichsweise komplizierten Weg. Dieser Weg eignet sich z.b. wenn noch andere Routinen in den Worflow eingebaut werden müssen.

Zunächst erzeugen wir ein Punktlicht der Klasse PointLight3D, das wir im Raum platzieren und eine MaterialsList, welche wir für die Darstellung eines Quaders brauchen. Als nächstes erzeugen wir die zwei grundlegenden Objekte.
*Das von Papervision3D darzustellende Objekt, welches immer von DisplayObject3D ableitet. In unserem Falle ist es ein „Cube“.
*Der dem darstellenden Objekt entsprechende physikalische Körper, immer eine Subklasse von RigidBody. Der RigidBody muss wissen, welches Darstellungs-Objekt er beeinflusst. In unserem Falle entspricht dem Cube die JBBox; sie sollte auch die selben Maße haben.
Da wir zwei getrennte Libraries haben wird grundsätzlich immer mit diesen beiden Objekten gearbeitet. Da es aber etwas umständlich ist, beide Objekte einzeln zu erzeugen, lernen wir im folgenden noch eine verkürzte Schreibweise, bei dir die Erzeugung und Verknüpfung beider Objekte im Hintergrund abläuft.

Wir können jetzt noch die Rotation oder Position des Quaders verändern. Beachte, dass die Koordinatenachsen nicht wie in der Informatik üblich von links oben nach rechts unten verlaufen. Stattdessen beginnen sie in der Mitte. Y-Werte werden nach oben und X-Werte nach rechts größer.

Wie bereits erwähnt stellt uns das Papervision3DPhysics-Objekt Komfortfunktionen zur Verfügung mit der wir die Erzeugung von Objekten vereinfachen können. Mit physics.createGround() erzeugen wir einen begrenzte Ebene und mit createSphere() eine Kugel. Das Objekt kümmert sich darum das flashjiglib-Objekt als auch das enstprechende Papervision-Objekt zu erzeugen und es zur Szene hinzuzufügen.

Zuletzt fügen wir einen EventListener auf ENTER_FRAME hinzu.

<source lang="actionscript">
private function onEnterFrame(evt: Event):void
{
this.physics.step();
this.renderEngine.render();
}

}
}
</source>

Alles war wir jetzt noch tun müssen ist den Renderer sowie die Physics-Engine jeden Schritt zu aktualisieren.

=Quellen=
*[http://www.papervision3d.org/docs/as3/]
*[http://as3.miguelmoraleda.com/2009/04/24/flash/jiglibflash/tutorial-jiglibflash-how-to-create-basic-physics-3d-scenetutorial-jiglibflash-como-crear-una-scena-en-3d-con-fisica/]
*[http://blog.zupko.info/?p=96]

[[Kategorie:Spielephysik]]
[[Kategorie:Flex]]
[[Kategorie:Flash]]
[[Kategorie:Flash-HowTo]]

AS3-Tutorium:Physics:3D-Physics-Engines

2009-07-11T08:31:05Z

Jakobw: /* Tutorial */

{{In Bearbeitung}}

=Grundlegendes Prinzip=
Physics-Engines stellen lediglich Algorithmen für die physikalische Berechnung, jedoch keine Routinen zur Darstellung von Objekten, zur Verfügung! Da Flex oder Flash selber auch keine echten 3D-Engines besitzen, brauchen Sie für die Darstellung eine zusätzliche Bibliothek. Im Code müssen Sie selbständig die physikalische Objekte mit den darstellenden Objekten verbinden, da beide sonst unabhängig voneinander agieren würden. Weiterhin müssen sie beachten, dass die physikalische Berechnung so kompliziert ist, dass nicht alle Objekte die Sie darstellen können, auch physikalisch in ihrer ganzen Komplexität berücksichtigen können. Auf den Umgang mit den Libraries in AS3 wird später genauer eingegangen.

==Bemerkung 1==
Zu einer Definition kann man viele sinnvolle Bemerkungen angeben.

==Bemerkung 2==
Natürlich sollte eine Bemerkung einen sinnvollen Titel erhalten und nicht einfach ''Bemerkung 1'', ''Bemerkung 2'' etc.
genannt werden.

=3D-Engines=

==Papervision3D==
Papervision3D eine sehr populäre 3D-Engine für Actionscript. Sie kann alle wichtigen primitive Objekte wie Quader, Kugeln, Ebenen und Zylinder darstellen. Auch komplexe Objekte, beispielsweise 3D-Models aus Maya sind mit einer Hilfsklasse, dem Collada, sehr einfach einzubinden.

Man kann koordinatengenau Punktlichter setzen und verschiedene Materialen, wie beispielweise das einfache FlatShadeMaterial oder das WireFrameMaterial auf seine Objekte anwenden.

Und auch sonst ist Papervision eine recht mächtige Engine. Sie unterstützt beispielsweise die komplexe Rechnung mit Matrizen und stellt uns mit der Matrix3D eine Klasse mit vielen nützlichen Methoden zur Verfügung.

Die Dokumentation von Papervision3D fällt etwas spärlich aus und verzichtet auf eine ausführliche Beschreibung der Methoden. Da aber einige gute Tutorials im Web zu finden sind fällt der Einstieg nicht schwer.

Insgesamt ist die Arbeit mit Papervision sehr simpel und effektiv: Man erstellt seine Objekte; fügt diese der Szene hinzu, konfiguriert den Renderer, und los geht’s.

==Sonstiged Engines==

Sandy3D

Away3D

Alternativa

=3D-Physics-Engines=

==WOW-Engine==

WOW, nicht zu verwechseln mit World of Warcraft, ist die verbreitetste aller 3D-Physics-Engines für Actionscript. Man stößt bei der Internet-Recherche fast nur auf Beispiele mit der WOW-Engine, was nicht ganz verständlich ist.

Die Arbeit mit der WOW-Engine ist durchweg intuitiv und komfortabel. Man erstellt seine Objekte, modifiziert ggbf. die Elastizität o.ä., verbindet sie mit der Darstellung und aktualisiert sie jedes Frame.

Die Engine hat jedoch einige große Nachteile:

1. Die Performance lässt zu wünschen übrig. Schon nicht allzu viele gleichzeitig zu berechnende Objekten zwingen die Physics-Engine in die Knie.

2. Es gibt keine Kollisionsberechnung von Quader, Würfeln.

3. Auch sonstige Feinheiten wie Federn o.ä. fehlen.

Was dann überhaupt noch übrig bleibt: Die Kollision von Kugeln sowie einfache Gravitation; bei schlechter Performance. Es ist daher unverständlich, warum die WOW-Engine einen solchen Status erlangt hat. Eine bessere Alternative wird im Folgenden dargestellt.

==flashjiglib==

Die flashjiglib ist aus unerklärchlich Gründen in den Weiten des World Wide Webs sehr schwer zu entdecken. Sie ist eine Portierung der jiglib aus C++ und deutlich ausgereifter als die WOW-Engine:

Die Arbeit mit der flashjiglib ist ebenso intuitiv, die Performance um Welten besser( durch zahlreiche Demos bewiesen, siehe[...Link..]). Die jiglib unterstützt die Kollision von Kugeln, Quadern, begrenzten Ebenen und Kapseln. Die physikalische Berechnung von Federn ist ebenfalls möglich. Last but not least bringt die flashjiglib Komfortfunktionen mit sich; die es beispielsweise erlauben, die Papervision-Initialisierung zu verkürzen.

=Tutorial=

Im Folgenden werden wir eine einfache 3D-Physics-Szene mit Papervision3D und flashjiglib bauen.

package {
import flash.display.Sprite;
import flash.events.Event;

import jiglib.geometry.JBox;
import jiglib.math.JNumber3D;
import jiglib.physics.RigidBody;
import jiglib.plugin.papervision3d.Papervision3DPhysics;
import jiglib.plugin.papervision3d.Pv3dMesh;

import org.papervision3d.cameras.Camera3D;
import org.papervision3d.lights.PointLight3D;
import org.papervision3d.materials.WireframeMaterial;
import org.papervision3d.materials.shadematerials.FlatShadeMaterial;
import org.papervision3d.materials.utils.MaterialsList;
import org.papervision3d.objects.primitives.Cube;
import org.papervision3d.render.LazyRenderEngine;
import org.papervision3d.scenes.Scene3D;
import org.papervision3d.view.Viewport3D;

public class Physics3DTutorial extends Sprite
{
private var physics:Papervision3DPhysics;

private var camera3D:Camera3D;
private var viewport3D:Viewport3D;
private var renderEngine:LazyRenderEngine;
private var scene3D:Scene3D;

public function Physics3DTutorial()
{
initPapervision();
initJiglib();

initObjects();
}

Man kann den Programmfluß in 4 wichtige Schritte aufteilen. Drei davon sind Initialisierungsschritte und werden direkt im Konstruktor aufgerufen. (( Der vierte Schritt, die Aktualisierung der Engines pro Frame, wird über einen EventListener auf ENTER_FRAME aufgerufen. Der EventListener wird bei erfolgreicher Initalisierung, also nach der Erzeugung aller Objekte hinzugefügt. ))

private function initPapervision () :void {
this.camera3D = new Camera3D();
this.viewport3D = new Viewport3D(640, 480);
this.scene3D = new Scene3D();
this.renderEngine = new LazyRenderEngine(this.scene3D, this.camera3D, this.viewport3D);
this.addChild(this.viewport3D);
}

Hier wird die Papervision3D-Engine zur Darstellung von dreidimensionalen Objekten intialisiert. Dafür braucht man folgende Elemente:
*Die Kamera. Sie ist der Blickpunkt auf die Szene. Du kannst es dir also genau so vorstellen wie eine Filmkamera. Man sie beispielsweise nach oben verschieben um eine „Draufsicht“ auf die Szene zu erreichen.
*Die Szene. Sie enthält alle zu renderenden Objekte. Wenn du später ein Objekt erzeugst musst du es der Szene per addChild() übergeben.
*Der Viewport ist die Zeichenfläche für die Darstellung. Den Viewport musst du immer deiner darstellenden Klassen mitt addChild übergeben. In unserem Falle ist dies das eigene Objekt.
*Der Renderer. Ihm musst die restlichen Elemente übergeben damit er weiß was er wie rendern muss. Außerdem musst du ihn später pro Schritt updaten.

private function initJiglib():void
{
physics = new Papervision3DPhysics(this.scene3D, 7);
physics.engine.setGravity(new JNumber3D(0, -1, 0));

}

Die Initialisierung der Physics-Engine ist recht einfach; wir müssen lediglich ein Papervision3DPhysics-Objekt erzeugen. Dieses Objekt muss wissen auf welche Szene sie einen Einfluss hat, in unserem Falle „scene3D“. Anschließend können wir noch Einstellungen vornehmen und so z.B. die Gravitation verändern.

private function initObjects():void
{
var pointLight3D:PointLight3D = new PointLight3D();
pointLight3D.x = 1000;
pointLight3D.y = 1000;
pointLight3D.z = -1000;

var materialsList1 :MaterialsList = new MaterialsList({all: new FlatShadeMaterial(pointLight3D)});
var boxPV:Cube = new Cube(materialsList1, 100, 10, 40 );
var boxJL:JBox = new JBox(new Pv3dMesh(boxPV), 100, 10, 40);

boxJL.y = 30;
boxJL.rotationY = 20;
boxJL.rotationZ = 20;

this.scene3D.addChild(boxPV);
this.physics.addBody(boxJL);

var ground:RigidBody = physics.createGround(new FlatShadeMaterial(pointLight3D), 300, 2);
ground.y = - 100;

var sphere:RigidBody = physics.createSphere(new WireframeMaterial(0xFF44FF), 20);

this.addEventListener(Event.ENTER_FRAME, this.onEnterFrame);
}

Zunächst erzeugen wir ein Objekt auf einem vergleichsweise komplizierten Weg. Dieser Weg eignet sich z.b. wenn noch andere Routinen in den Worflow eingebaut werden müssen.

Zunächst erzeugen wir ein Punktlicht der Klasse PointLight3D, das wir im Raum platzieren und eine MaterialsList, welche wir für die Darstellung eines Quaders brauchen. Als nächstes erzeugen wir die zwei grundlegenden Objekte.
• Das von Papervision3D darzustellende Objekt, welches immer von DisplayObject3D ableitet. In unserem Falle ist es ein „Cube“.
• Der dem darstellenden Objekt entsprechende physikalische Körper, immer eine Subklasse von RigidBody. Der RigidBody muss wissen, welches Darstellungs-Objekt er beeinflusst. In unserem Falle entspricht dem Cube die JBBox; sie sollte auch die selben Maße haben.
Da wir zwei getrennte Libraries haben wird grundsätzlich immer mit diesen beiden Objekten gearbeitet. Da es aber etwas umständlich ist, beide Objekte einzeln zu erzeugen, lernen wir im folgenden noch eine verkürzte Schreibweise, bei dir die Erzeugung und Verknüpfung beider Objekte im Hintergrund abläuft.

Wir können jetzt noch die Rotation oder Position des Quaders verändern. Beachte, dass die Koordinatenachsen nicht wie in der Informatik üblich von links oben nach rechts unten verlaufen. Stattdessen beginnen sie in der Mitte. Y-Werte werden nach oben und X-Werte nach rechts größer.

Wie bereits erwähnt stellt uns das Papervision3DPhysics-Objekt Komfortfunktionen zur Verfügung mit der wir die Erzeugung von Objekten vereinfachen können. Mit physics.createGround() erzeugen wir einen begrenzte Ebene und mit createSphere() eine Kugel. Das Objekt kümmert sich darum das flashjiglib-Objekt als auch das enstprechende Papervision-Objekt zu erzeugen und es zur Szene hinzuzufügen.

Zuletzt fügen wir einen EventListener auf ENTER_FRAME hinzu.

private function onEnterFrame(evt: Event):void
{
this.physics.step();
this.renderEngine.render();
}

}
}

Alles war wir jetzt noch tun müssen ist den Renderer sowie die Physics-Engine jeden Schritt zu aktualisieren.

=Quellen=
*[http://www.papervision3d.org/docs/as3/]
*[http://as3.miguelmoraleda.com/2009/04/24/flash/jiglibflash/tutorial-jiglibflash-how-to-create-basic-physics-3d-scenetutorial-jiglibflash-como-crear-una-scena-en-3d-con-fisica/]
*[http://blog.zupko.info/?p=96]

AS3-Tutorium:Physics:3D-Physics-Engines

2009-07-11T08:21:58Z

Jakobw:

{{In Bearbeitung}}

=Grundlegendes Prinzip=
Physics-Engines stellen lediglich Algorithmen für die physikalische Berechnung, jedoch keine Routinen zur Darstellung von Objekten, zur Verfügung! Da Flex oder Flash selber auch keine echten 3D-Engines besitzen, brauchen Sie für die Darstellung eine zusätzliche Bibliothek. Im Code müssen Sie selbständig die physikalische Objekte mit den darstellenden Objekten verbinden, da beide sonst unabhängig voneinander agieren würden. Weiterhin müssen sie beachten, dass die physikalische Berechnung so kompliziert ist, dass nicht alle Objekte die Sie darstellen können, auch physikalisch in ihrer ganzen Komplexität berücksichtigen können. Auf den Umgang mit den Libraries in AS3 wird später genauer eingegangen.

==Bemerkung 1==
Zu einer Definition kann man viele sinnvolle Bemerkungen angeben.

==Bemerkung 2==
Natürlich sollte eine Bemerkung einen sinnvollen Titel erhalten und nicht einfach ''Bemerkung 1'', ''Bemerkung 2'' etc.
genannt werden.

=3D-Engines=

==Papervision3D==
Papervision3D eine sehr populäre 3D-Engine für Actionscript. Sie kann alle wichtigen primitive Objekte wie Quader, Kugeln, Ebenen und Zylinder darstellen. Auch komplexe Objekte, beispielsweise 3D-Models aus Maya sind mit einer Hilfsklasse, dem Collada, sehr einfach einzubinden.

Man kann koordinatengenau Punktlichter setzen und verschiedene Materialen, wie beispielweise das einfache FlatShadeMaterial oder das WireFrameMaterial auf seine Objekte anwenden.

Und auch sonst ist Papervision eine recht mächtige Engine. Sie unterstützt beispielsweise die komplexe Rechnung mit Matrizen und stellt uns mit der Matrix3D eine Klasse mit vielen nützlichen Methoden zur Verfügung.

Die Dokumentation von Papervision3D fällt etwas spärlich aus und verzichtet auf eine ausführliche Beschreibung der Methoden. Da aber einige gute Tutorials im Web zu finden sind fällt der Einstieg nicht schwer.

Insgesamt ist die Arbeit mit Papervision sehr simpel und effektiv: Man erstellt seine Objekte; fügt diese der Szene hinzu, konfiguriert den Renderer, und los geht’s.

==Sonstiged Engines==

Sandy3D

Away3D

Alternativa

=3D-Physics-Engines=

==WOW-Engine==

WOW, nicht zu verwechseln mit World of Warcraft, ist die verbreitetste aller 3D-Physics-Engines für Actionscript. Man stößt bei der Internet-Recherche fast nur auf Beispiele mit der WOW-Engine, was nicht ganz verständlich ist.

Die Arbeit mit der WOW-Engine ist durchweg intuitiv und komfortabel. Man erstellt seine Objekte, modifiziert ggbf. die Elastizität o.ä., verbindet sie mit der Darstellung und aktualisiert sie jedes Frame.

Die Engine hat jedoch einige große Nachteile:

1. Die Performance lässt zu wünschen übrig. Schon nicht allzu viele gleichzeitig zu berechnende Objekten zwingen die Physics-Engine in die Knie.

2. Es gibt keine Kollisionsberechnung von Quader, Würfeln.

3. Auch sonstige Feinheiten wie Federn o.ä. fehlen.

Was dann überhaupt noch übrig bleibt: Die Kollision von Kugeln sowie einfache Gravitation; bei schlechter Performance. Es ist daher unverständlich, warum die WOW-Engine einen solchen Status erlangt hat. Eine bessere Alternative wird im Folgenden dargestellt.

==flashjiglib==

Die flashjiglib ist aus unerklärchlich Gründen in den Weiten des World Wide Webs sehr schwer zu entdecken. Sie ist eine Portierung der jiglib aus C++ und deutlich ausgereifter als die WOW-Engine:

Die Arbeit mit der flashjiglib ist ebenso intuitiv, die Performance um Welten besser( durch zahlreiche Demos bewiesen, siehe[...Link..]). Die jiglib unterstützt die Kollision von Kugeln, Quadern, begrenzten Ebenen und Kapseln. Die physikalische Berechnung von Federn ist ebenfalls möglich. Last but not least bringt die flashjiglib Komfortfunktionen mit sich; die es beispielsweise erlauben, die Papervision-Initialisierung zu verkürzen.

=Tutorial=

Im Folgenden werden wir eine einfache 3D-Physics-Szene mit Papervision3D und flashjiglib bauen.

package {
import flash.display.Sprite;
import flash.events.Event;

import jiglib.geometry.JBox;
import jiglib.math.JNumber3D;
import jiglib.physics.RigidBody;
import jiglib.plugin.papervision3d.Papervision3DPhysics;
import jiglib.plugin.papervision3d.Pv3dMesh;

import org.papervision3d.cameras.Camera3D;
import org.papervision3d.lights.PointLight3D;
import org.papervision3d.materials.WireframeMaterial;
import org.papervision3d.materials.shadematerials.FlatShadeMaterial;
import org.papervision3d.materials.utils.MaterialsList;
import org.papervision3d.objects.primitives.Cube;
import org.papervision3d.render.LazyRenderEngine;
import org.papervision3d.scenes.Scene3D;
import org.papervision3d.view.Viewport3D;

public class Physics3DTutorial extends Sprite
{
private var physics:Papervision3DPhysics;

private var camera3D:Camera3D;
private var viewport3D:Viewport3D;
private var renderEngine:LazyRenderEngine;
private var scene3D:Scene3D;

public function Physics3DTutorial()
{
initPapervision();
initJiglib();

initObjects();
}

Man kann den Programmfluß in 4 wichtige Schritte aufteilen. Drei davon sind Initialisierungsschritte und werden direkt im Konstruktor aufgerufen. (( Der vierte Schritt, die Aktualisierung der Engines pro Frame, wird über einen EventListener auf ENTER_FRAME aufgerufen. Der EventListener wird bei erfolgreicher Initalisierung, also nach der Erzeugung aller Objekte hinzugefügt. ))

private function initPapervision () :void {
this.camera3D = new Camera3D();
this.viewport3D = new Viewport3D(640, 480);
this.scene3D = new Scene3D();
this.renderEngine = new LazyRenderEngine(this.scene3D, this.camera3D, this.viewport3D);
this.addChild(this.viewport3D);
}

Hier wird die Papervision3D-Engine zur Darstellung von dreidimensionalen Objekten intialisiert. Dafür braucht man folgende Elemente:
*Die Kamera. Sie ist der Blickpunkt auf die Szene. Du kannst es dir also genau so vorstellen wie eine Filmkamera. Man sie beispielsweise nach oben verschieben um eine „Draufsicht“ auf die Szene zu erreichen.
*Die Szene. Sie enthält alle zu renderenden Objekte. Wenn du später ein Objekt erzeugst musst du es der Szene per addChild() übergeben.
*Der Viewport ist die Zeichenfläche für die Darstellung. Den Viewport musst du immer deiner darstellenden Klassen mitt addChild übergeben. In unserem Falle ist dies das eigene Objekt.
*Der Renderer. Ihm musst die restlichen Elemente übergeben damit er weiß was er wie rendern muss. Außerdem musst du ihn später pro Schritt updaten.

code3

Die Initialisierung der Physics-Engine ist recht einfach; wir müssen lediglich ein Papervision3DPhysics-Objekt erzeugen. Dieses Objekt muss wissen auf welche Szene sie einen Einfluss hat, in unserem Falle „scene3D“. Anschließend können wir noch Einstellungen vornehmen und so z.B. die Gravitation verändern.

code4

Zunächst erzeugen wir ein Objekt auf einem vergleichsweise komplizierten Weg. Dieser Weg eignet sich z.b. wenn noch andere Routinen in den Worflow eingebaut werden müssen.

Zunächst erzeugen wir ein Punktlicht der Klasse PointLight3D, das wir im Raum platzieren und eine MaterialsList, welche wir für die Darstellung eines Quaders brauchen. Als nächstes erzeugen wir die zwei grundlegenden Objekte.
• Das von Papervision3D darzustellende Objekt, welches immer von DisplayObject3D ableitet. In unserem Falle ist es ein „Cube“.
• Der dem darstellenden Objekt entsprechende physikalische Körper, immer eine Subklasse von RigidBody. Der RigidBody muss wissen, welches Darstellungs-Objekt er beeinflusst. In unserem Falle entspricht dem Cube die JBBox; sie sollte auch die selben Maße haben.
Da wir zwei getrennte Libraries haben wird grundsätzlich immer mit diesen beiden Objekten gearbeitet. Da es aber etwas umständlich ist, beide Objekte einzeln zu erzeugen, lernen wir im folgenden noch eine verkürzte Schreibweise, bei dir die Erzeugung und Verknüpfung beider Objekte im Hintergrund abläuft.

Wir können jetzt noch die Rotation oder Position des Quaders verändern. Beachte, dass die Koordinatenachsen nicht wie in der Informatik üblich von links oben nach rechts unten verlaufen. Stattdessen beginnen sie in der Mitte. Y-Werte werden nach oben und X-Werte nach rechts größer.

Wie bereits erwähnt stellt uns das Papervision3DPhysics-Objekt Komfortfunktionen zur Verfügung mit der wir die Erzeugung von Objekten vereinfachen können. Mit physics.createGround() erzeugen wir einen begrenzte Ebene und mit createSphere() eine Kugel. Das Objekt kümmert sich darum das flashjiglib-Objekt als auch das enstprechende Papervision-Objekt zu erzeugen und es zur Szene hinzuzufügen.

Zuletzt fügen wir einen EventListener auf ENTER_FRAME hinzu.

code5

Alles war wir jetzt noch tun müssen ist den Renderer sowie die Physics-Engine jeden Schritt zu aktualisieren.

=Quellen=
*[http://www.papervision3d.org/docs/as3/]
*[http://as3.miguelmoraleda.com/2009/04/24/flash/jiglibflash/tutorial-jiglibflash-how-to-create-basic-physics-3d-scenetutorial-jiglibflash-como-crear-una-scena-en-3d-con-fisica/]
*[http://blog.zupko.info/?p=96]

AS3-Tutorium:Physics:3D-Physics-Engines

2009-07-11T08:16:43Z

Jakobw: Die Seite wurde neu angelegt: {{In Bearbeitung}} =Grundlegendes Prinzip= Physics-Engines stellen lediglich Algorithmen für die physikalische Berechnung, jedoch keine Routinen zur Darstellung von ...

AS3-Tutorium:Physics:Vertiefung

2009-07-11T08:09:36Z

Jakobw: /* Überblick */

= Überblick =

Dieser Artikel erklärt den Aufbau und die Funktionsweise einer vollwertigen Physics-Engine und stellt außerdem die wichtigsten Physics-Engines vor. Im Detail werden die Vorgehensweisen und Algorithmen erklärt, welche in der lyneth Physics API verwendet werden. Diese Sammlung stellt nur eine begrenzte Zahl der Möglichkeiten dar, welche im Bereich der Physics zum Einsatz kommen. Für den 3D-Raum werden einige Sachverhalte komplizierter, deshalb beschränkt sich die Beschreibung auf den 2D-Raum. Informationen zur Verwendung von vorhanden 3D-Physics-Engines in Actionscript3 finden sie im Artikel [[AS3-Tutorium:Physics:3D-Physics-Engines]].

= Komponenten einer Physics-Engine =

== Mathematische Objekte ==

Die wichtigste Grundlage für alle physikalischen Simulationen sind mathematische Hilfsklassen. Diese werden nicht zwingend für die Realisierung eine Physics-Engine benötigt, sind aber aufgrund der Vereinfachung der Sachverhalte unverzichtbar.

=== [http://de.wikipedia.org/wiki/Vektor Vektor] ===

Ein zweidimensionaler Vektor besteht aus einer x- und einer y-Komponente. Dieser hat immer eine Länge und eine Richtung. Benutzt man einen Vektor für eine Position, so versteht man den Vektor als Abstand und Richtung der Position vom Ursprung aus. Vektoren werden für folgende Sachverhalte verwendet:
* Position
* Geschwindigkeit
* Beschleunigung
* Kollisionsnormale
* Kollisionstangente
* Koordinatensysteme (ein Paar von Vektoren)

Wichtig ist also alle relevanten mathematischen Funktionalitäten für Vektoren zu implementieren. Dazu gehören:
* Addition, Subtraktion, Multiplikation, Division
* Längenbestimmung
* Normierung (den Vektor auf Länge 1 skalierung)
* Normalenberechnung (einen Vektor berechnen, welcher senkrecht auf dem Ursprungsvektor steht)
* Skalarprodukt von zwei Vektoren
* Kreuzprodukt von zwei Vektoren (in 2D-Raum ein Skalar)

=== Projektion ===

Für 2D-Physics-Engines sind lediglich 1D-Projektionen relevant. Hierzu wird ein Projektionsvektor (Vektor mit der Länge 1) und mindestens ein zu projizierender Vektor benötigt. Die Projektion wird berechnet, indem man das Skalarprodukt für alle gewünschten Vektoren mit dem Projektionsvektor berechnet. Es entsteht ein Intervall, welches in Kombination mit dem Projektsvektor die Projektion innerhalb des ursprünglichen Koordinatensystems beschreibt. Projektionen werden benötigt für:
* Berechnung der Tiefe einer Kollision (Minimum Translation Distance)
* Berechnung der Normalen- und Tangenanteile von Geschwindigkeiten
* Bestimmung von Überschneidung von polygonalen Formen

== Geometrische Objekte ==

Geometrische Objekte sind relevant für die Beschreibung der Formen von physikalischen Objekten. Die Geometrie wird strikt von der Dynamik getrennt, um beide Bereiche unabhängig voneinander zu halten.

=== Abstrakte Form ===

Eine Form besitzt immer eine globale Position und Rotation (unter Umständen auch eine lokale Position und Rotation).

=== Kreis ===

Der Kreis ist die einfachste geometrische Form, er wird durch die Attribute einer Form und einen Radius beschrieben.

=== (Konvexes) Polygon ===

Ein Polygon erweitert eine abstrakte Form um eine feste Anzahl von Eckpunkten. Für die meisten Algorithmen der Kollisionserkennung werden konvexe Polygone benötigt. Konkave Polygone setzen sich aus der Kombination von mehreren konvexen Polygonen zusammen. Um Berechnungen sparen zu können werden die Normalen der Seiten eines Polygons und die Projektionen entlang der eigenen Normalen zwischengespeichert.

== Dynamik ==

<blockquote>Die Dynamik (gr. dynamis Kraft) ist das Teilgebiet der Mechanik, das sich mit der Wirkung von Kräften befasst. [..] Hier wird unter Dynamik die Beschreibung der Bewegung von Körpern unter Einfluss von Kräften verstanden, im allgemeineren Sinn auch das Zeitverhalten eines Systems und die zu seiner Beschreibung verwendeten Bewegungsgleichungen.<cite>(Quelle: Wikipedia)</cite></blockquote>

=== Zustand ===

Ein Zustand zu einem bestimmten Zeitpunkt t setzt sich zusammen aus Position, Geschwindigkeit und Beschleunigung. Jedes dieser Attribute wird durch einen 2D-Vektor kombiniert mit einem Wert für die Rotation realisiert (für Rotation, Winkelgeschwindigkeit und Winkelbeschleunigung).

=== Körper ===

Jeder Sammlung von geometrischenen Form wird ein Zustand zugeordnet. Die Kombination von geometrischen Formen und Zuständen ergibt einen Körper.

=== Kräfte ===

Kräfte sind im Normalfall Dynamik-Objekte ohne geometrische Form. Für den Zustand ist in den meisten Fällen allein eine Position ausreichend. Zusätzlich besitzt eine Kraft einen Kraftvektor und einen Wirkungsbereich (oft durch einen Radius realisiert). Wie die Kraft letzendlich auf Körper angewendet wird, hängt von der Art der Kraft ab. Die Hook´sche Feder (siehe letzter Vortrag) kann ebenfalls als Kraft realisiert werden, welche allerdings nur auf zwei Körper wirkt und allein diese beeinflusst.

Beispiele:
* [[Medium:TutoriumPhysics-2-01-Formen.swf]]
* [[Medium:TutoriumPhysics-2-02-Kräfte.swf]]
* [[Medium:TutoriumPhysics-2-03-Kräfte.swf]]
* [[Medium:TutoriumPhysics-2-04-Kräfte.swf]]

== Integration ==

Die Integration beschreibt numerische Lösungsverfahren für Differentialgleichungen. Die Zustandsänderungen der Dynamik eines Körpers werden mithilfe dieser Algorithmen berechnet (Kräfte, Beschleunigungen, Geschwindigkeiten, Orte). Es gibt viele verschiedene Algorithmen, welche sich in Effizienz und Exaktheit unterscheiden. Wichtige Links zu diesem Thema sind:
* [http://de.wikipedia.org/w/index.php?title=Datei:RK_Verfahren.png&filetimestamp=20090121000101]
* [http://gafferongames.com/game-physics/integration-basics/]
* [http://lab.generalrelativity.org/foam/demos/orbit/]

=== [http://en.wikipedia.org/wiki/Euler%27s_method Euler] ===

Das Verfahren nach Euler ist die einfachste Form der Integration. Hierbei wird abhängig von der vergangenen Zeit (im Normalfall ein festes Zeitintervall) die Beschleunigung auf die Geschwindigkeit und die Geschwindigkeit auf die Position addiert. Die Beschleunigung setzt sich aus der Summe der wirkenden Kräfte zusammen. In einfachen Fällen wird die Beschleunigung einfach manuell gesetzt.

a1 = f / m
v1 = v0 + a1 * t
x1 = x0 + v1 * t

Liegt etwas anderes als eine konstante Geschwindigkeit und keine Beschleunigung vor, so erzeugt dieses Verfahren sehr große Berechnungsfehler. Das Euler-Verfahren kommt jedoch sehr häufig zum Einsatz, vor allem auch in AS3-Physics-Engines, da es einfachste und performanteste Verfahren darstellt. Die Berechnungsfehler sind zu vernachlässigen, da die Ergebnisse meistens trotzdem realistisch wirken.

=== [http://de.wikipedia.org/wiki/Klassisches_Runge-Kutta-Verfahren Runge-Kutta] ===

Das Runge-Kutta-Verfahren ist dem Taylor-Polynom sehr ähnlich. In Physics wird meistens das Verfahren in der viersten Ordnung verwendet (man spricht daher von RK4). Dieses Verfahren zur Integration ist das mit dem geringsten Fehler aber auch dem höchsten Rechenaufwand. Hierbei wird pro Zeitintervall nicht nur der neue Wert berechnet, sondern auch zwei weitere Zwischenwerte, außerdem wird der alte Wert mit in Betracht gezogen. Diese werden dann gewichtet miteinander verrechnet.

<blockquote>Die dabei bei nichtlinearen Funktionen notwendigerweise auftretenden Fehler (es werden sämtliche höheren Glieder der Taylor-Entwicklung vernachlässigt) können durch geeignete Kombinationen verschiedener Differenzquotienten teilweise kompensiert werden. Das Runge-Kutta-Verfahren ist nun eine solche Kombination, die Diskretisierungsfehler bis zur dritten Ableitung kompensiert.<cite>(Quelle:Wikipedia)</cite></blockquote>

[http://de.wikipedia.org/wiki/Klassisches_Runge-Kutta-Verfahren Formel bei Wikipedia]

=== [http://en.wikipedia.org/wiki/Midpoint_method Midpoint] ===

Das sogenannte Midpoint-Verfahren wird in den meisten als RK2, also als Runge-Kutta-Verfahren der 2. Ordnung implementiert. Dementsprechend ist der Rechenaufwand etwas höher als bei Euler, das Ergebnis allerdings nicht so genau wie RK4. Der Algorithmus wird nicht häufig in Physics-Engines eingesetzt.

=== [http://en.wikipedia.org/wiki/Verlet_integration Verlet] ===

Der Verlet-Algorithmus verspricht eine größere Stabilität und einen geringeren Fehler als bei Euler. Dazu wird nicht mit Variablen für Geschwindigkeiten gerechnet, sondern werden diese Werte aus der aktuellen Position und der vorgehenden berechnet. Das Verfahren ist allerdings nicht sehr weit verbreitet, da die Implementierung oftmals Änderungen an der Architektur von Engines voraussetzt.

== Kollisionen ==

Im Folgenden werden die beiden gängigsten Verfahren für die Kollisionserkennung und -auflösung erklärt.

=== Kollisionserkennung ===

Wie bereits in der Einführung vorgestellt reicht der Satz von Pythagoras und ein simpler Wertevergleich aus um die Kollision zwischen zwei Kreisen zu bestimmen. Für Rechtecke mit Seiten parallel zu den Achsen des Koordinationssystems auf Kollision zu testen reicht ebenfalls ein Wertevergleich aus. Diese Verfahren funktionieren nicht bei Polygonen, jedoch benutzt man sie gerne um erstmalig festzustellen ob Polygone potentiell überhaupt kollidieren können. Dazu wird jedem Polygon ein Bounding Circle (Umkreis) oder eine Bounding Box (umschließendes Rechteck) zugewiesen. Somit muß nicht für jedes Polygonenpaar eine aufwändige Kollisionerkennung durchgeführt werden.

Das einfachste Verfahren ist die Anwendung des [http://en.wikipedia.org/wiki/Separating_hyperplane_theorem Trennungssatzes] (englisch: Seperating Axis Theorem oder SAT). Dabei wird jede Normale (Vektor senkrecht zur Seite eines Polygons) als Projektionsachse für beide Polygone benutzt. Sobald eine dieser Projektionen zu keiner Überlappung der beiden Intervalle führt, liegt keine Kollision vor. Gibt es allerdings auf jeder Achse eine Überlappung der Intervalle, so liegt eine Kollision vor. Die Kollisionnormale ist der Vektor bei welchen die Überlappung der Projektionsintervalle minimal ist. Der Betrag dieser Überlappung beschreibt die Tiefe der Kollision. Der Teil mit dem größten Aufwand ist die Berechung der Kollisionspunkte. Hierbei muß nach den Fällen Punkt-Flächen- und Flächen-Flächen-Kollisionen unterschieden werden (Punkt-Punkt-Kollision wird ignoriert).

Das SAT-Verfahren arbeitet nach dem Ausschlussprinzip, d.h. es arbeitet sehr schnell wenn wenig Kollisionen vorliegen. Bei vielen Kollisionen arbeitet das Verfahren aber umso langsamer, da es immer alle Normalen aller Polygone testen muß. Abgesehen von der Performance, erzeugt das Verfahren gerine Fehler und funktioniert stabil.

=== Kollisionsauflösung ===

Ebenso wie bei der Kollisionserkennung gibt es verschiedene Algorithmen um die Kollisionen zu lösen. Bei den meisten Systemen und den angeführten Verfahren werden Kollisionen erst erkannt und aufgelöst wenn sie bereits geschehen sind. Deshalb ist es wichtig die miteinander kollidierenden Objekte erst wieder so weit voneinander zu entfernen, bis sie sich nicht mehr überschneiden. Kollisionsauflösungen dieser Art werden als "penalty based" bezeichnet. Wie bereits im vorherigen Vortrag erwähnt, wird dazu die Minimum Translation Distance (MTD) kombiniert mit der Kollisionsnormale benötigt. Die Objekte werden abhängig von ihrer Masse voneinander entfernt.

Nun kommt es zu eigentlichen Reaktion auf die Kollision. Wie bei einer Kollision von Kreisen kann man das Prinzip des zentralen, unelastischen Stoßes implementieren, allerdings wird man bei diesem Verfahren keine Winkelgeschwindigkeiten und entsprechende Rotationsänderung berechnen können. Um dies möglichst einfach berechnen zu können verwendet man den Gesamtimpuls der Kollision am Kollisionspunkt. Dazu werden Linear- und Winkelgeschwindigkeiten an diesem Punkt, die Trägheiten der Körper (massenabhängig), die Reibung und die Elastizität (nicht sichtbar) der Körper berechnet. Die Geschwindigkeiten werden in Normalen- und Tangenanteil aufgeteilt und zusammen mit den neuen Winkelgeschwindigkeiten den Körpern zugewiesen.

Für exakte Beschreibungen gibt es [http://chrishecker.com/Rigid_Body_Dynamics#articles hier] eine Sammlung Dokumenten. Diese wurde auch als Basis für die Implementierung des lyneth Physics API benutzt.

= Verfügbare Physics-Engines =

== [http://box2dflash.sourceforge.net/ Box2D] ==

Die Box2D-Engine basiert auf der gleichnamigen C++-Engine von Erin Catto. Die Engine ist plattformunabhängig, wurde bereits für den Nintendo DS und das iPhone eingesetzt und wird in vielen aktuellen PC-Spielen verwendet. Box2D ist mit Abstand die performanteste und umfangreichste Physics-Engine für AS3. Die einzige Kritik gilt dem Aufbau der API, diese wird manchmal als unhandlich und/oder unverständlich bezeichnet, hauptsächlich weil die AS3-Version ein direkter Port der C++-Version ist und somit für viele Actionscript-Entwickler nicht intuitiv genug ist.

== [http://lab.polygonal.de/2007/12/31/motor-physics-released/ Motor Physics] ==

Motor Physics ist im Inneren Box2D sehr ähnlich, da der Entwickler sich stark an den Algorithmen und Vorgehensweise von Erin Catto orientiert hat. Die Engine soll in gewissen Bereichen eine bessere Performance bieten als Box2D, jedoch gibt es bisher keine direkten Vergleiche oder Benchmarks. Außerdem bietet Motor Physics nicht den vollen Funktionsumfang von Box2D. Der Aufbau der API unterscheidet sich jedoch etwas, da die Engine von Anfang auf AS3 ausgelegt war.

== [http://www.fisixengine.com/ Fisix Engine] ==

Die Fisix Engine ist eine der älteren Physics-Engines. Anfangs wirkte sie sehr vielsprechend, liegt jedoch inzwischen in Sachen Performance und Möglichkeiten hinter Box2D und Motor. Ein nennenswertes Feature ist Gravitation von Körpern. Das größte Problem ist allerdings, dass die Engine nur frei ist für nichtkommerzielle Zwecke. Alle anderen Engines sind komplett Open-Source.

== [http://cove.org/ape/ APE - Another Physics Engine] ==

Die APE ist eine Weiterentwicklung der AS2-Physics-Engine [http://www.cove.org/flade/ Flade]. Ein zentrales Argument für diese Engine, ist die oft genannte einfache und intuitive Struktur der API, was dadurch begründet sein kann, dass die Engine bereits seit 2005 entwickelt wurde und von Beginn an für Actionscript ausgelegt war. Im Gegensatz zu den oben genannten Engines besitzt sie jedoch einen sehr eingeschränkten Funktionsumfang.

== [http://lab.andre-michelle.com/physics-engine aM Physics Engine] ==

André Michelle, bekannter Actionscript-Entwickler und Sprecher auf vielen Flash-Konferenzen, stellt eine einfache Physics-Engine zur Verfügung. Diese ist jedoch nicht für die Produktion von Applikationen sondern für das Ausprobieren von Physics geeignet.

== [http://code.google.com/p/foam-as3/ FOAM] ==

<blockquote>It is meant as an architectural and mathematical reference for developers interested in physics simulation in the area of game development or otherwise. It trades efficiency for modularity and extensibility.<cite>(Quelle:[http://code.google.com/p/foam-as3/])</cite></blockquote>

Die FOAM-Engine ist ebenfalls nicht für den Produktionsbetrieb geeignet, zeigt jedoch eindrucksvoll und verständlich wie Algorithmen für eine Physics-Engine implementiert werden müssen.

== [http://alex-lawrence.com/work/lyneth/current-status lyneth] ==

lyneth ist eine Physics-Engine von Alexander Lawrence. Der Fokus dieser Engine liegt auf der Verständlichkeit der API und der Anbindung an Flash-Applikationen. Die Performance ist jedoch in keiner Weise vergleichbar mit der von Box2D oder Motor Physics. Die lyneth-Engine ist nicht für den Produktionsbetrieb geeignet und momentan nicht frei verfügbar. Der Kern der Engine wird unter einer Open-Source Lizenz veröffentlicht.

[[Kategorie:Spielephysik]]
[[Kategorie:Flex]]
[[Kategorie:Flash]]
[[Kategorie:Flash-HowTo]]

AS3-Tutorium:Physics:Vertiefung

2009-07-11T08:08:58Z

Jakobw: /* Überblick */

= Überblick =

Dieser Artikel erklärt den Aufbau und die Funktionsweise einer vollwertigen Physics-Engine und stellt außerdem die wichtigsten Physics-Engines vor. Im Detail werden die Vorgehensweisen und Algorithmen erklärt, welche in der lyneth Physics API verwendet werden. Diese Sammlung stellt nur eine begrenzte Zahl der Möglichkeiten dar, welche im Bereich der Physics zum Einsatz kommen. Für den 3D-Raum werden einige Sachverhalte komplizierter, deshalb beschränkt sich die Beschreibung auf den 2D-Raum. [[AS3-Tutorium:Physics:3D-Physics-Engines]]

= Komponenten einer Physics-Engine =

== Mathematische Objekte ==

Die wichtigste Grundlage für alle physikalischen Simulationen sind mathematische Hilfsklassen. Diese werden nicht zwingend für die Realisierung eine Physics-Engine benötigt, sind aber aufgrund der Vereinfachung der Sachverhalte unverzichtbar.

=== [http://de.wikipedia.org/wiki/Vektor Vektor] ===

Ein zweidimensionaler Vektor besteht aus einer x- und einer y-Komponente. Dieser hat immer eine Länge und eine Richtung. Benutzt man einen Vektor für eine Position, so versteht man den Vektor als Abstand und Richtung der Position vom Ursprung aus. Vektoren werden für folgende Sachverhalte verwendet:
* Position
* Geschwindigkeit
* Beschleunigung
* Kollisionsnormale
* Kollisionstangente
* Koordinatensysteme (ein Paar von Vektoren)

Wichtig ist also alle relevanten mathematischen Funktionalitäten für Vektoren zu implementieren. Dazu gehören:
* Addition, Subtraktion, Multiplikation, Division
* Längenbestimmung
* Normierung (den Vektor auf Länge 1 skalierung)
* Normalenberechnung (einen Vektor berechnen, welcher senkrecht auf dem Ursprungsvektor steht)
* Skalarprodukt von zwei Vektoren
* Kreuzprodukt von zwei Vektoren (in 2D-Raum ein Skalar)

=== Projektion ===

Für 2D-Physics-Engines sind lediglich 1D-Projektionen relevant. Hierzu wird ein Projektionsvektor (Vektor mit der Länge 1) und mindestens ein zu projizierender Vektor benötigt. Die Projektion wird berechnet, indem man das Skalarprodukt für alle gewünschten Vektoren mit dem Projektionsvektor berechnet. Es entsteht ein Intervall, welches in Kombination mit dem Projektsvektor die Projektion innerhalb des ursprünglichen Koordinatensystems beschreibt. Projektionen werden benötigt für:
* Berechnung der Tiefe einer Kollision (Minimum Translation Distance)
* Berechnung der Normalen- und Tangenanteile von Geschwindigkeiten
* Bestimmung von Überschneidung von polygonalen Formen

== Geometrische Objekte ==

Geometrische Objekte sind relevant für die Beschreibung der Formen von physikalischen Objekten. Die Geometrie wird strikt von der Dynamik getrennt, um beide Bereiche unabhängig voneinander zu halten.

=== Abstrakte Form ===

Eine Form besitzt immer eine globale Position und Rotation (unter Umständen auch eine lokale Position und Rotation).

=== Kreis ===

Der Kreis ist die einfachste geometrische Form, er wird durch die Attribute einer Form und einen Radius beschrieben.

=== (Konvexes) Polygon ===

Ein Polygon erweitert eine abstrakte Form um eine feste Anzahl von Eckpunkten. Für die meisten Algorithmen der Kollisionserkennung werden konvexe Polygone benötigt. Konkave Polygone setzen sich aus der Kombination von mehreren konvexen Polygonen zusammen. Um Berechnungen sparen zu können werden die Normalen der Seiten eines Polygons und die Projektionen entlang der eigenen Normalen zwischengespeichert.

== Dynamik ==

<blockquote>Die Dynamik (gr. dynamis Kraft) ist das Teilgebiet der Mechanik, das sich mit der Wirkung von Kräften befasst. [..] Hier wird unter Dynamik die Beschreibung der Bewegung von Körpern unter Einfluss von Kräften verstanden, im allgemeineren Sinn auch das Zeitverhalten eines Systems und die zu seiner Beschreibung verwendeten Bewegungsgleichungen.<cite>(Quelle: Wikipedia)</cite></blockquote>

=== Zustand ===

Ein Zustand zu einem bestimmten Zeitpunkt t setzt sich zusammen aus Position, Geschwindigkeit und Beschleunigung. Jedes dieser Attribute wird durch einen 2D-Vektor kombiniert mit einem Wert für die Rotation realisiert (für Rotation, Winkelgeschwindigkeit und Winkelbeschleunigung).

=== Körper ===

Jeder Sammlung von geometrischenen Form wird ein Zustand zugeordnet. Die Kombination von geometrischen Formen und Zuständen ergibt einen Körper.

=== Kräfte ===

Kräfte sind im Normalfall Dynamik-Objekte ohne geometrische Form. Für den Zustand ist in den meisten Fällen allein eine Position ausreichend. Zusätzlich besitzt eine Kraft einen Kraftvektor und einen Wirkungsbereich (oft durch einen Radius realisiert). Wie die Kraft letzendlich auf Körper angewendet wird, hängt von der Art der Kraft ab. Die Hook´sche Feder (siehe letzter Vortrag) kann ebenfalls als Kraft realisiert werden, welche allerdings nur auf zwei Körper wirkt und allein diese beeinflusst.

Beispiele:
* [[Medium:TutoriumPhysics-2-01-Formen.swf]]
* [[Medium:TutoriumPhysics-2-02-Kräfte.swf]]
* [[Medium:TutoriumPhysics-2-03-Kräfte.swf]]
* [[Medium:TutoriumPhysics-2-04-Kräfte.swf]]

== Integration ==

Die Integration beschreibt numerische Lösungsverfahren für Differentialgleichungen. Die Zustandsänderungen der Dynamik eines Körpers werden mithilfe dieser Algorithmen berechnet (Kräfte, Beschleunigungen, Geschwindigkeiten, Orte). Es gibt viele verschiedene Algorithmen, welche sich in Effizienz und Exaktheit unterscheiden. Wichtige Links zu diesem Thema sind:
* [http://de.wikipedia.org/w/index.php?title=Datei:RK_Verfahren.png&filetimestamp=20090121000101]
* [http://gafferongames.com/game-physics/integration-basics/]
* [http://lab.generalrelativity.org/foam/demos/orbit/]

=== [http://en.wikipedia.org/wiki/Euler%27s_method Euler] ===

Das Verfahren nach Euler ist die einfachste Form der Integration. Hierbei wird abhängig von der vergangenen Zeit (im Normalfall ein festes Zeitintervall) die Beschleunigung auf die Geschwindigkeit und die Geschwindigkeit auf die Position addiert. Die Beschleunigung setzt sich aus der Summe der wirkenden Kräfte zusammen. In einfachen Fällen wird die Beschleunigung einfach manuell gesetzt.

a1 = f / m
v1 = v0 + a1 * t
x1 = x0 + v1 * t

Liegt etwas anderes als eine konstante Geschwindigkeit und keine Beschleunigung vor, so erzeugt dieses Verfahren sehr große Berechnungsfehler. Das Euler-Verfahren kommt jedoch sehr häufig zum Einsatz, vor allem auch in AS3-Physics-Engines, da es einfachste und performanteste Verfahren darstellt. Die Berechnungsfehler sind zu vernachlässigen, da die Ergebnisse meistens trotzdem realistisch wirken.

=== [http://de.wikipedia.org/wiki/Klassisches_Runge-Kutta-Verfahren Runge-Kutta] ===

Das Runge-Kutta-Verfahren ist dem Taylor-Polynom sehr ähnlich. In Physics wird meistens das Verfahren in der viersten Ordnung verwendet (man spricht daher von RK4). Dieses Verfahren zur Integration ist das mit dem geringsten Fehler aber auch dem höchsten Rechenaufwand. Hierbei wird pro Zeitintervall nicht nur der neue Wert berechnet, sondern auch zwei weitere Zwischenwerte, außerdem wird der alte Wert mit in Betracht gezogen. Diese werden dann gewichtet miteinander verrechnet.

<blockquote>Die dabei bei nichtlinearen Funktionen notwendigerweise auftretenden Fehler (es werden sämtliche höheren Glieder der Taylor-Entwicklung vernachlässigt) können durch geeignete Kombinationen verschiedener Differenzquotienten teilweise kompensiert werden. Das Runge-Kutta-Verfahren ist nun eine solche Kombination, die Diskretisierungsfehler bis zur dritten Ableitung kompensiert.<cite>(Quelle:Wikipedia)</cite></blockquote>

[http://de.wikipedia.org/wiki/Klassisches_Runge-Kutta-Verfahren Formel bei Wikipedia]

=== [http://en.wikipedia.org/wiki/Midpoint_method Midpoint] ===

Das sogenannte Midpoint-Verfahren wird in den meisten als RK2, also als Runge-Kutta-Verfahren der 2. Ordnung implementiert. Dementsprechend ist der Rechenaufwand etwas höher als bei Euler, das Ergebnis allerdings nicht so genau wie RK4. Der Algorithmus wird nicht häufig in Physics-Engines eingesetzt.

=== [http://en.wikipedia.org/wiki/Verlet_integration Verlet] ===

Der Verlet-Algorithmus verspricht eine größere Stabilität und einen geringeren Fehler als bei Euler. Dazu wird nicht mit Variablen für Geschwindigkeiten gerechnet, sondern werden diese Werte aus der aktuellen Position und der vorgehenden berechnet. Das Verfahren ist allerdings nicht sehr weit verbreitet, da die Implementierung oftmals Änderungen an der Architektur von Engines voraussetzt.

== Kollisionen ==

Im Folgenden werden die beiden gängigsten Verfahren für die Kollisionserkennung und -auflösung erklärt.

=== Kollisionserkennung ===

Wie bereits in der Einführung vorgestellt reicht der Satz von Pythagoras und ein simpler Wertevergleich aus um die Kollision zwischen zwei Kreisen zu bestimmen. Für Rechtecke mit Seiten parallel zu den Achsen des Koordinationssystems auf Kollision zu testen reicht ebenfalls ein Wertevergleich aus. Diese Verfahren funktionieren nicht bei Polygonen, jedoch benutzt man sie gerne um erstmalig festzustellen ob Polygone potentiell überhaupt kollidieren können. Dazu wird jedem Polygon ein Bounding Circle (Umkreis) oder eine Bounding Box (umschließendes Rechteck) zugewiesen. Somit muß nicht für jedes Polygonenpaar eine aufwändige Kollisionerkennung durchgeführt werden.

Das einfachste Verfahren ist die Anwendung des [http://en.wikipedia.org/wiki/Separating_hyperplane_theorem Trennungssatzes] (englisch: Seperating Axis Theorem oder SAT). Dabei wird jede Normale (Vektor senkrecht zur Seite eines Polygons) als Projektionsachse für beide Polygone benutzt. Sobald eine dieser Projektionen zu keiner Überlappung der beiden Intervalle führt, liegt keine Kollision vor. Gibt es allerdings auf jeder Achse eine Überlappung der Intervalle, so liegt eine Kollision vor. Die Kollisionnormale ist der Vektor bei welchen die Überlappung der Projektionsintervalle minimal ist. Der Betrag dieser Überlappung beschreibt die Tiefe der Kollision. Der Teil mit dem größten Aufwand ist die Berechung der Kollisionspunkte. Hierbei muß nach den Fällen Punkt-Flächen- und Flächen-Flächen-Kollisionen unterschieden werden (Punkt-Punkt-Kollision wird ignoriert).

Das SAT-Verfahren arbeitet nach dem Ausschlussprinzip, d.h. es arbeitet sehr schnell wenn wenig Kollisionen vorliegen. Bei vielen Kollisionen arbeitet das Verfahren aber umso langsamer, da es immer alle Normalen aller Polygone testen muß. Abgesehen von der Performance, erzeugt das Verfahren gerine Fehler und funktioniert stabil.

=== Kollisionsauflösung ===

Ebenso wie bei der Kollisionserkennung gibt es verschiedene Algorithmen um die Kollisionen zu lösen. Bei den meisten Systemen und den angeführten Verfahren werden Kollisionen erst erkannt und aufgelöst wenn sie bereits geschehen sind. Deshalb ist es wichtig die miteinander kollidierenden Objekte erst wieder so weit voneinander zu entfernen, bis sie sich nicht mehr überschneiden. Kollisionsauflösungen dieser Art werden als "penalty based" bezeichnet. Wie bereits im vorherigen Vortrag erwähnt, wird dazu die Minimum Translation Distance (MTD) kombiniert mit der Kollisionsnormale benötigt. Die Objekte werden abhängig von ihrer Masse voneinander entfernt.

Nun kommt es zu eigentlichen Reaktion auf die Kollision. Wie bei einer Kollision von Kreisen kann man das Prinzip des zentralen, unelastischen Stoßes implementieren, allerdings wird man bei diesem Verfahren keine Winkelgeschwindigkeiten und entsprechende Rotationsänderung berechnen können. Um dies möglichst einfach berechnen zu können verwendet man den Gesamtimpuls der Kollision am Kollisionspunkt. Dazu werden Linear- und Winkelgeschwindigkeiten an diesem Punkt, die Trägheiten der Körper (massenabhängig), die Reibung und die Elastizität (nicht sichtbar) der Körper berechnet. Die Geschwindigkeiten werden in Normalen- und Tangenanteil aufgeteilt und zusammen mit den neuen Winkelgeschwindigkeiten den Körpern zugewiesen.

Für exakte Beschreibungen gibt es [http://chrishecker.com/Rigid_Body_Dynamics#articles hier] eine Sammlung Dokumenten. Diese wurde auch als Basis für die Implementierung des lyneth Physics API benutzt.

= Verfügbare Physics-Engines =

== [http://box2dflash.sourceforge.net/ Box2D] ==

Die Box2D-Engine basiert auf der gleichnamigen C++-Engine von Erin Catto. Die Engine ist plattformunabhängig, wurde bereits für den Nintendo DS und das iPhone eingesetzt und wird in vielen aktuellen PC-Spielen verwendet. Box2D ist mit Abstand die performanteste und umfangreichste Physics-Engine für AS3. Die einzige Kritik gilt dem Aufbau der API, diese wird manchmal als unhandlich und/oder unverständlich bezeichnet, hauptsächlich weil die AS3-Version ein direkter Port der C++-Version ist und somit für viele Actionscript-Entwickler nicht intuitiv genug ist.

== [http://lab.polygonal.de/2007/12/31/motor-physics-released/ Motor Physics] ==

Motor Physics ist im Inneren Box2D sehr ähnlich, da der Entwickler sich stark an den Algorithmen und Vorgehensweise von Erin Catto orientiert hat. Die Engine soll in gewissen Bereichen eine bessere Performance bieten als Box2D, jedoch gibt es bisher keine direkten Vergleiche oder Benchmarks. Außerdem bietet Motor Physics nicht den vollen Funktionsumfang von Box2D. Der Aufbau der API unterscheidet sich jedoch etwas, da die Engine von Anfang auf AS3 ausgelegt war.

== [http://www.fisixengine.com/ Fisix Engine] ==

Die Fisix Engine ist eine der älteren Physics-Engines. Anfangs wirkte sie sehr vielsprechend, liegt jedoch inzwischen in Sachen Performance und Möglichkeiten hinter Box2D und Motor. Ein nennenswertes Feature ist Gravitation von Körpern. Das größte Problem ist allerdings, dass die Engine nur frei ist für nichtkommerzielle Zwecke. Alle anderen Engines sind komplett Open-Source.

== [http://cove.org/ape/ APE - Another Physics Engine] ==

Die APE ist eine Weiterentwicklung der AS2-Physics-Engine [http://www.cove.org/flade/ Flade]. Ein zentrales Argument für diese Engine, ist die oft genannte einfache und intuitive Struktur der API, was dadurch begründet sein kann, dass die Engine bereits seit 2005 entwickelt wurde und von Beginn an für Actionscript ausgelegt war. Im Gegensatz zu den oben genannten Engines besitzt sie jedoch einen sehr eingeschränkten Funktionsumfang.

== [http://lab.andre-michelle.com/physics-engine aM Physics Engine] ==

André Michelle, bekannter Actionscript-Entwickler und Sprecher auf vielen Flash-Konferenzen, stellt eine einfache Physics-Engine zur Verfügung. Diese ist jedoch nicht für die Produktion von Applikationen sondern für das Ausprobieren von Physics geeignet.

== [http://code.google.com/p/foam-as3/ FOAM] ==

<blockquote>It is meant as an architectural and mathematical reference for developers interested in physics simulation in the area of game development or otherwise. It trades efficiency for modularity and extensibility.<cite>(Quelle:[http://code.google.com/p/foam-as3/])</cite></blockquote>

Die FOAM-Engine ist ebenfalls nicht für den Produktionsbetrieb geeignet, zeigt jedoch eindrucksvoll und verständlich wie Algorithmen für eine Physics-Engine implementiert werden müssen.

== [http://alex-lawrence.com/work/lyneth/current-status lyneth] ==

lyneth ist eine Physics-Engine von Alexander Lawrence. Der Fokus dieser Engine liegt auf der Verständlichkeit der API und der Anbindung an Flash-Applikationen. Die Performance ist jedoch in keiner Weise vergleichbar mit der von Box2D oder Motor Physics. Die lyneth-Engine ist nicht für den Produktionsbetrieb geeignet und momentan nicht frei verfügbar. Der Kern der Engine wird unter einer Open-Source Lizenz veröffentlicht.

[[Kategorie:Spielephysik]]
[[Kategorie:Flex]]
[[Kategorie:Flash]]
[[Kategorie:Flash-HowTo]]