Fluid Simulation [KSR Wiki]

Diese Seite ist nicht editierbar. Du kannst den Quelltext sehen, jedoch nicht verändern. Kontaktiere den Administrator, wenn du glaubst, dass hier ein Fehler vorliegt.
====== Fluid Simulation ======

**Umgang mit AI:**

   * Der **Weg ist das Ziel**!
   * Challenge:
     * Verwende keine AI für die Logik.
     * Lasse dir von AI keinen Code schreiben.
     * Verwende AI höchstens als Tutor, um dir Dinge zu erklären.

===== - Fluid aus Teilchen (A) =====

Als Vorbereitung versuchen wir zuerst, ein 2D-Fluid aus vielen Teilchen zu simulieren, die sich gegenseitig stossen. Die Grundidee hinter diesem - physikalisch nicht sehr realistischen - Fluid ist wie folgt:

   1. **Spawning:** Erzeuge eine möglichst grosse Anzahl an Teilchen, alle mit identischem Radius und Masse. Visualisiert werden sie als kleine, einfarbige Kreise. Spawne diese z.B. an Zufallspositionen mit zufälligem Anfangsgeschwindigkeitsvektor.
   1. **Collision Detection:** Ermittle, welche Teilchen mit den Wänden und v.a. miteinander kollidieren, also aktuell überlappen. Für diesen Schritt werden wir verschiedene Möglichkeiten anschauen.
   1. **Collision Handling:** Kümmere dich um alle Teilchen, die aktuell gerade kollidieren. Zum Beispiel muss man dafür die neuen Geschwindigkeitsvektoren nach der Kollision berechnen. Für einen gewissen Realismus sollten die Teilchen bei jeder Kollision einen gewissen Anteil ihrer Energie oder Geschwindigkeit verlieren.


==== Auftrag A - Teil I ====

   1. Erstelle ein **GitHub-Repo** für alle Projekte in diesem Modul. Nenne es z.B. `FluidSimulationsUnity` und wähle die passenden Einstellungen (private, gitignore-File). Clone es auf deinen Computer. Arbeite von nun an darin. **Add, commit, push selbständig und regelmässig**.\\ \\
   1. **Installiere Unity-Hub** und darin eine aktuelle Unity-Version.\\ \\
   1. Erstelle nun ein **neues Unity Projekt** vom Typ *Core: Universal 2D* (z.B. `FluidParticles`).\\ \\
   1. Implementiere nun das **Template-Projekt** (siehe unten), welche als Ausgangslage dient. Wird das Projekt ausgeführt, sollte ein farbiges Teilchen erscheinen, welches sich nach oben bewegt. Studiere den Code genau und stelle sicher, dass du diesen verstehst.\\ \\
   1. Passe den Code nun so an, dass eine **grössere Anzahl Teilchen** (sagen wir ca. $100$) erzeugt werden. Diese sollen an Zufallspositionen gespawned werden. Dafür werden zwei Arrays benötigt: Eines für die ParticleModels und eines für die ParticleViews.\\ \\
   1. Implementiere eine **erste Dynamik:**
     1. Jedes Particle soll eine zufällige Anfangsgeschwindigkeit haben (versch. Richtungen und Speed) und sich entsprechend bewegen.
     1. An den Wänden sollen sie ohne Energieverlust reflektiert werden.
     1. Kollisionen zwischen Teilchen werden noch ignoriert, sie bewegen sich also einfach durch einander hindurch.\\ \\
   1. **Collision Detection V1: Brute Force**
     1. Implementiere nun eine erste Version - Brute Force - der Collision Detection: Iteriere über alle Teilchen. Iteriere für jedes Teilchen über alle anderen Teilchen und schaue, ob sie kollidieren. Dafür benötigst du also zwei ineinander verschachtelte Schleifen.
     1. Zwei Teilchen kollidieren dann, wenn deren Abstand kleiner ist als $2\times$ der Radius.
     1. Alle Teilchen sollen, während sie miteinander kollidieren, eine **andere Farbe** annehmen. Siehe Tipps unten.
     1. Für wie viele Teilchen kannst du deine Simulation flüssig laufen lassen? Warum geht nicht mehr? Was ist das Problem mit dieser Art von Collision Detection?\\ \\

=== Unity Tipps ===

