Modification des méthodes getMinMax.

LrEntity.cpp

@@ -62,5 +62,3 @@ LrMatrix LrEntity::getMat() const
 {
      return m_mat;
 }
-
-

LrEntity.h

@@ -26,15 +26,14 @@ class LrGeometry;
  *
  * Cette classe gère un objet  générique.
  */
+class LrEntity;
+
 class LrEntity
 {
 public:
     ///@brief Liste d'entités.
     typedef std::list<LrEntity *> LrEntityList;
     
-    ///@brief Liste de géométries.
-    typedef std::list<LrGeometry *> LrGeometryList;
-    
     /**
      * @brief Constructeur.
      */
@@ -116,7 +115,7 @@ public:
                                  Real minBound=0, Real maxBound=INFINITY) const=0;
     
     /**
-     * @brief Donne le nombre de fragments de la géométrie.
+     * @brief Donne le nombre de fragments de l'entitée.
      * @return Un entier.
      */
     virtual int getNbFragments() const = 0;
@@ -130,9 +129,10 @@ public:
      * @param fragmentLocal fragment de l'entitée locale.
      *
      * Calcule le point "en bas, devant, à gauche" et le point "en haut,
-     * derrière, à droite" de la géométrie.
+     * derrière, à droite" de l'entitée.
      */
-    virtual void getMinMax(LrPoint &min, LrPoint &max, int fragment, LrEntity &*entityLocal, int &fragmentLocal) const = 0;
+    virtual void getMinMax(LrPoint &min, LrPoint &max, int fragment, 
+                           LrEntity *&entityLocal, int &fragmentLocal) const = 0;
     
     /**
      * @brief Calcul des points min et max de la boîte englobante.
@@ -140,15 +140,9 @@ public:
      * @param max LrPoint maximum de la boîte"
      *
      * Calcule le point "en bas, devant, à gauche" et le point "en haut,
-     * derrière, à droite" de la géométrie.
-     */
-    virtual void getMinMax(LrPoint &min, LrPoint &max) const;
-    
-    /**
-     * @brief Donne la liste de géométries qui composent cette entitée.
-     * @param geometryList Liste dans laquelle seront ajoutées les géométries.
+     * derrière, à droite" de l'entitée.
      */
-    virtual void mkGeometryList(LrGeometryList & geometryList) const=0;
+    virtual void getMinMax(LrPoint &min, LrPoint &max) const = 0;
 private:
     /// @brief Matrice de position.
     LrMatrix m_mat;

LrEntityComposed.cpp

@@ -18,6 +18,7 @@
 
 #include "LrEntityComposed.h"
 #include <algorithm>
+#include <cmath>
 
 LrEntityComposed::LrEntityComposed(const LrMatrix &mat, const LrEntityList &entities)
         :
@@ -113,10 +114,52 @@ bool LrEntityComposed::remove(LrEntity& entity)
     return true;
 }
 
-void LrEntityComposed::mkGeometryList(LrGeometryList & geometryList) const
+void LrEntityComposed::getMinMax(LrPoint &min, LrPoint &max) const
 {
-    for (LrEntityList::const_iterator it=m_entities.begin();it!=m_entities.end();it++)
+    max = LrPoint(-INFINITY,-INFINITY,-INFINITY);
+    min = LrPoint(INFINITY,INFINITY,INFINITY);
+    
+    for (LrEntityList::const_iterator it=m_entities.begin(); it != m_entities.end(); it++)
+    {
+        LrPoint lmin, lmax;
+        (*it)->getMinMax(lmin, lmax);
+        
+        if (lmin.x < min.x)
+            min.x = lmin.x;
+        if (lmin.y < min.y)
+            min.y = lmin.y;
+        if (lmin.z < min.z)
+            min.z = lmin.z;
+        
+        if (lmax.x > max.x)
+            max.x = lmax.x;
+        if (lmax.y > max.y)
+            max.y = lmax.y;
+        if (lmax.z > max.z)
+            max.z = lmax.z;
+    }
+}
+
+void LrEntityComposed::getMinMax(LrPoint &min, LrPoint &max, int fragment, 
+                                 LrEntity *&entityLocal, int &fragmentLocal) const
+{
+    int nbFrags;
+    for (LrEntityList::const_iterator it=m_entities.begin(); it != m_entities.end(); it++)
+    {
+        nbFrags = (*it)->getNbFragments();
+        if(fragment < nbFrags){
+            (*it)->getMinMax(min, max, fragment, entityLocal, fragmentLocal);
+            break;
+        }
+        fragment -= nbFrags;
+    }
+}
+
+int LrEntityComposed::getNbFragments() const{
+    int somFrags=0;
+    for (LrEntityList::const_iterator it=m_entities.begin(); it != m_entities.end(); it++)
     {
-        (*it)->mkGeometryList(geometryList);
+        somFrags += (*it)->getNbFragments();
     }
+    return somFrags;
 }

