\section{Les modifications apportées}
\subsection{\textit{materials.h}}

De base, le programme permettait uniquement d'attribuer une couleur unique
aux objets, et le GMaterial défini se contentait de renvoyer la couleur
à chaque appel de la fonction \textit{getColor()}. Une texture ne pouvant pas se
résumer à une seule couleur, nous avons dû apporter des modifications à 
ce niveau. Tout d'abord, nous avons ajouté un constructeur permettant de
spécifier une texture au matériau, sous la forme d'un tableau en deux
dimensions de couleurs. Le type de ces dernières est celui défini de base
dans le projet. Deux arguments supplémentaires sont requis, il s'agit des
dimensions du tableau. Au cas où le constructeur de base, avec une couleur
unie, est utilisé, ces dimensions seront mises à -1.\\

Ensuite, nous avons ajouté une fonction \textit{getColor} qui prend deux
coordonnées en argument, \textit{u} et \textit{v}, et qui renvoie la couleur
correspondante dans le tableau représentant la texture. En effet, le matériau
est totalement indépendant de l'objet qui l'utilise, ce n'est donc pas à lui
d'effectuer une éventuelle transformation de coordonnées. Ces transformations
seront effectuées dans les objets, puisque chacun d'entre eux devra utiliser
des équations différentes, et devra appliquer un mapping différent. Nous
avons laissé la fonction \textit{getColor()} de base, qui renvoie la couleur
unie, pour laisser cette possibilité à l'utilisateur.\\

Ces modifications n'ont donc pas d'influence sur le code actuel du projet, et
permettront pour la suite du développement une modularité et une souplesse
certaine au niveau de l'implémentation des textures.

\subsection{\textit{models.h} et \textit{models.cc}}

Ces fichiers contiennent les déclarations, définitions, et implémentations des
différents objets disponibles dans le projet. C'est ici que nous allons devoir
transformer les coordonnées des points de l'objet (en 3D) en coordonnées 2D à
aller chercher dans la texture. Ainsi, en implémentant cette association ici,
nous avons directement à notre disposition les informations nécessaires sur les
objets, et nous n'avons pas besoin de créer de multiples fonctions d'accès.\\

Nous retrouvons ici le même principe que dans \textit{materials.h}, à savoir 
la fonction \textit{getColor()}. Nous avons modifié la fonction qui va demander
en argument les coordonnées du point en trois dimensions. Cela ne changera pas
le comportement de la fonction de base. En effet, nous commençons par tester 
les dimensions du tableau. Si les dimensions sont égales à -1, il s'agit d'un 
objet à couleur unie, et nous appelons la fonction \textit{getColor} du matériau
sans argument. Dans le cas contraire, nous avons une texture, et nous devons 
trouver le point de cette dernière qui doit \^{e}tre appliqué au point spécifié.\\

A ce niveau, chaque fonction \textit{getColor} des différents objets sera différente.
En effet, c'est ici que va se trouver la transformation du point à trois coordonnées
en point à deux coordonnées, que nous utiliserons pour récupérer la couleur du
matériau.\\

\subsection{\textit{scene.cc}}

La modification effectuée dans ce fichier est triviale, et se situe dans la fonction
\textit{shade}. La fonction doit récupérer la couleur de l'objet. Nous avons donc 
remplacé l'appel à \textit{getColor()} par un appel à notre nouveau \textit{getColor}, 
en passant en argument les coordonnées du point d'intersection avec le rayon. Les
calculs seront donc effectués avec comme base les couleurs de la texture.

%-------------------------------------------------------------------------------

  \subsection{Fichiers ajoutés}
    
    Pour représenter la texture à appliquer, nous utilisons des images au format 
    PPM3 très simple à lire. En effet, ce format contient un header de quatre
    éléments : \textit{le type de format}, \textit{la largeur de l'image}, 
    \textit{la hauteur de l'image} et \textit{la plus haute valeur de couleur possible}.
    Nous avons pour cela créé une nouvelle structure de classes :
    
    \begin{enumerate}
      \item \textit{ImageParser} est une classe abstraite représentant tout ce
            qu'il est nécessaire de disposer après la lecture d'un format quelconque.
            C'est-à-dire la table des couleurs relatives à chaque pixel et les dimensions
            de la texture. Ainsi, la classe est prête à être héritée pour n'importe quel
            parser qui permettrait de générer des images dans le format choisi par l'utilisateur.
      \item \textit{PPMParser} est la classe qui hérite de la class \textit{ImageParser}
            chargée de lire un fichier au format PPM3 et d'en extraire l'information
            utile. 
    \end{enumerate}      
    
    Nous avons également créé un générateur de fichier PPM3 en \textit{Java} pour
    tester différentes textures. Ce programme génère des damiers de dimensions
    données (largeur et hauteur de l'image et largeur et hauteur des rectangles) 
    avec un nombre de couleurs donné.
    