Sujets et Corrections |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
|
TD n°1 et 2 : 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 3 (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°1 : Premières implantations OpenGL Exercice n°1
Télécharger le fichier archive IG-2018-2019.zip. Ce fichier archive contient une "solution" Visual Studio
2015.
La solution comprend un seul projet nommé Exemple. Ce projet référence un seul fichier source Exemple.cpp et est configuré pour une compilation utilisant
OpenGL: (1) Extraire l'archive IG-2018-2019.zip. Lancer Visual Studio 2015 et charger la solution. Vérifier la compilation et l'exécution du projet Exemple. (2) Implanter la question (3) de l'exercice n°1 du TD n°1. On pourra directement modifier le fichier Exemple.cpp de la question précédente pour y intégrer le code de génération de la scène. (3) Implanter la question (4) de l'exercice n°1 du TD n°1. Solutions
TP n°1 : GLUt Le fichier code source GLUtMinimum.cpp illustre le fonctionnement événementiel de la librairie GLUt. On rappelle que nous allons utiliser cette librairie annexe 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 à OpenGL de façon à mettre en évidence
les fonctionnalités GLUt et non les fonctionnalités OpenGL. La scène construite est constituée d'un unique tore. 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 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": 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 suivantes. a) 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. b) Implanter une animation telle que le tore tourne sur lui-même autour de l'axe x à raison de 1° de rotation entre chaque image. c) Implanter un contrôle clavier permettant d'activer/désactiver l'animation au moyen de la touche Entrée. d) Implanter un contrôle clavier permettant de faire tourner le tore sur lui-même autour de l'axe y dans un sens ou dans l'autre en utilisant les touches Flèche gauche et Flèche droite. e) Implanter un contrôle clavier permettant de passer l'affichage en mode plein écran en utilisant les touches de clavier 'f' ou 'F'. f) Implanter un contrôle souris permettant d'inverser le sens de rotation de l'animation par clic du bouton droit de la souris dans la fenêtre de dessin. g) Corriger le problème de déformation de la scène lorsque la dimension de la fenêtre est changée par l'utilisateur vers des valeurs différentes de résolutions en x et en y.
TD n°3 : Modélisation par facettes Exercice n°1
(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.
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 (1) Implanter l'exercice n°2 du TD n°1 en version "parallélépipèdes" et en version "cylindres". On utilisera la fonction de modélisation de cylindre développée au cours du TD n°3. (2) Ajouter les contrôles clavier permettant de faire varier les angles de rotation de l'avant-bras et du bras. Exemple: Up/Down pour changer l'angle r1 par incrément de 1.0° et Page up/Page down pour changer l'angle r2 par incrément de 1.0°. (3) Ajouter au bras robot une "pince robot" formée de deux mandibules modélisées par des cones. En dehors du fait d'utiliser des cones pour les mandibules, vous êtes libre de définir votre pince comme vous le souhaitez (objets canoniques de modélisation, taille(s) de ces objets, ...) (4) Ajouter les contrôles clavier permettant d'ouvrir/fermer la pince et de la faire tourner sur elle-même au bout du bras robot autour de l'axe du bras. Exemple: Right/Left pour changer l'angle de rotation de la pince par incrément de 1.0° et +/- pour ouvrir/fermer la pince.
Solutions
TD n°4 : Paramètrage numérique de caméras
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 circulaire 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 circulaire 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 : Caméras virtuelles
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 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é 7.0 centré sur l'origine du repère de modélisation. Les cubes sont colorés en fonction
de leur position dans la scène. L'affichage est réalisé en projection parallèle orthographique de façon à ce que l'intégralité de la zone
d'affichage de la fenêtre soit utilisée pour le viewport OpenGL. On rappelle que la direction de visualisation est la direction -z.
a) Lorsque la fenêtre de visualisation est modifiée par l'utilisateur pour adopter une résolution en x différente de la résolution en y, les objets affichés sont déformés.
Résoudre ce problème de façon que cette déformation disparaisse et que la scène reste intégralement visible quel que soit le ratio résolution en x / résolution en y.
b) Modifier le code source pour que l'affichage ne soit plus réalisé en projection parallèle orthographique mais en projection en perspective.
On placera la caméra virtuelle en position (0.0,0.0,100.0). On l'orientera de façon qu'elle regarde l'origine du repère de modélisation
(sur laquelle la scène est centrée). On choisira la direction y comme direction de la verticale.
c) Modifier une nouvelle fois le code source pour que la caméra virtuelle soit maintenant placée en position (0.0,0.0,10.0).
d) Modifier une dernière fois le code source pour qu'il soit possible de contrôler la position de la caméra en utilisant le clavier:
Question supplémentaire: On a placé l'appel à gluLookAt entre les appels aux fonctions glLightfv et scene. Déplacer l'appel à gluLookAt juste avant l'appel à glLightfv et tester le programme ainsi obtenu. La scène affichée est géométriquement identique mais les couleurs issus des calculs d'éclairage sont différents. Pourquoi?
Solutions
TP n°5 : Plaçage de texture L'archive zip ChargementImagePNG.zip contient les fichiers "code source" d'une librairie de gestion de fichiers "image" au format png accompagnés d'un exemple d'utilisation sous la forme d'une fonction main tentant deux chargements d'image successifs : Test.png et Emojis.png.
Plus précisément, une fonction d'importation et une fonction d'exportation sont décrites dans le fichier
ChargePngFile.h.
a) Télécharger et désarchiver ce fichier zip. b) Développer un programme OpenGL permettant d'afficher une scéne composée d'un rectangle de coté 7.5 x 5.0. On pourra utiliser comme base le code développé au cours du TP n°4.
c) Modifier le code source de la question (b) pour que le rectangle soit muni d'une texture le recouvrant entièrement utilisant l'image contenue dans le fichier Emojis.png.
d) Reprendre la fonction de modélisation de cylindre de l'exercice n°2 du TD n°3 pour y ajouter les instructions permettant de le recouvrir d'une texture. Dans le programme de la question (c), remplacer le rectangle par un cylindre de hauteur 5.0 et de rayon 2.5.
Solutions
Utiliser plusieurs textures
Les programmes ci-dessous montrent l'utilisation de plusieurs textures pour dessiner un cube où chacune des 6 faces est texturée au moyen d'une
image différente de celles des 5 autres faces.
Epreuve n°1 : Modélisation géométrique Question 1 a) 6 types de surfaces existent : GL_POLYGON, GL_TRIANGLES, GL_QUADS, GL_TRIANGLE_STRIP, GL_TRIANGLE_FAN et GL_QUAD_STRIP. b) Les normales étant utilisées pour les calculs d'éclairage, celles-ci doivent impérativement être spécifiées pour que ceux-ci s'opérent correctement. Question 2 La façon la plus simple de modéliser la facette carrée trouée demandée consiste à utiliser un GL_QUAD_STRIP formé de 4 quadrilatères (10 vertices). Les bords du GL_QUAD_STRIP sont constitués des bords intérieurs et extérieurs. Les arêtes de recollement sont constituées des "diagonales" de la facette trouée. Les deux premiers et deux derniers vertices sont identiques de façon à fermer le GL_QUAD_STRIP.
Question 3 Le cube schématisé est constitué de 12 "boites" parallélépipédiques rectangulaires. Une recherche des éléments pouvant être reproduits permet de déterminer qu'une structure en U formée de 3 boites peut être générée 4 fois avec une rotation de 90° entre chaque instanciation. Une fonction est donc développée pour modéliser cette structure. Pour faciliter la modélisation des boites, on aura intérêt à créer une fonction ad hoc avec passage en paramètres des largeur, hauteur et profondeur.
Solutions
TP n°6 : Lumières et matériaux
Le fichier source LumieresEtMaterielBase.cpp implante un programme d'affichage OpenGL
dans lequel, à l'exception d'une, toutes les instructions spécifiques à la gestion des matériaux et des lumières ont été omises. L'instruction
conservée se trouve dans la fonction init. Elle a pour but de supprimer (configurer à noir) la lumière ambiante existant par défaut au sein d'OpenGL
(configurée à (0.2,0.2,0.2,1.0)) en plus des lumières classiques (GL_LIGHT0 à GL_LIGHT7). A noter : Dans la fonction display, les fonctions OpenGL glPushAttrib et glPopAttrib sont utilisées pour sauvegarder dans une pile ad hoc et restaurer de façon rapide l'intégralité de la configuration des lumières et du matériel. Le paramètre de glPushAttrib dédié à cette sauvegarde est GL_LIGHTING_BIT.
Le but du TP consiste à placer les instructions de configuration des calculs d'illumination dans le respect des questions posées. a) Activer l'utilisation des calculs d'éclairage.
b) Activer et configurer la lumière 0 selon les caractéristiques suivantes:
c) Désactiver la lumière 0. Activer et configurer la lumière 1 selon les caractéristiques suivantes:
d) Désactiver la lumière 1. Activer et configurer la lumière 2 selon les caractéristiques suivantes:
e) Activer simultanément les lumières 0, 1 et 2.
f) On aura remarqué que les émissions spéculaires des questions (c) et (d) 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.
g) Modifier le matériel des tores selon les caractéristiques suivantes:
Questions supplémentaires
1) Tester la possibilité offerte par OpenGL de créer des lumières ponctuelle ou spot intégrant une atténuation de l'éclairage fonction de la
distance entre la lumière et le point qu'elle éclaire : atténuation linéaire, atténuation quadratique. 2) Réaliser une animation où les lumières tournent autour de l'origine et la scène reste immobile. 3) Tester l'influence du nombre de facettes de modélisation sur les éclairages et la vitesse d'animation.
4) Tester l'utilisation de valeurs supérieures à 1.0 pour les coefficients des "couleurs" pour les lumières et les matériels. Solutions
TP n°7 : Lancement du projet Description du travail à réaliser
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 ê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 : double free ou
delete, 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 une troisième fenêtre permettant de visualiser la scène depuis un 3ème point de vue (au choix).
Epreuve n°2 : Caméras virtuelles 1a) Une projection parallèle orthographique est une projection planaire (plan de projection plan) caractérisée par le fait que la projection de chaque objet sur le plan de projection est réalisée selon un vecteur (une direction) unique et que ce vecteur projection unique est orthogonal au plan de projection.
1b) Non exhaustivement :
1c) La fonction OpenGL dédiée à la configuration d'une projection parallèle orthographique est la fonction
2a) Le rôle de la fonction gluPerspective est de configurer une caméra virtuelle de visualisation en perspective selon l'axe -z pour un observateur
placé à l'origine. Elle permet de configurer l'angle d'ouverture vertical (fov ci-dessous, valeur en degrés), le ratio par lequel il
faut multiplier l'angle d'ouverture vertical pour obtenir l'angle d'ouverture horizontal (ratio ci-dessous), la distance en z (valeur
positive) en dessous de laquelle les objets à visualiser sont clippés (cMin ci-dessous) et la distance en z (valeur positive) au delà de laquelle
les objets à visualiser sont clippés (cMax ci-dessous).
2b) La fonction gluLookAt est utilisée pour résoudre le problème du placement et de l'orientation d'une caméra virtuelle de visualisation
lorsque celle-ci n'est pas placée à l'origine ou n'est pas orientée selon l'axe -z. Son appel est réalisé entre la configuration
de la caméra et la modélisation de la scène. 2c) L'appel à gluLookAt peut être placé dans la fonction display juste avant la modélisation de la scène ou bien dans la fonction reshape après le glLoadIdentity en mode GL_MODELVIEW.
#ifndef M_PI Solutions
TP n°8 : Coordonnées homogènes Le fichier CH3D.h est le fichier de déclaration d'une classe destinée à coder des coordonnées homogènes. Pour faciliter les opérations matricielles (TD n°5), le choix a été fait de ne pas utiliser en attribut 4 champs réels mais un tableau de 4 réels. Ce tableau est déclaré en public.
a) Développer le fichier CH3D.cpp implantant cette classe.
b) Développer les fichiers .h et .cpp d'une classe dérivée de CH3D permettant de coder des positions dans un espace à trois dimensions (4ème
coordonnée égale à 1.0 en coordonnées homogènes). Cette classe sera nommée Pos3D. Elle contiendra les trois constructeurs :
c) Développer les fichiers .h et .cpp d'une classe dérivée de CH3D permettant de coder des directions dans un espace à trois dimensions(4ème
coordonnée égale à 0.0 en coordonnées homogènes). Cette classe sera nommée Dir3D. Elle contiendra les quatre constructeurs suivants : On donne le fichier Mathematiques1.cpp. Ce fichier contient un programme constitué d'une unique fonction void main(void) destinée à valider les développements que vous allez réaliser aux questions (d), (e) et (f). Vous devriez obtenir un affichage voisin de celui donné ci-dessous (valeurs identiques éventuellement formatées de façon différente).
d) Développer une méthode d'instance (méthode "classique") et une méthode de classe (méthode statique) permettant de calculer la distance existant entre une position et une autre position. Les méthodes développées doivent être compatibles avec les appels réalisés dans la fonction main du programme Mathematiques1.cpp. e) Développer une méthode permettant de calculer la norme d'une direction. Développer une méthode permettant de normer une direction. f) Développer une méthode d'instance et une méthode de classe permettant de calculer le produit scalaire d'une direction par une autre direction. g) Développer une méthode d'instance et une méthode de classe permettant de calculer le produit vectoriel d'une direction par une autre direction. Solutions Si on souhaite disposer d'une classe "Coodonnées Homogènes" permettant d'utiliser des attributs x, y, z et w de type réel tout aussi bien qu'un attribut c de type tableau de 4 réels avec concordance mémoire entre x et c[0], y et c[1], z et c[2] et w et c[3] (utilisation d'une union), on pourra substituer au fichier CH3D.h cette version de fichier CH3D.h. Remarque : Dans un but d'efficacité à l'exécution, les solutions proposées ci-dessus ne sont pas programmées en respectant les recommandations usuelles de la programmation orientée objet (protection des attributs, protection des types, méthodes private/protected, ...). On trouvera ci-dessous une implantation respectant ces recommandations.
TD n°5 : Transformations géométriques On souhaite implanter les outils informatiques qui nous permettront de réaliser des transformations géométriques.
a) Implanter un classe mère TG3D permettant de coder des transformations géométriques génériques en coordonnées homogènes.
b) Dériver de la classe TG3D une classe fille Tr3D permettant de coder des transformations géométriques de type translation.
c) Dériver de la classe TG3D une classe fille Rt3D permettant de coder des transformations géométriques de type rotation.
d) Dériver de la classe TG3D une classe fille Sc3D permettant de coder des transformations géométriques de type zoom (scale). e) On souhaite réaliser la transformation d'une position ou d'une direction codée en coordonnées homogènes par une transformation géométrique. Implanter une méthode d'instance permettant de réaliser cette opération. f) On souhaite réaliser la composition de deux transformations géométriques. Implanter une méthode d'instance permettant de réaliser cette opération. Solutions
Les solutions ci-dessous ont été réalisées avec respect des recommandations usuelles du développement orienté objet :
TD n°6 : Courbes B-Splines a) On dispose d'un tableau de quatre Pos3D (voir TP n°8). On souhaite déterminer la position, pour une valeur t donnée, d'un point situé sur la courbe B-Spline définie par la ligne polygonale constituée de ces quatre positions.
Développer une fonction ad hoc prenant en paramètres le tableau g des quatre Pos3D, la valeur de t (0.0 <= t <= 1.0), la matrice de base mb
utilisée et le pointeur p sur la Pos3D résultat du calcul :
b) On dispose d'un tableau de Pos3D. Le nombre de ces positions est au moins égal à quatre. On souhaite tracer la courbe B-Spline par morceaux
définie par la ligne polygonale constituée de ces positions. Pour ce faire, on souhaite calculer n positions de lissage (n >= 2) uniformément
réparties.
Solutions
Epreuve n°3 : Matériels et lumières
TP n°9 : Courbes lissées
On considère la liste de positions trois dimensions suivante :
a) Implanter une fonction de lissage par B-Spline par morceaux applicable à un ensemble de points de contrôle, pour une matrice de base particulière et générant n points répartis uniformément sur la courbe.
b) Implanter un programme OpenGL complet permettant de dessiner simultanément avec des couleurs différentes: c) Implanter une fonction de lissage par courbe de Bézier applicable à un ensemble de points de contrôle et générant n points répartis uniformément sur la courbe.
d) Modifier le programme de la question (b) pour dessiner en plus la courbe de Bézier contrôlée par les 37 points.
Solutions
TD n°7 : Remplissage d'une facette triangulaire Implanter une fonction de remplissage 2D d'un triangle.
Méthode: Remplir un triangle en 2D peut être réalisé en traçant toutes les lignes horizontales de pixels délimitées par ses bords gauche et droit. Il convient donc de déterminer les abscisses extrèmes de ces lignes horizontales pour chacun des y compris entre ymin et ymax où ymin (resp. ymax) est la valeur minimale (resp. maximale) des ordonnées des 3 sommets de définition du rectangle.
Ainsi, deux tableaux xd et xg sont calculés dont les indices correspondent aux ordonnées y des lignes de pixels.
Solutions
TP n°10 : TP Projet
TP n°11 : Calcul de la direction des rayons réfléchis et transmis dans le cadre d'un algorithme de lancer de rayons
L'implantation d'un algorithme de lancer de rayons nécessite l'implantation d'un certain nombre de fonctions de calcul. Par exemple, pour chaque
type d'objet graphique géré, il sera nécessaire de tester s'il existe une intersection entre un objet graphique de ce type et un rayon. Un autre
exemple de fonctions devant être implantées sont les fonctions nécessaires aux calculs d'illumination : diffusion, réflexions spéculaires, ... Vous trouverez dans le fichier RayTracing.zip l'ensemble des fichiers sources constitutifs d'un programme permettant d'afficher des scènes constituées de sphères en utilisant un algorithme de lancer de rayons. Ces sphères peuvent être diffusantes, transparentes et réfléchissantes. Plus exactement ce programme ouvre deux fenêtres. La première réalise l'affichage de façon habituelle en utilisant OpenGL. La seconde fenêtre permet l'affichage de la même scène, mais en utilisant le lancer de rayons. La touche Enter permet de lancer l'affichage en lancer de rayons. La touche Espace permet de changer de scène. La souris peut être utilisée dans la fenêtre OpenGL pour faire tourner la scène sur elle-même. Il est alors possible de relancer le calcul en lancer de rayons. a) Télécharger le fichier RayTracing.zip. Réaliser l'extraction de l'ensemble des fichiers qu'il contient. Intégrer ces fichiers à un projet de développement permettant la compilation en utilisant OpenGL et GLUt. Compiler le projet. La compilation n'aboutit pas car deux méthodes ont été supprimées : une première pour calculer la direction du rayon réfléchi, une deuxième pour calculer la direction du rayon transmis. b) Déterminer la classe dans laquelle ces méthodes manquent et leurs entêtes. c) Développer ces deux méthodes pour obtenir un programme fonctionnel. Vous vous reporterez au cours sur le lancer de rayons pour trouver les formules de calcul.
Hiérarchie de classes
|