Rapport de Stage

M
M
a
Master Professionnel SIS
Option Imagerie Numérique
MODELISATION EN TROIS
DIMENSIONS D’OCEAN ET DE
ROULEAUX
Valentin LEONARDI
Entreprise : Phoenix Studio
Dates : du 17/03/09 au 30/09/09
Tuteurs : Julien Blervaque et Denis Dufour
Responsable de Master : Jean Sequeira
28 / 08 / 09
Sommaire
REMERCIEMENTS .................................................................................................................................... 3
INTRODUCTION ....................................................................................................................................... 4
1 - REFERENCES - BIBLIOGRAPHIE - DOCUMENTATION.................................................................. 4
1.1 - Création des vagues ................................................................................................................. 4
1.2 - Mers et océans ........................................................................................................................... 5
1.3 - Implémentation – Bibliographie ........................................................................................ 10
1.4 - Concentration sur la topologie ........................................................................................... 13
2 - RENDU D'UNE SURFACE D'EAU (OU HEIGHT FIELD)................................................................. 14
2.1 - Bruit de Perlin ......................................................................................................................... 14
2.2 - Equations de Gerstner ........................................................................................................... 17
2.2.1 - Calcul de la height field ......................................................................................................... 17
2.2.2 - Normales ................................................................................................................................ 18
2.2.3 - Illumination............................................................................................................................ 19
2.2.4 - Avantages et inconvénients ................................................................................................... 20
2.2.5 - Conclusion ............................................................................................................................. 21
2.3 - Utilisation de transformées de Fourier rapides (FFT pour Fast Fourier
Transform) ......................................................................................................................................... 22
2.3.1 - Calcul de la height field ......................................................................................................... 22
2.3.2 - Formation de crêtes................................................................................................................ 24
2.3.3 - Normales ................................................................................................................................ 24
2.3.4 - Illumination............................................................................................................................ 25
2.3.5 - Avantages et inconvénients ................................................................................................... 25
2.3.6 - Conclusion ............................................................................................................................. 27
3 - RENDU DE ROULEAUX..................................................................................................................... 29
3.1 - Bibliographie ........................................................................................................................... 29
3.2 - Implémentation ....................................................................................................................... 31
3.2.1 - Implémentation actuelle......................................................................................................... 31
3.2.2 - Implémentation future ........................................................................................................... 36
CONCLUSION ........................................................................................................................................... 38
BIBLIOGRAPHIE – REFERENCES – SOURCES..................................................................................... 39
2
REMERCIEMENTS
Je souhaiterais remercier la société Phoenix Studio et son directeur pour m’avoir donné l’opportunité de travailler
au sein de leur entreprise.
Je remercie également Julien Blervaque et Denis Dufour pour m’avoir confié ce projet, et pour leur aide et leurs
conseils lors de son déroulement.
Enfin, je remercie toutes les personnes de la section Recherche et Développement pour leur aide, leur gentillesse
et leur accueil.
3
INTRODUCTION
Dans le cadre de ma deuxième année de Master Professionnel d'Imagerie Numérique, j'ai effectué un stage
de 6 mois au sein de la société Phœnix Studio. C'est une société de jeu vidéo, basée à Lyon, à qui on doit
notamment le jeu à licence Alexandra Ledermann: Le Haras de la Vallée. Nous étions deux stagiaires (Denis
Fillot et moi-même) à devoir développer un rendu d'eau. Ce rendu, développé pour un projet confidentiel, devait
être en temps réel d'une part (ou tout du moins avoir un temps de rendu relativement court de l’ordre d’une
dizaine de secondes) et intégré au propre moteur graphique de Phœnix d'autre part.
La première partie du stage a été consacrée à un travail de recherche ; nous devions nous documenter sur les
différents états de la mer, sur ses différents mouvements ainsi que sur les méthodes connues et publiées à ce jour
pour développer le rendu que nous devions implémenter. La deuxième partie a été destinée à une partie
programmation, plus précisément à la modélisation d'une surface d'eau. Enfin, la troisième partie a été consacrée,
elle, au rendu de rouleaux. Mon stage ne se finissant que le 30 septembre, cette partie est toujours en cours de
développement comme détaillé plus loin dans ce rapport.
1 - REFERENCES - BIBLIOGRAPHIE - DOCUMENTATION
Le but de cette partie était de nous familiariser avec le sujet, d'effectuer un état de l'art afin de n'en retenir
que le plus important ; il nous a été demandé de référencer tous les états de la mer que l'on peut rencontrer,
l'impact que peut avoir l'environnement sur celle-ci, les différentes zones que l'on peut distinguer, et illustrer tout
ceci par des documents (photos, vidéo).
1.1 - Création des vagues
Logiquement, la première étape a été de comprendre ce qu'est une vague et comment elle est formée. En
effet, les vagues sont toujours présentes sur la surface de la mer, quel que soit la zone (littoral, large, ...), son état
(mer calme, agitée, ...) ou l'impact qu'a l'environnement au moment où la vague est observée (vent, pluie, …).
Les vagues sont des ondes transversales et longitudinales, c'est-à-dire qu'elles se déplacent parallèlement et
perpendiculairement au sens de propagation. En fait, en regardant le comportement d'une particule d'eau, on se
rend compte que son déplacement décrit un cercle (Figure 1).
Figure 1 – Mouvement circulaire de deux particules d'eau (en jaune)
4
La formation des vagues est influencée par quatre facteurs :
• La vitesse du vent
• La distance sur laquelle souffle le vent (fetch)
• La durée pendant laquelle il souffle
• La profondeur de l'eau
En fonction des ces facteurs (au plus ils seront importants, au plus les vagues seront grosses), les vagues créées
peuvent avoir différentes tailles, allant de simples ondelettes à de la forte houle. Néanmoins, quelque soit son
type, une vague est toujours caractérisée par sa hauteur H (distance creux-crête), sa longueur d'onde λ (distance
entre deux crêtes), sa période T (durée entre deux crêtes à un point stationnaire) et son sens de propagation
(Figure 2). D'autres grandeurs peuvent ensuite être déduites des précédentes (comme la fréquence, la pulsation,
etc...).
Figure 2 – Schéma d'un train de vagues et mise en évidence des ses caractéristiques
1.2 - Mers et océans
Par la suite, nous nous sommes concentrés sur les différentes parties qui composent les mers et les océans.
A partir des observations, de la recherche et de la documentation qui a été faite, nous avons synthétisé la mer par
le graphe en Figure 3. Les parties mentionnées dans le graphe sont détaillées et éventuellement illustrées par la
suite.
5
Figure 3 – Graphe des différentes parties composant la mer
Fin des vagues :
Une vague se « finit » soit en s'échouant sur une plage, soit en s'écrasant contre la côte. Dans le cas où elle
s'échoue sur une plage, on parle de vague déferlante. Une vague déferlante est une vague dont la base ne supporte
plus le haut, causant alors un déferlement (“écroulement”) de celle-ci. Près du rivage, où la profondeur est petite
par rapport à sa longueur d'onde, une vague se brise lorsque sa hauteur H est 0,8 fois plus grande que la
profondeur h de l'eau (H > 0,8 h). En fonction du degré d'inclinaison du fond, un déferlement différent est
observé.
6
•
Déferlement progressif ou glissant : Les
vagues commencent à s'écrouler loin du
rivage avec une crête à l'aspect
mousseux. Ce déferlement, qui se
produit sur les plages à très faible pente,
est le plus fréquent.
Figure 4 – Schéma d'un déferlement glissant
•
Déferlement plongeant : Également
appelé rouleau. La vague s'enroule
autour d'une poche d'air puis se brise en
créant beaucoup d'éclaboussures. Ce
déferlement se produit sur les plages à
pente plus forte ou lorsqu'il y a un brutal
changement du relief du fond.
Figure 5 – Schéma d'un déferlement plongeant
•
Déferlement frontal : Se forme comme
le déferlement plongeant, mais la vague
s'écrase sur la plage avant qu'elle n'ait
pu s'enrouler. On retrouve ce type de
déferlement sur les plages les plus
pentues.
Figure 6 – Schéma d'un déferlement frontal
Figure 7 – Déferlement glissant
Figure 8 – Déferlement plongeant
7
Impact environnement :
L'impact le plus important est évidemment le vent puisque, comme on l'a vu précédemment, il permet la création
de vagues plus ou moins hautes. Par ailleurs, l'environnement a un impact important sur l'aspect final de l'eau. En
effet la réfraction du fond conduit à un bleu plus clair près du rivage contre un bleu foncé et profond loin des
côtes (voir également la partie profondeur pour plus de détails). La réflexion du soleil va par ailleurs faire
apparaître une tâche spéculaire à la surface de l'eau (surtout lorsque le soleil est bas sur l'horizon), tandis que celle
du ciel va grandement influer sur la couleur perçue de la mer (orange lors d'un coucher de soleil, gris-bleu lorsque
le ciel est nuageux, ...). Il se peut également que des ombres soient projetées sur la surface ou le fond de la mer
(nuages).
Figure 9 – Réflexion du soleil sur l'eau
Figure 10 – Différence de couleur de la mer
selon la profondeur
Mouvements :
Comme vu au début de ce paragraphe, la taille des vagues est différente selon la grandeur des facteurs qui en sont
à l'origine. Bien qu'ils soient les mêmes dans tous les cas, on différencie plusieurs états de la mer selon la taille
des vagues. Ainsi, on peut aller de la mer calme à la mer agitée, en passant par la houle ou de simples vaguelettes.
A noter qu'on désigne ici par le terme “mascaret” le phénomène qui se produit lorsque deux vagues de sens de
propagation différent se rencontrent (c'est notamment le cas lorsqu'une vague est réfléchie contre un récif ou un
quelconque autre obstacle). A noter également que les tsunamis n'ont pas été inclus (car ils sont provoqués par un
séisme et non le vent), ni le phénomène très rare que sont les vagues scélérates.
Figure 11 – Mer calme, peu de vagues
Figure 12 – Mer agitée, grosses vagues et
présence d'écume
8
Profondeur :
Comme énoncé précédemment, la profondeur de l'eau aura une incidence directe sur sa couleur. D'une part, plus
l'eau sera profonde, moins les rayons lumineux atteindront le fond ; ceux-ci sont absorbés par les particules en
suspension naturellement présentes dans l'eau. D'autre part, la couleur de l'eau que perçoit un observateur est
également influencée par les rayons lumineux réfléchis au fond de l'eau, puis réfractés lorsqu'ils traversent la
surface pour atteindre l'œil dudit observateur. Ainsi, plus l'eau est profonde, moins l'observateur percevra de
rayons réfractés, résultant en une couleur de l'eau plus foncée. Par ailleurs, au plus l'observateur est à la
perpendiculaire de l'eau, au plus il perçoit de rayons réfractés (à l'opposé au plus il est parallèle, au plus il perçoit
de rayons réfléchis). Ceci est appelé effet de Fresnel. Là encore les rayons réfractés seront d'autant moins
nombreux que la profondeur est plus grande.
Figure 13 – Eau bleu foncé traduisant une grande
profondeur (observateur perpendiculaire à la surface)
Figure 14 - Pas de réflexions au bas de l’image (c’est là où on est le
plus perpendiculaire à l’eau).Plus on va vers le haut, au plus de
réflexions apparaissent
9
1.3 - Implémentation – Bibliographie
La finalité des travaux effectués jusqu'à maintenant étant d'implémenter un rendu d'océan, les recherches
ont ensuite été concentrées sur l'aspect implémentation des différentes parties trouvées précédemment ; une partie
de bibliographie a alors été abordée en parallèle. Le graphe en Figure 15 synthétise les différents points à
implémenter afin d'obtenir un rendu d'océan complet, ainsi que les méthodes (soulignées) rencontrées dans les
publications pour y parvenir.
Figure 15 – Présentation des méthodes possibles pour chaque zone de la mer
10
Fin de vagues : Les deux méthodes pour implémenter la fin des vagues qui reviennent le plus dans les
publications abordées sont basées sur les équations de Navier-Stokes et celles de Biesel
•
Équations de Navier-Stokes : Les équations de Navier-Stokes décrivent le mouvement d'un fluide
incompressible et peut, par conséquent, s'appliquer à n'importe quelle situation de simulation d'eau. C'est
pourquoi on les retrouvera comme possible implémentation dans plusieurs points suivants. Ces équations
sont un ensemble complexe d'équations différentielles. Elles peuvent cependant être simplifiées comme
décrit un ultérieurement.
•
Équations de Biesel : Les équations de Biesel sont une extension de celles de Gerstner (voir chapitre 2.2)
; là où les équations de Gerstner décrivent un mouvement circulaire (Figure 1), celles de Biesel vont
décrire un mouvement elliptique. Ces équations sont applicables aux fins de vagues car les ellipses
décrites par le mouvement d'une particule vont évoluer selon la profondeur et l'inclinaison du fond ; au
moins grande sera la profondeur au plus le grand axe sera parallèle au fond (voir illustration Figure 20).
Couleur finale / Effets optiques : L'aspect final de l'eau sera donné par sa couleur, couplée aux divers effets
optiques abordés auparavant.
•
Écume : Afin de simuler la présence d'écume (cette mousse blanche que l'on retrouve au niveau de crêtes
des vagues, notamment lorsqu'il y a beaucoup de vent) la méthode la plus répandue est l'émission de
particules. En revanche, la difficulté réside en la détection des endroits où les émettre. La plupart des
algorithmes rencontrés utilisent des critères basés sur la différence de hauteur par rapport au voisinage, ou
sur divers paramètres comme l'amplitude des vagues.
•
Effet de Fresnel : L'effet de Fresnel a été abordé dans le paragraphe 1.2 – Mers et Océans
•
Loi de Snell : Cette loi, également appelée loi de Snell - Descartes, régit les effets d'optique comme la
réflexion, la réfraction, la diffusion. Elle est très facilement implémentable puisqu'elle repose sur un
rapport de sinus. Une autre méthode consiste à utiliser une texture pour stocker les réflexions et/ou les
réfractions et de s'y référer lors du calcul de la couleur.
•
Caustic : Les “Caustic” sont ces rides lumineuses que l'on aperçoit au
fond de l'eau. Celles-ci sont dues au fait que les rayons de lumière se
concentrent ou, au contraire, se dispersent lorsqu'ils passent au travers de
la surface. La plupart des méthodes pour générer ces “caustic”sont
basées sur la loi de Snell - Descartes ; l'intensité des rayons lumineux
réfractés en chaque sommet d'un triangle est évalué (la surface de l'eau
étant triangulée) ce qui va servir à générer une texture qui représentera le
fond de l'eau. Cette texture peut éventuellement être manipulée afin de
pouvoir la répéter indéfiniment.
Figure 16 – Concentration et dispersion des
rayons lumineux lors de leur réfraction
Figure 17 – Illustration réelle du phénomène de « caustic »
11
Rouleaux et surface / height field : Ces deux points seront abordés plus en détail dans les paragraphes suivants.
Espace sous-marin : Afin d'avoir un rendu final complet, il est nécessaire d'implémenter également les espaces
sous-marins. Cependant, une très grande minorité des auteurs des publications ont choisi de prendre en compte de
tels espaces.
•
•
•
Absorption de la lumière : Comme vu dans le paragraphe précédent, les rayons lumineux qui traversent la
surface de l'eau sont absorbés. C'est pour cette raison que la distance maximale que l'on peut percevoir
sous l'eau est beaucoup moins importante qu'hors de l'eau. Afin de simuler cet effet d'atténuation de la
lumière, on va là encore évaluer l'intensité d'un rayon lumineux après un parcours d'une longueur donnée
dans le volume d'eau (cette longueur est en général la distance objet / caméra).
Caustic : Les “caustic” ont déjà été abordés précédemment.
God-Ray : Les “God-Ray” sont les rayons lumineux que peut
apercevoir un observateur lorsqu'il est situé sous la surface de
l'eau et regarde en direction d'une source lumineuse. Une (et la
seule) méthode rencontrée afin de modéliser cet effet avec un
temps d'exécution relativement court est basée sur la répétition
d'une texture de caustic devant la caméra (Figure 18). Le rendu
est ensuite effectué en attribuant à la composante alpha de ces
textures une valeur adaptée et en désactivant l'écriture dans le zbuffer (autrement seule la texture la plus proche serait rendue).
Figure 18 – Répétition d'une texture de caustic
devant la caméra pour rendre les « God-Ray ».
Image issue de [4]
Figure 19 – Illustration réelle de « God-Rays »
12
1.4 - Concentration sur la topologie
Suite aux travaux synthétisés dans le graphe en Figure 15, les points les plus importants pour débuter
l'implémentation de notre rendu ont semblé être ceux en rapport avec la géométrie de la surface de l'eau, c'est-àc'est
dire, les points permettant d'obtenir un maillage se rapprochant le plus fidèlement possible d'un océan. Nous
avons donc
nc répertorié l'ensemble des méthodes temps réel à notre disposition en les mettant en relation avec les
différentes “régions” de la mer, selon celles qui sont applicables pour modéliser une région précise (Figure 20).
Figure 20 – Présentation des différents
différents algorithmes en temps réel selon les zones de la mer
Bien qu'elles pourraient s'appliquer à toutes les régions, les équations de Navier-Stokes
Navier Stokes ne sont pas considérées
car leur exécution ne permet pas un rendu temps réel. Une méthode permet néanmoins de réduire
considérablement leur temps d'exécution ; cette méthode consiste à utiliser une grille rectangulaire pour
représenter le volume d'eau. Pour chaque colonne, on utilise un ensemble de tuyaux virtuels pour décrire le
comportement de l'eau entre une colonne et celles qui lui sont adjacentes (Figure 21). Mais malgré cette
amélioration, les équations de Navier-Stokes
Navier Stokes ne pourraient être utilisées, tout du moins pour une grande surface
(ce qui est notre cas).
13
Figure 21 – Approximation des équations de Navier-Stokes. Image issue de [14]
2 - RENDU D'UNE SURFACE D'EAU (OU HEIGHT FIELD)
Nous nous sommes d'abord concentrés sur la modélisation des zones allant de la haute mer à celle des
interactions avec la côte. L'avantage est qu'en changeant certains paramètres (la hauteur des vagues notamment),
on peut couvrir toutes ces zones avec une même méthode.
Le but de notre application n'était pas d'avoir un rendu parfait, mais plutôt de se concentrer sur la géométrie de la
surface. Nous n'avons donc pas utilisé de skybox ni la technologie des Shaders par exemple, ce qui aurait
grandement amélioré le réalisme des rendus. Ceci explique pourquoi les captures d’écran montrées ici pourront
paraître fades et pixélisés.
Par ailleurs, notre implémentation devrait être réutilisée dans le moteur graphique de Phœnix. Par conséquent une
période de prise en main était nécessaire au préalable, mais elle ne sera pas abordée ici pour des raisons de
confidentialité.
Enfin, l'application développée comporte une interface basique axée sur des entrées souris et clavier et une sortie
console. Les touches permettent la modification de divers paramètres propres ou communs à chaque méthode,
tandis que la combinaison des touches directionnelles et de la souris permet le déplacement dans la scène à la
manière d'un jeu de FPS (First Person Shooter).
2.1 - Bruit de Perlin
Cette partie a implémentée par Denis Fillot (le second stagiaire), elle ne sera donc abordée que
superficiellement.
Le bruit de Perlin est une fonction pseudo-aléatoire qui permet d'obtenir un bruit cohérent permettant de
modéliser certains phénomènes naturels comme des nuages, de la fumée, des veinures de bois ou des vagues.
Le principe de ce bruit est qu'il renvoie une valeur aléatoire en fonction du(des) paramètre(s) qui est(sont)
passé(s), mais que cette valeur est identique si le(s) même(s) paramètre(s) sont utilisé(s) à nouveau. D'autre part,
si la valeur de retour d'un paramètre n'est pas connue, elle sera interpolée, comme illustré en Figure 22
14
Soit ℱ: ℕ → ℝ une fonction qui, à chaque entier de
l'intervalle 1,14 attribue une valeur réelle comprise dans
0,1.
En interpolant, on pourra connaître les valeurs retournées par
tout l'intervalle de départ 1,14 et pas seulement les entiers.
Figure 22 – Interpolation d'une fonction.
Image issue de http://freespace.virgin.net/hugo.elias/models/m_perlin.htm
Dans notre cas, le bruit de Perlin sera utilisé pour obtenir la hauteur d'un point du maillage de coordonnées
horizontale (, ) à un temps t.
L'utilisation d'un seul bruit de Perlin ne conduirait pas à un rendu réaliste. Par conséquent, plusieurs bruits avec
des amplitudes et fréquences différentes on été utilisés puis sommés (Figure 23). Chaque bruit ajouté est désigné
comme une octave, car sa fréquence est le double de celle du bruit précédent (en musique les octaves ont
également cette propriété).
Figure 23 – Addition de 4 octaves de bruit de Perlin. Image issue de [14]
Dans un souci d'optimisation, le rendu n'est effectué que pour le champ de
vision de la caméra ; l'intersection entre le plan d'eau et le champ de vision
est calculé, nous donnant ainsi les quatre points qui vont délimiter la zone
de rendu. Ces points vont ensuite servir à interpoler tous les points qui
constitueront le maillage final. Cela reviendrait à avoir une grille uniforme
devant la caméra dont les points qui seraient projetés sur le plan d'eau. En
plus d'éviter les temps de calcul inutiles de rendu hors champ, cette
méthode offre une illusion de plan d'eau infini.
Figure 24 – Projection d'une grille sur
le plan d'eau. Image issue de [14]
Des captures d’écran de cette implémentation sont montrées dans les figures suivantes. La Figure 25 montre un
rendu en polygones plein, tandis que la Figure 26 montre un rendu en fil de fer. Du fait de la perspective, le
maillage paraît uniforme, alors que la Figure 27 prouve qu'il ne l'est pas.
15
Figure 25 – Surface d'eau obtenue avec du bruit de Perlin (rendu en polygones plein)
Figure 26 – Surface d'eau obtenue avec du bruit de Perlin (rendu en fil de fer)
16
Figure 27 – Mise en évidence de la projection de la grille
2.2 - Equations de Gerstner
Les équations de Gerstner, découvertes il y a près de 200 ans, ont permis d'approximer celles de la
dynamique des fluides. Leur première application en imagerie numérique semble dater de 1986 avec les travaux
de Fourier et Reeves [2]. Ces équations permettent de décrire le mouvement circulaire qu'aurait un point si il était
à la surface de l'eau (Figure 1).
2.2.1 - Calcul de la height field
Soit = ( , ) les coordonnées horizontales d'un point à la surface non perturbée et = 0 , la hauteur
de ce point. Au passage d'une vague, le point de la surface est déplacé pour un temps t en:
= + sin (. − )
= cos (. − )
où est l'amplitude de la vague, un vecteur horizontal qui pointe dans le sens de propagation de la vague et sa phase, définie en fonction de sa vitesse ! et de sa fréquence " telle que :
= !"
En utilisant les équations de Gerstner telles que définies jusqu'à maintenant, le résultat serait beaucoup trop
répétitif et uniforme pour être réaliste (Figure 28). En revanche, on peut étendre l'utilisation de ces équations pour
générer une height field plus complexe en sommant un ensemble de plusieurs vagues, chacune d'elles ayant leur
propre caractéristique vues plus haut (amplitude, phase, fréquence, …) (Figure 29). Le déplacement d'un point est
alors défini par :
= + ∑ $ sin ($ . − $ )
y= ∑ $ cos ($ . − $ )
17
Figure 28 – Rendu d'une seule vague de Gerstner
Figure 29 – Rendu d'une somme de 5 vagues
de Gerstner
L'animation des vagues est déterminée, entre autres, par les fréquences de celles-ci. Pour les vagues d'eau de mer,
il existe une relation bien connue entre cette fréquence " et la magnitude d'une vague. Au large, où l'influence
du fond peut être ignorée, la relation est donnée par
"()2 = &
où & = 9,81 m/s² est la constante gravitationnelle
La magnitude étant elle-même définie en fonction de la longueur d'onde ' par :
=
()
*
Dans le cas où le fond est suffisamment proche de la surface pour avoir une influence, la relation devient
"()2 = & tanh (.)
où . est la profondeur de l'eau
A noter que dans le cas d'une profondeur très grande, le facteur tanh tendrait vers limx→∞ (tanh (x)) = 1,
donnant alors la formule du dessus.
2.2.2 - Normales
Afin d'avoir un rendu en polygone plein et
de pouvoir avoir des effets d'optiques, il est
nécessaire de connaître les normales de la height
field en chaque point.
Par conséquent, la normale d'un point va être
calculée en fonction de ses voisins de la manière
suivante :
soit T le tableau à double entrée dans lequel sont
stockés les coordonnées des points constituant la
height field et (i ; j) les indices d'un point P (ie,
P = T[i][j]).
Considérons les vecteurs horizontaux 3 et 3
ayant pour coordonnées respectives (T[i+1][j] –
T[i-1][j]) et (T[i][j+1] – T[i][j-1]). La normale
au point P est alors donnée par le produit vectoriel
3 ∧ 3 (Figure 30).
Figure 30 – Calcul de la normale par produit vectoriel
18
2.2.3 - Illumination
Maintenant que les normales sont connues, il est possible de rendre la height field en polygone plein. On
utilisera ici le modèle d'illumination de Phong afin d'avoir une meilleure qualité de rendu que celui obtenu avec le
modèle d'illumination de base d'OpenGL : Pour chaque point de la height field on calcule la couleur issue de son
illumination ambiante, diffuse et spéculaire de la manière suivante :
567859:;$<=>? = 567859:@AB?C
38DDEF:;$<=>? = 38DDEF:@AB?C (G. H)
FIéKEL58M:;$<=>? = FIéKEL58M:@AB?C (!. N)<
où G est le vecteur allant du point de la surface à la source lumineuse, H la normale en ce point, ! est le vecteur
vue, 9 un paramètre constant et N, réflexion de G au point courant, défini par :
N = G − 2 (G. H) H
La couleur finale du point sera alors donnée par la somme des trois composantes ambiante, diffuse et spéculaire.
De plus, du fait de la nature des calculs, la couleur change selon le point de vue, permettant ainsi de mettre en
évidence les réflexions de la source lumineuse sur la height field.
Des captures d’écran du rendu final sont visibles en Figures 31 et 32.
Figure 31
Figure 32
Rendus de 4 vagues de Gerstner en polygone plein avec illumination de Phong (résolution de 256 x 256)
19
2.2.4 - Avantages et inconvénients
Au cours du développement, de l'utilisation et des observations, il s'est avéré que le rendu d'océan utilisant
les équations de Gerstner n'est pas une très bonne méthode pour plusieurs raisons :
Dépendance aux paramètres :
L'aspect final de la height field dépend grandement des
paramètres des vagues (amplitude, longueur d'onde,
phase, …). Notre application choisissant ces paramètres
aléatoirement, il est possible de passer d'un rendu correct
(Figures 31 - 32) à un rendu peu réaliste et au mouvement
non naturel (Figure 33) selon la combinaison des
paramètres.
F
Figure 33 – Des mauvais paramètres conduisent à un
rendu médiocre
Non Juxtaposition :
La nature des équations de Gerstner ne permet pas de juxtaposer
côte à côte une même height field qui serait répétée sans que cela
soit détectable (Figure 34).
En effet, tous les points constituant une bordure de la première
height field ne sont pas à la même hauteur que tous les points
constituant la bordure de la deuxième height field qui serait à côté.
Par conséquent, le seul moyen d'avoir un rendu plus étendu est
d'agrandir cette height field (sans nécessairement changer le
nombre de points), étirant du coup sa géométrie, ce qui peut nuire
au réalisme.
Figure 34 – Juxtaposition de 4 height fields
Normales :
Comme il est visible sur les screenshots précédents, le rendu final est beaucoup trop lisse pour être réaliste. Dans
le monde réel, il existe toujours de petites rides à la surface des vagues, que celles-ci soient grandes ou au
contraire très petites.
Pour pallier à cet effet, un bruit a été appliqué à la height field afin de modifier légèrement la hauteur des points la
constituant. Cela est particulièrement visible lorsque la source lumineuse se reflète sur les vagues (Figures 33 34), mais malheureusement cette technique n'est guère satisfaisante.
Par conséquent, il est nécessaire d'utiliser la méthode de Bump Mapping évoquée en Figure 20 pour modéliser la
haute mer ; les normales calculées à partir de la géométrie du maillage (comme expliqué et illustré
précédemment) vont être modifiées grâce à une normal map adaptée.
Répétition :
Les Figures 31 à 34 montrent également que le rendu de la height field est bien trop répétitif. Cet effet est d'autant
plus notable lors de l'animation. En pleine mer, il est quasi improbable de trouver deux vagues qui soient
exactement identiques, qui aient la même amplitude au même point de passage ou le même mouvement. Cet effet
de répétition peut cependant être réduit avec l'utilisation d'un shader, grâce notamment aux effets de réflexions
qui la camoufleront.
20
Les équations de Gerstner comportent cependant quelques bons côtés :
Répétition :
La répétitivité évoquée en tant qu'inconvénient peut cependant s'avérer utile lorsqu'il s'agit de modéliser la zone
d'interaction avec la côte. En effet, à mesure que les vagues s'approchent du rivage, elles s'alignent pour devenir
quasiment parallèles avec la côte. C'est pourquoi il est extrêmement rare de trouver des vagues s'échouant sur une
plage en biais par rapport à celle-ci, et encore plus encore de trouver une vague s'échouant avec un angle
grandement différent d'une autre. Par conséquent, il est possible d'exploiter le fait que, avec cette méthode de
rendu, deux vagues qui se suivent se ressemblent.
Figure 35 – Les vagues s'alignent avec la côte
plus elles s'en approchent
Figure 36 – Rendu de vagues parallèles
pouvant se rapprocher de la photo en Figure 35
Implémentation :
Les mathématiques qui régissent les équations de Gerstner sont faciles à comprendre et à appréhender (il s'agit
d'une somme de sinus et cosinus - voir formules en 2.2.1 -). Par conséquent, l'implémentation de la modélisation
par les équations de Gerstner est facile.
2.2.5 - Conclusion
Malgré une implémentation facile et un mouvement de point tout à fait réaliste, le rendu d'eau utilisant les
équations de Gerstner présente beaucoup de désavantages et ne convient pas pour la modélisation de la pleine
mer. Cette méthode peut cependant être plus utile pour les zones d'interaction avec la côte.
Concernant le temps de rendu, l'application développée s'exécute en temps réel ; pour une seule vague
« sommée » et un maillage de 256 x 256 points, la moyenne est de 138 fps (Frame Per Second). L'augmentation
du nombre de vagues à sommer diminue le nombre d’images par seconde, mais on reste toujours dans du temps
réel (37 fps pour 8 vagues sommées). En revanche, l'augmentation du nombre de points a beaucoup plus d'impact
sur le temps de rendu. Ces résultats sont visibles en Figure 37.
Nombre
de points
1 vague
4 vagues
8 vagues
FPS Min FPS Moy FPS Max FPS Min FPS Moy FPS Max FPS Min FPS Moy FPS Max
128 x 128
976,5
2488,25
> 4000
642,3
1321,15
> 2000
452,6
746,55
1040,5
256 x 256
113,1
138,7
164,3
64
73,3
82,6
33,8
37,4
41
512 x 512
7,7
8
8,4
4
4,1
4,2
2,2
2,25
2,3
Figure 37 – FPS obtenus pour un rendu d'eau utilisant un nombre différent de vagues de Gerstner sommées. Données
calculées avec un ordinateur de bureau possédant un processeur Intel Quad Core Q6660 cadencé à 2,41GHz, et une carte
graphique ATI Radeon HD 4870.
21
2.3 - Utilisation de transformées de Fourier rapides (FFT pour Fast Fourier
Transform)
L'utilisation de FFT pour les rendus d'océan est récente. En effet, c'est en 2001 que Jerry Tessendorf décrit
cette méthode de rendu dans sa publication « Simulating Ocean Water » [16], même si elle été déjà utilisée
quelques années auparavant. Plutôt que d'utiliser un modèle purement mathématique, le rendu par FFT s'appuie
sur une combinaison de modèles statistiques et d'observations expérimentales. Cependant, la base de la méthode
s'appuie toujours sur une somme de sinus et cosinus étant donné que les FFT sont utilisées. En effet, une FFT est
définie comme suit :
Soit (9) une série de nombres complexes de H éléments de la forme , O , ( , … , Q , … , RSO où est un
complexe ( = Té?> + 8 $U=V )
La transformée de Fourier de cette série, notée (9), comprendra également H éléments et est définie par :
$(Q)X
(9) = R ∑RSO
QY ():
pour 9 = 0, … , H − 1
$(Q)
X
(9) = ∑RSO
QY ():
pour 9 = 0, … , H − 1
O
W
La transformée inverse sera définie par :
W
Or, : $Z = cos() + 8 sin (). On retrouve donc une somme de sinus et cosinus, comme dans les équations de
Gerstner.
2.3.1 - Calcul de la height field
Le principe du rendu est de calculer le spectre d'un océan, puis d'obtenir la height field finale grâce à une
FFT inverse de ce spectre. Ainsi la hauteur ℎ(, ) de chaque point du maillage = (, ) est donnée en fonction
du temps par :
ℎ(, ) = ∑ ℎ\(, ): $Q]
où est le temps et un vecteur à deux dimensions de coordonnées = (Z , ^ ) où Z = 2_ ` , ^ = 2_ . 9 et
<
a
Ù
b
6 étant des entiers tels que 9 soit compris dans l'intervalle c− ( ; ( cet 6 compris dans c− ( ; ( c, où H et f sont
respectivement la résolution en et en du maillage (ie, le nombre de points). On fait ainsi apparaître le terme en
2_ présent dans la formule d'une FFT inverse. De même, GZ et G^ sont la longueur de la height field selon et .
`
`
Le point dont la hauteur est évalué est donc le point = (9 Ra , 6 eb) (9 et 6 devront donc prendre
successivement toutes les valeurs entières de l'intervalle auquel ils appartiennent afin d'évaluer la hauteur de tous
les points du maillage).
R R
e e
Les analyses statistiques de données collectées par « bouées à vagues » (wave buoy), photographies ou par
mesures radar de la surface des océans démontrent que l'amplitude des vagues ℎ\(, ) se rapproche d'une
distribution gaussienne couplé à un spectre adéquat.
Plusieurs spectres existent, tous basés sur des observations, notamment par l'intermédiaire de wave buoy. Ces
bouées restent immobiles sur l'eau et suivent le mouvement des vagues afin de mesurer le déplacement vertical de
l'eau en fonction du temps. Une FFT est alors appliqué aux données enregistrées afin de passer du domaine
temporel au domaine fréquentiel, donnant ainsi un spectre.
Figure 38 – Mesure d'un spectre d'océan à l'aide d'une wave buoy
22
jk
Le spectre utilisé dans notre implémentation est le spectre de Phillips défini par la formule suivante :
gh () =
? (lmln)
i lQlp
o
q (. r)²
où est une constante affectant légèrement la hauteur des vagues, G =
t²
V
obtenue avec une vitesse de vent de ! (en m/s), r est la direction du vent et & est la constante gravitationnelle.
est la vague la plus haute possible
Ce spectre donne des résultats corrects mais peut être grandement amélioré. En effet, en l'utilisant telle quelle,
cette formule fait apparaître de nombreuses petites vagues, nuisant au réalisme du rendu. Pour pallier à ce
problème, il est possible de supprimer les vagues dont la hauteur est inférieure à une certaine hauteur L (L ≪ G)
en multipliant le spectre de Phillips par le facteur :
: SlQl²>²
D'autre part, il est possible de faire en sorte que les vagues rendues soient dans l'alignement du vent ; il suffit de
changer l'exposant du terme (. r), les vagues étant d'autant plus alignées que l'exposant est grand. Nous utilisons
dans notre implémentation un exposant 6. Les Figures 39 et 40 représentent deux heightmap(1) différentes,
mettant en évidence l'impact de l'exposant.
Il est maintenant nécessaire d'introduire la partie « distribution gaussienne » évoquée plus haut. Bien qu'un autre
type de génération de nombres aléatoires fonctionnerait, une génération aléatoire gaussienne tend à suivre les
données expérimentales. Il est encore plus efficace d'introduire cette partie aléatoire directement dans le domaine
de Fourier, donnant ainsi la formule d'amplitude de la height field suivante :
ℎ\ () =
O
√(
(wT + 8 w$ )xgh ()
où wT et w$ sont des tirages d'une génération de nombres aléatoires gaussiens de moyenne 0 et d'écart type 1.
Ainsi, il est possible d'écrire la formule complète des amplitudes de Fourier de la height field en fonction du
temps :
ℎ\(, ) = ℎ\ (): $y(Q)C + ℎ\∗ (−): S$y(Q)C
où "() est la fréquence définie dans le paragraphe 2.2.1 et ℎ\∗ () le conjugué de ℎ\ (). Le terme de droite, lui,
empêche les vagues de se propager dans deux directions différentes
.
Figure 39 – Heightmap obtenue sans aligner
les vagues au vent (facteur (. r)²)
Figure 40 – Heightmap obtenue en
alignant les vagues au vent (facteur (. r){
(1) : Une heightmap est une texture ou une image dont la hauteur de chaque texel / pixel est codé selon sa couleur.
Au plus il est haut, au plus il sera clair.
23
2.3.2 - Formation de crêtes
Jusqu'à maintenant, les points formant la height field ne sont déplacés que verticalement, résultant en des
vagues rondes au sommet, ce qui est en réalité peu fréquent. Dans le soucis d'une modélisation encore plus
réaliste, il est possible de faire apparaître des crêtes afin d'avoir des vagues plus « pointues ». Ces crêtes vont
apparaître en déplaçant légèrement le point dans le plan horizontal (, ). Ce déplacement sera lui aussi calculé à
l'aide d'une FFT par :
|(, ) = ∑ −8 lQl ℎ\(, ): $Q.]
Q
La nouvelle position d'un point = (, ) de la surface au temps sera désormais } = + '|(, ) où ' est un
paramètre permettant d'accentuer l'importance du déplacement. Cependant il ne convient pas d'avoir un trop grand
déplacement auquel cas les points se « rentreraient » les uns dans les autres, ce qui formerait un looping aux
sommets, créant ainsi un effet peu désirable.
Figure 41 – Comparaison entre deux profils de vague. Image issue de [16]
2.3.3 - Normales
Pour les mêmes raisons de rendu que pour les équations de Gerstner, il est nécessaire de connaître la
normale de la height field en chaque point. Là également, il est possible d'utiliser le produit vectoriel ; bien que
cette méthode soit efficace en terme d'utilisation de mémoire et de temps d'exécution, il est préférable d'utiliser à
nouveau des FFT pour calculer les normales. Plus précisément, on calculera le gradient en chaque point (dans le
domaine de Fourier). En effet, pour un point d'une surface, si le gradient est non nul, il est perpendiculaire au plan
tangent à la surface en ce point, c'est-à-dire colinéaire à la normale en ce point. La normale en un point est donc
donnée par la formule :
9(, ) = ∇ ℎ(, ) = ∑ 8ℎ\ (, ): $Q.]
où = (, ) est le point auquel la normale est calculé et le temps.
L'utilisation du produit vectoriel pour le calcul des normales n'est pas adaptée pour les vagues de très faible
hauteur. Le rendu apparaîtrait donc beaucoup plus lisse, nuisant à son réalisme final.
24
2.3.4 - Illumination
De même que pour les équations de Gerstner, notre implémentation utilise le modèle d'illumination de
Phong, mettant ainsi d'autant plus en évidence les petites vagues qui augmentent la crédibilité de la height field.
Des capture d’écran montrant le rendu final obtenu avec cette méthode sont visibles en Figures 42 à 44.
Figure 42 - Rendu d'une surface d'eau obtenu par FFT
Figure 43 - Rendu de la même surface sans calculer
les normales par FFT mais par produit vectoriel
Figure 44 - Rendu de la même surface sans utiliser le déplacement horizontal
2.3.5 - Avantages et inconvénients
Les principaux désavantages rencontrés au cours du développement de cette méthode sont les suivants :
Temps de calcul :
Le temps de calcul de chaque frame est relativement long, ne permettant malheureusement qu'une application en
temps quasi-réel (de l'ordre de 10 fps). La principale raison est l'utilisation de six FFT pour le calcul d'une height
field ; une FFT est nécessaire pour le calcul de chaque coordonnée (, , ) de tous les points du maillage. De
même, une FFT devra être utilisée pour connaître chaque composante de la normale en un point. Cependant, le
temps de rendu d’une image peut être augmenté ou diminué selon la résolution du maillage ; celle-ci a en effet
une très grande influence sur les temps de calcul (Figure 46).
25
Résolution :
Du fait de la nature de l'algorithme d'une FFT, il est nécessaire que la résolution du maillage soit une puissance de
2, limitant ainsi grandement les possibilités de la résolution. Cela est d'autant plus désavantageux que, comme
évoqué plus haut, le nombre de points a une forte répercussion sur le nombre d’images affichées par seconde.
Les avantages du rendu d'océan par FFT sont :
Rendu réaliste :
Comparées à toutes les autres méthodes de modélisation d'océan en temps réel (Figure 20), c'est celle basée sur
les FFT qui donne les résultats les plus satisfaisants. Les vagues sont réalistes, le mouvement de celles-ci n'est pas
répétitif comme c'était le cas pour les équations de Gerstner et paraît naturel. Les normales permettent
l'apparition de petites ridules à la surface des vagues, ajoutant de la crédibilité à la scène sans avoir recours à une
autre méthode. Enfin, il est possible d'utiliser un autre spectre (plus réaliste éventuellement) sans rien changer
d'autre à l'implémentation.
Juxtaposition :
Afin d'avoir une zone de rendu plus étendue, il est possible d'agrandir la taille de la height field. Bien que tout à
fait convenable, cette méthode peut déformer la géométrie des vagues pour de grandes tailles, réduisant la qualité
dudit rendu (comme cela avait été évoqué pour les équations de Gerstner). Une autre méthode est de répéter une
même height field ; contrairement aux height field obtenues avec les équations de Gerstner, celles obtenues par
les FFT sont parfaitement juxtaposables à l'infini (Figure 45). Cependant, cette technique induit logiquement une
périodicité des vagues. Cet effet indésirable sera imperceptible si la taille de la height field et grande comparée au
champ de vue de la caméra. Une autre méthode pour réduire cette répétition est de placer la caméra près de la
surface de l'eau.
Figure 45 – Répétition et juxtaposition d'une seule height field
26
2.3.6 - Conclusion
L'utilisation de FFT pour la modélisation d'océan en « temps réel » donne des résultats probants. Parmi
toutes les autres méthodes disponibles, elle est celle qui donne les vagues les plus réalistes et les effets d'optiques
les plus proches de ceux rencontrés dans le monde réel. D'ailleurs, cette méthode a été utilisée dans différents
films (comme Waterworld, Titanic, Pearl Harbor, Seul au monde, X-Men 2) mais aussi dans des jeux vidéos
(Myst III : Exile ou Far Cry par exemple).
Comme évoqué plus haut, les temps de rendu sont longs mais permettent cependant un rendu temps réel ou quasi
temps réel. Comme le montre la Figure 46, c'est la résolution du maillage qui a la plus grande influence, mais il
est possible d’économiser du temps de calcul en limitant le nombre de FFT (réduisant ainsi la qualité de la scène).
Nombre
de points
Sans calcul du déplacement Sans calcul des normales par Avec calcul du déplacement
horizontal par FFT
FFT
et des normales par FFT
FPS
Min
FPS
Moy
FPS
Max
FPS
Min
FPS
Moy
FPS
Max
FPS
Min
FPS
Moy
FPS
Max
128 x 128 450,3
745,4
1040,5
340,2
606,8
873,5
251,9
362,25
472,6
256 x 256 33,8
37,4
41
28,6
31,35
34,1
9,3
9,75
10,2
512 x 512 0,9
0,95
1
0,68
0,69
0,7
0,55
0,55
0,56
Figure 46 - FPS obtenus pour un rendu d'eau utilisant un différent nombre de FFT. Données calculées avec un ordinateur
de bureau possédant un processeur Intel Quad Core Q6660 cadencé à 2,41GHz, et une carte graphique ATI Radeon HD
4870.
27
Figure 47 - Rendu d'une surface d'eau utilisant la méthode basée sur les FFT pour un temps t = t1. Height field de résolution
1024 x 1024 pour une taille de 300, répétée deux fois
Figure 48 - Rendu de la même surface d'eau utilisant la méthode basée sur les FFT pour un temps t = t2. Height field de
résolution 1024 x 1024 pour une taille de 300, répétée deux fois
28
3 - RENDU DE ROULEAUX
La deuxième partie du stage était consacrée à la modélisation de rouleaux, cas particulier d'une vague
déferlante (Figure 5), mais néanmoins importante dans l'utilisation future de notre implémentation. Les méthodes
trouvées jusqu'à maintenant et répertoriées en Figure 20 n'étaient pas satisfaisantes :
Les équations de Biesel ont l'avantage d'être une extension de celles de Gerstner, ce qui aurait facilité
l'implémentation et l'intégration au code déjà existant. Cependant, il n'est pas possible d'avoir un écroulement de
la vague avec cette méthode. D'autre part, la méthode décrite dans Real-time Breaking Waves for Shallow Water
Simulations [9] qui consiste à placer un patch au sommet d'une vague détectée comme assez raide pour simuler un
rouleau n'est pas non plus applicable à notre cas. En effet, malgré un temps de calcul rapide et un rendu de la
« naissance » et de la « vie » d'un rouleau assez réaliste, le problème intervient là aussi au niveau de l'écroulement
; afin que celui-ci soit réaliste, il faudrait d'une manière ou d'une autre que la hauteur de la vague baisse. Ainsi la
vague ne serait plus détectée comme assez raide et le patch ajouté disparaitrait subitement.
Devant l'absence de méthode « automatique » efficace, nous avons choisi une modélisation manuelle de rouleaux
à l'aide de Free Form Deformation (FFD). Cette technique, utilisée notamment dans le film d'animation Surf's Up,
donne d'excellents résultats. Une FFD est une « boite » de déformation composée de plusieurs points de contrôle.
En bougeant ces points on fait subir à la boîte une déformation qui va se répercuter sur l'objet.
3.1 - Bibliographie
Là encore, un travail préalable de bibliographie était nécessaire, le but étant d'implémenter nos propres
FFD et de les intégrer dans l'IDE (Integrated Development Environment) du moteur graphique de la société.
Ainsi, même si n'importe quel logiciel de modélisation graphique contient des FFD dans l'ensemble bien
implémentées et interfacées, nous devions créer les nôtres. Par ailleurs, de cette manière il est également possible
d'inclure diverses options ou notions qu'on ne retrouverait pas forcément dans un logiciel et qui pourrait être utile
pour modéliser des rouleaux.
Nous avons trouvé beaucoup moins de publications concernant les FFD que nous en avions trouvé pour la
modélisation de l'océan. La première publication traitant de FFD est le travail de Thomas Sederberg et Scott Parry
(Free Form Deformation of Solid Geometric Models) et date de 1984[32]. La méthode part du principe qu'on
dispose d'une boite (qu'on appellera par la suite lattice) composée de N points de contrôles qui englobe un objet.
Cette boite va définir un système de coordonnées local (F, , E) d'origine de manière à ce que tous les points de
contrôles aient des coordonnées compris dans l'intervalle 0,1. Autrement dit, les 3 vecteurs définissant cette
nouvelle base seront 3 arêtes de la boite de départ, de manière à ce que les points de contrôle de coordonnées
locales (0,0,0) et (1,1,1) soient diagonalement opposés (Figures 49 et 50).
Figure 49 – Forme initiale de la lattice et
position initiale des points de contrôle
Figure 50 – Repère de coordonnées locales
défini par 3 arêtes de la lattice
29
Le nombre de points de contrôle constituant la lattice peut être choisi librement ; soient (L, 6, 9) trois entiers tels
que la lattice comporte L + 1 points de contrôle dans le sens F, 6 + 1 dans le sens et 9 + 1 dans le sens E. Les
coordonnées d'un point de contrôle g$BQ sera donc :
g$BQ = + F +
$
>
B
U
+ E
Q
<
Comme évoqué en introduction du paragraphe, la déformation de la lattice (ie, le mouvement des points de
contrôle) se répercutera de manière identique sur l'objet. Cette déformation sera calculée en deux étapes.
La première consiste à calculer les coordonnées locales (F, , E) des points de l'objet. Pour ce faire, la formule
suivante utilisant de l'algèbre linéaire est utilisée :
F=
C∧.(]SZ€ )
C∧.
=
∧.(]SZ€ )
∧.C
E=
∧C.(]SZ€ )
∧C.
où = (, , ) sont les coordonnées globales du point de l'objet.
La seconde étape sera le calcul de la nouvelle position de point. Ce calcul, basé sur le polynôme de Bernstein,
utilise la formule :
USB B
} = ∑>$Y ‚>$ (1 − F)>S$ F $ (∑U
(∑<QY ‚<Q (1 − E)<SQ EQ g$BQ ))
BY ‚U (1 − )
B
On remarquera que cette méthode de FFD se rapproche assez des courbes de Bézier, au niveau de la formule
notamment, mais également au niveau de l'approche, avec la manipulation de points de contrôles qui extrapolent
la nouvelle position des points de l'objet.
D'autres publications, plus récentes, traitent également d'autres méthodes de FFD.
Celle de Sabine Coquillard (Extended Free Form Deformation : A Sculpturing Tool For 3D Geometric Modeling)
[31] s'appuie sur les travaux de Thomas Sederberg et Scott Parry, mais permet la manipulation d'une lattice de
forme choisie par l'utilisateur (cylindrique notamment) obtenue en bougeant, supprimant et fusionnant des points
d'une lattice initialement parallélépipédique.
La méthode décrite par William M Hsu, John F. Hughes et Henry Kaufman dans Direct Manipulation of FreeForm Deformations [29] permet une modélisation beaucoup plus fine. En effet, au lieu de déplacer un point de
contrôle puis de calculer la nouvelle position des points de l'objet, l'utilisateur bougera un point de l'objet. Des
calculs seront alors destinés à calculer les positions des points de contrôle nécessaires au déplacement du point
modifié par l'utilisateur, entraînant du coup le déplacement d'autres points de l'objet. Cette méthode est plus
intuitive car elle se base sur le principe de « bouger ce point de l'objet d'ici à là ».
Les travaux de Karan Singh et Eugene Fiume (Wires A Geometric Deformation Technique) [34] utilisent non pas
des lattices mais des courbes pour déformer l'objet. Ces courbes se voient attribuer un paramètre afin de définir la
portée de leur déformation sur l'objet, ainsi qu'un autre paramètre définissant lui l'importance de la déformation.
La nouvelle position d'un point est ensuite calculée en utilisant une combinaison de rotation, translation et
homotétie selon des axes propres à la courbe. Cette méthode est très pratique pour la modélisation de drapés
notamment.
La publication de Wenhao Song et Xunnian Yang (Free-form deformation with weighted T-spline) [33] décrit une
méthode de FFD basée sur des T-Splines et non sur des polynômes de Bernstein. Par ailleurs la lattice est
initialement un parallélépipède englobant l'objet puis est affinée au plus proche de celui-ci grâce à une
subdivision par octree.
Malgré le développement (assez poussé quelques fois) de la méthode initiale de Thomas Sederberg et Scott Parry
que nous avons pu rencontrer dans les autres publications, pouvant ainsi conduire à des modélisations très
réalistes, l'utilisation qui serait faite de notre implémentation ne justifierait pas tant de moyens. Par conséquent
nous avons choisi de développer la méthode de FFD « de base », décrite dans la publication Free Form
Deformation of Solid Geometric Models.
30
3.2 - Implémentation
Je ne décrirai ici que la partie que j'ai implémentée, à savoir la manipulation et la déformation de la lattice,
Denis Fillot (le second stagiaire), implémentant lui la partie interpolation dans le temps et l’espace.
3.2.1 - Implémentation actuelle
L'application développée se compose d'une fenêtre OpenGL dans laquelle apparaît l'objet à déformer ainsi
que la lattice. Une simple interface avec entrée clavier et sortie console permet de choisir le type d'objet (plan,
sphère, cylindre, …) ainsi que le nombre de points de contrôle de la lattice (Figure 51).
Figure 51 – Présentation de l'interface et des options de l'implémentation actuelle
Il est également possible de se déplacer dans la scène grâce aux touches directionnelles et la souris, là encore à la
manière d'un jeu de FPS.
31
A l'heure actuelle, l'application comprend les options listées et détaillées ci-dessous.
Picking & Dragging
Outre le déplacement de la caméra, la souris permet également le picking et le dragging des points de l'objet ou de
la lattice enfin de les déplacer de manière interactive. La méthode utilisée est décrite ci-après.
La première étape est de connaître les coordonnées monde du point cliqué (souris) dans la fenêtre. Une fonction
inclue dans OpenGL, GluUnProject, permet cela. Le calcul effectué dans cette fonction est le suivant :
Soient rƒML3, rƒML3„, rƒML3… les coordonnées globales cherchées, elles seront obtenues par :
2(r89 − !O )
−1
!Œ
rƒML3
‹

2(r89„ − !( )
rƒML3„
Š
†
‡ = ˆH!(g ∗ f)
− 1
rƒML3…
Š

!
r
2 ∗ r89… − 1
‰
Ž
1
0
0
Où g représente la matrice de projection, f la matrice de modèle de vue, ! la matrice †
‡, L5M&:EM et
L5M&:EM
ℎ5E:EM
ℎ5E:EM étant la taille de la fenêtre, le vecteur (r89, r89„, r89…) représente les coordonnées fenêtre du point
cliqué (r89… étant 0 pour le plan near et 1 pour le plan far de la caméra) et ˆH!() donne la matrice inverse de
.
En ayant les coordonnées monde du point cliqué et en connaissant la position de la caméra, on va détecter si la
droite portée par ces deux points coupe un des points de l'objet ou de la lattice. En fait, on considèrera non le
point lui-même mais une sphère centrée en ce point et de rayon défini arbitrairement, autorisant ainsi une « marge
d'erreur » pour le clic. L'intersection sera calculée de la manière suivante :
Soit (‘) la droite définie précédemment, étant la position de la caméra et ‘ le point cliqué. Son équation
paramétrique est :
–––––––—
• = Z + ‘Z
“ = + ‘
–––––––—
˜
˜š
” = + ‘
––––––––—
“
’
∈ℝ
Par ailleurs, l'équation d'une sphère de rayon N centrée en ›‚Z , ‚˜ , ‚^ œ est :
( − ‚Z )( + ( − ‚˜ )( + ( − ‚^ )( = N²
En remplaçant , et dans l'équation de la sphère par leur expression de l'équation paramétrique de la droite, on
obtient une équation du second degré en qui, une fois factorisée, donne :
•
“
5² + 7 + K = 0
–––––––—Z ² + ‘
–––––––—
–––––––—
5 = (‘
˜ ² + ‘^ ²)
––––––––— + ‘
––––––––— − ‚ ‘
––––––––— − ‚ ––––––––—
7 = 2( ––––––––—
‘ + ‘
‘ − ‚ ––––––––—
‘
”
“
––––––––— ² + ‘
––––––––— ² + ‘
––––––––— ² − 2› ‚ + ‚ + ‚ œ + ‚ ² + ‚ ² + ‚ ² − N²
’K = ‘
š
L'intersection existe si le déterminant de cette équation est positif. Si tel est le cas, on a alors la relation
–––––––—Z
‚Z = Z + ‘
š
–––––––—
 ‚˜ = ˜ + ‘
˜
––––––––—
‚ = + ‘
32
NB : Cette relation serait exacte si ›‚Z , ‚˜ , ‚^ œ était un des deux points d'intersection de la sphère avec la droite.
Néanmoins, on considèrera pour la suite ›‚Z , ‚˜ , ‚^ œ comme étant un point de l'objet ou de la lattice.
Maintenant que le point est « pické » il faut le « dragger »*. Pour cela, nous calculons d'abord le issu de la
relation précédente. Ensuite, avec la même méthode qu'auparavant, on va calculer les coordonnées monde de la
nouvelle position de la souris dans la fenêtre. Une nouvelle droite va alors être créée, portée par la position de la
caméra et le point que l'on vient de calculer. Les nouvelles coordonnées monde (, , ) du point « draggé »
seront alors donnés par :
–––––––—Z
= Z + ‘
š
–––––––—
 = ˜ + ‘
˜
––––––––—
= + ‘
où est la position de la caméra et ‘ la nouvelle position de la souris.
* Le dragging n'est valable que pour un point de l'objet, la méthode pour le déplacement des points de la lattice
est expliquée ci-dessous.
Translation
La translation telle que décrite ici n'est applicable que pour les points de contrôle de la lattice. Il est possible de
modifier des points de l'objet par la méthode vue dans le paragraphe précédent, mais le but premier de
l'implémentation étant la manipulation de la lattice, il n'aurait pas été utile d'appliquer ce qui va suivre aux points
de l'objet.
La même méthode de picking vue au-dessus est également utilisée pour « picker » les points de contrôle. En
revanche, lorsque ceux-ci sont « pickés », ils sont ajoutés dans un ensemble de points contenant tous les points
actuellement « pickés ». A chaque ajout de point, le nouveau barycentre de l'ensemble est calculé.
La translation sera alors effectuée par le « pick & drag » du barycentre, comme décrit plus haut. Le déplacement
par rapport à la position d'origine du barycentre est calculé pour chaque axe puis appliqué aux points de contrôle
sélectionnés. Ainsi, il est très facile de limiter la translation qu'à un seul axe (les composantes des autres axes
restent inchangées), ou au contraire de l'appliquer à tous, permettant alors une translation « libre » (Figures 52 à
54).
Figure 52 – Sélection de 4 points de contrôle ; les points « pickés » sont
colorés différemment, ainsi que les arêtes auxquelles ils appartiennent
33
Figure 53 – Translation des points « pickés » selon un axe
préalablement choisi. L’axe choisi porte une flèche et est mis en évidence
Figure 54 – Translation libre des points « pickés »
A noter que lorsque tous les points de la lattice sont sélectionnés, c'est la lattice en tant que telle qui sera
translatée, c'est-à-dire les points de contrôle la composant ainsi que le repère local (Figures 55 et 56). Par ailleurs,
lorsqu'un point de l'objet a une composante locale F, ou E supérieure à 1 ou inférieure à 0 (le point n'est plus
dans la lattice), la lattice n'a plus d'influence sur lui et est donc replacé à sa position d'origine.
Figure 55 – Sélection de la lattice entière et
affichage du repère local
Figure 56 – Translation de la lattice et du repère local
Rotation
De la même manière que les points de contrôle sont « pickés » pour être translatés, ils peuvent également l'être
pour être tournés. Là encore la transformation peut se faire selon un axe préalablement choisi ou librement et est
régie par le déplacement de la souris.
La rotation selon un axe est obtenue en appliquant à chaque point de contrôle la formule suivante :
′
i′q = f5Nƒ Ÿ ′
où (, , ) est la position du point de contrôle avant la rotation, (′, ′, ′) sa position après et f5Nƒ une des
trois matrices de rotation suivantes :
Rotation selon X
Rotation selon Y
1
0
0
cos (¡) 0 sin (¡)
0
1
0 q
i0 cos (¡) sin (¡) q i
0 sin (¡) cos (¡)
−sin (¡) 0 cos (¡)
Rotation selon Z
cos (¡) sin (¡) 0
i sin (¡) cos (¡) 0q avec ¡ l'angle de la rotation
0
0
1
34
Figure 57 – Sélection de 4 points de contrôle
Figure 58 – Rotation des points « pickés » selon un axe
Pour la rotation dite « libre », on va effectuer deux rotations successives. La première selon l'axe perpendiculaire
au vecteur vue et au vecteur up de la caméra (cet axe sera donc donné par le produit vectoriel entre ces deux
vecteurs) (Figure 59). La deuxième rotation sera effectuée selon l'axe Y de l'espace 3D.
Figure 59 – Illustration de l'axe autour duquel est faite la première rotation pour une rotation libre. En rouge le vecteur up
de la caméra, en vert le vecteur vue, en jaune le vecteur résultant du produit vectoriel, donnant l'axe de rotation
35
La matrice de rotation utilisée dans ce cas sera une matrice de rotation généralisée à l'axe (, , ) de formule :
² + K(1 − ( )
† (1 − K) + F
((1 − K) − F
(1 − K) − F (1 − K) + F
² + K(1 − ( ) (1 − K) − F‡
(1 − K) + F ² + K(1 − ( )
où K = cos (¡) et F = sin (¡), ¡ étant l'angle de la rotation.
Pour la rotation comme pour la translation, lorsque tous les points de contrôle sont sélectionnés, le système de
coordonnées locales est également tourné. Par ailleurs, on fait subir aux points de contrôle une translation de
›−‚Z , −‚˜ , −‚^ œ avant tous les calculs de rotation, puis de ›‚Z , ‚˜ , ‚^ œ après, ›‚Z , ‚˜ , ‚^ œ étant les coordonnées
du centre de la lattice.
Ainsi, la rotation n'impliquera pas un déplacement autour de l'axe autour duquel elle est effectuée (Figure 60 et
61). Enfin, l'angle de la rotation est donné par le déplacement (dans la fenêtre) de la souris ; seul le déplacement
en est pris en compte lorsque l'axe est choisi au préalable. Dans le cas d'une rotation « libre », le déplacement de
la souris en donnera l'angle de la rotation faite selon Y, tandis que le déplacement en celui de la rotation faite
selon l'axe calculé par le produit vectoriel (Figure 59).
Figure 60 – Sélection de la lattice
Figure 61 – Rotation libre de la lattice et du
repère local
3.2.2 - Implémentation future
L'implémentation des FFD étant toujours en cours de développement, nous allons dresser une liste les
points restant à implémenter.
Homothétie
C'est la seule transformation de base qui ne soit pas encore inclue à l'application. En plus d'être facile à
implémenter, elle peut être très utile, notamment dans la modification de la taille de la lattice.
36
Influence des points de contrôle
Un des problèmes rencontrés dans la manipulation de la lattice (et qui reste à régler) est l'influence qu'ont les
points de contrôle sur ceux de l'objet. En effet, en l'état actuel de l'implémentation, les points de contrôle n'ont pas
assez d'influence, obligeant du coup à déformer énormément la lattice pour obtenir une déformation beaucoup
plus légère sur l'objet (Figure 62 et 63)
Figure 62
Figure 63
Afin d'obtenir le début de rouleau en Figure 62, le déplacement de lattice montré en Figure 63 est nécessaire
Mise en commun du code et intégration
En parallèle à la partie manipulation détaillée ci-dessus, une partie interpolation dans le temps et l'espace de la
lattice est en cours d'implémentation. Cette partie, développée par Denis Fillot, est en effet essentielle à la
création d'une vague animée par « keyframe » ; cette méthode, que l'on retrouve dans la plupart des logiciels de
modélisation 3D, consiste à définir la position dans l'espace d'un objet à un temps t1, et sa nouvelle position à un
temps t2. Les positions intermédiaires aux temps compris entre t1 et t2 seront alors calculées par l'interpolation
des deux précédemment définies. Il est donc nécessaire d'avoir ces deux parties mises en commun afin d'avoir une
implémentation qui permettrait à un artiste de modéliser un rouleau animé.
Enfin, il est là encore nécessaire d'intégrer notre travail au moteur de Phœnix.
37
CONCLUSION
A travers nos recherches, l'implémentation que nous avons faite pendant le stage ainsi que les problèmes
rencontrés, nous nous sommes rendu compte que la modélisation d'océan en temps réel n'est pas quelque chose de
simple.
A ce jour, il n'existe pas de méthode « automatique » et en temps réel capable de créer un rouleau réaliste. La
seule solution est de le modéliser manuellement, ce qui implique la prise en main d'un logiciel ou d'une
application le permettant, ainsi qu'un certain talent artistique. Par ailleurs, cela implique également que le rendu
ne pourra être fait en temps réel.
Concernant les autres zones de la mer, bien qu'il existe des méthodes temps réel permettant de les modéliser, le
problème majeur sera de les mettre en commun afin d'avoir un océan entier, allant de la formation des vagues en
pleine mer à leur échouage sur la plage, en passant par les différentes parties qui composent l'espace sous-marin
(God-Ray, caustic, absorption de la lumière, …). Il sera évidemment encore plus difficile de mettre en commun le
rendu obtenu par ces méthodes avec celui d'un rouleau modélisé manuellement.
D'un point de vue plus humain, ce stage a été enrichissant. A l'heure où de plus en plus de modèles 3D sont
utilisés dans divers domaines, le sujet sur lequel j'ai travaillé m'a permis d'acquérir de l'expérience qui pourrait
m'être utile dans ma future carrière. D'autre part, il était intéressant de devoir se pencher d'assez près sur les
phénomènes liés ou faisant partie de la mer, me permettant de les étudier et de les comprendre. En revanche il
était frustrant de ne pas avoir eu plus de temps à consacrer à la modélisation de la surface de l'eau. Il aurait été
gratifiant d'avoir une modélisation plus étoffée, comprenant entre autre des effets de réflexion et de réfraction plus
réalistes.
Enfin, en y étant au plus près tous les jours, j'ai pu découvrir les différentes étapes que comporte la conception
d'un jeu vidéo, les différentes compétences que cela requiert et les contraintes qu'impliquent le respect d'un délai.
Ainsi, j'ai pu me faire une opinion plus objective sur l'emploi dans ce domaine.
38
BIBLIOGRAPHIE – REFERENCES – SOURCES
Modélisation d'océan
[1] - A phenomenological Model of Coastal Scenes Based on Physical Considerations (Jean-Christophe Gonzato
& Bertrand Le Saec)
[2] - A Simple Model of Ocean Waves 1986 (A. Fournier)
[4] - Deep Water Animation and Rendering (Lasse Staff Jensen, Robert Goliáš)
[5] - Efficient rendering of breaking waves using MPS method 2005 (W. Qiang, Z. Yao, C. Chun, F. Tadahiro, C.
Norishige)
[6] - GPU-based Ocean Rendering 2006 (Yung-Feng Chiu & Chun-Fa Chang)
[7] - Interactive Animation of Ocean Waves (Damien Hinsinger, Fabrice Neyret, Marie-Paul Cani)
[8] - Ocean Waves Synthesis and Animation Using Real World Information 2002 (S.Thon & D.Ghazanfarpour)
[9] - Real-time Breaking Waves for Shallow Water Simulations (Nils Thurey, Matthias Muller-Fischer, Simon
Schirm, Markus Gross)
[10] - Real-time Generation of Plausible Surface Waves (Kristian Yrjola & Thomas Larsson)
[11] - Real-Time Parametric Shallow Waves Simulation (John Van Drasek III, David Bookout, Adam Lake)
[12] - Real-Time Simulation and Visualization of Large Sea Surface 2007 (Tarjei Kvamme Løset)
[13] - Real-Time Synthesis and Rendering of Ocean Water 2005 (Jason L. Mitchell)
[14] - Real-time Water Rendering, Introduction to Projected Grid 2004 (Claes Johanson)
[15] - Rendering Natural Waters 2001 (Simon Premoze & Michael Ashikhmin)
[16] - Simulating Ocean Water 2001 (Jerry Tessendorf)
[17] - Water surface rendering Using Shader Technologies 2006 (Zsolt Mátyás )
[18] - http://paws.kettering.edu/~drussell/Demos/waves/wavemotion.html
[19] - http://en.wikipedia.org/wiki/Wave
[20] - http://www.bbcmotiongallery.com
[21] - http://en.wikipedia.org/wiki/Navier%E2%80%93Stokes_equations
[22] - http://en.wikipedia.org/wiki/Snell%27s_law
[23] - http://freespace.virgin.net/hugo.elias/models/m_perlin.htm
[24] - http://http.developer.nvidia.com/GPUGems/gpugems_ch01.html
[25] - http://local.wasp.uwa.edu.au/~pbourke/miscellaneous/dft/
Free Form Deformation
[26] - A Generalized de Casteljau Approach to 3D Free-form Deformation 1994 (Yu-Kuang Chang & Alyn P.
Rockwood)
[27] - Animated Free Form Deformation , An Interactive Animation Technique 1991 (Sabine Coquillart & Pierre
Jancène)
[28] - Deformation Techniques, Exploring the Blending of Free Form Deformation and Linear Blend Skinning
(Stuart Bryson)
[29] - Direct Manipulation of Free-Form Deformations 1992 (William M Hsu, John F. Hughes, Henry Kaufman)
[30] - Etude sur les Déformations Libres 1999 (Laurent Lefebvre)
[31] - Extended Free-From Deformation, A Sculpturing Tool for 3D Geometric Modeling 1990 (Sabine
Coquillart)
[32] - Free Form Deformation of Solid Geometric Models 1986 (T. Sederberg & S. Parry)
[33] - Free-form deformation with weighted T-spline 2005 (Wenhao Song & Xunnian Yang)
[34] - Wires A Geometric Deformation Technique 1998 (Karan Singh, Eugene Fiume)
39