Contenu de l'UE ACAMP

Animation, Corps Articulés Et Moteurs Physiques (ACAMP) est une UE du tronc commun du Master 2e année ID3D de l'Université Lyon 1. Les cours ont lieu à l'automne. L'objectif de l'UE est de donner les bases de l'animation en synthèse d'images. Nous aborderons les deux grandes familles de méthodes. L'animation basée sur des données, par exemple pour l'animation d'humain virtuel (données issues de capture de mouvement). Et l'animation basée sur un modèle physique pour la simulation de phénomènes naturels comme le mouvement de textiles ou de fluide. L'UE laissera une grande part à l'application pratique avec la réalisation de TPs en C++/OpenGL et avec Unity proposant d'animer par exemple des humains virtuels, des vêtements, des cordes, une surface d'eau, des objets rigides, etc.

Supports du CM de la partie "Animation par modèles physiques" - F. Zara

• Introduction - Chap1-Intro.pdf
• Simulation par modèle physique
• Dynamique des particules - Chap2-Particule.pdf
• Mouvement d'une particule
• EDO à résoudre du premier et second ordre
• Dynamique Newtonienne
• Dynamique des objets rigides - Chap3-RigidBody.pdf
• Concepts de la dynamique des objets rigides : repère objet, repère monde, etc.
• Evolution de l'état de l'objet rigide
• Point de vue animation 3D : structure de données de l'objet rigide, algorithmes
• Simulation de fluides - Chap4-SPH.pdf
• Equations de la dynamique des fluides
• Méthode SPH - Smoothed particle hydrodynamics
• Position Based Dynamics (PBD) - Chap5-PBD.pdf
• Approche Position Based Dynamics
• Contrainte de distance
• Contrainte pour les fluides

Code source du TP de la partie "Animation par modèle physique" - F. Zara

1 - Récupération du code source pour faire le TP

• Nous allons utiliser la librairie gKit2 light développée par Jean-Claude Iehl
• Le code de départ (code source de la librairie gkit2light + code pour ce TP - répertoire gkit2light/src/master_MecaSim) se récupère avec Git comme ceci :

  
  git clone https://forge.univ-lyon1.fr/Alexandre.Meyer/gkit2light
  cd gkit2light/
  git checkout -b master_MecacSim origin/master_MecacSim
                                  

2 - Compilation du code source

• Suivez ces instructions pour compiler les codes sources selon votre plateforme (Linux, MacOS, Windows)

3 - Exécution du code depuis le répertoire gkit2light

• Le programme nécessite de mettre en paramètres, le nombre d'objets de la simulation, le fichier des paramètres généraux de la simulation, ainsi qu'un fichier de paramètres pour chacun des objets simulés.
• Si vous lancez l'application sans paramètre, il prendra les paramètres qui ont été écrits directement dans le fichier src-etudiant/main.cpp. Il faudra ainsi les modifier directement dans le code et recompiler, si vous souhaitez les changer.
• Sinon, nous avons créé un fichier qui s'appelle go dans le répertoire gkit2light
• Nous avons mis dedans l'instruction suivante afin de donner les paramètres nécessaires :

./bin/master_MecaSim_etudiant 1 ./src/master_MecaSim/exec/Fichier_Param.simu ./src/master_MecaSim/exec/Fichier_Param.objet1
                                    

• Et pour le convertir en exécutable, nous avons fait :

 chmod +x go 

• Vous pouvez ainsi lancer le programme en tapant dans un terminal depuis le répertoire gkit2light

 ./go 

• ou de manière générale :

‹Executable› ‹nbObjet› ‹fichier param simulation› ‹fichier param Obj1› ‹fichier param Obj2› ...
                                    

4 - Compréhension du code source

• Prenez le temps de lire les explications du code source

Sujet du TP de la partie "Animation par modèle physique" - F. Zara

Plusieurs choix possibles :

• Animation de textiles (uniquement si pas fait en M1)
• Animation d'un objet rigide
• Animation de fluide en utilisant la méthode SPH
• Animation en utilisant l'approche PBD (Position Based Dynamics) : objet rigide, objet déformable, fluide

Ce qui est attendu pour votre TP :

