007 - Physics System

Das Physics System bietet Verlet-basierte Physik-Simulation.

Warum Physik in Creative Coding?

Physik macht generative Kunst lebendig. Ein Partikel, das der Schwerkraft folgt, wirkt natürlicher als einer, der linear fliegt. Ein Schwarm, dessen Individuen aufeinander reagieren, erzeugt emergente Muster, die man nicht hätte programmieren können.

Warum Verlet?

Es gibt viele Physik-Ansätze. Ich nutze Verlet-Integration, weil sie:

• Stabil ist – Auch bei großen Zeitschritten explodiert nichts
• Einfach ist – Position + vorherige Position = Geschwindigkeit (implizit)
• Constraint-freundlich ist – "Diese zwei Punkte sollen Abstand X haben" → einfach Positionen korrigieren

Klassische Euler-Integration (position += velocity * dt) akkumuliert Fehler und braucht kleine Zeitschritte. Verlet (position_new = 2*position - position_old + acceleration*dt²) ist stabiler und erlaubt größere Zeitschritte.

Warum zwei Ebenen?

Das System hat zwei getrennte Physik-Welten:

1. PhysicsWorld – Für Partikel, Schwärme, Ketten. Jeder Punkt ist ein Particle.
2. SoftShape – Für deformierbare Formen. Die Vertices haben eigene Mini-Physik.

Warum getrennt? Weil ein Soft Circle seine interne Jelly-Physik behält, auch wenn er als Ganzes in der PhysicsWorld herumfliegt. Der ShapePhysicsAdapter verbindet beide Welten.

Zwei-Ebenen-Architektur

┌─────────────────────────────────────────────────────────────────────────┐
│                       Ebene 1: PhysicsWorld                             │
│  ┌───────────────────────────────────────────────────────────────────┐  │
│  │                        PhysicsWorld                               │  │
│  └───────────────────────────────────────────────────────────────────┘  │
│         │              │              │              │                  │
│         ▼              ▼              ▼              ▼                  │
│  ┌────────────┐ ┌────────────┐ ┌────────────┐ ┌────────────┐            │
│  │ Particles  │ │ Behaviors  │ │Constraints │ │  Springs   │            │
│  └────────────┘ └────────────┘ └────────────┘ └────────────┘            │
└─────────────────────────────────────────────────────────────────────────┘
                                    ▲
┌───────────────────────────────────┼─────────────────────────────────────┐
│                       Adapter     │                                     │
│  ┌───────────────────────────────────────────────────────────────────┐  │
│  │                    ShapePhysicsAdapter                            │  │
│  └───────────────────────────────────────────────────────────────────┘  │
└───────────────────────────────────┼─────────────────────────────────────┘
                                    ▼
┌─────────────────────────────────────────────────────────────────────────┐
│                        Ebene 2: SoftShape                               │
│  ┌───────────────────────────────────────────────────────────────────┐  │
│  │                          SoftShape                                │  │
│  └───────────────────────────────────────────────────────────────────┘  │
│                │                              │                         │
│                ▼                              ▼                         │
│      ┌─────────────────┐          ┌────────────────────────┐            │
│      │    Vertices     │          │  Internal Constraints  │            │
│      └─────────────────┘          └────────────────────────┘            │
└─────────────────────────────────────────────────────────────────────────┘

Ebene 1: PhysicsWorld

• Globale Punkt-basierte Simulation
• Particles mit Position, Velocity, Mass
• Für: Partikel-Systeme, Schwärme, Ketten

Ebene 2: SoftShape

• Shape-interne Simulation
• Für: Deformierbare Formen (Blob, SoftCircle)

Komponenten

PhysicsWorld

Container und Update-Loop.

Update-Reihenfolge:

1. Behaviors anwenden (Kräfte)
2. Particles updaten (Verlet)
3. Springs aktualisieren
4. Constraints anwenden

API:

Particle

Verlet-Partikel.

Properties:

Methoden:

Behaviors

Kräfte die auf Particles wirken.

GravityBehavior

FrictionBehavior

AttractionBehavior

ConstantForceBehavior

Presets: createWindBehavior(), createUpdraftBehavior()

Flocking Behaviors (Boids)

Flocking Presets:

Constraints

Regeln die Particles einhalten müssen.

RectConstraint

Hält Particles in einem Rechteck.

CircularConstraint

Hält Particles in/außerhalb eines Kreises.

DistanceConstraint

Fester Abstand zwischen zwei Particles.

AxisConstraint

Beschränkt auf eine Achse.

Presets: createHorizontalRail(), createVerticalRail()

MinConstraint / MaxConstraint

Minimum/Maximum-Grenze.

Presets: createFloor(), createCeiling(), createLeftWall(), createRightWall()

Springs

Federkräfte zwischen Particles.

Optionen:

ParticleString

Kette von Particles mit Constraints.

Factory-Funktionen:

CollisionZone

Bereiche mit speziellem Verhalten.

Behaviors:

ProximityConnection

Zeichnet Linien zwischen nahen Particles.

Presets:

Presets & Factory-Funktionen

Soft Body Kollisionen

Das Soft Body System (siehe 004-Shapes) unterstützt Shape-zu-Shape Kollisionen.

Kollisions-Pipeline

┌─────────────────┐    ┌─────────────────┐    ┌─────────────┐
│   Broad-Phase   │ -> │  Narrow-Phase   │ -> │  Response   │
│      AABB       │    │      SAT        │    │   Impulse   │
└─────────────────┘    └─────────────────┘    └─────────────┘

Phasen:

Aktivieren

import { ShapeStateManager } from '@carstennichte/cc-toolbox';

// Shapes erstellen und konfigurieren...
const shapes: ShapeStateManager[] = [...];

// Alle Shapes kennen alle anderen
const decorators = shapes.map(s => s.getDecorator());
for (const shape of shapes) {
  shape.setCollisionBodies(decorators);
}

Parameter-Einfluss

Performance-Hinweise

• Alle-gegen-Alle: Bei n Shapes → n² Checks
• Empfehlung: ~20-30 Shapes mit Kollision, ~50 ohne
• Konkave Shapes: SAT funktioniert nur zuverlässig für konvexe Polygone