4/5

4. Animation descriptive

Interpolation par spline cardinale

Explication du code

  • Considérez le code associé au fichier 03_animation/example_interpolation.

  • Ce code modélise une série de positions clés \(p_i\) (keyframe_position) affichées par des sphères blanches. Chaque position est associée à un temps \(t_i\) (keyframe_time).

  • Le déplacement de la sphère bleue au cours du temps correspond à l’interpolation linéaire entre ces positions clés.

  • L’initialisation des positions et temps clés est réalisée dans la fonction setup_data alors que l’interpolation linéaire est calculée depuis la fonction frame_draw.

  • Il est également possible de modifier interactivement les positions clés. Pour cela, appuyez sur shift pendant que vous sélectionnez puis déplacez une sphère d’une des positions de passage.

La gestion de la sélection et translation des sommets est réalisée dans les fonctions mouse_click et mouse_move. Vous pouvez utiliser ces deux fonctions telles quelles sans modifications dans la suite de l’exercice.

Note: Pour simplifier la mise en place d’une spline cardinale suivant une trajectoire périodique sans discontinuités, les trois derniers sommets des positions clés correspondent aux trois premiers sommets dupliqués. Le timer est adapté afin de prendre cela en compte.

Interpolation

Votre objectif est de modifier la fonction de calcul du déplacement de la sphère bleue sous la forme d’une spline cardinale. Cette interpolation permettra, par exemple, de modéliser le déplacement lisse d’un objet le long de la trajectoire définie par un utilisateur à l’aide des positions clés.

Considérons un instant \(t\in [t_i,t_{i+1}]\). La spline cardinale interpolant les sommets \(p_i\) (au temps \(t_i\)) et \(p_{i+1}\) (au temps \(t_{i+1}\)) peut être défini de la manière suivante [1]

  • On calcule \(d_i\) et \(d_{i+1}\) correspondant aux dérivées aux positions respectives \(p_i\) et \(p_{i+1}\), avec

    • \(\displaystyle d_i=\mu\,\frac{t_{i+1}-t_{i}}{t_{i+1}-t_{i-1}}(p_{i+1}-p_{i-1})\)

    • \(\displaystyle d_{i+1}=\mu\,\frac{t_{i+1}-t_{i}}{t_{i+2}-t_{i}}(p_{i+2}-p_{i})\)

    • \(\mu\) est le paramètre de tension de la spline.

  • Puis on évalue la position interpolée sous la forme d’un polynôme de degré trois

    • \(\displaystyle p(t)=(2 s ^ 3-3s ^ 2+1)p_i+(s ^ 3-2s ^ 2+s)d_i + (-2s ^ 3+3s ^ 2) p_{i+1}+(s ^ 3-s ^ 2)d_{i+1}\)

    • \(\displaystyle s=\frac{t-t_i}{t_{i+1}-t_i}\)

Rem. Par rapport au cours, la formule précédente est reparamétrée par le facteur \(t_{i+1}-t_i\) afin de prendre en compte le fait que le paramètre temporelle \(t\) varie sur une plage de valeur quelconque (et non uniquement entre 0 et 1).

  • Sur le même schéma que la fonction d’interpolation linéaire (linear_interpolation), implémentez une fonction cardinal_spline_interpolation

vec3 cardinal_spline_interpolation(float t, float t0, float t1, float t2, float t3, const vec3& p0, const vec3& p1, const vec3& p2, const vec3& p3)

Remplacez l’interpolation linéaire par l’interpolation spline. Vous devriez obtenir une trajectoire continue et lisse.

Animation hiérarchique

Cette partie s’intéresse à la modélisation d’une forme articulée. Les formes articulées sont généralement modélisées par des primitives reliées entre elles par des relations hiérarchiques: ex. pour un personnage, les bras, jambe et tête sont des enfants du corps, les pieds étant eux même des enfants de la jambe, etc. Chaque enfant hérite alors de la transformation du parent, et possède lui-même sa propre transformation. Il est généralement plus simple d’exprimer la position et les transformations à appliquer sur un élément dans le repère local de son parent.

Considérez le code associé au fichier 03_animation/example_animated_hierarchy. Ce code met en oeuvre un modèle articulé modélisé à l’aide de l’objet mesh_drawable_hierarchy.

mesh_drawable_hierarchy modélise une hiérarchie d’éléments. Chaque élément est défini dans le repère local à son parent et est associé à une transformation locale (translation, rotation). Avant l’affichage, les transformations exprimées dans le repère global sont mises à jour en suivant la hiérarchie des éléments.

  • Compilez et exécutez le code

  • Observez la création du personnage dans la fonction setup_data, et en particulier l’ajout d’un élément dans la hiérarchie.

    • Chaque élément est associé à un nom, qui permet de le retrouver dans la hiérarchie des éléments par la suite.

    • Le nom de l’élément parent doit être indiqué afin de connaitre sa position dans la hiérarchie. (le nom du parent de l’élément racine est arbitraire)

    • Chaque élément peut être associé à une translation (par défaut nulle) et rotation (par défaut l’identité) par rapport à son parent.

Les translations et rotations locales sont stockées séparément afin de permettre leur modification au cours d’une animation.

  • Observez la fonction d’affichage frame_draw.

    • Les translations et rotations des différents éléments peuvent être accédées et modifiées pour réaliser une animation. Notez qu’il s’agit des translations et rotations exprimées dans le repère local de l’élément parent à celui désigné.

  • Au moment de l’affichage hierarchy.draw les transformations respectives de chaque élément sont exprimées dans le repère global, et celles-ci sont utilisées en tant que paramètres uniformes pour chaque élément [2]

Modifiez la forme et l’animation de l’objet pour modéliser une forme animée ressemblant à un oiseau.

Exemple de modèle possible

(vous êtes libre de générer un modèle ayant une autre apparence et de l’adapter à votre convenance)

Scène finale

  • Incorporez votre élément animé dans votre scène de terrain.

  • Faite en sorte que le mouvement de l’oiseau (translation de l’élément racine) suive une trajectoire définie par position clés et calculée par spline cardinale.

  • (extension) Réfléchissez à une manière d’adapter l’orientation de votre personnage animé lors de son mouvement.

  • (extension) Il est possible de faire en sorte que l’élément animé se déplace à vitesse (approximativement) constante: pour cela, adaptez les instants associés aux points de contrôle en fonction de la longueur des segments du polygone de controle.

Rem. Les extensions, ainsi que l’incorporation de l’interface de manipulation des points de contrôle dans votre scène demande un travail conséquent. Ne passez pas trop de temps dessus si vous n’êtes pas en avance.

1. Représentation sous la forme d’une interpolation de Hermite (position/dérivées) avec estimation de la dérivée par différence finie
2. Notez qu’il n’est pas possible d’imposer directement le paramètre uniforme de translation, rotation et scaling d’un élément de la hiérarchie, car celui-ci est automatiquement mis à jour par la fonction d’affichage