• Animation de textiles
• Simulation d'un tissu soumis à la gravité
• Possibilité de déplacer un des coins du tissu
• Au choix :
• Possibilité de déchirer le tissu
• Collision du tissu avec un objet (sphère, sol, table, etc.) dont on connait la position
• Animation d'un objet rigide
• Simulation d'un objet rigide soumis à la gravité
• Collision de l'objet rigde avec un sol dont on connait la position
• Animation de fluide en utilisant la méthode SPH
• Simulation du mouvement d'un fluide composé de plusieurs particules
• Le fluide est contenu dans une boite : il s'agit de gérer les collisions avec les bords de la boite
• Animation en utilisant l'approche PBD
• Au choix :
• Simulation d'un tissu soumis à la gravité
• Simulation d'un objet rigide soumis à la gravité
• Simulation du mouvement d'un fluide composé de plusieurs particules

Bonus - D'autres idées pour vous amuser

• Faire une belle scène avec plusieurs objets de modèles physiques différents (objet déformable avec système masses-ressorts, objet rigide, SPH), des textures sur les objets, etc. Gérer les collisions entre les objets : tissu qui tombe sur une sphère, une table, un cube, etc.
• Des ballons (particules) qui se déplacent dans un labyrinthe. Un curseur permet de déplacer la direction du vent qui souffle pour déplacer les ballons.
• Animation d'un système de particules soumis à la gravité et qui rentrent en collision avec la grille horizontale positionnée en y=0. La class ObjetSimuleParticule a été faite pour cela. On utilise les fichiers employés pour le système masses-ressorts, mais on ne connecte pas les masses par des ressorts. Il faut juste compléter le fichier CalculsParticule.cpp pour gérer les collisions.
• Faire rebondir un objet rigide sur le sol
• Etc.

Evaluation du TP de la partie "Animation par modèle physique" - F. Zara

1. les fichiers de code que vous avez modifiés (fichiers .cpp et .h uniquement)
2. un rapport de 5 à 10 pages.

