Sujets et Corrections |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
|
TP n°1 et TP n°2 : Premières implantations OpenGL Exercice n°1
Télécharger le fichier archive IG-2020-2021.zip. Ce fichier archive contient une "solution" Visual Studio
2015. Une solution est un package destiné à contenir des projets de développement (exécutables, librairies, dll, drivers, ...). Une solution est
formée à minima d'un fichier .sln quand elle ne contient aucun projet de développement. Elle consistera plus généralement en un fichier .sln,
en les fichiers .vcxproj des projets qu'elle inclut et en les fichiers (source ou autre) nécessaires à la compilation de ces projets. Il est
bon que tout cela soit organisé physiquement en répertoires pour que tout ne soit pas mélangé.
Le contenu de la solution peut être visualisé dans Visual Studio en utilisant l'explorateur de solution. La solution fournie comprend un seul
projet de développement nommé Exemple. Ce projet référence un seul fichier source Exemple.cpp et est préconfiguré
pour une compilation utilisant OpenGL : 1) Extraire l'archive IG-2020-2021.zip. Lancer Visual Studio et charger la solution. Vérifier la compilation et l'exécution du projet Exemple. 2) Le fichier code source GLUtMinimum.cpp illustre le fonctionnement événementiel de la librairie GLUt. On rappelle que nous allons utiliser cette librairie annexe à OpenGL pour construire l'interface utilisateur de nos programmes OpenGL, celui-ci ne contenant aucune fonction dédiée à cette fin.
Le fichier source GLUtMinimum.cpp contient le minimum d'appels possible à OpenGL tout en affichant
quand-même quelque chose, de façon à mettre en évidence les fonctionnalités GLUt et non les fonctionnalités OpenGL.
Les événements suivants sont gérés "normalement" avec exécution de code OpenGL : a) Télécharger et remplacer le fichier Exemple.cpp par le fichier GLUtMinimum.cpp dans le projet VisualStudio.
Le fichier GLUt-3-spec.pdf contient la documentation de référence de GLUt. Il pourra vous aider à implanter les réponses
aux questions b) à f). b) Implanter un contrôle clavier permettant de switcher entre les modes d'affichage plein et fil de fer en utilisant la touche de clavier Espace. Il convient de modifier la fonction keyboard du fichier source et d'utiliser la fonction OpenGL glPolygonMode pour le paramétrage du mode d'affichage dans la fonction display.
c) Implanter une animation telle que le tore tourne sur lui-même autour de l'axe Ox à raison de 1° de rotation entre chaque image. d) Implanter un contrôle clavier permettant d'activer/désactiver l'animation au moyen de la touche Entrée. On s'inspirera de la méthode utilisée dans Exemple.cpp. e) Implanter un contrôle clavier permettant de faire tourner interactivement le tore sur lui-même autour de l'axe Oy dans un sens ou dans l'autre en utilisant les touches Flèche gauche et Flèche droite. Il convient d'adapter la fonction special. f) Implanter un contrôle permettant de faire tourner le tore sur lui-même autour de l'axe Oz en réaction aux mouvements horizontaux de la souris bouton appuyé à raison de 1° de rotation par pixel de déplacement. Il convient d'adapter les fonctions mouse et mouseMotion.
TD n°1 : Premières scènes OpenGL Exercice n°1
(1) Programmer en OpenGL la scène suivante sous la forme d'une fonction C sans utiliser les fonctions glPushMatrix et glPopMatrix ailleurs
qu'en début et fin de fonction : (2) Reprogrammer en OpenGL la scène de la question (1) de telle manière que les cubes aient une de leurs faces orientée vers l'origine du repère. (3) Reprogrammer en OpenGL la scène de la question (2) en utilisant les fonctions glPushMatrix et glPopMatrix pour rendre les objets indépendants les uns des autres et simplifier l'écriture de la fonction scène.
(4) Programmer une scène OpenGL en plaçant 3 cubes de coté 2.0 aux 3 sommets d'un triangle équilatéral défini
avec les caractéristiques suivantes :
Exercice n°2
(1) Programmer la scène OpenGL modélisant un bras robot simplifié composé d'un bras et d'un avant-bras.
(2) Modifier la fonction OpenGL de l'exercice n°1 en remplaçant les parallélépipèdes par des cylindres de tailles équivalentes à celles des objets qu'ils remplacent.
Exercice n°3 (supplémentaire) (1) Implanter en OpenGL une fonction de dessin d'une molécule de Benzène (C6H6).
Les atomes de carbone (atomes centraux) ont un rayon égal à 0.5.
(2) Modifier la modélisation de la molécule de benzène de la question précédente pour que les liaisons carbone-carbone
soient alternativement des liaisons simples et des liaisons doubles (voir figure ci-dessous).
Solutions
TD n°2 : Modélisation par facettes Exercice n°1
Modéliser par facettes une facette carrée percée d'un trou carré.
Exercice n°2
(1) Modéliser par facettes un cube de coté c centré sur l'origine du repère de modélisation. On ne générera
pas les normales.
(2) Modifier la modélisation de la question précédente pour ajouter la gestion des normales.
Exercice n°3 (supplémentaire)
Modéliser par facettes un cylindre selon les caractéristiques suivantes:
Question supplémentaire : Ajouter un découpage latéral (selon l'axe y) pour une valeur nl.
Solutions
TP n°3 : Modélisation géométrique à base de facettes et d'objets canoniques Exercice n°1 Implanter et valider la fonction de modélisation d'une facette trouée d'un trou carré de l'exercice 1 du TD n°2. Exercice n°2
Implanter et valider la fonction de modélisation d'un cube de l'exercice 2 du TD n°2. Exercice n°3
Lors du TD n°2, une étape importante de la modélisation géométrique a été laissée de coté : la modélisation des normales. En effet, c'est à partir
des normales aux sommets d'une primitive graphique qu'OpenGL réalise les calculs d'éclairage lorsque le mode GL_LIGHTING est activé.
Si on souhaite pouvoir éclairer les objets, la spécification des normales est obligatoire car OpenGL ne les calcule pas seul. Il existe dans OpenGL
une variable d'environnement qui définit la valeur de normale qui sera affectée automatiquement à tout sommet créé. La fonction glNormal* permet
de configurer la valeur de cette variable d'environnement. Solutions
TD n°3 : Paramètrage numérique d'une caméra OpenGL
a) On considère une caméra de visualisation en projection parallèle orthographique placée en position (0.0, 0.0, 0.0) orientée selon l'axe (0.0,
0.0, -1.0). On considère une scène centrée sur le point de coordonnées (0.0, 0.0, -100.0) et occupant un volume sphérique de rayon 10.0.
b) On considère une caméra de visualisation en projection en perspective placée en position (0.0, 0.0, 0.0) orientée selon l'axe (0.0, 0.0, -1.0).
On considère une scène centrée sur le point de coordonnées (0.0, 0.0, -100.0) et occupant un volume sphérique de rayon 10.0. c) Dans le cadre d'une implantation OpenGL, décrire une solution permettant de s'assurer que l'intégralité de la scène sera visualisée quel que soit le ratio résolution horizontale sur résolution verticale adopté par le viewport d'affichage. Solutions
TP n°4 : Paramètrage numérique d'une caméra OpenGL
Le fichier code source ParametrageCamera.cpp contient un programme C+OpenGL complet réalisant
la modélisation géométrique d'une scène et organisant incomplètement son affichage écran. Cette scène est constituée de 64 cubes de coté 0.5
placés en 4 plans de 4x4 cubes de façon à occuper un volume cubique de coté 6.5 centré sur le point de coordonnées (0.0,0.0,-100.0). Les cubes sont
colorés en fonction de leur position dans la scène (de plus en plus rouge de gauche à droite, de plus en plus vert de bas en haut, de plus en plus
bleu de l'arrière vers l'avant). L'affichage est incomplètement implanté avec pour conséquence que l'exécution est possible, mais
que la scène n'est pas visible.
a) Modifier la fonction reshape en décommentant la ligne glOrtho et en paramétrant cet appel de fonction pour visualiser la scène au moyen d'une
caméra réalisant une projection parallèle orthographique, placée en position 0.0 et orientée selon l'axe -z.
b) Modifier la fonction reshape en recommentant la ligne glOrtho, en décommentant la ligne gluPerspective et en paramétrant cet appel de fonction
pour visualiser la scène au moyen d'une caméra réalisant une projection en perspective, placée en position 0.0 et orientée selon l'axe -z.
c) On souhaite maintenant donner l'illusion que la caméra de visualisation en perspective n'est plus placée à l'origine, mais en position
(0.0,0.0,-50.0) c'est à dire environ deux fois plus proche de la scène qu'initialement. d) Déplacer de nouveau la caméra vers les positions (0.0,0.0,-90.0), (0.0,0.0,-95.0), (-5.0,-5.0,-95.0), (-10.0,-15.0,-90.0), (-10.0,-15.0,-120.0). e) Implanter des contrôles clavier permettant de faire varier la position de la caméra au moyen des touches right et left pour les déplacements en x, up et down pour les déplacements en y, et page up et page down pour les déplacements en z. Solutions
TP n°5 : Paramètrage numérique d'un matériel et de lumières
Le fichier code source ParametrageMaterielEtLumieres.cpp contient un programme C+OpenGL
complet réalisant la modélisation géométrique d'une scène et organisant incomplètement son affichage écran. Cette scène est constituée d'ellispoïdes
organisés pour matérialiser les arêtes et les sommets d'un cube. L'affichage est incomplètement implanté avec pour conséquence que l'exécution
est possible, mais que la scène n'est pas correctement éclairée.
a) Ajouter un contrôle clavier à ce programme permettant d'activer/désactiver la gestion de l'éclairage au moyen de la touche "Entrée". b) Ajouter les contrôles claviers permettant d'activer/désactiver individuellement les 4 ptemières lumières d'OpenGL (lumières 0 à 3) au moyen des touches de fonction F1, F2, F3 et F4 (touches spéciales).
c) Configurer la lumière 1 selon les caractéristiques suivantes :
d) Configurer la lumière 2 selon les caractéristiques suivantes :
e) Configurer la lumière 3 selon les caractéristiques suivantes:
f) Configurer la lumière 4 selon les caractéristiques suivantes:
g) On aura remarqué que les émissions spéculaires des questions (d) et (e) semblent ne pas produire de résultat à l'écran. Ceci s'explique
par le fait que le matériel par défaut d'OpenGL ne génère pas de réponse à ce type d'éclairage.
h) Implanter les contrôles clavier permettant de modifier les valeurs de réflexion diffuse, réflexion ambiante et émission du matériel au moyen des
touches de fonction F6, F7 et F8 selon les modalités suivantes : Solutions
TD n°4 : Principes du plaçage de texture et application en OpenGL Explication du fonctionnement du programme TD-PlacageTexture.cpp qui permet de placer une texture sur un rectangle.
TP n°6 : Plaçage de texture OpenGL n'inclut pas de fonction permettant de réaliser l'importation d'une image depuis un fichier.
a) Télécharger l'archive ChargementImagePNG.zip. Cette archive contient les fichiers de code source nécessaires
à la compilation d'une librairie contenant des fonctions d'importation et d'exportation d'images au format PNG 24 bits. L'utilisation
de la fonction d'importation est montrée dans la fonction main du fichier ChargementImagePNG.cpp
qui tente de charger une image. Si le chargement échoue, un message d'indique. Si le chargement aboutit, un message l'indique et la résolution
de l'image est affichée. Ce programme n'affiche pas l'image. Il se contente de la télécharger en mémoire.
b) Récupérer le fichier de code source TD-PlacageTexture.cpp du TD n°4. Intégrer le code source de la fonction main du fichier ChargementImagePNG.cpp dans le fichier TD-PlacageTexture.cpp. Vérifier la compilation et l'exécution. c) Remplacer l'image générée algorithmiquement dans le fichier TD-PlacageTexture.cpp par une image obtenue par téléchargement d'un fichier image PNG 24 bits.
d) Reprendre et adapter la fonction de modélisation de cube développée au TP n°3 pour qu'elle permette le placement d'une texture sur chacune
des 6 faces d'un cube.
e) Adapter une seconde fois la fonction de modélisation de cube de façon qu'elle réalise le placement de textures différentes sur les 6 faces
du cube.
Solutions
Solutions
TP n°7 : Animation
Le programme Animation.cpp modélise deux scènes. Les touches 'o' et 'O' permettent de
switcher entre chacune des deux. Ces deux scènes modélisent des tunnels schématisés par une suite de tores. Les tunnels sont placés dans le plan
xOz. Les tores qui les schématisent ont pour rayons 2.0 pour le tore lui-même et 0.1 pour le tube du tore. Les scènes sont centrées sur le repère
de modélisation.
a) Importer le fichier Animation.cpp, l'intégrer à un projet de développement, le compiler et l'exécuter.
b) Implanter une animation dans chacune des deux scènes :
c) La scène est maintenant immobile et on souhaite que l'animation porte sur la caméra. Celle-ci est donc en déplacement. Elle suivra la trajectoire définie par l'axe du tunnel dont il convient de désactiver l'affichage pour éviter que la caméra soit placée à l'intérieur de l'axe du tunnel. La caméra sera orientée selon la direction tangente à la courbe définie par l'axe de déplacement.
d) Au lieu d'utiliser glutIdleFunc, utiliser glutTimerFunc pour tester l'implantation d'un déplacement à vitesse constante quel que soit l'ordinateur utilisé pour l'exécution. Solutions
TD n°5 : Mathématiques Coordonnées homogènes, test de planarité, transformations géométriques Exercice n°1 Proposer une méthode permettant de tester la planarité d'une facette non dégénérée à 4 sommets. Exercice n°2 a) Développer en C++ une classe coordonnées homogenes 3D nommée CH3D. b) Dériver de la classe CH3D une classe position 3D nommée Pos3D utilisable pour le stockage de positions dans un espace à trois dimensions. c) Dériver de la classe CH3D une classe direction 3D nommée Dir3D utilisable pour le stockage de directions dans un espace à trois dimensions. d) Développer une méthode de calcul du produit scalaire de deux Dir3D. e) Développer une méthode de calcul du produit vectoriel de deux Dir3D. f) Implanter une fonction ou une méthode de test de la planarité de facettes à 4 sommets. g) Tester les classes ci-dessus sur les données ci-dessous.
Exercice n°3 a) Développer en C++ une classe transformation géométrique 3D en coordonnées homogènes. Cette classe sera nommée TG3D. b) Dériver de la classe TG3D une classe translation 3D pour le stockage d'opérateurs de type translation de vecteur (tx, ty, tz). Cette classe sera nommée Tr3D. c) Dériver de la classe TG3D une classe rotation3D pour le stockage d'opérateurs de type rotation d'angle a autour de l'axe (ax, ay, az) passant par l'origine. Cette classe sera nommée Rt3D. d) Implanter une méthode de transformation d'une position 3D ou d'une direction 3D par une translation 3D ou une rotation 3D (voir l'exercice n°2 pour les classes Pos3D et Dir3D). e) Implanter une méthode de composition d'une transformation géométrique 3D par une transformation géométrique 3D. f) Tester les classes ci-dessus sur les données ci-dessous. Solutions
TP n°8 : Mathématique de l'Infographie Implanter et valider les classes dont le développement a été amorcé au cours du TD n°5. Solutions
TP n°10 : Projet
De façon à faciliter le développement du projet, réaliser le test des deux fichiers sources suivants: Le fichier DeuxFenetres.cpp illustre la possibilité offerte par GLUt de gérer plusieurs fenêtres d'affichage OpenGL. La fonction int glutCreateWindow(void) permet de créer les fenêtres. Elle retourne un handle entier à mémoriser permettant de garder une référence sur chaque fenêtre ouverte. Les fenêtres sont individuellement munies de leurs fonctions display, reshape, keyboard, special, mouse, ... qui permettent de gérer leur fonctionnement événementiel. Attention, les fenêtres partagent une et une seule fonction idle. Chaque fenêtre peut recevoir en propre un ordre de rafraichissement en utilisant la fonction void glutPostWindowRedisplay(int f) où f est le handle de la fenêtre à rafraîchir. Dans chaque fenêtre est géré un environnement OpenGL complet pouvant/devant être intégralement paramétré : lumières, matériaux, textures, caméra, options d'affichage, ...
Le fichier TestMemoire.cpp montre une technique spécifique à VisualStudio permettant de contrôler les opérations de gestion dynamique de la mémoire
: new, delete, calloc, malloc, free,... Le but de cette technique est de faciliter la détection des problèmes souvent constatés quant à la gestion
dynamique de la mémoire : free ou delete dupliqué, pas de free pour un alloc, pas de delete pour un new, ... Il s'agit d'un équivalent à
valgrind. Attention, les bibliothèques de compatibilté mfc doivent être installées (option non activée par défaut au moment de l'installation
de VisualStudio) pour que TestMemoire.cpp puisse être compilé et donc exécuté. a) Corriger le problème mémoire existant dans TestMemoire.cpp. b) Ajouter l'ouverture d'une troisième fenêtre au programme DeuxFenetres.cpp permettant de visualiser la scène depuis un 3ème point de vue (au choix). Solutions
TP n°11 : Projet
TP n°12 : Projet
Hiérarchie de classes
|