LrEntityComposed.h

@@ -86,6 +86,35 @@ public:
     virtual bool getIntersection(const LrRay &ray, LrHit *hit,
                                  Real minBound=0, Real maxBound=INFINITY) const;
     
+    /**
+     * @brief Donne le nombre de fragments de l'entitée.
+     * @return Un entier.
+     */
+    virtual int getNbFragments() const;
+    
+    /**
+     * @brief Calcul des points min et max de la boîte englobante.
+     * @param min LrPoint minimum de la boîte.
+     * @param max LrPoint maximum de la boîte.
+     * @param entityLocal Entitée dans lequel se trouve le fragment.
+     * @param fragmentLocal fragment d'entitée.
+     *
+     * Calcule le point "en bas, devant, à gauche" et le point "en haut,
+     * derrière, à droite" de l'entitée.
+     */
+    virtual void getMinMax(LrPoint &min, LrPoint &max, int fragment, 
+                           LrEntity *&entityLocal, int &fragmentLocal) const;
+    
+    /**
+     * @brief Calcul des points min et max de la boîte englobante.
+     * @param min LrPoint minimum de la boîte.
+     * @param max LrPoint maximum de la boîte"
+     *
+     * Calcule le point "en bas, devant, à gauche" et le point "en haut,
+     * derrière, à droite" de l'entitée.
+     */
+    virtual void getMinMax(LrPoint &min, LrPoint &max) const;
+    
     /**
      * @brief Ajout d'une sous-entité.
      * @param entity Référence de l'entité à ajouter.
@@ -100,12 +129,6 @@ public:
      */
     bool remove(LrEntity& entity);
     
-    /**
-     * @brief Donne la liste de géométries qui composent cette entitée.
-     * @param geometryList Liste dans laquelle seront ajoutées les géométries.
-     */
-    virtual void mkGeometryList(LrGeometryList & geometryList) const;
-    
 protected:
     ///@brief Liste des entités
     LrEntityList m_entities;

LrEntityElementary.cpp

@@ -91,7 +91,19 @@ bool LrEntityElementary::getIntersection(const LrRay &ray, LrHit *hit,
     }
 }
 
-void LrEntityElementary::mkGeometryList(LrGeometryList & geometryList) const
+void LrEntityElementary::getMinMax(LrPoint &min, LrPoint &max) const
 {
-    geometryList.push_back(m_geometry);
+    m_geometry->getMinMax(min,max,m_transf);
+}
+
+void LrEntityElementary::getMinMax(LrPoint &min, LrPoint &max, int fragment, 
+               LrEntity *&entityLocal, int &fragmentLocal) const
+{
+    fragmentLocal = fragment;
+    entityLocal = (LrEntity*)this;
+    m_geometry->getMinMax(min,max,fragment);
+}
+
+int LrEntityElementary::getNbFragments() const{
+    return m_geometry->getNbFragments();
 }

LrEntityElementary.h

@@ -91,10 +91,33 @@ public:
                                  Real minBound=0, Real maxBound=INFINITY) const;
     
     /**
-     * @brief Donne la liste de géométries qui composent cette entitée.
-     * @param geometryList Liste dans laquelle seront ajoutées les géométries.
+     * @brief Donne le nombre de fragments de l'entitée.
+     * @return Un entier.
      */
