Animazioni


Variazione nel tempo di una o piu' caratteristiche dei nodi della scena 3D.

Ad es.:
  1. posizione e orientazione nello spazio (movimento)
  2. proprieta' visuali (colore, trasparenza, intensita' della luce, ...)
  3. geometria dell'oggetto (posizione dei vertici)

Le tecniche usate in VRML sono:

keyframe
vengono specificati una serie di stati chiave dell'animazione, e gli stati intermedi vengono calcolati in modo automatico
procedurale
viene usato un nodo Script (un programma) per decidere il comportamento dell'animazione

Modello degli eventi VRML


Il modello degli eventi e' la base di tutte le funzionalità di animazione e interattività in VRML.

Un evento è un messaggio che viene inviato (generato) da un nodo e ricevuto da un altro nodo, e permette di:
  1. notificare cambiamenti avvenuti nello stato del nodo che invia
  2. modificare lo stato del nodo che riceve

Due nodi possono scambiare eventi solo se sono connessi.

La connessione (detta route) tra il nodo che genera l'evento e quello che lo riceve deve essere dichiarata esplicitamente dal programmatore.

Eventi e nodi


Un evento è composto da un valore (di un certo tipo di dato) e da un timestamp (valore che indica quando l'evento è stato generato)

Un nodo VRML spedisce e riceve eventi tramite i suoi:

eventOut
inviano un evento di un certo tipo
eventIn
ricevono un evento di un certo tipo
exposedField
combinano insieme un field, un eventIn e un eventOut (se l'exposedField si chiama zzz, l'eventIn si chiama set_zzz e l'eventOut si chiama zzz_changed)

Route


Per connettere un eventOut di un nodo ad un eventIn di un altro nodo (e quindi permettere l'invio di eventi dal primo nodo al secondo), è necessario che:
La connessione avviene tramite l'istruzione:

ROUTE nomeNodoInviante.nome_eventOut TO nomeNodoRicevente.nome_eventIn


che di solito si scrive in fondo al file VRML e comunque dopo aver creato i nodi coinvolti

Animazioni tramite keyframe


Sono composte da almeno tre nodi connessi tra loro:
  1. un nodo che produce eventi temporali e stabilisce la durata dell'animazione (detto timer)
  2. un nodo che, in base agli stati chiave dell'animazione e il tempo attuale, calcola lo stato attuale dell'animazione (detto interpolatore)
  3. un nodo che riceve, al passare del tempo, lo stato dell'animazione, e aggiorna il suo stato (detto target)
    timer -> interpolatore -> target

TimeSensor
{
   exposedField SFTime  cycleInterval    1
   exposedField SFBool  enabled          TRUE
   exposedField SFBool  loop             FALSE
   exposedField SFTime  startTime        0
   exposedField SFTime  stopTime         0
   eventOut     SFTime  cycleTime
   eventOut     SFFloat fraction_changed
   eventOut     SFBool  isActive
   eventOut     SFTime  time
}


Come un timer, genera eventi temporali (cioè, eventi il cui valore è una quantità di tempo), sia di tipo continuo che discreto

N.B. il tipo di dato SFTime è un float che indica il numero di secondi trascorsi dalla mezzanotte del 1 gennaio 1970, GMT

enabled
TimeSensor abilitato (TRUE) o disabilitato (FALSE)
startTime stopTime
quando il TimeSensor deve partire e fermarsi (attenzione: vanno specificati tempi assoluti)
cycleInterval
durata (in secondi) di un ciclo del TimeSensor
loop
se FALSE, il TimeSensor si ferma a startTime+cycleInterval
se TRUE, si ferma a stopTime, ma
se stopTime <= startTime il TimeSensor cicla all'infinito.

Quando il TimeSensor è in esecuzione, può generare i seguenti eventi:

time
(continuo): il tempo attuale [di solito, serve per gestire eventi singoli]
cycleTime
(discreto): il tempo attuale (viene generato solo alla fine di ogni ciclo) [di solito, serve per gestire attività periodiche]
fraction_changed
(continuo): percentuale completata (nell'intervallo [0.0, 1.0]) del ciclo attuale [di solito, serve per gestire animazioni]
isActive
viene generato quando il TimeSensor parte (TRUE) e quando si ferma (FALSE)

Esempio

TimeSensor
{
   cycleInterval 5
   enabled       TRUE
   loop          TRUE
   startTime     x
   stopTime      y
}


image

Interpolatori


Permettono di cambiare un valore nel tempo. A seconda del valore da cambiare, esistono 6 diversi interpolatori

Un interpolatore ha due campi:

key
lista non decrescente di tempi frazionali nell'intervallo [0,1] (ad es. [ 0 .25 .5 .75 1]
keyValue
lista di valori, ognuno corrispondente al valore del campo key che si trova nella stessa posizione

Ogni volta che l'interpolatore riceve un input tra 0 e 1 (tramite l'eventIn set_fraction), genera in output (tramite l'eventOut value_changed) il valore interpolato corrispondente.

ScalarInterpolator
{
   eventIn      SFFloat set_fraction
   exposedField MFFloat key           []
   exposedField MFFloat keyValue      []
   eventOut     SFFloat value_changed
}


Produce valori scalari: utile per modificare nel tempo qualsiasi valore float.

Ad esempio, per modificare la trasparenza di un nodo Shape nel tempo, basta usare il suo nodo Material come target, e il suo eventIn set_transparency:
TimeSensor -> ScalarInterpolator -> Material

PositionInterpolator
{
   eventIn      SFFloat set_fraction
   exposedField MFFloat key           []
   exposedField MFVec3f keyValue      []
   eventOut     SFVec3f value_changed
}


Produce valori di traslazione: utile per modificare nel tempo la posizione di uno o più nodi Shape.
In questo caso, va usato il nodo Transform che contiene lo Shape come target, e il suo eventIn set_translation:
TimeSensor -> PositionInterpolator -> Transform

Altri interpolatori


OrientationInterpolator
permette di variare valori di rotazione nel tempo
ColorInterpolator
permette di variare il colore nel tempo
CoordinateInterpolator
permette di variare nel tempo le coordinate di uno o più vertici

Progettare un'animazione

  1. Definire un TimeSensor con cycleInterval pari alla durata di un ciclo dell'animazione, e startTime, stopTime e loop appropriati
  2. Definire un interpolatore adatto al valore che si vuole "animare" (se si vuole una transizione fluida tra diversi cicli dell'animazione, vanno usati gli stessi valori nella prima e nell'ultima posizione di keyValue)
  3. Inviare il valore calcolato dall'interpolatore al nodo target che definisce la proprietà che si vuole animare, usando l'eventIn o exposedField corrispondente.
There are no comments on this page.
Valid XHTML :: Valid CSS: :: Powered by WikkaWiki