Sujets et Corrections |
|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
|
|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
|
TP n°1 et TP n°2 : Premières implantations OpenGL Exercice n°1
Télécharger le fichier archive IG-2023-2024.zip. Ce fichier archive contient une "solution" Visual Studio 2022. Une solution est un package destiné à référencer
des projets de développement Visual Studio (exécutables, librairies, dll, drivers..., mais aussi éventuellement sites web statiques ou dynamiques). La concrétisation physique d'une solution est formée
a 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 (item supérieur du menu Affichage). La solution IG-2023-2024 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-2023-2024.zip. Lancer Visual Studio et charger la solution. Elle est théoriquement compatible avec les versions 2015, 2017, 2019 et 2022 de
Visual Studio au prix d'une conversion qui devrait être proposée lors du premier chargement. 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 possible d'appels à 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. a) Repérer dans le code les appels de fonction qui semblent correspondre aux fonctionnalités implantées listées ci-dessous en italique. Placer des commentaires dans le code pour garder une trace de ce que vous avez repéré.
La scène construite est constituée d'un unique tore muni du matériel par défaut d'OpenGL. Le calcul d'illumination est activé et une seule lumière est allumée. L'élimination des parties
cachées est activée. La projection est réalisée en projection orthographique. Le contenu du volume cubique dont la diagonale est définie par les positions (-1.0,-1.0,-1.0) et (1.0,1.0,1.0) du repère de
modélisation est affiché dans le viewport de visualisation (la fenêtre) en projection selon l'axe -z du repère de modélisation. Le viewport de visualisation est configuré pour occuper automatiquement
(dynamiquement) l'intégralité de la fenêtre.
Les événements suivants sont gérés "normalement" avec exécution de code OpenGL valide et cohérent : b) 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 c) à g).
De part sa nature non orientée objet la librairie GLUt ne peut pas être employée sans utiliser des variables globales. Celles-ci permettent le partage d'informations entre les différentes fonctions
implantées pour être exécutées en réponse aux événements. De façon à ne pas aller contre le fonctionnement événementiel de GLUt mais plutôt à s'inscrire dans son cadre, on évitera de s'autoriser
à placer des instructions OpenGL dans toutes les fonctions événementielles et on limitera un tel placement aux seules fonctions display (rafraichissement de la fenêtre de dessin) et reshape (changement
de la taille de la fenêtre de dessin). Il est naturel que ces deux fonctions aient à contenir de l'OpenGL car la fonction reshape devra configurer la caméra virtuelle de visualisation OpenGL et la
fonction display devra modéliser la scène en OpenGL. Au lancement de l'application, GLUt entre en boucle infinie après post automatique d'un événement reshape et d'un événement display. Il
exécute donc la fonction reshape puis la fonction display, et se met en attente d'événements. Les événements peuvent arriver à n'importe quel instant et être de n'importe quel type lorsqu'ils
arrivent y compris des reshape et des display. Placer des instructions OpenGL dans d'autres fonctions que reshape et display n'est pas interdit mais présenterait pour inconvénient de générer un
flux OpenGL plus difficile à rendre déterministe, nous allons donc éviter de le faire.
c) 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.
d) 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.
e) Implanter un contrôle clavier permettant d'activer/désactiver l'animation au moyen de la touche Entrée.
f) 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 du clavier. On pourra par exemple appliquer une rotation de 1° ou de -1° à chaque utilisation d'une des flèches.
g) 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.
TD n°1 : Modélisation géométrique par objets canoniques, 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 côté 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
TP n°3 : Modélisation géométrique par objets canoniques Exercice n°1 (1) Implanter la question n°4 de l'exercice n°1 du TD n°1 (les trois cubes).
(2) Implanter la question n°1 de l'exercice n°2 du TD n°1 (le bras robot). Les cylindres n'étant pas disponibles dans GLUt, on pourra se limiter aux premières questions de l'exercice c'est
à dire celles où des "cubes" sont utilisés. On pourra aussi utiliser des "sphères" (des ellipsoïdes) au lieu de cylindres. (3) Implanter des contrôles clavier permettant de modifier les angles r1 et r2 du bras robot de la question n°2. On utilisera les touches '1' et '4' pour augmenter et diminuer r1 et les touches '2' et '5' pour augmenter et diminuer r2. Exercice n°2 On considère une scène constituée d'une sphère de rayon 0.5 et d'un cube de côté 0.1. La sphère est centrée sur l'origine. Le cube est "posé" sur la sphère (accolé à la sphère) sur l'axe 0z.
Pour la suite de l'exercice, pour changer la couleur des objets et donc mieux les visualiser, on pourra glisser les lignes de codes suivantes
(1) Implanter une animation où le cube tourne autour de la sphère (sur la surface de la sphère et autour du centre de la sphère) dans le plan xOz à raison de 2° de rotation entre chaque image. (2) Modifier l'animation de la question (1) de façon à ce que chaque fois que le cube repasse à sa position initale, son plan de rotation subisse une rotation de 6° autour de l'axe Oz.
Solutions
TD n°2 : Modélisation géométrique par facettes Exercice n°1
(1) Modéliser par facettes un cube de côté 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.
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°4 : Modélisation géométrique à base de facettes Exercice n°1
Modéliser par facettes une facette carrée percée d'un trou carré.
Exercice n°2
Implanter et valider la fonction de modélisation d'un cube de l'exercice 1 du TD n°2 (version avec normales). Solutions
TP n°5 : Modélisation géométrique Exercice n°1
Développer une fonction de création d'un maillage rectangulaire plan formé de nl lignes sur nc colonnes de facettes rectangulaires pour une dimension globale dc sur dl. Exercice n°2 Modifier le cube de l'exercice n°2 du TP n°4 de façon que chaque face carrée soit remplacée par un maillage de n x n facettes carrées élémentaires.
Inclure dans votre programme des contrôles clavier qui permettent : Solutions
Epreuve n°1 : Modélisation géométrique Solutions
TD n°3
Solutions
TP n°6 : Mise en route du projet
Le thème du projet est : moteur.
Les requis de développement sont les suivants :
Le calendrier du projet est :
TP n°7 : Matériels et lumières en OpenGL Exercice n°1
Soient les fichiers sources suivants : Le but de l'exercice consiste à modifier MateriauxEtLumieresBase.cpp pour y intégrer différentes fonctionnalités d'éclairage et d'attribution de matériaux.
(1) Ajouter les contrôles clavier permettant : (2) Modifier le paramétrage de la lumière 1 pour qu'elle devienne une lumière uniquement ambiante d'énergie (0.5,0.5,0.5). (3) Modifier le paramétrage de la lumière 2 pour qu'elle devienne une lumière uniquement diffuse d'énergie (1.0,0.0,0.0).
(4) Modifier le paramétrage de la lumière 3 pour qu'elle devienne une lumière uniquement spéculaire d'énergie (0.0,1.0,1.0).
(5) Modifier les paramétrages des lumières 1, 2 et 3 pour qu'elles deviennent respectivement :
(6) Configurer la lumière 4 pour qu'elle devienne un spot blanc et diffus placé en position (-5.0,-5.0,10.0) éclairant vers l'origine du
repère.
(7) Tester les animations suivantes :
(8) Jouer sur le paramétrage des matériaux pour que les objets de la scène aient des looks différents : (9) Modifier la lumière 4 pour qu'elle intégre une décroissance de l'éclairage fonction inverse du carré de la distance (au lieu de sans atténuation). Modifier l'énergie de votre spot pour que la scène redevienne visible.
TP n°8 : Matériels et lumières en OpenGL Fin du TP n°7
TP n°9 : 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 l'indique en disant que l'adresse mémoire du tableau d'unsigned char
obtenu est l'adresse 0x00000000 (NULL). Si le chargement aboutit, un message l'indique et la résolution de l'image est affichée ainsi
que l'adresse et la taille en octets du tableau d'unsigned char obtenu. 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. Ce fichier contient un exemple
de programme montrant comment OpenGL permet le plaçage d'une texture sur un rectangle ou un cylindre. Dans ce programme l'image est créée
algorithmiquement au moyen de la fonction static unsigned char *image(int nc,int nl) qui crée une image de résolution nc x nl pixels et retourne
cette image sous la forme d'un tableau unidimensionnel d'octets non signés. Le format de ce tableau est RVB entrelacé 24 bits c'est à
dire que chaque pixel est décrit par trois composantes rouge, verte et bleue stockées dans cet ordre et codées individuellement au moyen d'un
octet non signé, et que le fichier contient séquentiellement chaque pixel de l'image dans l'ordre gauche à droite et haut en bas.
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°4 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
TP n°10 : 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é (fonction ad hoc placées en commentaires) 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). d) Déplacer de nouveau la caméra vers les positions (0.0,0.0,-90.0) puis (0.0,0.0,-95.0) puis (-5.0,-5.0,-95.0) puis (-10.0,-15.0,-90.0) et enfin (-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 TD n°5 & n°6 : 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°11 : Coordonnées homogènes Implantation des exercices 1 et 2 du TD n°5-6
Hiérarchie de classes
|