-    virtual void mkGeometryList(LrGeometryList & geometryList) const;
+    virtual int getNbFragments() const;
+    
+    /**
+     * @brief Calcul des points min et max de la boîte englobante.
+     * @param min LrPoint minimum de la boîte.
+     * @param max LrPoint maximum de la boîte.
+     * @param entityLocal Entitée dans lequel se trouve le fragment.
+     * @param fragmentLocal fragment d'entitée.
+     *
+     * Calcule le point "en bas, devant, à gauche" et le point "en haut,
+     * derrière, à droite" de l'entitée.
+     */
+    virtual void getMinMax(LrPoint &min, LrPoint &max, int fragment, 
+                           LrEntity *&entityLocal, int &fragmentLocal) const;
+    
+    /**
+     * @brief Calcul des points min et max de la boîte englobante.
+     * @param min LrPoint minimum de la boîte.
+     * @param max LrPoint maximum de la boîte"
+     *
+     * Calcule le point "en bas, devant, à gauche" et le point "en haut,
+     * derrière, à droite" de l'entitée.
+     */
+    virtual void getMinMax(LrPoint &min, LrPoint &max) const;
     
 private:
     /// @brief Géométrie de l'objet.

LrEntityLight.cpp

@@ -70,4 +70,24 @@ bool LrEntityLight::operator != (const LrEntityLight& source)
 {
     return ! operator == (source);
 }
+    
+bool LrEntityLight::getIntersection(const LrRay &ray, LrHit *hit,
+                                         Real minBound, Real maxBound) const
+{
+    return false;
+}
+
+void LrEntityLight::getMinMax(LrPoint &min, LrPoint &max, int fragment, 
+                              LrEntity *&entityLocal, int &fragmentLocal) const
+{
+    
+}
 
+void LrEntityLight::getMinMax(LrPoint &min, LrPoint &max) const
+{
+    
+}
+
+int LrEntityLight::getNbFragments() const{
+    return 1;
+}

LrEntityLight.h

@@ -104,6 +104,53 @@ public:
      * @brief Renvoi le type de lumiere.
      */
     virtual int typeLumiere() const=0;
+    
+    /**
+     * @brief Donne d'intersection entre un rayon et l'entitée.
+     * @param ray Référence d'un objet LrRay.
+     * @param hit Adresse de l'objet LrHit dans lequel sera stocké le résultat.
+     * @param minBound Distance minimum par rapport à l'origine (défaut : 0).
+     * @param maxBound Distance maximum par rapport à l'origine (défaut : INFINITY).
+     * @return vrai si il y a une intersection, sinon faux.
+     *
+     * Cette méthode calcul l'intersection entre le rayon @a ray et l'entitée
+     * et stocke le résultat dans la sructure LrHit pointée par @a hit si ce
+     * dernier n'est pas égal à NULL. On peut également spécifier la portion du
+     * rayon, à l'aide des paramètres @a minBound @a maxBound , à prendre en
+     * compte pour ce calcul.
+     */
+    virtual bool getIntersection(const LrRay &ray, LrHit *hit,
+                                 Real minBound=0, Real maxBound=INFINITY) const;
+    
+    /**
+     * @brief Donne le nombre de fragments de l'entitée.
+     * @return Un entier.
+     */
+    virtual int getNbFragments() const;
+    
+    /**
+     * @brief Calcul des points min et max de la boîte englobante.
+     * @param min LrPoint minimum de la boîte.
+     * @param max LrPoint maximum de la boîte.
+     * @param fragment fragment de l'entitée raçine.
+     * @param entityLocal Entitée dans lequel se trouve le fragment.
+     * @param fragmentLocal fragment de l'entitée locale.
+     *
+     * Calcule le point "en bas, devant, à gauche" et le point "en haut,
+     * derrière, à droite" de l'entitée.
+     */
+    virtual void getMinMax(LrPoint &min, LrPoint &max, int fragment, 
+                           LrEntity *&entityLocal, int &fragmentLocal) const;
+    
+    /**
+     * @brief Calcul des points min et max de la boîte englobante.
+     * @param min LrPoint minimum de la boîte.
+     * @param max LrPoint maximum de la boîte"
+     *
+     * Calcule le point "en bas, devant, à gauche" et le point "en haut,
+     * derrière, à droite" de l'entitée.
+     */
+    virtual void getMinMax(LrPoint &min, LrPoint &max) const;
 
 private :
     /// @brief Couleur de la lumiere.

