Benjamin Herrmann computer graphics & visualization Physics Based Simulation on GPUs

computer graphics & visualization Benjamin Herrmann Technologie MemoryObjects (OpenGL): - Textur - Render Target - Vertex Array Verwendungsunabhängiger Speicherblock auf Graphikkarte Verwendungsunabhängiger Speicherblock auf Graphikkarte Hauptprogrammlogik in Fragment-Programm Hauptprogrammlogik in Fragment-Programm Simulation (praktisch) ohne Datentransfer CPU GPU

computer graphics & visualization Benjamin Herrmann Körperdarstellung - Körper als Massenpunkte (Partikel) mit Distanz- Bedingung zwischen je zwei Partikeln - Entspricht ungerichtetem Graphen mit Knoten- und Kantenbelegung

computer graphics & visualization Benjamin Herrmann Partikel-System - Hier besteht ein Partikel-System aus - Partikeln mit den Attributen: -Masse (tatsächlich wird deren Reziprokes gespeichert) -Position (3 Freiheitsgrade pro Partikel) -Alte Position (für Verlet Integrations Schema) -Beschleunigung (ergibt sich als Summe aller externen Kräfte auf den Partikel unter Berücksichtigung seiner Masse) -Normalen Vektor (3 Komponenten, zum Rendern und für einige Collision Responses) - Constraints mit den Attributen: -Index des Start Partikels -Index des End Partikels -(Anfangs-) Länge

computer graphics & visualization Benjamin Herrmann Inhalt Grobe Gliederung (Komponenten): - Verlet Integration - Constraint Solver - Collision-Detection und Collision-Response

computer graphics & visualization Benjamin Herrmann Verlet Integration - Unabhängig für jeden Partikel (unconstrained dynamics) - Speichere zum Zeitpunkt t pro Partikel: x(t) und x(t-t) - Nur implizite Geschwindigkeit (vgl. Euler: Geschwindigkeit und Position separat aktualisiert) - Damit Geschwindigkeit immer an tatsächliche Bewegung angepasst

computer graphics & visualization Benjamin Herrmann Intuitiv: Fehlerentwicklung (für x 1,x 2 und x 3, x 0 =0) Verlet Integration

computer graphics & visualization Benjamin Herrmann Verlet Integration Korrekt: Fehlerentwicklung (für x 1,x 2 und x 3, x 0 =0)

computer graphics & visualization Benjamin Herrmann Verlet Integration - Implementierung

computer graphics & visualization Benjamin Herrmann Verlet Integration - Implementierung - Benötige MemoryObjects für folgende Partikelattribute: - Aktuelle Positionen aller Partikel - Alte Positionen aller Partikel - Beschleunigungen aller Partikel - Massen aller Partikel (kann in beliebiger der obigen Texturen gespeichert werden) - Zusätzliches MemoryObject für Ping-Pong - Zeigervertauschung, um die Partikelattribute für den nächsten Simulationsschritt zu aktualisieren: - Aktuelle Positionen Alte Positionen - Aktuelle Positionen Ergebnis der Integration

computer graphics & visualization Benjamin Herrmann Verlet Integration - WorldBox (AA): w min =(w x,w y,w z ), w max =(W x,W y,W z ) => Projektion: min( max(w min,x(t)), w max ) - Reibung: - Projektionstiefe berücksichtigen - Faktor d um Luftwiederstand zu simulieren - Demo 1

computer graphics & visualization Benjamin Herrmann Constraints - Hinzufügen topologischer Informationen, um Festkörper zu simulieren => Distanz-Bedingungen zwischen je 2 Partikeln - Lokale Lösung: Massen abhängig (x j analog):

computer graphics & visualization Benjamin Herrmann Constraints - Globale Lösung für Distanz-Bedingungen durch: - Auflösen der lokalen Distanz-Bedingungen in fester Reihenfolge (berücksichtigt aktuelle Positionen) => Es können nur unabhängige Constraints parallel verarbeitet werden (Matching): mindestens h interne Render Passes, wobei h der maximale Knotengrad ist.

computer graphics & visualization Benjamin Herrmann Constraints - Paralleles Lösen aller lokalen Distanz-Bedingungen, indem für jeden Constraint c ij der Ausgleichsvektor ermittelt wird. Aufsummieren und Mitteln (Stabilität) aller d ij für die an einen Partikel angrenzende Kanten ergibt den nötigen Offset pro Partikel (vgl. Feder-Masse System) => Durchhängen im Gleichgewichtszustand:

computer graphics & visualization Benjamin Herrmann Constraints - Datenstrukturen zur Speicherung der Topologie - Knotenbasiert: h Nachbarschafts-Texturen N k (1kh). Sei (s i,t i ) die Textur Koordinate für Partikel i, dann speichert N k in Texel (s i,t i ) das Tupel (s j,t j,l ij ), falls Partikel j der k-te Nachbar von Partikel i ist. - Kantenbasiert: -Kantentextur, die für Kante c ij das Tupel (s i,t i,s j,t j ) speichert. -Textur, die die Länge aller Kanten speichert. - Nachfolgend implementiert und besprochen: - Knotenbasiert: unter Berücksichtigung der aktuellen Position - Paralleles Auflösen der Constraints: -Kantenbasiertes Gathering -Kantenbasiertes Scattering

