cc
L´image mobile
L´image de synthèse, en particulier lorsqu´elle est interactive,
est essentiellement mobile. La fameuse trilogie
modélisation-animation-rendu est donc un non-sens. Dans anyflo
il n´y a pas de bases de données et tout objet (que ce soit une
primitive graphic, un volume, une trajectoire, une caméra, une
lumière, ...) est d´abord une description abstraite, un acteur
programmable comportant des datas et des programmes.
De même que la modélisation d´une vague est inséparable de celle
de son mouvement, la construction des entités dans anyflo ne se
conçoivent pas sans leur devenir dans le temps. C´est dire que
la notion de dynamique (au sens large) y est importante.
Nous envisagerons différents types d´animation, des plus traditionnels
aux plus recents:
D´abord l´animation de type cinématique par trajectoires
et lois de mouvement (très en vogue chez les animateurs professionnels mais
qui reste une méthode manuelle n´utilisant que fort peu les potentialités
de la machine).
Ensuite l´animation de type procédurale, qui est l´animation
de synthèse par excellence (très utilisée en production mais qui
nécessite des équipes de programmeurs).
Puis l´animation dynamique autorisant un haut degré de
réalisme sur des objets inertes.
Ensuite l´animation comportementale qui, via la notion
d´acteur, permet de gérer des êtres complexes et/ou nombreux
sans qu´il ne faille en contrôler tous les paramètres.
Puis des méthodes connexionnistes et évolutionnistes
s´inspirant de modèles biologiques et de la vie artificielle, comme
les réseaux neuronaux et les algorithmes génétiques.
Enfin l´optimisation de ces méthodes permet le temps réel.
Animation par trajectoires et lois de mouvement
Principe
Les trajectoires et les
lois de mouvements permettent
de contrôler les objets et leurs propriétés dans le temps:
Géométrie: Formes, positions et orientations de volumes, de caméras,
de lumières, etc...
D´une façon plus générale tout paramètre:
Sommet particulier d´un objet
Couleurs
Modèles d´éclairement,
Coefficients d´extension courbe
etc...
Pour cela des trajectoires (objets de type ´traj´) sont associées aux objets
à animate et des lois de mouvements sont associées à ces trajectoires.
traj donne les syntaxes des commandes.
Pratiquement
Il suffit de:
définir des trajectoires encapsulées sur des paramètres des entités à animer,
ou des objets de type trajectoire affectés à ces paramètres.
éventuellement définir des trajectoires sur ces trajectoires, etc..
Animation procédurale
Principe
Les méthodes précédentes simulent en particulier les techniques
classiques d´animation, elles en ont les avantages (contrôle exhaustif) mais
aussi les inconvenients (impossibilité de gérer des événements
complexes ou imprévisibles). L´animation procédurale consiste
à générer une séquence animée non pas par des descriptions
géometriques mais par des procédures.
Pratiquement
Pratiquement il suffit d´exécuter, à chaque image, une fonction qui
analyse la scène et en déduit des actions (par exemple tester les collisions
entre objets et les faire rebondir).
Pour cela des call back
permettent d´intervenir à différents niveaux de l´animation.
Animation dynamique
Principe
La technique précédente permet un contrôle plus systématique et permet
de simuler une infinité d´effets, parmi ceux-ci figurent les lois naturelles
(par exemple la mécanique) dont il suffit d´écrire les équations dans les
fonctions appelées à chaque image. Pour simplifier ce travail certains
algorithmes classiques sont écrits ´en dur´ (appel de commandes anyflo), c´est
le cas par exemple des lois de la dynamic
des corps pesants, de celle des
ressorts,
de celle des chocs, etc...
Forces, masses, vitesses et accélérations
Une mass peut être affectée à un volume par la commande:
mass vol(id)=m;
De même une force peut être affectée à un volume par:
force vol(id)=f;
Masse et force peuvent également être affectées individuellement à un ou
plusieurs sommets d´un volume par:
mass vertex(s) vol(id)=m;
force vertex(s) vol(id)=f;
Des champs de forces peuvent être définis globalement
pour tous les objets ou être affectés à certains objets ou certains sommets.
Ils peuvent être uniformes, centraux, linéaires, surfaciques ou même
proceduraux.
Animation dynamique
Au cours de l´animation, la géométrie, la topologie, les masses et les
forces de tout les objets peuvent être modifiées. Par exemple on peut
définir un field de force par f=fonction(p) pour un point pdonné.
Vitesse et accélération sont accessibles en lecture et en écriture par:
speed vol(id)
speed vertex(s) vol(id)
acc vol(id)
acc vertex(s) vol(id)
Détection de collisions
Les détection de collisions sont gérées par la commande collision.
Ressorts
Des ressorts peuvent être affectés entre certains sommets d´un volume.
Lorsque des masses ont été affectées à ces sommets, leurs interactions
sont automatiquement gérées si yes dynamic est actif.
La commande spring vertex (s) vol (id) = r, v
permet de préciser la raideur(r) et la viscosité(v) du spring associé au
sommet s du volume id.
Tout déplacement des sommets entraine une réponse adéquate des ressorts.
Systèmes de particules
Des volumes de type particle peuvent être définis,
leurs sommets peuvent recevoir des propriétés géométriques,
colorométriques, dynamiques, etc...
Animation comportementale
La notion d´acteur
Les techniques précédentes s´appliquent bien à l´animation d´objets
physiques mais échouent avec les êtres vivants qui obéissent, en plus, à
d´autres lois dites ´comportementales´ (par référence au comportement d´un
être face à une situation donnée).
Un acteur est un objet muni d´un comportement, c´est à dire d´un
esemble de fonctions locales et de mémoires internes.
Plusieurs acteurs peuvent dialoguer en exécutant chacun une fonction
local de l´autre, et l´utilisateur peut dialoguer avec les acteurs en
exécutant certaines de leurs fonctions locales.
La gestion d´acteurs munis de comportements ne peut pas se faire avec
les langages procéduraux traditionnels, et il faut faire appel aux
langages dits orientés objets dans lesquels les structures de données
intégrent non seulement des datas (physique) mais aussi du code
(intelligence).
Pour cela anyflo propose un
langage orienté objet
permettant d´affecter à tout
objet, en plus de ses propriétés physiques, un programme (code et mémoires)
pouvant se dérouler indépendemment des programmes inclus dans les autres
objets: Les commandes (local) et (memory)
permettent de créer de tels acteurs
Fonctions locales d´un objet
(manuel.object.htm)object oriented language:
Affecte au volume id une nouvelle fonction local dont le contenu est une copie
de la fonction de nom f.
La fonction f est alors dupliquée, compilée et des mémoires statiques
sont éventuellement réservées; tous ces éléments sont locaux au volume id,
c´est à dire inconnus à l´exterieur.
local(n)vol(id): Retourne le texte de la fonction local numéro n du
volume id
local(n)vol(id) = "ttt": Modifie la fonction local numéro n du
volume id.
local("toto")vol(id): Retourne le texte de la fonction local "toto"
du volume id.
Un nombre quelconque de fonctions locales peuvent être associées à un
volume, chacune pouvant en appeler une autre par simple invocation de son
nom (même si une autre fonction portant le même nom existe par ailleurs).
Lors de l´affichage du volume, si yes local est actif, la première
de ses fonctions locales sera exécutée.
Il est possible d´exécuter, de l´extérieur, une fonction local par:
exec local(n) vol(id) var(p1) var(p2) ...
n = numéro, ou nom (entre guillemets), de la fonction local
id = identificateur du volume
p1, p2, ... = paramètres passés à la fonction local
Fonctions locales d´autres objets
Des fonctions locales peuvent aussi être définies sur:
Des lumières: local(0)light(id) = "text"
Des vues: local(0)view(id) = "text" (permet de définir des
perspectives adaptatives)
Mémoires locales
Dans une fonction local d´un objet des mémoires statiques (´static´)
peuvent être réservées, ce sont des variables permanentes mais inconnues à
l´exterieur
Des mémoires globales à un objet peuvent aussi être déclarées par:
memory object
Animation connexionniste
Les méthodes précédentes sont très artificielles. Paradoxalement,
une façon de retrouver des mouvements naturels est de faire appel aux techniques de la
Vie Artificielle et, plus particulièrement aux
réseaux neuronaux. On trouvera dans le
manuel sur les réseaux un ensemble de
commandes permettant de construire
et d´utiliser de tels réseaux.
Une méthode consiste à construire des acteurs virtuels munis:
1) D´un corps sous la forme d´une structure hiérarchisée de volumes
auxquels sont attribués des propriétés de dynamique.
2) De perceptions sous forme de capteurs connectés au cerveau.
3) D´un cerveau sous la forme de réseaux neuronaux dont les entrées sont
connectées aux capteurs et dont les sorties sont connectées à des actuateurs agissant sur la dynamique
des volumes constituant les corps.
4) De procédures d´apprentissage (supervisés ou non) permettant d´entrainer les réseaux à répondre
correctement à certaines configurations de l´environnement
(voir manuel sur les réseaux neuronaux).
Voir:
Une méthode comportementale de modélisation et d´animation du corps humain.
Interaction avec un danseur virtuel intelligent.
Animation évolutionniste
Une autre façon artificielle de retrouver le naturel est d´utiliser des techniques
évolutionnistes et, plus particulièrement les
algorithmes génétiques. On trouvera dans le
manuel sur les génétiques un ensemble de
commandes permettant de construire
et d´utiliser de tels algorithmes. On trouvera dans le fichier
mouv_gen.func un exemple d´une telle technique.
Une façon intéressante de construire des réseaux neuronaux optimaux consiste à créer arbitrairement
une population de réseaux définis aléatoirement (et donc peu performants), et de soumettre cette
population à une évolution darwinienne. Pour cela on définit une application bijective de l´ensemble
des réseaux sur un ensemble de codes génétiques sur lesquels on fait travailler des algorithmes génétiques
optimisant une certaine fonction d´adaptation.
Par exemple, pour faire se déplacer des acteurs, on pourra optimiser la distance qu´ils parcourent.
Temps réel
Principe
Un module temps réel
(interaction)
permet de gérer des animations en temps réel avec le rendu
que permet OpenGL. Ainsi certains types de mappes, le rendu de Phong, les
perspectives adaptatives ne sont pas supportés. Presque tous les types d´animation y sont
possibles.
generate interaction time permet de réduire
les temps de calcul.
Types d´animation
Les acteurs.
Bitmaps.
Les trajectoires.
voir demo1_traj.func.
Les modèles
dynamiques.
Les modèles
procéduraux
nbsp;
Grâce à des callbacks donnant accès, à chaque image,
au niveau interpréteur.
Les modèles
comportementaux
Grâce aux fonctions locales.
Aux réseaux neuronaux
Aux algorithmes génétiques.
Aux capteurs
En nombre indeterminé, ils peuvent être utilisés via la
mémoire partagée, des fichiers, des ports série, des USB, etc...
Des outils de debuggage
Permettant une mise au point interactive, en particulier:
displ affichant toutes
sortes d´informations (volumes, trajectoires, dynamique, réseaux neuronaux,
génétiques, etc..
interaction debug donnant accès
à des échelles graphiques sur les quelles on peut rentrer des paramètres
(également utilisable en langage C).
Toutes ces méthodes permettent de construire des installations interactives,
en définissant des acteurs munis de propriétés physiques (gérées par la dynamique),
ayant des comportements (fonctions locales),
"intelligents" (réseaux neuronaux),
évolutifs (algorithmes génétiques),
en interaction entre eux et avec leur environnement virtuel et réel (capteurs).
Pour bien comprendre ces principes on pourra consulter les
articles et les descriptions des
installations.
Gestion d´une animation en temps réel
Méthode
La commande
interaction
fait passer en mode interactif temps réel. La boucle MainLoop d´OpenGL
a alors la main, mais des "call back" permettent d´intervenir à tous les niveaux.
Stockage
L´écriture d´une image sur le disque
peut ralentir le temps réel et déphaser l´interaction entre les captures
(de son, de mouvement, ...) et leur interprétation par le programme. Pour résoudre ce
problème on peut décomposer le processus en deux processus que l´on exécutera l´un
après l´autre:
Dans un premier temps on réalise l´interaction avec des images simplifiées suivant
bien le temps rél (modèles pauvres en fil de fer, sans extension, ...).
Puis dans un deuxième temps on enregistre les capteurs:
interaction stock device
interaction stock(ni)device name("nn")
Initialise le stockage des valeurs du capteur sur ni images.
interaction device(val)
Appelée à chaque image cette commande stocke effectivement la valeur courante
val du capteur en mémoire.
la commande
A la fin de l´animation les valeurs mémorisées du capteur sont sauvées dans le
fichier nn.cap et les interventions (< ... et ! ...) sont sauvées dans le
fichier nn.eff.
Pour caler le départ du stockage avec les évènements d´un capteur on peut:
1) Donner un tempo de na images d´attente par:
interaction stock(ni)device name("nn")wait(na)
2) Ou démarrer le stockage dès que le module du capteur dépasse un seuil mod par:
interaction stock(ni)device name("nn")module(mod)
Play
Puis dans un deuxième temps on relit ces fichiers qui permettent d´affecter aux sorties
des capteurs les valeurs enregistrées et de reproduire les évènements,
on a alors tout le temps pour calculer des images complexes et les stocker sur
le disque grâce à la commande:
interaction play device.
Bitmaps
interpol texture d´animer des bitmaps stockées
dans des images 3D lues par texture directory.
Animation en temps différé
J´ai commencé l´écriture d´anyflo à une époque où les machines étaient très
lentes et où il n´y avait pas de cartes graphiques avec des fonctions évoluées
cablées, c´est dire que le temps réel n´était guère possible. Comme je voulais
quand même faire des films j´ai implémenté des procédures permettant de gérer
automatiquement la simulation d´une interaction (que j´avais appelée "endogène")
entre,d´une part, le système et un interacteur réel (au clavier, à la souris, ...) et,
d´autre part, entre deux interacteurs virtuels (deux acteurs, deux processus, ...) ou,
plus généralement, entre plusieurs types de ces interacteurs. J´ai réalisé sur ce modèle
de nombreux
films.
La commande displ(n) permet de préciser le niveau de complexité de l´image calculée:
n=0: pas d´affichage.
n=1: complexité OpenGL (temps réel).
n=2: complexité z buffer (en développement).
n=3: complexité ray tracing (en développement).
interaction write vol name("nnn")
Stockera les descriptions des volumes sous les noms:
nnn1.vol nnn2.vol ...
interaction write image name("nnn.eee")
Stockera les mémoires d´images sous les noms:
nnn1.eee nnn2.eee... (ext est bmp, jpg, tga).
interaction stock image number(im,ni)
stocke les images dans lmes images numéros im à im+ni-1. On obtient un play back de ces images par
play image number(im,ni).
Remarque:
Les fichiers portent les noms: A1 A2 A3 A4 ... A10 A11 ... A100 A101 ...
Il est possible de les écrire A0001 A002 ... A0010 ... A0100 en faisant:
nn="A",(string("4D",im))
Post production
Des outils permettent d´intervenir sur les fichiers images:
smooth image read("...")number(nb)write("...")
pour des images parasites.
image(id1,id2)image(id3)interpol coe(c1,c2)
mélande de séquences
image(id1,id2)image(id3)interpol coe(1-c,c)
ondu enchaineacute;
write image NP interpol: lissage d´une animation
read image directory write directoryinterpol
pour concaténer des directoriys avec interpolation.
image(id1,id2)image(id3)interpol coe(c1,c2)
Post production
Lancer anyflo avec l´option:
anyflo hau=2
L´image en mémoire centrale a 4 fois la taille vidéo. Lors d´un
´write image´, cette image sera convolée à la taille video.
On peut préciser la taille de l´image antialiasée (dimx,dimy) et le
facteur d´antialiasage k:
anyflo x=dimx y=dimy gra=0 mem=1 hau=k
Animation d´ordres supérieurs
L´idée est de considérer chaque image d´une animation (d´ordre n) comme la trace (c´est à dire en
no screen) d´une animation d´ordre n-1.
Il suffit pour cela d´utiliser le fait qu´une trajectoire, comme
objet standard d´anyflo, peut être animée (par d´autres
trajectoires, la dynamique ou toute autre méthode).
La commande
interaction stock image
gère ce processus.