Nessun risultato. Prova con un altro termine.
Guide
Notizie
Software
Tutorial

Usare gli interpolatori

OrientationInterpolator, CoordinateInterpolator e ColorInterpolator
OrientationInterpolator, CoordinateInterpolator e ColorInterpolator
Link copiato negli appunti

Come già anticipato, Vrml 2.0 fornisce una serie di interpolatori predefiniti,
oltre a quello visto nel capitolo precedente, che possono essere utili nella
realizzazione di animazioni. Questi sono: ColorInterpolator, CoordinateInterpolator,
NormalInterpolator, OrientationInterpolator e ScalarInterpolator. Ognuno di
questi interpolatori esporta tipi diversi, ma il metodo di impiego è fondamentalmente
comune, se non identico. In questo capitolo verranno analizzati gli interpolatori
più di frequente utilizzati.

OrientationInterpolator

Supponiamo per esempio di voler far ruotare un cubo intorno al proprio asse
verticale; in tale caso bisognerà utilizzare un interpolatore che fornisca in
uscita dei valori di rotazione. Il nodo che svolge questa funzione è il nodo
OrientationInterpolator. Il suo funzionamento risulta sostanzialmente
identico a quello di un PositionInterpolator.

Eccone un esempio :Scarica l'esempio

L'esempio è molto semplice per cui non necessita di altre spiegazioni. Quello
che cambia è solo il tipo del valore esportato dall'interpolatore.

CoordinateInterpolator
Un effetto molto interessante e al tempo stesso molto semplice da ottenere
è rappresentato dal "morphing" tra oggetti di forma differente.

In primo luogo, si devono descrivere le diverse forme che l'oggetto dovrà assumere
nel tempo: a tale scopo occorre utilizzare il nodo IndexedfaceSet. CoordinateInterpolator
si occuperà poi di interpolare i punti intermedi per realizzare un passaggio
graduale da una forma all'altra.

Grazie al comando ROUTE, l'evento in uscita dall'interpolatore viene inviato
all'adeguato campo di un nodo Coordinate.

Ecco il codice:

#VRML V2.0 utf8
# esempio di morphing
Viewpoint {
description "Vista iniziale"
position 0 1 6
}
DEF oggetto transform {
rotation 0 1 0 0
children [
Shape {
appearance Appearance {
material Material { emissiveColor 1 .25 0 }
}
geometry IndexedfaceSet {
coord DEF punti Coordinate {
point [ -1 0 -1,
-1 0 1,
1 0 1,
1 0 -1,
-1 2 -1,
-1 2 1,
1 2 1,
1 2 -1
]
}
coordIndex [
1,5,4,0,-1,
1,2,6,5,-1,
2,3,7,6,-1,
3,0,4,7,-1,
4,5,6,7,-1,
3,2,1,0,-1,
]
}
}
]
}
DEF morphing_oggetto CoordinateInterpolator
{
key [0 .125 .175 .3 .35 .5 .625 .675 .8 .85 1]
keyValue [
-1 0 -1, -1 0 1, 1 0 1, 1 0 -1, 0 0 0, 0 0 0, 0 0
0, 0 0 0,
-1 0 -1, -1 0 1, 1 0 1, 1 0 -1, 0 0 0, 0 0 0, 0 0
0, 0 0 0,
-1 0 -1, -1 0 1, 1 0 1, 1 0 -1, 0 2 0, 0 2 0, 0 2
0, 0 2 0,
-1 0 -1, -1 0 1, 1 0 1, 1 0 -1, 0 2 0, 0 2 0, 0 2
0, 0 2 0,
-1 0 -1, -1 0 1, 1 0 1, 1 0 -1, -1 2 -1, -1 2 1,
1 2 1, 1 2 -1,
-1 0 -1, -1 0 1, 1 0 1, 1 0 -1, -1 2 -1, -1 2 1,
1 2 1, 1 2 -1,
-1 0 -1, -1 0 1, 1 0 1, 1 0 -1, -1 2 -1, -1 2 1,
1 2 1, 1 2 -1,
-1 0 -1, -1 0 1, 1 0 1, 1 0 -1, 0 2 0, 0 2 0, 0 2
0, 0 2 0,
-1 0 -1, -1 0 1, 1 0 1, 1 0 -1, 0 2 0, 0 2 0, 0 2
0, 0 2 0,
-1 0 -1, -1 0 1, 1 0 1, 1 0 -1, 0 0 0, 0 0 0, 0 0
0, 0 0 0,
-1 0 -1, -1 0 1, 1 0 1, 1 0 -1, 0 0 0, 0 0 0, 0 0
0, 0 0 0,
]
}
DEF rotazione OrientationInterpolator
{
key [0 .25 .5 .75 1]
keyValue [ 0 1 0 0, 0 1 0 1.57, 0 1 0 3.14, 0 1 0 4.71, 0 1
0 0 ]
}
DEF tempo TimeSensor {
cycleInterval 9
enabled trUE
startTime 1
loop trUE
}
DEF tempo_rotazione TimeSensor {
cycleInterval 3
enabled trUE
startTime 1
loop trUE
}
ROUTE tempo.fraction_changed TO morphing_oggetto.set_fraction
ROUTE morphing_oggetto.value_changed
TO punti.point
ROUTE tempo_rotazione.fraction_changed
TO rotazione.set_fraction
ROUTE rotazione.value_changed TO oggetto.set_rotation

Si noti che occorre particolare attenzione nel definire i punti che formano
l'oggetto. Infatti l'interpolazione avviene tra punti corrispondenti, tra quei
punti cioè che occupano la stessa posizione all'interno della lista.

ColorInterpolator

L'ultimo esempio riguarda l'interpolazione di colori. Anche in questo caso,
ritengo che il codice sia talmente semplice da non richiedere ulteriori spiegazioni.

#VRML V2.0 utf8
# transizione di colori
Shape {
appearance Appearance {
material DEF mioMateriale Material { }
}
geometry Sphere { radius 2 }
}
DEF mioColore ColorInterpolator {
key [ 0.0, 0.5, 1.0 ]
keyValue [ 1 0 0, 0 1 0, 0 0 1 ]
}
DEF tempo TimeSensor {
cycleInterval 6
loop trUE
}
ROUTE tempo.fraction_changed TO mioColore.set_fraction
ROUTE mioColore.value_changed TO mioMateriale.set_diffuseColor


Ti consigliamo anche