LrEntityLightPlane.cpp

@@ -18,9 +18,9 @@
 #endif
 
 #include "LrEntityLightPlane.h"
-#include <cstdlib>
-
-
+#include <cstdlib>
+
+
 
 LrEntityLightPlane::LrEntityLightPlane(const LrMatrix &mat)
 :
@@ -90,14 +90,3 @@ int LrEntityLightPlane::typeLumiere() const
 {
     return LrEntityLight::LIGHT_PLANE;
 }
-
-bool LrEntityLightPlane::getIntersection(const LrRay &ray, LrHit *hit,
-        Real minBound, Real maxBound) const
-{
-    return false;
-}
-
-void LrEntityLightPlane::mkGeometryList(LrGeometryList & geometryList) const
-{
-    //?
-}

LrEntityLightPlane.h

@@ -92,29 +92,6 @@ public:
      */    
     virtual int typeLumiere() const;
     
-    /**
-     * @brief Donne d'intersection entre un rayon et l'entitée.
-     * @param ray Référence d'un objet LrRay.
-     * @param hit Adresse de l'objet LrHit dans lequel sera stocké le résultat.
-     * @param minBound Distance minimum par rapport à l'origine (défaut : 0).
-     * @param maxBound Distance maximum par rapport à l'origine (défaut : INFINITY).
-     * @return vrai si il y a une intersection, sinon faux.
-     *
-     * Cette méthode calcul l'intersection entre le rayon @a ray et l'entitée
-     * et stocke le résultat dans la sructure LrHit pointée par @a hit si ce
-     * dernier n'est pas égal à NULL. On peut également spécifier la portion du
-     * rayon, à l'aide des paramètres @a minBound @a maxBound , à prendre en
-     * compte pour ce calcul.
-     */
-    virtual bool getIntersection(const LrRay &ray, LrHit *hit,
-                                 Real minBound=0, Real maxBound=INFINITY) const;
-    
-     /**
-      * @brief Donne la liste de géométries qui composent cette entitée.
-      * @param geometryList Liste dans laquelle seront ajoutées les géométries.
-      */
-    virtual void mkGeometryList(LrGeometryList & geometryList) const;
-    
     private :
         
         unsigned int m_nbRay;

LrEntityLightPoint.cpp

@@ -77,14 +77,3 @@ int LrEntityLightPoint::typeLumiere() const
 {
     return LrEntityLight::LIGHT_POINT;
 }
-    
-bool LrEntityLightPoint::getIntersection(const LrRay &ray, LrHit *hit,
-        Real minBound, Real maxBound) const
-{
-    return false;
-}
-
-void LrEntityLightPoint::mkGeometryList(LrGeometryList & geometryList) const
-{
-    //?
-}

LrEntityLightPoint.h

@@ -90,29 +90,6 @@ public:
      * @brief Renvoi le type de lumiere.
      */    
     virtual int typeLumiere() const;
-    
-    /**
-     * @brief Donne d'intersection entre un rayon et l'entitée.
-     * @param ray Référence d'un objet LrRay.
-     * @param hit Adresse de l'objet LrHit dans lequel sera stocké le résultat.
-     * @param minBound Distance minimum par rapport à l'origine (défaut : 0).
-     * @param maxBound Distance maximum par rapport à l'origine (défaut : INFINITY).
-     * @return vrai si il y a une intersection, sinon faux.
-     *
-     * Cette méthode calcul l'intersection entre le rayon @a ray et l'entitée
-     * et stocke le résultat dans la sructure LrHit pointée par @a hit si ce
-     * dernier n'est pas égal à NULL. On peut également spécifier la portion du
-     * rayon, à l'aide des paramètres @a minBound @a maxBound , à prendre en
-     * compte pour ce calcul.
-     */
-    virtual bool getIntersection(const LrRay &ray, LrHit *hit,
-                                 Real minBound=0, Real maxBound=INFINITY) const;
-    
-     /**
-      * @brief Donne la liste de géométries qui composent cette entitée.
-      * @param geometryList Liste dans laquelle seront ajoutées les géométries.
-      */
-    virtual void mkGeometryList(LrGeometryList & geometryList) const;
 };
 
 #endif

