In generale, funzione delle pos attuali

Forze

In generale, funzione delle pos attuali

Gravità Attriti

(ma, questi simulatbili anche da damping – vedi poi)

Opposizione dei materiali solidi

(ma, queste simulate bene anche da vincoli… vedi poi)

Vento, elettrica, magentica, forza di archiede, molle, onde d’urto (esplosioni), etc etc…

Forze di controllo “posticcie” / “magiche”

(aggiunte x controllare l’evoluzione, non giustificate)

...

...) , ( ...

p funz f =

r

Forze: molle

Modello semplificato per forze elastiche 1 molla

connette due particelle Va e Vb

caratterizzata da:

lunghezza a riposo L costante elastica k

Forza:

si oppone a allungamento

e compressione ^Va

Vb

esercitata su Va e su Fb:

data da:

• direzione: quella della molla

• magnitudine: ( distanza(Va,Vb) – L )* K

• verso: l’altra estremita’, se distanza(Va,Vb) > L o in verso opposto, altrimenti

Forze: molle

Modello semplificato per forze elastiche 1 molla

connette due particelle Va e Vb

caratterizzata da:

lunghezza a riposo L costante elastica K

Forza:

si oppone a allungamento

e compressione ^Va

Vb

b a

b a b

a

v v

v L v

v v K

f −

⋅ −

−

−

⋅

= ( )

) (

r

Forze: molle

Utili per comporre oggetti deformabili, per es cloth, ropes, hairs…

molle extra, di resistenza al piegamento

Forze: molle

Utili per comporre oggetti deformabili, per es cloth, ropes, hairs…

img by msqrt (pauli kemppinen)

Forze: molle

Composizione di molle:

oggetti deformabili elastici

(tendono sempre a tornare alla forma originale)

Idea: modificare la lunghezza a riposo

(in risposta a compressioni/espansioni) oggetti deformabili plastici

(assumono permanentemente la posa deformata)

Oggetti rigidi?

concetto simile, ma vincoli non molle (“hard constraints”)

vedi poi!

Forze: di controllo

Esempio:

il player ha premuto il tasto “avanti”:

il suo avatar subisce una forza in avanti

(“non fare domande, motore fisico”)

secondo alcuni:

meglio quando non è mai così

(difficile da ottenere, di solito) plausibilità contro realismo

Continuità di pos e vel

In teoria, in un sistema fisico

pos e vel possono variare solo con continuità In pratica, a volte utile introdurre cambiamenti discontinui, in entrambi:

nelle posizioni: “teletrasporti”

nelle volocità: “impulsi”

modellano forze molto grandi

esercitate su intervalli di tempo molto piccoli es.: impatti, v. collision handling

(sono variazioni non necess. giustificate da forze)

Impulsi

Forze (continue)

applicazione continuata ogni frame

( )

...

/ ...

dt m f v

v = + ⋅

r r r

Impulsi

tempo infinitesimo una tantum

( )

...

/ ...

m i v v

r r

r = +

modifica diretta (e discontinua!) dello stato (velocità)

modellano forze molto brevi e intense (es: impatti)

Impulsi VS forze

Forza:

determina accelerazione

accdetermina cambiamento (continuo!) di vel fisicamente corretto

Impulso:

cambiamento (discontinuo!) di vel es: l’impulso causato dal rimbalzo

di una pallina da tennis contro una racchetta fisicamente: forza con:

tempo di applicazione che tende a zero magnitudine che tende ad infinito (??) fisicamente corretto?

no, ma approssima fenomeni che avvengono a dt molto minori di quelli simulati

(cosa succede davvero quando la pallina viene colpita dalla racchetta?)

forze molto forti su tempi molto brevi (ma non istantantei)

Euler pseudo code

Vec3 position = … Vec3 velocity = …

void initState(){

position = … velocity = … }

void physicStep( float dt ) {

position += velocity * dt;

Vec3 acceleration = compute_force( position ) / mass;

velocity += acceleration * dt;

}

void main(){

initState();

while (1) do physicStep( 1.0 / FPS );

}

Metodi numerici:

passo di integrazione

dt : delta di tempo virtuale dall’ultimo step

la “risuluzione temporale” della simulazione!

se piccolo: poca efficienza

più steps per simulare stessa quantità tempo virtuale

se grande: poco accuratezza

soprattutto in presenza di forze e/o vel grandi

valori tipici: 1 / 60 sec -- 1 / 30 sec

nota: non necess. lo stesso refresh rate del rendering

ordine della simulazione:

quanto cresce l’errore al crescere di dt

Metodo Eulero: limitazioni

cattivo rapporto efficienza / accuratezza

errore accumulato nel tempo = lineare con dt

persino la plausibilità può essere compromessa

non mantenimento energia ! es: oscillazioni divergenti !

patch: dampingdella velocità (ad ogni step) float damp = 1.0 – PICCOLA_CONST ; velocity *= damp;

perdita continua dell’energia cinetica

scusa ufficiale: “sono gli attriti con… tutto (aria compresa)”

Trick: velocity «Damping»

(o «Drag», resistenza e.g. dell’aria)

Vec3 position = … Vec3 velocity = …

void initState(){

position = … velocity = … }

void physicStep( float dt ) {

Vec3 acceleration = force( positions ) / mass;

velocity += acceleration * dt;

position += velocity * dt;

}

void main(){

initState();

while (1) do physicStep( 1.0 / FPS );

}

velocity *= (1.0 – DRAG * dt);

decurtamento aritificiale energia cinetica:

• robustezza

(evita aumeto energia x errori numerici) (es. evita oscillazioni divergenti)

• dispersioni non modellate (attriti vari)

• damp alto = come muoversi nella melassa

• aka DRAG (spesso: DRAG = 1-DAMP)

Sotto problema:

Se voglio ridurre la velocità di una percentuale ogni sec

es del 20%

DRAG = 0.2 (o DAMPING = 0.8)

per quanto devo moltiplicare la vel ogni dt ?

per DRAG suff. piccoli, ben approssimato da

Drag

v

v r = r ⋅ ( − 1 ) ) 1