computer graphics & visualization Benjamin Herrmann Constraints – Knotenbasiert - Mit aktualisierten Positionen nur mit h internen Rendering Passes möglich! - Pro Pass müssen genau wh Fragmente generiert werden, wobei w,h die Breite und Höhe der Partikel-Texturen sind. - Pro Pass k und pro Partikel i: - 1 direkter Texture-fetch für die eigene Position - 1 dependant Texture-fetch für die Position des k-ten Nachbarn (aus N k ) - Berechnung der aktuellen Position von Partikel i -(1kh): N k besteht nur aus vollständigen Kanten eines Matchings. - Zwischen zwei Rendering Passes: Ping-Pong, damit immer die aktualisierten Positionen benutzt werden. - d ij wird pro Kante zweimal berechnet => Kantenbasiert

computer graphics & visualization Benjamin Herrmann Constraints – Kantenbasiert (Gathering) - 1. Rendering Pass rendert ein Fragment pro Kante c ij und berechnet aus zwei dependant texture- fetches den Vektor d ij. => Offset Textur - 2. Rendering Pass rendert ein Fragment pro Partikel. Für alle Partikel i: - Summiere die maximal h Offsetvektoren zu den zu i inzidenten Kanten. Dazu sind h Inzidenz-Texturen notwendig (vgl. Nachbarschafts-Texturen) sowie h dependant texture-fetches. - Teile den Gesamt-Offsetvektor durch den Grad des Partikels (entweder immer h oder mit in Inzidenz-Texturen speichern).

computer graphics & visualization Benjamin Herrmann Constraints – Kantenbasiert (Scattering) - 1. Rendering Pass wie vorher => Offset-Textur - 2. Rendering Pass benutzt Kantentextur als VertexArray und das Positions MemoryObject als Render Target. Clip Space Koordinaten entsprechend dem Start- Knoten einer Kante generiert Rendering Pass: wie 2. Pass aber mit End- Knoten. Anmerkung: Clamping => Rendering Passes 2pos/2neg und- 3pos/3neg, welche positive/negative Komponenten der Offset Vektoren in seperate Texturen blenden.

computer graphics & visualization Benjamin Herrmann Constraint - Demos - Demo2:ebenso wie Demo1 nur diesmal mit eingeschaltetem Constraint Solver - Demo3: Knotenbasiert - Demo4: Kantenbasiert – Gathering - Demo5: Scattering - Scattering

computer graphics & visualization Benjamin Herrmann Collision Detection - Partikelbasierte Kollisionserkennung => O(n²) Vergleiche - Binning der AABB des Partikelsystems - Reduziert die Anzahl der notwendigen Partikelvergleiche - Ggf. Jittering - Größe der Bins

computer graphics & visualization Benjamin Herrmann Collision Detection - AABB - Berechnung der AABB (B min /B max ) auf GPU: - 2 Rendering Passes je aller Partikelpositionen auf ein einzelnes Fragment mit blenden (Komponentenweise min bzw. max) - 2ln(max(w,h)) Rendering Passes über je (1/4) k wh (k=1,...) Partikel:

computer graphics & visualization Benjamin Herrmann Collision Detection – Implementierung 1.Rendering Pass: Ordne jedem Partikel eine BinID zu =>Zuordnungs- MemoryObject. Texel ist Tupel (s i,t i,id) 2.Rendering Pass: - Benutze Zuordnungs-MemoryObject als VertexArray - Dereferenziere VertexArry als GL_POINTS. - Rendere in Bin MemoryObject (Einsortieren der Partikel). 3.Rendering Pass: Benutze Bin MemoryObject und Zuordnungs MemoryObject als Textur und rendere über alle Partikel => Kontrolliere für jeden Partikel, ob zugeordneter Bin bereits belegt ist.

computer graphics & visualization Benjamin Herrmann Collision Detection – Implementierung 1.Rendering Pass: Ordne jedem Partikel eine BinID zu =>Zuordnungs- MemoryObject. Texel ist Tupel (s i,t i,id) 2.Rendering Pass: - Benutze Zuordnungs-MemoryObject als VertexArray - Dereferenziere VertexArry als GL_POINTS. - Rendere in Bin MemoryObject (Einsortieren der Partikel). 3.Rendering Pass: Benutze Bin MemoryObject und Zuordnungs MemoryObject als Textur und rendere über alle Partikel => Kontrolliere für jeden Partikel, ob zugeordneter Bin bereits belegt ist.