LrGeometry.cpp

@@ -207,6 +207,35 @@ void LrGeometry::getMinMax(LrPoint &min, LrPoint &max) const
     }
 }
 
+void LrGeometry::getMinMax(LrPoint &min, LrPoint &max, 
+                           const LrMatrix &transform) const
+{
+    int nbFragments = getNbFragments();
+
+    // amorce avec min max du premier fragment
+    getMinMax(min, max, 0, transform);
+    
+    for (int i = 1; i < nbFragments; i++)
+    {
+        LrPoint lmin, lmax;
+        getMinMax(lmin, lmax, i, transform);
+        
+        if (lmin.x < min.x)
+            min.x = lmin.x;
+        if (lmin.y < min.y)
+            min.y = lmin.y;
+        if (lmin.z < min.z)
+            min.z = lmin.z;
+        
+        if (lmax.x > max.x)
+            max.x = lmax.x;
+        if (lmax.y > max.y)
+            max.y = lmax.y;
+        if (lmax.z > max.z)
+            max.z = lmax.z;
+    }
+}
+
 void LrGeometry::getMinMax(LrPoint &min, LrPoint &max, int fragment, const LrMatrix &transform) const
 {
     getMinMax(min, max);

LrGeometry.h

@@ -135,8 +135,7 @@ public:
     /**
      * @brief Calcul des points min et max de la boîte englobante.
      * @param min LrPoint minimum de la boîte.
-     * @param max LrPoint maximum de la boîte"
-     * @param fragment Fragment de la géométrie.
+     * @param max LrPoint maximum de la boîte.
      *
      * Calcule le point "en bas, devant, à gauche" et le point "en haut,
      * derrière, à droite" de la géométrie.
@@ -146,7 +145,8 @@ public:
     /**
      * @brief Calcul des points min et max de la boîte englobante.
      * @param min LrPoint minimum de la boîte.
-     * @param max LrPoint maximum de la boîte"
+     * @param max LrPoint maximum de la boîte.
+     * @param fragment Fragment de la géométrie.
      *
      * Calcule le point "en bas, devant, à gauche" et le point "en haut,
      * derrière, à droite" de la géométrie.
@@ -157,7 +157,7 @@ public:
      * @brief Calcul des points min et max de la boîte englobante suite à une
      * @brief transormation.
      * @param min LrPoint minimum de la boîte.
-     * @param max LrPoint maximum de la boîte"
+     * @param max LrPoint maximum de la boîte.
      * @param fragment Fragment de la géométrie.
      * @param transform Transformation à appliquer auparavent.
      *
@@ -168,6 +168,20 @@ public:
     virtual void getMinMax(LrPoint &min, LrPoint &max, int fragment,
                            const LrMatrix &transform) const;
     
+    /**
+     * @brief Calcul des points min et max de la boîte englobante suite à une
+     * @brief transormation.
+     * @param min LrPoint minimum de la boîte.
+     * @param max LrPoint maximum de la boîte.
+     * @param transform Transformation à appliquer auparavent.
+     *
+     * Calcule le point @a min (en bas, devant, à gauche) et le point @a max
+     * (en haut, derrière, à droite" de la géométrie après la transformation
+     * @a transform.
+     */
+    virtual void getMinMax(LrPoint &min, LrPoint &max,
+                           const LrMatrix &transform) const;
+    
 protected:
     /**
      * @brief Conversion de coordonnées absolues en paramétriques.

LrGeometryCube.h

@@ -15,7 +15,7 @@
 #ifndef LRGEOMETRYCUBE_H
 #define LRGEOMETRYCUBE_H
 #include "LrGeometry.h"
-#include "LrPoint.h"
+#include "LrPoint.h"
 
 /**
  * @brief GÉOMÉTRIE : Gestion d'une géométrie cubique
@@ -35,12 +35,12 @@ public:
      * @param src Référence d'un objet LrGeometryCube.
      */
     LrGeometryCube(const LrGeometryCube& src);
-
-    /**
-     * @brief Constructeur personnel.
-     * @param isIn Boolean :est-ce que l'on est à l'intérieure du cube ?
-     */
-    LrGeometryCube(bool isIn);
+
+    /**
+     * @brief Constructeur personnel.
+     * @param isIn Boolean :est-ce que l'on est à l'intérieure du cube ?
+     */
+    LrGeometryCube(bool isIn);
 
     /**
      * @brief Destructeur.
@@ -81,25 +81,25 @@ public:
      * compte pour ce calcul.
      */
     virtual bool getIntersection(const LrRay &ray, LrHit *hit, int fragment,
-                                 Real minBound=0, Real maxBound=INFINITY) const;
-
-
-    /**
-     * @brief Calcul des points min et max de la boîte englobante.
-     * @param min LrPoint minimum de la boîte.
-     * @param max LrPoint maximum de la boîte"
-     *
-     * Calcule le point "en bas, devant, à gauche" et le point "en haut,
-     * derrière, à droite" de la géométrie.
-     */
-    virtual void getMinMax(LrPoint &min, LrPoint &max, int fragment) const;
-
-
-    /**
-     * @brief Donne le nombre de fragments de la géométrie.
-     * @return Un entier.
-     */
-    virtual int getNbFragments() const;
+                                 Real minBound=0, Real maxBound=INFINITY) const;
+
+
+    /**
+     * @brief Calcul des points min et max de la boîte englobante.
+     * @param min LrPoint minimum de la boîte.
+     * @param max LrPoint maximum de la boîte.
+     *
+     * Calcule le point "en bas, devant, à gauche" et le point "en haut,
+     * derrière, à droite" de la géométrie.
+     */
+    virtual void getMinMax(LrPoint &min, LrPoint &max, int fragment) const;
+
+
+    /**
+     * @brief Donne le nombre de fragments de la géométrie.
+     * @return Un entier.
+     */
+    virtual int getNbFragments() const;
 
 protected:
     /**
@@ -121,10 +121,10 @@ protected:
     virtual void uv2xyz(Real u, Real v, LrPoint *point,
                         LrVector *normal, LrVector *tangent) const;
 
-private:
-
-    /// @brief est-ce que l'on est à l'interieure du cube
-    bool m_isIn; // boolean on est dedans ?
+private:
+
+    /// @brief est-ce que l'on est à l'interieure du cube
+    bool m_isIn; // boolean on est dedans ?
 
 };
 

LrGeometryPoint.h

@@ -85,7 +85,7 @@ public:
     /**
      * @brief Calcul des points min et max de la boîte englobante.
      * @param min LrPoint minimum de la boîte.
-     * @param max LrPoint maximum de la boîte"
+     * @param max LrPoint maximum de la boîte.
      *
      * Calcule le point "en bas, devant, à gauche" et le point "en haut,
      * derrière, à droite" de la géométrie.

LrGeometryQuadrangle.h

@@ -85,7 +85,7 @@ public:
     /**
      * @brief Calcul des points min et max de la boîte englobante.
      * @param min LrPoint minimum de la boîte.
-     * @param max LrPoint maximum de la boîte"
+     * @param max LrPoint maximum de la boîte.
      *
      * Calcule le point "en bas, devant, à gauche" et le point "en haut,
      * derrière, à droite" de la géométrie.

LrGeometrySphere.h

@@ -87,7 +87,7 @@ public:
     /**
      * @brief Calcul des points min et max de la boîte englobante.
      * @param min LrPoint minimum de la boîte.
-     * @param max LrPoint maximum de la boîte"
+     * @param max LrPoint maximum de la boîte.
      *
      * Calcule le point "en bas, devant, à gauche" et le point "en haut,
      * derrière, à droite" de la géométrie.

LrGeometryTriangle.h

@@ -15,7 +15,7 @@
 #ifndef LRGEOMETRYTRIANGLE_H
 #define LRGEOMETRYTRIANGLE_H
 #include "LrGeometry.h"
-#include "LrPoint.h"
+#include "LrPoint.h"
 
 /**
  * @brief GÉOMÉTRIE : Gestion d'une géométrie triangulaire
@@ -35,15 +35,15 @@ public:
      * @param src Référence d'un objet LrGeometryTriangle.
      */
     LrGeometryTriangle(const LrGeometryTriangle& src);