( dt Drag v

v r = r ⋅ − ⋅

1/FPS sec

Integrazione Leapfrog

(“a cavallina”)

Integrazione Leapfrog

t

0.0 0.5 1.0 1.5 2.0 2.5

Pos Vel Pos Vel Pos Vel

Integrazione Leapfrog first step

t

0.0 0.5 1.0 1.5 2.0 2.5

Pos₀ Vel₀

Vel

2 / ...) , (

0 5 . 0

0

dt a v v

p f a

⋅ +

=

=

r

r

r

t

0.0 0.5 1.0 1.5 2.0 2.5

Pos Vel Pos Vel Vel

dt v p p₁= ₀+r_0.5⋅

dt a v v

p f a

⋅ +

=

=

5 . 0 5 . 1

1, ...) ( r r

dt v p p₂= ₁+r_1.5⋅

dt a v v

p f a

⋅ +

=

=

5 . 1 5 . 2

2 , ...) (

r r

Pos

dt v p p₃= ₂+r_2.5⋅

Pos

Metodo Leapfrog: vantaggi

Miglior accuratezza per lo stesso dt

(miglior comportamento asintotico)

“second’ordine invece che primo ordine”

(errore residuo dt^3 invece che dt^2)

ma stesso costo di Euler

bonus: fully reversible! ☺

Metodo Verlet

(“position based dynamics”)

Idea: rimuovere la velocità dallo stato Velocità corrente: implicita.

Approssimata da:

delta fra

pos corrente ultima posizione

dt p

p

v r = ( _now − _old ) /

p

p

Metodo Verlet

(“position based dynamics”)

init state

one step

dt v p

p

dt a v v

dt p

p v

m f a

p funz f

p p

now next

old now

now old

now

⋅ +

=

⋅ +

=

−

=

=

=

=

=

r r

r r r r r r

/ ) (

/

) ( ...

...

svolgendo…

(position based dynamics)

next now

now old

p p

p p

=

=

init state

one step

...

...

=

=

old now

p p

2

/

) (

dt a p

p p

m f a

p funz f

old now

next

now

⋅ +

−

=

=

=

r r r

r

Verlet: caratteristiche

Implicit velocity!

Buon rapporto efficienza / accuratezza

errore accumulato: ordine di dt^2

Bonus extra: invertibilità del sistema

(volendo, posso percorrere l’evoluzione all’indietro nel t e tornare nello stato iniziale corretto)

(stando attenti con dettagli implementativi)

Vantaggio principale: flessibilità

possibile imporre vincoli direttamente sulle posizioni!

adeguamento della velocità “automatico”

(non corretto ma plausibile)

Verlet: caveats

si assume dt (time-step) costante

se varia: necessarie correzioni! (quali?)

come agire direttamente sulla velocità (che è implicita?)

es, per: damping es, per: impulsi

modificare

come modificare la posizione

senza impattare la velocità (implicita)?

modificare sia che

p

p

p

La vera forza del position based

next now

now old

p p

p p

=

=

init state

one step

...

...

=

=

old now

p p

2

/

) (

dt a p

p p

m f a

p funz f

old now

next

now

⋅ +

−

=

=

=

r r r

r

soddifacimento vincolisu

( p

)

(“positional constraints”)

generici e espressivi

molti fenomeni possibili per es: “no compenetrazioni”

intuitivi da definire semplici da imporre

imporre un vincolo (posizionale) =

= trovare le posizioni più simile alle attuali che lo soddisfano

= proiettarelo stato attuale nello spazio degli stati ammissibili

il beneficio di Verlet:

aggiornamento velocità: conseguenza automatica!

senza passare dalle forze / impulsi

(quelle che nella realtà impongono il vincolo) approssimazione cruda, ma risultati plausibili!

Esempio di

vincolo posizionale

«Le particelle devono stare dentro [0 – 100] x [0 – 100] »

for(int i=0; i<NUM_PARTICLES; i++) {

p[i].x = clamp( p[i].x, 0, 100 );

p[i].y = clamp( p[i].y, 0, 100 );

} a

b

imposizione del vincolo: semplice clamp ! es:

100 0

100

imporre vincoli come questo è una prima collision response.

Ma: per avere rimbalzi, serve aggiungere impulsi da impatto.

Es: Vincoli di equidistanza

«Le particelle a e b devono stare a distanza d »

d p

p

−

| =

|

p

p

d

d

Imporre

i vincoli di equidistanza

d p

p

−

| >

|

d p

p

−

| <

|

se

se

p

p

d

p

p

pseudocodice

Point3 delta = p[b] - p[a];

float curr_dist = delta.length;

Point3 diff = (curr_dist – d ) / curr_dist;

p[a] += delta * (0.5 * diff);

p[b] -= delta * (0.5 * diff);

Combinazioni di vincoli di equidistanza

Per ottenere:

Corpi rigidi nota:

solo posizioni / vel / acc!

no: angoli, vel angolare acc angolare

una cassa?

(oggetto rigido) configuraz di:

• 4 particelle

• 6 vincoli di equidistanza

Combinazioni di vincoli di equidistanza

Per ottenere:

Corpi rigidi

Corpi snodati

Tessuti

Corde

…

Azione simile a molle, ma per oggetti rigidi!

Altri esempi

di vincoli posizionali

Mantenimento area / volume: «il volume sia

»

come imporlo:

1. stima del volume totale attuale

2. scalatura unforme dell’oggetto di /

Posizioni fisse: «la particella stia in

»

particelle «inchiodate sul posto»

(banale, ma utile!)

Vincoli su angoli

per es, sui giunti: «i gomiti non si piegano all’indietro»

Coplanarità / colinearità Non compenetrazione

(parte del collision handling)

insiemi di vincoli

Molti vincoli da imporre:

risolverne uno romperne un altro!

Soluzione simultanea: computazionalmente onerosa Soluzione pratica: in cascata (analogo a Gauss-Seidel):

Ripetere fino a soddisfacimento (= errore max sotto soglia)

…ma al max N volte! (remember: soft real time)

imposiz.

vincolo 1

imposiz.

vincolo 2

imposiz.

vincolo N ...

Soddisfare

insiemi di vincoli

Nota:

l’intero loop di imposizione vincoli avviene in un solo step della fisica!

Convergenza:

se vincoli non contraddittori

se non converge in tempo (o soluz non esiste):

pazienza, frames successivi provvederanno (abb. robusto)

iterazioni richieste (di solito): 1 ~ 10 (efficiente!).

Ottimizzazione(x ridurre iterazioni richieste):

risolvere per primi i vincoli maggiormente infranti

Problema: approccio sequenziale!

ma le versioni parallelizzate (analogo a Jacobi) convergono peggio in pratica

Esempio

NO NO

STEP 0 STEP 1

before constraints

NO

STEP 1 after 1st constraint

Esempio

STEP 1 (implicit) velocities NO

STEP 1 after all constraints

multiple times

NO

In totale:

la “cassa”, sotto l’effetto di gravità + impatto

• ha ruotato

• ha acquisito momento angolare (continuerà a ruotare per inerzia)

anche il sistema non gestisce (esplicitamente) rotazioni,

ne’ momenti angolari (funz. anche in 3D!)