computer graphics & visualization Benjamin Herrmann Collision Detection – Boolean Binning - Bin MemoryObject hat GL_RGBA8 Format - Jede 8-bit Komponente repräsentiert einen Bin (Maske) und speichert die Anzahl der Partikel darin. - Alles größer 1 zählt als Kollision - Rendern in Bin MemoryObject durch normales Blending - Platzverbrauch ideal, aber kleine Bins nötig - Nur Kollision Ja/Nein, keine Information über Kollisions-Partner

computer graphics & visualization Benjamin Herrmann Collision Detection – Stencil Routing - Implementiert für maximal 4 Partikel pro Bin (beliebig auf x² Partikel erweiterbar) - Bin MemoryObject benutzt Fließkomma-Genauigkeit - Je 4 Texel entsprechen einem Bin - Statt einzelner Fragmente werden Fat Points gerendert (hier: glPointSize(2.0f)) - StencilBuffer vor Pass 2 (Einsortieren) vorbelegt mit Muster: -Stencil-Test testet auf Gleichheit mit 3 - Stencil-Wert immer um 1 erhöht

computer graphics & visualization Benjamin Herrmann Collision Detection – Stencil Routing - Beispielablauf (Fragmentreihenfolge a priori unbekannt): - Speichert Textur-Koordinaten der bis zu 4 Partikel pro Bin => beliebige Attribute des Kollisions Partners zugreifbar - 16 Mal größeres Bin MemoryObject als bei Boolean Binning (sogar 64 Mal so viel Speicher)

computer graphics & visualization Benjamin Herrmann Collision Detection – Stencil Routing - Partikel i kollidiert mit Partikel j, falls: - Textur-Koordinaten von beiden befinden sich im gleichen Bin - Ihr Abstand ist geringer als eine vorgegebene Grenze (wichtig, wenn mehrere Bins auf den gleichen Fat-Point gerendert werden) - Komplexere Kollisions-Bestimmung => Stencil Routing ist langsamer als Boolean Binning - Aber komplexere Collision-Responses möglich, die Attribute des Kollisions-Partners einbeziehen. Zum Beispiel:- Position - (implizite) Geschwindigkeit

computer graphics & visualization Benjamin Herrmann Collision Detection – Demos - Demo 6:Self-Collision bei Cloth (Nur Kollision- erkennung, keine Response) - Demo 7:Self-Collision bei Cloth (Collision- Response stößt Partikel ab) - Demo 8:Self-Collision bei Cloth (Collision- Response ändert relative Geschwindigkeit) - Demo 9:Kollision vieler Objekte (Collision- Response ändert Partikelpositionen) - Demo 10:Kollision vieler Objekte (s.o., aber anderer Kollisionsabstand) - Demo 11: Massenabhängigkeit (schwere Würfel) - Demo 12: Massenabhängigkeit (leichte Würfel)

computer graphics & visualization Benjamin Herrmann Bemerkungen - Normalenberechnung - Wind: Skalarprodukt des (unnormalisierten) Wind- Vektors mit dem (unnormalisierten) Normalenvektor jedes Dreiecks. - Performance - Ping Pong vs. Unroll - Taylorapproximation der Wurzelfunktion bei Constraint Solvern - Index MemoryObject vs. system memory Index Array - Vertex Programm Bandbreite reduzieren: Bilineare Interpolations Textur (Geschwindigkeitsgewinn durch geringere Auflösung wg. größerer Lokalität -> Caching) - GPU basiertes Picking

computer graphics & visualization Benjamin Herrmann Letzte Demos - Demo 13:Fahne (Wind und Picking) - Demo 14:Performance Layout

computer graphics & visualization Benjamin Herrmann 128x128 GPU 128x128 CPU 256x256 GPU 256x256 CPU 512x512 GPU 512x512 CPU Scattering0.4fps----- Gathering186fps48.45fps58fps12.43fps16.45fps0.15fps Knoten282fps76fps108fps fps0.18fps +AABB212fps74fps84fps fps0.17fps +BB174fps32fps62fps7.52fps15.5fps- +SR116fps32Fps40.7fps7.52fps9.69fps- Performance Alle Tests ohne Rendern und auf - Pentium 3.2 GHz mit 1.5 GB RAM - ATI X600 mit 256 MB TRAM

computer graphics & visualization Benjamin Herrmann Zusammenfassung +Weit schneller als die CPU-Implementierung der Algorithmen +Graphik Hardware Entwicklung verdreifacht Moores Law –Algorithmen stark vereinfacht –Partikelsystem, das unabhängig aktualisiert werden kann ist sehr gut auf GPU zugeschnitten, ebenso sind komplexere Algorithmen mit zugeschnittenen Datenstrukturen denkbar bei denen eine CPU Lösung (noch) besser abschneidet => In Anbetracht der Entwicklung sind GPU basierte Simulationen allerdings sehr interessant

computer graphics & visualization Benjamin Herrmann Danke für die Aufmerksamkeit! Fragen?