1. explication de la boucle de simulation permettant de réaliser l'animation d'un objet - en détaillant chacune des étapes (en donnant l'équation et les explications adéquates). Pour cela, imaginez que vous deviez expliquer à une personne qui n'a pas suivi le cours comment vous faites une simulation 3D.
2. explication du système masses-ressorts / de l'objet rigide / du fluide par la méthode SPH / de l'animation par l'approche PBD : démarche identique.
3. explication de tout ce que vous avez effectué dans votre code en plus de la simulation initiale : déchirure, mouvement d'un coin, collision avec un objet / collision objet rigide / collision SPH / collision PBD / etc.
4. une partie un peu plus libre (vous pouvez vous aider d'articles vus sur internet) : si vous aviez beaucoup plus d'heures pour améliorer votre projet, que feriez-vous ? Voici quelques idées non exhaustives : meilleure prise en compte des collisions : comment implémenter cela ? ; améliorer le système masses-ressorts (liaisons entre les ressorts, coefficient des raideurs, etc.) ; parallélisation des algorithmes sur GPU - sur multi-cpu ; amélioration objet rigide / SPH.

Compilation du code source du TP

cd gkit2light
premake/premake4.linux --file=master_MecaSim.lua codeblocks
ouvrir le projet master_MecaSim_etudiant.cbp
                        

cd gkit2light
premake/premake4.linux --file=master_MecaSim.lua gmake
make -f master_MecaSim_etudiant.make
./bin/master_MecaSim_etudiant
                        

• Voir le apt-get install ici
• Puis reprendre les instructions mises ci-dessus

cd gkit2light
premake/premake4.macosx --file=master_MecaSim.lua gmake
make -f master_MecaSim_etudiant.make
./bin/master_MecaSim_etudiant
                        

• Installez Git avec tortoiseGit
• Installez Codeblocks, la version 16 avec Mingw
• Explorateur de fichier, placez vous dans le répertoire de vos fichiers, bouton droit menu 'TortoiseGit puis cloner', puis entrez le chemin Git indiqué plus haut commençant par https …
• Téléchargez les librairies (SDL,Glew, etc.) pour windows ici, copiez le répertoire 'extern' dans le répertoire principale de gkit2light
• Vous devez aussi copier toutes les .dll du répertoire extern/mingw/lib dans gkit2light/bin (répertoire des exécutables), sinon vous aurez des erreurs à l’exécution des programmes
• Lancez le script gkitlight/premake/premake-meca.bat qui va créer les projets makefile/codeblocks dans le répertoire gkitlight
• Ouvrez le projet gkitlight/master_MecaSim_etudiant.cbp
• Remarque : le code exporté avec Git contient une version compilée des librairies (SDL2, glew, etc.) pour windows donc rien à installer

• Changez build target en debug">x32 au lieu de debug">x64.
• Si l'erreur provient de M_PI qui n'est pas reconnu (malgré le #include ), il faut rajouter le code suivant dans le fichier gkit2light/src/master_MecaSim/src-etudiant/Matrix.cpp juste après les includes

#ifndef M_PI
#define M_PI    3.14159265358979323846264338327950288   /* pi */
#endif
                            

Compréhension du code source

• Votre code prendra place dans le répertoire
gkit2light/src/master_MecaSim/src-etudiant
• Pour générer la documentation Doxygen

cd gkit2light/src/master_MecaSim
 doxygen ./Doxyfile
                        

• Lisez la documentation Doxygen à partir du fichier gkit2light/src/master_MecaSim/doc/html/index.html
  • Si vous n'arrivez pas à générer la documentation, voici la page principale
• Le répertoire gkit2light/data contient les données de la simulation :
• gkit2light/data/ textures : pour placer des textures
• gkit2light/data/ CreateMesh : programme pour créer des maillages de tissu ou convertir des fichiers .obj .off en fichiers pour l'application
• gkit2light/data/ drap10 : fichiers de données d'un tissu de 10 particules
• gkit2light/data/ drap70 : fichiers de données d'un tissu de 70 particules
• gkit2light/data/ vache : fichiers de données d'une vache
• gkit2light/data/ sphere : fichiers de données d'une sphère
• gkit2light/data/ bunny : fichiers de données du Standford bunny
• Chacun de ces sous-répertoires contient plusieurs fichiers :
• faceset.eti : définition des facettes triangulaires de l'objet
• masses.eti : définition des masses associées aux sommets de l'objet
• points.eti : définition des coordonnées (x,y,z) des sommets de l'objet
• texcoord.eti : définition des coordonnées de textures des sommets de l'objet
• Le répertoire gkit2light/src/master_MecaSim/exec contient les fichiers pour l'exécution de l'application :
• Fichier_Param.simu : paramètres de la simulation - gravité, viscosité, nb itérations
• Fichier_Param.objet : paramètres de l'objet simulé - données, k, nu, dt, etc.

Sujet de TP - Simulation de textiles

Travail à effectuer pour simuler le mouvement d'un textile

• Vous devez compléter le code de l'application pour simuler le mouvement d'un tissu carré discrétisé par 70 x 70 particules (fichiers de données dans le répertoire gkit2light/data/drap70).
• Le tissu est discrétisé par un ensemble de particules de masses mi=1 connectées entre elles par des ressorts de raideurs kij = 15000.0, de viscosité nuij = 0.01, et de longueur au repos lij = 0.1. La gravité et la viscosité du milieu sont également pris en compte pour simuler la scène. Ces paramètres sont notamment mis dans les fichiers de données de l'application qui se trouvent dans le répertoire gkit2light/src/master_MecaSim/exec.
• Le tissu est notamment fixé par deux coins. D'ailleurs, comment ces coins ont été fixés ? Pour vous aider, vous pouvez regarder les fichiers de données relatifs à cet objet.

Géneration du maillage

• Vous pouvez débuter en utilisant des tissus de tailles plus petites en les générant à l'aide du programme CreateData du répertoire /gkit2light/data/CreateMesh.
• Dans ce répertoire :
• Makefile : pour compiler tous les programmes
• CreateData.cpp : permet de créer les fichiers de données (format texte) relatifs à des carrés de tissu de taille paramétrable
• obj2sappe.cpp, Donnees.h : permet de convertir les fichiers de données des facettes du format .obj au format utilisé par l'application
• off2sappe.cpp, Donnees.h : permet de convertir les fichiers de données des facettes du format .off au format utilisé par l'application
• scalepoints.cpp, Donnees.h : permet de modifier le fichier des positions des particules en les divisant par un facteur donné

Voici les étapes (détaillées ci-dessous) pour réaliser cette simulation de textiles

1. Affichage de l'objet simulé
2. Calcul des forces appliquées sur les particules
3. Calcul des accélérations des particules au cours du temps, en utilisant la loi fondamentale de la dynamique
4. Intégration des accélérations pour obtenir les vitesses
5. Intégration des vitesses pour obtenir les positions
6. Animation du tissu
7. Interaction avec l'utilisateur
8. Déchirure
9. Tombé de tissu

Affichage de l'objet simulé

• Complétez la fonction ObjetSimuleMSS::initMeshObjet() pour créer le maillage de l'objet simulé.
• Complétez la fonction ObjetSimuleMSS::updateVertex() pour mettre à jour le maillage de l'objet simulé au cours de la simulation.

Calcul des forces

• Quelles sont les forces qui sont exercées sur chacune des particules du tissu ?
• Complétez le code de l'application pour calculer les forces qui sont exercées sur chacune des particules. Pensez à prendre en compte les forces d'amortissement des ressorts.

Calcul des accélérations

• Complétez ensuite le code de l'application, pour calculer les accélérations des particules au cours du temps.

Calcul des vitesses et des positions

• Complétez le code de l'application pour calculer par intégration numérique les nouvelles vitesses et positions des particules à partir des accélérations et des vitesses. Implémentez tout d'abord le schéma d'Euler explicite. Puis, utilisez le schéma de leapfrog-Verlet ou le schéma d'Euler semi-implicite.
• Comparer ces schémas d'intégration numérique en modifiant la taille des pas de temps. Lequel vous paraît le plus stable ?
• Enfin, afin de dissiper les vitesses, multipliez-les par le coefficient de dissipation (ou de viscosité) qui est lié à la scène.

Animation du tissu

• Maintenant que les calculs des forces, accélérations, vitesses et positions ont été complétés, vérifiez que l'animation du tissu vous paraît cohérente. Vous pouvez notamment modifier les paramètres du vecteur gravité, la raideur des ressorts, etc.

Interaction avec l'utilisateur

• Modifiez l'application afin d'ajouter une interaction avec l'utilisateur. L'interaction avec le clavier (touche m enfoncée + flèches direction) doit permettre de faire bouger un des coins initialement fixe du tissu. Par exemple, vous pouvez modifier l'application pour que la position de la particule 0 soit déterminée par le mouvement de la souris.

Déchirure

• Vous pouvez considérer que si la force appliquée à un ressort est trop importante (ou si sa longueur dépasse une certaine taille), le tissu se déchire c'est-à-dire que le ressort considéré est supprimé.

Tombé de tissu

• Modifiez les fichiers de données relatifs au tissu de façon à ne plus avoir de points fixes c'est-à-dire que sous l'emprise de la gravité, le tissu doit tomber.
• Ajoutez le code permettant de détecter et traiter la collision du tissu sur le sol (dont on connait son emplacement) en faisant en sorte que le tissu reste immobile sur le sol.

Sujet de TP - Simulation d'un objet rigide

Travail à effectuer pour simuler le mouvement d'un objet rigide

• Les paramètres de l'objet rigide sont mis dans les fichiers de données de l'application qui se trouvent dans le répertoire gkit2light/src/master_MecaSim/exec.
• Vous devez compléter le code de l'application pour simuler le mouvement d'un objet rigide soumis à la gravité.

Affichage de l'objet simulé

• Complétez la fonction ObjetSimuleRigidBody::initMeshObjet() pour créer le maillage de l'objet simulé.
• Complétez la fonction ObjetSimuleRigidBody::updateVertex() pour mettre à jour le maillage de l'objet simulé au cours de la simulation.

Initialisation de l'objet rigide

• Complétez le code des différentes méthodes appelées dans ObjetSimuleRigidBody::initObjetSimule() : méthodes se trouvant dans le fichier CalculsRigidBody.cpp

Boucle de la simulation

• Complétez le code des différentes méthodes appelées dans ObjetSimuleRigidBody::Simulation() : méthodes se trouvant dans le fichier CalculsRigidBody.cpp

Collision avec le sol

• Complétez le code de ObjetSimuleRigidBody::Collision() pour gérer les collisions de l'objet rigide avec un sol

Sujet de TP - Simulation d'un fluide avec la méthode SPH

Travail à effectuer pour simuler le mouvement d'un fluide en utilisant la méthode SPH

• Les paramètres du fluide sont mis dans les fichiers de données de l'application qui se trouvent dans le répertoire gkit2light/src/master_MecaSim/exec.
• Complétez le code des différentes méthodes appelées dans ObjetSimuleSPH::Simulation(..) : méthodes se trouvant dans le fichier CalculsSPH.cpp

Calcul des densités des particules

• Complétez la méthode suivante permettant de calculer la densité de chaque particule du fluide.
void ObjetSimuleSPH::CalculDensite(){}

Calcul des forces d'interaction entre particules

• Complétez la méthode suivante permettant de calculer les interactions qu'il y a entre deux particules i et j, dans le cas où celles-ci rentrent en interaction l'une avec l'autre.
• Nous ferons directement le calcul de fij / rho_i pour la particule i.
void ObjetSimuleSPH::CalculInteraction(float visco)

Calcul des vitesses et position

• Comme nous faisons directement le calcul des forces d'interaction entre les particules i et j divisées par la densité de la particule i (soit fij / rho_i), nous devons modifier légèrement le solveur dans le cas où nous simulons un fluide par la méthode SPH. Ci-dessous la modification à apporter :

void SolveurExpl::CalculAccel_ForceGravite(...){
    // On a calcule dans Force[i] : fij / rho_i
    // Il ne reste qu'à ajouter le vecteur g de la gravité
    A[i] = Force[i] + g;
}
                            

Calcul de collision

• On considère que le fluide se trouve dans une boite
• Il faut donc gérer les collisions entre les différentes frontières de la boite que vous définirez
void ObjetSimuleSPH::CollisionPlan()

Sujet de TP - Simulation avec PBD

Travailler à effectuer pour simuler le mouvement d'un objet (tissu, objet rigide, fluide) avec l'approche PBD

• Pour un textile : Le tissu est discrétisé par un ensemble de particules de masses mi=1 connectées entre elles par des ressorts de raideurs kij = 15000.0, de viscosité nuij = 0.01, et de longueur au repos lij = 0.1. La gravité et la viscosité du milieu sont également pris en compte pour simuler la scène. Ces paramètres sont notamment mis dans les fichiers de données de l'application qui se trouvent dans le répertoire gkit2light/src/master_MecaSim/exec.
  
• Pour un fluide : Les paramètres du fluide sont mis dans les fichiers de données de l'application qui se trouvent dans le répertoire gkit2light/src/master_MecaSim/exec.
• Pour un objet rigide : Les paramètres de l'objet rigide sont mis dans les fichiers de données de l'application qui se trouvent dans le répertoire gkit2light/src/master_MecaSim/exec.

Intégration de l'approche PBD dans le code source

• Vous pouvez définir une nouvelle classe ObjetSimulePBD :
• Créer les fichiers ObjetSimulePBD.h, ObjetSimulePBD.cpp et CalculsPBD.cpp
• Il s'agira ensuite de définir et d'implémenter les méthodes adaptées à l'approche PBD

Initialisation de l'algorithme PBD : ObjetSimulePBD::initObjetSimule()

• Récupération des paramètres spécifiques au type d'objet simulé : voir ce qui a été fait pour les simulations de textile, fluide ou objet rigide
• Initialisation des vitesses : voir ce qui a été fait pour les simulations de textile, fluide ou objet rigide
• Initialisation des positions : voir ce qui a été fait pour les simulations de textile, fluide ou objet rigide
• Initialisation des masses : voir ce qui a été fait pour les simulations de textile, fluide ou objet rigide
• Définition des contraintes en fonction du type d'objet que vous souhaitez simuler (textile, fluide, objet rigide)

Affichage de l'objet simulé

• Implémentez la fonction ObjetSimulePBD::initMeshObjet() pour créer le maillage de l'objet simulé.
• Implémentez la fonction ObjetSimulePBD::updateVertex() pour mettre à jour le maillage de l'objet simulé au cours de la simulation.

Définition et implémentation des méthodes de la classe ObjetSimulePBD

• Calcul de la vitesse en fonction des forces extérieures
• Calcul de la prédiction de la position en fonction des vitesses
• Calcul de la correction de la prédiction en tenant compte des contraintes
• Calcul des nouvelles vitesses en utilisant les positions et leurs prédictions
• Calcul des nouvelles positions

Implémentation de la méthode ObjetSimulePBD::Simulation

• Cette méthode correspondant à la boucle de simulation de PBD permet d'effectuer les différents appels aux méthodes de la classe :
• Calcul de la vitesse en fonction des forces extérieures
• Calcul de la prédiction de la position en fonction des vitesses
• Calcul de la correction de la prédiction en tenant compte des contraintes
• Calcul des nouvelles vitesses en utilisant les positions et leurs prédictions
• Calcul des nouvelles positions

Références bibliographiques

Articles de recherche

• Jos Stam, Stable Fluids, SIGGRAPH 1999
• Jos Stam, Real-Time Fluid Dynamics for Games, Proceedings of the Game Developer Conference, March 2003
• Ronald Fedkiw, Jos Stam, Henrik Wann Jensen, Visual Simulation of Smoke, 2001
• Liste d'articles sur l'animation (Lionel Revéret)
• The SPH equations, Bindel, Fall. Applications of Parallel Computers 2011.
• Interactive Simulation of Rigid Body Dynamics in Computer Graphics. Computer Graphics Forum.
• Publications de Mathias Muller (PBD, SPH, etc.)

Livres

• Game Physics - David H. Eberly, Ken Shoemake - Morgan Kaufmann Publisher - 600 pages - Décembre 2003.
• 3D Game Engine Design: A practical approach to real-time computer graphics - David H. Eberly - Morgan Kaufmann Publisher - 561 pages - Second Edition (Series in interactive 3D technology) - Novembre 2006.
• Collision Detection in Interactive 3d Environments - Gino Van Den Bergen - Morgan Kaufmann Publishers - 277 pages - Juillet 2003.
• Physics-Based Animation - Kenny Erleben, Jon Sporring, Knud Henriksen, Henrik Dohlmann - Charles River Media Publisher - 817 pages - Août 2005.
• Fundamentals of Computer Graphics - Peter Shirley - AK Peters, Ltd. - 392 pages - Juillet 2002.
• Computer Animation: Algorithms and Techniques - Rick Parent - The Morgan Kaufmann Series in Computer Graphics - 560 pages - Septembre 2001.
• Game Programming Gems - Mark DeLoura (1), Mark DeLoura (2), Dante Treglia (3), Andrew Kirmse (4), Kim Pallister (5), Michael Dickheiser (6) - 6 volumes - Charles River Media Publisher.
• Un peu de Mécanique des Milieux Continus - Florence Zara (2017). HAL : cel-01520209
• Simulation d'objets rigides - Clermont Dupuis - Université de Laval.

Sites Web

• Cours de Adrien Treuille - The Animation of Natural Phenomena
• Cours de Jernej Barbic - Physically Based Modeling for Interactive Simulation and Games
• Cours University of Utah - Physical Simulation for Computer Animation
• Cours Carnegie Mellon University - The Animation of Natural Phenomena
• Introduction to Computer Game Design and Development
• Cours SIGGRAPH 2001 - Physically Based Modelling
• Cours SIGGRAPH 1997 - Physically Based Modeling: Principles and Practice
• Cours SIGGRAPH 2004 - Simulating Ocean Water
• Cours SIGGRAPH 2008 - Real Time Physics
• Cours SIGGRAPH 2006 - Simulation fluide
• Cours SIGGRAPH 2019 - An Introduction to Physics-Based Animation
• Page de Robert Bridson (animation de fluide, textile, etc.)
• Real Time Physics Class Notes - Matthias Muller, Jos Stam, Doug James, Nils Thurey
• Cours sur la simulation d'objets rigides.
• Rigid Body Collisions in 2D, Erik Neumann, 2004-2016.
• 2D Physics simulation, Erik Neumann, 2004-2016.

Galerie des projets d'étudiants