Master 2 Image Développement et Technologies 3D
UE Animation, Corps Articulés et Moteurs Physiques 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.

Retour vers la page principale de l'UE ACAMP

Supports pédagogiques 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
  • Anciens cours

Etape 1 - Récupération du code de départ

Nous vous fournissons un code de départ pour effectuer les TPs de la partie "Animation par modèle physique" - F. Zara.
Ce code est basé sur l'utilisation de la librairie gKit2light développée par Jean-Claude Iehl.

Voici les consignes pour récupérer le code de départ (gkit2light + code pour ce TP) :

  • Création d'un répertoire de travail dédié à l'UE
  • mkdir M2AnimationPhys
  • On se positionne dans ce répertoire
  • cd M2AnimationPhys

  • Le code de gkit2light se récupère ensuite avec Git comme ceci :
  • git clone https://forge.univ-lyon1.fr/Alexandre.Meyer/gkit2light

  • Le code de départ de M2 Animation Physique se récupère ICI :
    • Il faut décompresser l'archive
    • Puis mettre le répertoire animationphys dans le répertoire gkit2light/
  • Vous travaillerez ainsi dans le répertoire gkit2light/animationphys/.
  • Les fichiers C++ se trouvent dans gkit2light/animationphys/src/.

Etape 2 - Suivre ces consignes pour compiler le code

  1. On se place dans le répertoire gkit2light

  2. Vérifier que vous avez la commande premake5
    • Si vous ne l'avez pas :
      (1) récupérer la sur le site officiel
      (2) dezippez l'archive et copiez premake5 dans le répertoire de gkit2light
      (3) et il faut donner l'autorisation de l'exécuter :
    • chmod u+x ./premake5
  3. Dans le fichier gkit2light/premake5.lua, ajouter les lignes ci-dessous à la fin du fichier (si elles ne sont pas déja présentes) :
  4.  -- animationphys
    if os.isfile("animationphys/src/premake5.lua") then
        include "animationphys/src"
    end
  5. Si vous souhaitez utiliser codeblocks + Linux
    • Générer le projet codeblocks
    • premake5 codeblocks
    • Puis, ouvrir le projet animationphys.cbp
  6. Si vous souhaitez utiliser un Mac ou un Linux
    • Pour générer le Makefile (à ne faire qu'UNE seule fois)
    • premake5 gmake
    • Pour compiler (à faire à chaque fois que vous modifiez votre code)
    • make animationphys
    • L'exécutable de votre code sous Linux ou Mac sera :
    • ./bin/animationphys
  7. Pour compiler sous Linux de chez vous (ubuntu)
    • voir le apt-get install ... ici
    • Puis suivre les indications mises plus haut
    • Si probleme avec premake (qui est une application 32bits) pour l'executer sur un système 64 bits, il faut installer les librairies 32bits.
    • sudo apt-get install libc6-i386
  8. Si vous avez une erreur de compilation
    • Changez build target en debug|x32 au lieu de debug|x64
  9. Si vous avez une erreur de compilation sur les machines de l'université sous codeblocks
    • Vérifiez le compilateur utilisé par codeblocks : menu Setting/Compiler/Toolchain executable
    • C:\ProgramFiles\x86\CodeBlocks\MinGW
  10. Pour sauvegarder automatiquement sous vscode
  11. Préférences / Paramètres / éditeur de texte / Fichiers / Auto Save / onFocusChange

Etape 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 mis directement dans le fichier animationphys/src/main.cpp.
  • Il faudra ainsi les modifier directement dans le code et recompiler, si vous souhaitez les changer.

  • Sinon, vous pouvez créer un fichier qui s'appelle go dans le répertoire gkit2light
    et mettre les instructions suivantes afin de donner les paramètres nécessaires :
  • ./animationphys/bin/animationphys 1 ./animationphys/exec/Fichier_Param.simu ./animationphys/exec/Fichier_Param.objet1
  • Pensez à le convertir en exécutable :
  • 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› ...
  • Vous pouvez aussi utiliser votre logiciel de développement préféré, pour spécifier ces paramètres lors de l'exécution.

Etape 4 - Compréhension du code source

  • Votre code prendra place dans le répertoire
  • gkit2light/animationphys/src/
  • Pour générer la documentation Doxygen
  • 
    cd gkit2light/animationphys/
     doxygen ./Doxyfile
                            
  • Lisez la documentation Doxygen à partir du fichier gkit2light/animationphys/doc/html/index.html
  • Le répertoire gkit2light/animationphys/data contient les données de la simulation :
    • textures : pour placer des textures
    • CreateMesh : programme pour créer des maillages de tissu ou convertir des fichiers .obj .off en fichiers pour l'application
    • drap10 : fichiers de données d'un tissu de 10 particules
    • drap70 : fichiers de données d'un tissu de 70 particules
    • vache : fichiers de données d'une vache
    • sphere : fichiers de données d'une sphère
    • bunny : fichiers de données du Standford bunny
  • Les sous-répertoires drap10/drap70/vache/sphere/bunny contiennent 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/animationphys/exec contient les fichiers pour l'exécution de l'application :
    • Fichier_Param.simu : paramètres de la simulation - gravité, viscosité, nb itérations, type des objets simulés (mss, sph, pbd)
    • Fichier_Param.objet : paramètres de l'objet simulé - fichiers de données, k, nu, dt, etc.
    • Format des fichiers de paramètres :
      • une clé par ligne (`cle = valeur`)
      • Les commentaires `#`, `!` ou `//` en début de ligne sont ignorés
      • Les commentaires inline après `#` sont aussi supportés
      • Le point-virgule final est optionnel

  • Quelques explications lors du lancement de l'application
    • 'h' pour l'aide
    • 'n' pour faire apparaitre les normales
    • 'f' pour faire apparaitre les faces cachées
    • Mouvement possible de la lumière / caméra / d'un point du tissu

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

Plusieurs choix possibles pour votre TP :
  1. Animation de textiles (uniquement si pas fait en M1)
  2. Animation d'un objet rigide
  3. Animation de fluide en utilisant la méthode SPH
  4. Animation en utilisant l'approche PBD (Position Based Dynamics) : objet rigide, objet déformable, fluide

Ce qui est attendu pour votre TP :

  1. 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
  2. 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
  3. 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
  4. 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

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

Vous devrez déposer sur TOMUSS une archive dans la colonne Depot-FZ.
Cette archive contiendra (mettre votre nom prénom comme nom du répertoire) :
  1. les fichiers de code que vous avez modifiés (fichiers .cpp et .h uniquement)
  2. un rapport de 5 à 10 pages.
En ce qui concerne le TP, voir ce qui est attendu dans le sujet du TP.

En ce qui concerne le rapport, voici son contenu :
  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.

Sujet de TP - 1 - 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/animationphys/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/animationphys/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/animationphys/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 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

Ces étapes sont détaillées ci-dessous.

Affichage de l'objet simulé

  • Complétez la fonction Viewer::initMeshObjetDeformable() pour créer le maillage de l'objet simulé.
  • Complétez la fonction Viewer::updateMeshObjetDeformable() pour mettre à jour le maillage de l'objet simulé au cours de la simulation.
Ces méthode se trouvent dans le fichier Viewer-mesh.cpp.

Calcul des forces

  • Quelles sont les forces qui sont exercées sur chacune des particules du tissu ?
  • Complétez la méthode void ObjetSimuleMSS::CalculForceSpring() servant à calculer les forces qui sont exercées sur chacune des particules. Pensez à prendre en compte les forces d'amortissement des ressorts.
Méthode se trouve dans le fichier ObjetSimuleMSS.cpp.

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.
Méthode se trouvent dans le fichier SolveurExpl.cpp.

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.
Méthode se trouvent dans le fichier SolveurExpl.cpp.

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 - 2 - 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/animationphys/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 Viewer::initMeshRigidBody() pour créer le maillage de l'objet simulé.
  • Complétez la fonction Viewer::updateMeshRigidBody() pour mettre à jour le maillage de l'objet simulé au cours de la simulation.
Ces méthode se trouvent dans le fichier Viewer-mesh.cpp.

Initialisation de l'objet rigide

  • Complétez le code des différentes méthodes appelées dans ObjetSimuleRigidBody::initObjetSimule() relatives à la mécanique de l'objet..
Ces méthodes se trouvent dans le fichier ObjetSimuleRigidBody.cpp.

Boucle de la simulation

  • Vérifiez les appels effectués.
  • Complétez le code des différentes méthodes appelées dans ObjetSimuleRigidBody::Simulation().
Les méthodes se trouvent dans le fichier ObjetSimuleRigidBody.cpp

Collision avec le sol

  • Complétez le code de ObjetSimuleRigidBody::Collision() pour gérer les collisions de l'objet rigide avec un sol.
Méthode se trouvant dans le fichier ObjetSimuleRigidBody.cpp.

Sujet de TP - 3 - 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/animationphys/exec.

Affichage de l'objet simulé

  • Les appels pour effectuer l'affichage du fluide considéré comme un ensemble de particules (sphères) en mouvement sont effectués dans la fonction Viewer::render().
  • Juste à comprendre.

Initialisation de l'objet simulé

  • La méthode void ObjetSimuleSPH::initObjetSimule() a été implémentée.
  • Comprenez-la. Vous pouvez la modifier.
Méthode se trouvant dans le fichier ObjetSimuleSPH.cpp

Calcul des densités des particules

  • Complétez la méthode void ObjetSimuleSPH::CalculDensite() permettant de calculer la densité de chaque particule du fluide.
Méthode se trouvant dans le fichier ObjetSimuleSPH.cpp.

Boucle de la simulation

  • La méthode ObjetSimuleSPH::Simulation() a été implémentée. Elle se trouve dans le fichier ObjetSimuleSPH.cpp.
  • Il reste à compléter le code des différentes méthodes appelées.

Calcul des forces d'interaction entre particules

  • Complétez la méthode void ObjetSimuleSPH::CalculInteraction(float visco) 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.
Méthode se trouve dans le fichier ObjetSimuleSPH.cpp.

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 obtenons pour le calcul des accélérations :
  • 
        // 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
  • Implémentez la méthode void ObjetSimuleSPH::Collision() : méthode se trouvant dans le fichier ObjetSimuleSPH.cpp.
  • Elle peut utiliser la méthode void ObjetSimuleFluide::applyBoxCollision(int i) mise dans ObjetSimuleFluide.cpp.

Sujet de TP - 4 - Simulation avec PBD

Travail à 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.
    • Les paramètres du textile sont mis dans les fichiers de données de l'application dans le répertoire gkit2light/animationphys/exec.
  • Pour un fluide :
    • Les paramètres du fluide sont mis dans les fichiers de données de l'application dans le répertoire gkit2light/animationphys/exec.
  • Pour un objet rigide :
    • Les paramètres de l'objet rigide sont mis dans les fichiers de données de l'application dans le répertoire gkit2light/animationphys/exec.

Affichage de l'objet simulé

  • Complétez la fonction Viewer::initMeshObjetDeformable() pour créer le maillage de l'objet simulé.
  • Complétez la fonction Viewer::updateMeshObjetDeformable() pour mettre à jour le maillage de l'objet simulé au cours de la simulation.
Ces méthode se trouvent dans le fichier Viewer-mesh.cpp.

Implémentation de la méthode ObjetSimulePBD::initObjetSimule()

  • Cette méthode correspond à l'initialisation de l'objet dans le contexte de l'approche PBD :
    • Chargement des informations permettant d'initialiser les sommets, masses, ressorts (si textile)
    • Construction des contraintes de ressorts (si textile) : appel à ObjetSimulePBD::buildConstraints() qui devra etre implémentée.
    • Allocation du tableau des positions prédites
    Ces méthode se trouvent dans le fichier ObjetSimulePBD.cpp.

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

  • Cette méthode correspond à la boucle de simulation de PBD permettant 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
    • Gestion des collisions de l'objet avec le sol
    Cette méthode se trouve dans le fichier ObjetSimulePBD.cpp.

Références bibliographiques

Articles de recherche


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.
  • Collision de particules - CM de Fabrice Aubert

Sites Web


Podcasts


Pages utiles pour les cours

  • Explication sur les quaternions (utile pour la matrice de rotation de l'objet rigide)
  • Quaternion pour l'animation de personnage. Cours d'Alexandre Meyer.
  • Rotations. Correspondance matrice de rotation et quaternion.
  • Simulez des systèmes physiques avec la méthode d'Euler

  • Objets 3D

  • 3D Models (Stanford Bunny, Happy Buddha, Dragon, ...)
  • The Stanford 3D Scanning Repository
  • Large Geometric Models Archive at Georgia Tech
  • Galerie des projets d'étudiants