== Template-Projekt ==

   1. **Neues 2D Unity-Projekt** vom Type *Core: Universal 2D*\\ \\
   1. Erstelle unter Assets folgende Unterordner für saubere **Struktur**: Prefabs, Scripts. Ziehe dann später alle Scripts und Prefabs in den entsprechenden Ordner.\\ \\
   1. Erstelle ein neues, leeres GameObject z.B. mit Namen `Simulation`. Hänge diesem das Script `MainScript` (siehe unten) an. Alternativ könnte man das Scipt auch der `MainCamera` anhängen.\\ \\
   1. Füge die Scripts `Particle.cs` und `ParticleView.cs` an. Die Idee ist, dass unser Code einer Trennung von Modell (`Particle`) und Anzeige (`ParticleView.cs`) folgt.\\ \\
   1. **Particle Prefab:**
      1. Erstelle in der Hierarchy eine farbige Kugel (2D Objects / Sprites / Circle), Farbe aussuchen.
      1. Gib Namen `Particle`.
      1. Hänge `ParticleView` Script an.
      1. Speichere als Prefab: Einfach aus Hierarchy in Prefab-Ordner ziehen.
      1. Lösche wieder aus Hierarchy.\\ \\
   1. Der Code sollte nun wie folgt funktionieren: Führt man den Code aus, so erschein in der Mitte des Bildschirms ein farbige Kugel, die sich nach oben bewegt.

++++Code von Template|

**MainScript:**
<code csharp>
using UnityEngine;

public class MainScript : MonoBehaviour
{
    [Header("Simulation settings")] // creates header in Unity Inspector
    public GameObject prefabParticle; // drag particle prefab on this field in Inspector
    // and all other game settings

    // PRIVARTE FIELDS
    private ParticleModel particleModel;
    private ParticleView particleView;

    void Start()
    {
        InitParticles(); // create particles
    }

    void InitParticles()
    {
        Debug.Log("Instantiate Particles");

        // Check if prefab is assigned
        if (prefabParticle == null)
        {
            Debug.LogError("prefabParticle is not assigned! Please assign a prefab in the Inspector.");
            return;
        }
        
        // CREATE A PARTICLE AND ITS VIEW

        // create model for particle
        particleModel = new ParticleModel(new Vector2(0, 0),new Vector2(0, 1),1.0f);

        // create game object for particle with prefab as image, will be added to Unity Hierarchy:
        GameObject particleGameObject = Instantiate(prefabParticle, particleModel.position, Quaternion.identity);
        
        if (particleGameObject != null) // check if instantiation successful
        {
            // Try to get ParticleView component, if not found, add it
            particleView = particleGameObject.GetComponent<ParticleView>(); // doesn't work if forgot to assign ParticleView to particle prefab
            if (particleView == null) // add particle view to script via code
            {
                particleView = particleGameObject.AddComponent<ParticleView>();
                Debug.LogWarning("ParticleView component was missing on prefab, automatically added for particle");
            }
            
            particleView.Bind(particleModel);
        }
        else
        {
            Debug.LogError("Failed to instantiate prefab for particle! Make sure prefabParticle is assigned in Inspector.");
        }
    }

    void Update()
    {
        Step(); // one simulation step
    }

    void Step()
    {
        float dt = Time.deltaTime; // ensures that velocity is independent of frame-rate
        particleModel.position += particleModel.velocity * dt; // change position according to velocity
    }
}
</code>

**ParticleModel:**
<code csharp>
using UnityEngine;

public class ParticleModel
{
    public Vector2 position;
    public Vector2 velocity;
    public float mass;

    public ParticleModel(Vector2 position, Vector2 velocity, float mass)
    {
        this.position = position;
        this.velocity = velocity;
        this.mass = mass;
    }
}
</code>

**ParticleView:**
<code csharp>
using UnityEngine;

public class ParticleView : MonoBehaviour
{
    ParticleModel particleModel;

    void Start() {}

    public void Bind(ParticleModel p)
    {
        particleModel = p;
        transform.position = particleModel.position;
    }

    void Update()
    {
        // position of view = position of model (of ParticleModel)
        if (particleModel != null)
        {
            transform.position = particleModel.position;
        }
    }
}
</code>

++++

== Farbe von Kugel ändern ==

   * Greife auf SpriteRenderer von `particleView`-Objekt zu und ändere seine Farbe:<WRAP>