-
-    /**
-     * @brief Constructeur personnel.
-     * @param P1 Point 1 du triangle.
-     * @param P2 Point 2 du triangle.
-     * @param P3 Point 3 du triangle.
-     */
-    LrGeometryTriangle(const LrPoint& P1, const LrPoint& P2, const LrPoint& P3);
-
+
+    /**
+     * @brief Constructeur personnel.
+     * @param P1 Point 1 du triangle.
+     * @param P2 Point 2 du triangle.
+     * @param P3 Point 3 du triangle.
+     */
+    LrGeometryTriangle(const LrPoint& P1, const LrPoint& P2, const LrPoint& P3);
+
 
     /**
      * @brief Destructeur.
@@ -85,60 +85,60 @@ public:
      */
     virtual bool getIntersection(const LrRay &ray, LrHit *hit, int fragment,
                                  Real minBound=0, Real maxBound=INFINITY) const;
-
-
-    /**
-     * @brief Calcul des points min et max de la boîte englobante.
-     * @param min LrPoint minimum de la boîte.
-     * @param max LrPoint maximum de la boîte"
-     *
-     * Calcule le point "en bas, devant, à gauche" et le point "en haut,
-     * derrière, à droite" de la géométrie.
-     */
-    virtual void getMinMax(LrPoint &min, LrPoint &max, int fragment) const;
-
-
-    /**
-     * @brief Donne le nombre de fragments de la géométrie.
-     * @return Un entier.
-     */
-    virtual int getNbFragments() const;
-
-    /**
-     * @brief Retourne le point P1 du triangle.
-     * @return Un LrPoint.
-     */
-    virtual LrPoint getP1() const;
-
-    /**
-     * @brief Retourne le point P2 du triangle.
-     * @return Un LrPoint.
-     */
-    virtual LrPoint getP2() const;
-
-    /**
-     * @brief Retourne le point P3 du triangle.
-     * @return Un LrPoint.
-     */
-    virtual LrPoint getP3() const;
-
-    /**
-     * @brief Modifie le point P1 du triangle.
-     * @param point Nouveau point.
-     */
-    virtual void setP1(const LrPoint& point);
-
-    /**
-     * @brief Modifie le point P2 du triangle.
-     * @param point Nouveau point.
-     */
-    virtual void setP2(const LrPoint& point);
-
-    /**
-     * @brief Modifie le point P3 du triangle.
-     * @param point Nouveau point.
-     */
-    virtual void setP3(const LrPoint& point);
+
+
+    /**
+     * @brief Calcul des points min et max de la boîte englobante.
+     * @param min LrPoint minimum de la boîte.
+     * @param max LrPoint maximum de la boîte.
+     *
+     * Calcule le point "en bas, devant, à gauche" et le point "en haut,
+     * derrière, à droite" de la géométrie.
+     */
+    virtual void getMinMax(LrPoint &min, LrPoint &max, int fragment) const;
+
+
+    /**
+     * @brief Donne le nombre de fragments de la géométrie.
+     * @return Un entier.
+     */
+    virtual int getNbFragments() const;
+
+    /**
+     * @brief Retourne le point P1 du triangle.
+     * @return Un LrPoint.
+     */
+    virtual LrPoint getP1() const;
+
+    /**
+     * @brief Retourne le point P2 du triangle.
+     * @return Un LrPoint.
+     */
+    virtual LrPoint getP2() const;
+
+    /**
+     * @brief Retourne le point P3 du triangle.
+     * @return Un LrPoint.
+     */
+    virtual LrPoint getP3() const;
+