<code csharp>
var spriteRenderer = particleView.GetComponent<SpriteRenderer>();
spriteRenderer.color = Color.blue;
</code></WRAP>
   * Tipp 1: Damit man nicht für jedes Frame für jede particleView den `GetComponent()`-Befehl wiederholt aufrufen muss, lohnt es sich, ein Array `particleRenderers` zu erstellen, in dem man die spriteRenderer für die entsprechenden Particles speichert. \\ \\
   * Tipp 2: Passe gegebenenfalls den Code so an, dass die Farbzuweisung `... = Color.blue` nur dann ausgeführt wird, wenn sich die Farbe des Teilchens auch *ändert*. Verwende dazu z.B. zwei Flags (bool) `wasColliding` (ob kollidierte im letzten Frame) und `isColliding`. Jetzt wird nur die Farbe neu gesetzt, falls sich der Zustand von `wasColliding` zu `isColliding` geändert hat.

== Grösse von GameObject im Code ändern ==

```
someGameObject.transform.localScale = Vector3.one * 0.1f;
```

== Zufallszahlen ==

<code csharp>
UnityEngine.Random.InitState(42); // Zufallszahlen mit Seed (immer gleicher 'Zufall')
UnityEngine.Random.Range(0,10);
</code>



==== Auftrag A - Teil II ====

Wahrscheinlich hast du gemerkt, dass die Brute Force Methode für die Particle Collision Detection nicht sehr effizient ist, da man den Abstand von jedem Teilchen zu jedem anderen Teilchen berechnet, selbst wenn diese Teilchen sehr weit auseinander liegen. Hat man beispielsweise $1000$ Teilchen, so sind für diese Methode Rechenschritte in der Grössenordnung von $1000^2 =1’000’000$ notwendig. Dies wollen wir drastisch verbessern, indem wir **Spatial Hashing** für die Collision Detection verwenden. Auf dem MacBook eures Lehrers läuft die Simulation mit $5000$ Teilchens wie folgt:

   * Brute Force: $4-5$ FPS
   * Spatial Hashing: knapp $60$ FPS

Implementiere nun **Spatial Hashing**, um die Collision Detection zu optimieren:

   1. Der Bildschirm wird gleichmässig **unterteilt in Zellen**. Als Zellenbreite eignet sich der Teilchenradius.
   1. Jeder Zelle wird ein (möglichst) **eindeutiger Hash** (key) zugewiesen.
   1. Es wird ein **Dictionary** angelegt. Die Hashes dienen als key. Die Values sind Listen, die alle Particles beinhalten, die in der entsprechenden Zelle liegen.
   1. Anstelle dass man ein bestimmtes Particle mit allen anderen vergleicht, vergleicht man es nur mit denjenigen in der gleichen und **angrenzenden Zellen**. Dadurch skaliert der Code nur noch mit $O(n)$!
   1. Dazu ermittelt man zuerst die Hashes dieser (insg. $9$) Zellen.
   1. Dann liest man die entsprechenden Particles aus dem Dictionary aus.
   1. Nachdem man alle Zellen updated hat, **aktualisiert** man das Dictionary.

=== Unity Tipps ===

== Dictionaries ==

<code csharp>
using System.Collections.Generic; // required for dictionary

Dictionary<int, List<someDataType>> myDict = new Dictionary<int, List<someDataType>>(); // create empty dict

myDict.clear(); // clear the dictionary

myDict.Add(someObject); // add something to dict

myDict.ContainsKey(someKey); // checks if myDict contains a certain key
</code>

== Hash ==

<code csharp>
int CalculateCellHash(int xCell, int yCell)
{
    return xCell * 73856093 ^ yCell * 19349663;
}
</code>



==== Auftrag A - Teil III ====

   1. Implementiere nun elastische Stösse für die Brute-Force Collision Detection (siehe Theorie unten).
   1. Füge nun einen Energie-/Geschwindigkeitsverlust bei jeder Kollision ein - dies simuliert Reibung innerhalb des 'Fluids'.
   1. Mache nun das Gleiche für die Collision Detection mit Spatial Hashing.

Formel für elastischen Stoss in 2D:
[[https://sca.ksr.ch/lib/exe/fetch.php?media=talit:collisions.pdf|Slides Collision]]

===== - Smoothed Particle Hydrodynamics (SPH) =====

**Quellen:**

   * {{ :talit:sph_fluid_sim_mat_mueller.pdf |Particle-Based Fluid Simulation for Interactive Applications}}
   * {{ :talit:sph_tutorial.pdf |Smoothed Particle Hydrodynamics - Techniques for the Physics Based Simulation of Fluids and Solids}}