Independance de LrLight ! (LrEntityLight)

LrEntity.cpp

@@ -63,6 +63,11 @@ LrMatrix LrEntity::getMat() const
      return m_mat;
 }
 
+void LrEntity::setMat(const LrMatrix &mat)
+{
+    m_mat = mat;
+}
+
 bool LrEntity::getIntersection(const LrRay &ray, LrHit *hit, int fragment,
                                          Real minBound, Real maxBound) const
 {

LrEntity.h

@@ -71,7 +71,7 @@ public:
      * @brief Défini la matrice de position.
      * @param mat Référence d'un objet LrMatrix.
      */
-    void setMat(const LrMatrix &mat) const;
+    void setMat(const LrMatrix &mat);
 
     /**
      * @brief Opérateur d'affectation.

LrEntityLight.cpp → LrLight.cpp

 /**
- * @brief ENTITÉ : Gestion d'entité lumiere. Classe abstraite.
- * @file LrEntityLight.cpp
+ * @brief LUMIÈRE : Gestion d'une lumiere. Classe abstraite.
+ * @file LrLight.cpp
  * @date Jeudi 24 Avril 2008
  * @note
  * @author Josselin Francois
@@ -16,78 +16,61 @@
 #include "config.h"
 #endif
 
-#include "LrEntityLight.h"
+#include "LrLight.h"
 
-LrEntityLight::LrEntityLight(const LrMatrix &mat)
+LrLight::LrLight(const LrMatrix &mat)
 :
-    LrEntity(mat)
+    m_mat(mat)
 {
 }
 
 
-LrEntityLight::LrEntityLight(const LrEntityLight &source)
+LrLight::LrLight(const LrLight &source)
 :
-    LrEntity(source)
+    m_mat(source.m_mat)
 {
 }
 
-LrEntityLight::LrEntityLight(const LrMatrix &mat, const LrColor &col)
+LrLight::LrLight(const LrMatrix &mat, const LrColor &col)
 :
-    LrEntity(mat),
+    m_mat(mat),
     m_color(col)
 {
 }
 
-LrEntityLight::~LrEntityLight()
+LrLight::~LrLight()
 {
 }
 
-void LrEntityLight::pack(const LrMatrix &mat)
+LrMatrix LrLight::getMat() const
 {
+    return m_mat;
+}
 
+void LrLight::setMat(const LrMatrix &mat)
+{
+    m_mat = mat;
 }
 
-LrColor LrEntityLight::getColor()const
+LrColor LrLight::getColor()const
 {
     return m_color;
 }
 
-LrEntityLight& LrEntityLight::operator = (const LrEntityLight& source)
+LrLight& LrLight::operator = (const LrLight& source)
 {
     if (this==&source)
         return *this;
-    LrEntity::operator = (source);
     m_color=source.m_color;
     return *this;
 }
 
-bool LrEntityLight::operator == (const LrEntityLight& source)
+bool LrLight::operator == (const LrLight& source)
 {
-    return LrEntity::operator == (source) && m_color==source.m_color;
+    return m_color==source.m_color;
 }
 
-bool LrEntityLight::operator != (const LrEntityLight& source)
+bool LrLight::operator != (const LrLight& 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 → LrLight.h

 /**
- * @brief Classe abstraite pour la génération de lumiere.
- * @file LrEntityLight.h
+ * @brief LUMIÈRE : Classe abstraite pour la génération de lumiere.
+ * @file LrLight.h
  * @date Jeudi 24 Avril 2008
  * @note
  * @author Josselin Francois
@@ -20,49 +20,48 @@
 
 
 /**
- * @brief ENTITE :  Gestion d'objets.
+ * @brief LUMIÈRE : Gestion d'une lumière.
  *
  * Cette classe est une classe abstraite permettant la génération de lumiere.
  */
-class LrEntityLight : public LrEntity
+class LrLight
 {
 public:
-
-    typedef enum Type {
-
-        LIGHT_POINT,
-        LIGHT_SPOT,
-        LIGHT_PLANE
-
-    };
     /**
      * @brief Constructeur par defaut. La lumiere est blanche.
      * @param mat Référence d'un objet LrMatrix.
      */
-    LrEntityLight(const LrMatrix &mat);
+    LrLight(const LrMatrix &mat);
 
     /**
      * @brief Constructeur par copie.
-     * @param source Référence d'un objet LrEntityLight.
+     * @param source Référence d'un objet LrLight.
      */
-    LrEntityLight(const LrEntityLight &source);
+    LrLight(const LrLight &source);
 
     /**
      * @brief Constructeur par copie.
      * @param mat Référence d'un objet LrMatrix.
      * @param col Reference d'une objet LrColor.
      */
-    LrEntityLight(const LrMatrix &mat, const LrColor &col);
+    LrLight(const LrMatrix &mat, const LrColor &col);
 
     /**
      * @brief Destructeur.
      */
-    virtual ~LrEntityLight();
+    virtual ~LrLight();
 
     /**
-     * @brief Calcul des matrices de transformation.
+     * @brief Retourne une copie de la matrice de position.
+     * @return Objet LrMatrix.
      */
-    virtual void pack(const LrMatrix &mat);
+    LrMatrix getMat() const;
+    
+    /**
+     * @brief Défini la matrice de position.
+     * @param mat Référence d'un objet LrMatrix.
+     */
+    void setMat(const LrMatrix &mat);
 
     /**
      * @brief Retourne la position de l'entite
@@ -86,73 +85,22 @@ public:
      * @param source Entitée source.
      * @return Une référence sur l'objet affecté.
      */
-    LrEntityLight& operator = (const LrEntityLight& source);
+    LrLight& operator = (const LrLight& source);
 
     /**
      * @brief Opérateur de test d'égalité.
      * @return vrai ou faux.
      */
-    bool operator == (const LrEntityLight& source);
+    bool operator == (const LrLight& source);
 
     /**
      * @brief Opérateur de test d'inégalité.
      * @return vrai ou faux.
      */
-    bool operator != (const LrEntityLight& source);
-
-    /**
-     * @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;
+    bool operator != (const LrLight& source);
 
 private :
+    LrMatrix m_mat;
     /// @brief Couleur de la lumiere.
     LrColor m_color;
 };

LrEntityLightPlane.cpp → LrLightPlane.cpp

 /**
  * @brief ENTITÉ : Gestion d'entité lumiere-surface.
- * @file LrEntityLightPlane.cpp
+ * @file LrLightPlane.cpp
  * @date Jeudi 24 Avril 2008
  * @note
  * @author Josselin Francois
@@ -17,60 +17,60 @@
 #include "config.h"
 #endif
 
-#include "LrEntityLightPlane.h"
+#include "LrLightPlane.h"
 #include <cstdlib>
 
 
 
-LrEntityLightPlane::LrEntityLightPlane(const LrMatrix &mat)
+LrLightPlane::LrLightPlane(const LrMatrix &mat)
 :
-    LrEntityLight(mat),
+    LrLight(mat),
     m_nbRay(1)
 {
 }
 
-LrEntityLightPlane::LrEntityLightPlane(const LrEntityLightPlane &source)
+LrLightPlane::LrLightPlane(const LrLightPlane &source)
 :
-    LrEntityLight(source)
+    LrLight(source)
 {
     m_nbRay=source.m_nbRay;
 }
 
-LrEntityLightPlane::LrEntityLightPlane(const LrMatrix &mat, const LrColor &col, unsigned int nbRay)
+LrLightPlane::LrLightPlane(const LrMatrix &mat, const LrColor &col, unsigned int nbRay)
 :
-    LrEntityLight(mat, col),
+    LrLight(mat, col),
     m_nbRay(nbRay)
 {
 }
 
-LrEntityLightPlane * LrEntityLightPlane::clone() const
+LrLightPlane * LrLightPlane::clone() const
 {
-    return new LrEntityLightPlane(*this);
+    return new LrLightPlane(*this);
 }
 
-LrEntityLightPlane::~LrEntityLightPlane()
+LrLightPlane::~LrLightPlane()
 {
 }
 
-LrEntityLightPlane& LrEntityLightPlane::operator = (const LrEntityLightPlane& source)
+LrLightPlane& LrLightPlane::operator = (const LrLightPlane& source)
 {
     if (this==&source)
         return *this;
-    LrEntityLight::operator = (source);
+    LrLight::operator = (source);
     return *this;
 }
 
-bool LrEntityLightPlane::operator == (const LrEntityLightPlane& source)
+bool LrLightPlane::operator == (const LrLightPlane& source)
 {
-    return LrEntityLight::operator == (source);
+    return LrLight::operator == (source);
 }
 
-bool LrEntityLightPlane::operator != (const LrEntityLightPlane& source)
+bool LrLightPlane::operator != (const LrLightPlane& source)
 {
     return ! operator == (source);
 }
 
-LrPoint LrEntityLightPlane::getPos() const
+LrPoint LrLightPlane::getPos() const
 {
     LrVector v(
              (Real)(1.0 * rand()/RAND_MAX) * getMat().getCoeff(1,1),
@@ -82,11 +82,6 @@ LrPoint LrEntityLightPlane::getPos() const
     return LrPoint(getMat()*pt);
 }
 
-unsigned int LrEntityLightPlane::getNbRay() const{
+unsigned int LrLightPlane::getNbRay() const{
     return m_nbRay;
 }
-
-int LrEntityLightPlane::typeLumiere() const
-{
-    return LrEntityLight::LIGHT_PLANE;
-}

LrEntityLightPlane.h → LrLightPlane.h

 /**
- * @brief Classe pour la génération d'une lumière-surface qui éclaire dans
+ * @brief LUMIÈRE : Classe pour la génération d'une lumière-surface qui éclaire dans
  * @brief toutes les directions.
- * @file LrEntityLightPlane.h
+ * @file LrLightPlane.h
  * @date Jeudi 24 Avril 2008
  * @note 
  * @author Josselin Francois
@@ -13,30 +13,30 @@
  * Cette classe est une classe permettant la génération de lumiere-points. 
  */ 
 
-#ifndef LRENTITYLIGHTPLANE_H
-#define	LRENTITYLIGHTPLANE_H
+#ifndef LRLIGHTPLANE_H
+#define	LRLIGHTPLANE_H
 
-#include "LrEntityLight.h"
+#include "LrLight.h"
 
 /**
- * @brief ENTITÉ : Gestion d'entité élémentaire
+ * @brief LUMIÈRE : Gestion d'une lumière-surface.
  * 
  * Cette classe gère une entité de type lumiere-surface.
  */
-class LrEntityLightPlane : public LrEntityLight
+class LrLightPlane : public LrLight
 {
 public:
      /**
      * @brief Constructeur par defaut. La lumiere est blanche.
      * @param mat Référence d'un objet LrMatrix.
      */
-    LrEntityLightPlane(const LrMatrix &mat);
+    LrLightPlane(const LrMatrix &mat);
     
     /**
      * @brief Constructeur par copie.
-     * @param source Référence d'un objet LrEntityLightPlane.
+     * @param source Référence d'un objet LrLightPlane.
      */
-    LrEntityLightPlane(const LrEntityLightPlane &source);
+    LrLightPlane(const LrLightPlane &source);
     
     /**
      * @brief Constructeur par copie.
@@ -44,36 +44,36 @@ public:
      * @param col Reference d'une objet LrColor.
      * @param nbRay nombre de rayons a envoyer sur la surface.
      */
-    LrEntityLightPlane(const LrMatrix &mat, const LrColor &col, unsigned int nbRay);
+    LrLightPlane(const LrMatrix &mat, const LrColor &col, unsigned int nbRay);
     
     /**
      *  @brief Clone
      */
-    virtual LrEntityLightPlane *clone() const;    
+    virtual LrLightPlane *clone() const;    
     
     /**
      * @brief Destructeur.
      */
-    virtual ~LrEntityLightPlane();
+    virtual ~LrLightPlane();
     
     /**    
      * @brief Opérateur d'affectation.
      * @param source Entitée source.
      * @return Une référence sur l'objet affecté.
      */
-    LrEntityLightPlane& operator = (const LrEntityLightPlane& source);
+    LrLightPlane& operator = (const LrLightPlane& source);
     
     /**
      * @brief Opérateur de test d'égalité.
      * @return vrai ou faux.
      */
-    bool operator == (const LrEntityLightPlane& source);
+    bool operator == (const LrLightPlane& source);
     
     /**
      * @brief Opérateur de test d'inégalité.
      * @return vrai ou faux.
      */
-    bool operator != (const LrEntityLightPlane& source);
+    bool operator != (const LrLightPlane& source);
 
     /**
      * @brief Retourne la position de l'entite
@@ -87,11 +87,6 @@ public:
      */
     virtual unsigned int getNbRay() const;
     
-    /**
-     * @brief Renvoi le type de lumiere.
-     */    
-    virtual int typeLumiere() const;
-    
     private :
         
         unsigned int m_nbRay;

LrEntityLightPoint.cpp → LrLightPoint.cpp

 /**
- * @brief ENTITÉ : Gestion d'entité lumiere-point.
- * @file LrEntityLightPoint.cpp
+ * @brief LUMIÈRE : Gestion d'une lumiere-point.
+ * @file LrLightPoint.cpp
  * @date Jeudi 24 Avril 2008
  * @note
  * @author Josselin Francois
@@ -17,63 +17,58 @@
 #include "config.h"
 #endif
 
-#include "LrEntityLightPoint.h"
+#include "LrLightPoint.h"
 
-LrEntityLightPoint::LrEntityLightPoint(const LrMatrix &mat)
+LrLightPoint::LrLightPoint(const LrMatrix &mat)
 :
-    LrEntityLight(mat)
+    LrLight(mat)
 {
 }
 
-LrEntityLightPoint::LrEntityLightPoint(const LrEntityLightPoint &source)
+LrLightPoint::LrLightPoint(const LrLightPoint &source)
 :
-    LrEntityLight(source)
+    LrLight(source)
 {
 }
     
-LrEntityLightPoint::LrEntityLightPoint(const LrMatrix &mat, const LrColor &col)
+LrLightPoint::LrLightPoint(const LrMatrix &mat, const LrColor &col)
 :
-    LrEntityLight(mat, col)
+    LrLight(mat, col)
 {
 }    
     
-LrEntityLightPoint * LrEntityLightPoint::clone() const
+LrLightPoint * LrLightPoint::clone() const
 {
-    return new LrEntityLightPoint(*this);
+    return new LrLightPoint(*this);
 }
     
-LrEntityLightPoint::~LrEntityLightPoint()
+LrLightPoint::~LrLightPoint()
 {
 }
 
-LrEntityLightPoint& LrEntityLightPoint::operator = (const LrEntityLightPoint& source)
+LrLightPoint& LrLightPoint::operator = (const LrLightPoint& source)
 {
     if (this==&source)
         return *this;
-    LrEntityLight::operator = (source);
+    LrLight::operator = (source);
     return *this;
 }
 
-bool LrEntityLightPoint::operator == (const LrEntityLightPoint& source)
+bool LrLightPoint::operator == (const LrLightPoint& source)
 {
-    return LrEntityLight::operator == (source);
+    return LrLight::operator == (source);
 }
 
-bool LrEntityLightPoint::operator != (const LrEntityLightPoint& source)
+bool LrLightPoint::operator != (const LrLightPoint& source)
 {
     return ! operator == (source);
 }
 
-LrPoint LrEntityLightPoint::getPos() const
+LrPoint LrLightPoint::getPos() const
 {
     return LrPoint(getMat()*LrPoint::ZERO);
 }
 
-unsigned int LrEntityLightPoint::getNbRay() const{
+unsigned int LrLightPoint::getNbRay() const{
     return 1;
 }
-
-int LrEntityLightPoint::typeLumiere() const
-{
-    return LrEntityLight::LIGHT_POINT;
-}

LrEntityLightPoint.h → LrLightPoint.h

 /**
- * @brief Classe pour la génération d'une lumière-point qui éclaire dans
+ * @brief LUMIÈRE : Classe pour la génération d'une lumière-point qui éclaire dans
  * @brief toutes les directions.
- * @file LrEntityLightPoint.h
+ * @file LrLightPoint.h
  * @date Jeudi 24 Avril 2008
  * @note 
  * @author Josselin Francois
@@ -13,66 +13,66 @@
  * Cette classe est une classe permettant la génération de lumiere-points. 
  */ 
 
-#ifndef LRENTITYLIGHTPOINT_H
-#define	LRENTITYLIGHTPOINT_H
+#ifndef LRLIGHTPOINT_H
+#define	LRLIGHTPOINT_H
 
-#include "LrEntityLight.h"
+#include "LrLight.h"
 
 /**
- * @brief ENTITÉ : Gestion d'entité élémentaire
+ * @brief LUMIÈRE : Gestion d'une lumière-point.
  * 
  * Cette classe gère une entité de type lumiere-point.
  */
-class LrEntityLightPoint : public LrEntityLight
+class LrLightPoint : public LrLight
 {
 public:
      /**
      * @brief Constructeur par defaut. La lumiere est blanche.
      * @param mat Référence d'un objet LrMatrix.
      */
-    LrEntityLightPoint(const LrMatrix &mat);
+    LrLightPoint(const LrMatrix &mat);
     
     /**
      * @brief Constructeur par copie.
-     * @param source Référence d'un objet LrEntityLightPoint.
+     * @param source Référence d'un objet LrLightPoint.
      */
-    LrEntityLightPoint(const LrEntityLightPoint &source);
+    LrLightPoint(const LrLightPoint &source);
     
     /**
      * @brief Constructeur par copie.
      * @param mat Référence d'un objet LrMatrix.
      * @param col Reference d'une objet LrColor.
      */
-    LrEntityLightPoint(const LrMatrix &mat, const LrColor &col);
+    LrLightPoint(const LrMatrix &mat, const LrColor &col);
     
     /**
      *  @brief Clone
      */
-    virtual LrEntityLightPoint *clone() const;    
+    virtual LrLightPoint *clone() const;    
     
     /**
      * @brief Destructeur.
      */
-    virtual ~LrEntityLightPoint();
+    virtual ~LrLightPoint();
     
     /**    
      * @brief Opérateur d'affectation.
      * @param source Entitée source.
      * @return Une référence sur l'objet affecté.
      */
-    LrEntityLightPoint& operator = (const LrEntityLightPoint& source);
+    LrLightPoint& operator = (const LrLightPoint& source);
     
     /**
      * @brief Opérateur de test d'égalité.
      * @return vrai ou faux.
      */
-    bool operator == (const LrEntityLightPoint& source);
+    bool operator == (const LrLightPoint& source);
     
     /**
      * @brief Opérateur de test d'inégalité.
      * @return vrai ou faux.
      */
-    bool operator != (const LrEntityLightPoint& source);   
+    bool operator != (const LrLightPoint& source);   
 
     /**
      * @brief Retourne la position de l'entite
@@ -85,11 +85,6 @@ public:
      * @return entiers non signées.
      */
     virtual unsigned int getNbRay() const;
-    
-    /**
-     * @brief Renvoi le type de lumiere.
-     */    
-    virtual int typeLumiere() const;
 };
 
 #endif

LrScene.h

@@ -20,6 +20,7 @@
 #include <list>
 #include <semaphore.h>
 #include "LrEntity.h"
+#include "LrLight.h"
 #include "LrBinder.h"
 #include "LrCamera.h"
 #include "LrImage.h"
@@ -38,7 +39,12 @@ class LrScene
     /**
      * @brief Definition du type "LrEntityList" qui est un tabelau d'entites
      */  
-    typedef std::list<LrEntity *> LrEntityList;
+      typedef std::list<LrEntity *> LrEntityList;
+    
+    /**
+     * @brief Definition du type "LrEntityList" qui est un tabelau de lumières
+     */  
+      typedef std::list<LrLight *> LrLightList;
     
     /**
      * @brief Constructeur par défaut de LrScene.

LrSceneRayTracing.cpp

@@ -48,7 +48,7 @@ LrSceneRayTracing::LrSceneRayTracing(const LrSceneRayTracing &source)
 // ############################################################################
 
 LrSceneRayTracing::LrSceneRayTracing(const LrEntityList &entities,
-                                     const LrEntityList &lights,
+                                     const LrLightList &lights,
                                      LrBinder *binder,
                                      LrImage *image,
                                      LrCamera *camera,
@@ -204,18 +204,18 @@ LrColor LrSceneRayTracing::computeFromSource(const LrRay &ray, LrHit &hit)
  LrColor colorResult;
  colorResult = LrColor::BLACK;
 
- LrEntityList::const_iterator itObjs;
+ LrLightList::const_iterator itObjs;
 
  //on parcours la liste des lumieres
  for(itObjs = m_lights.begin(); itObjs != m_lights.end(); itObjs++)
  {
     LrPoint tmpOrig = LrPoint::translate(hit.point, EPSILON * hit.normal);
 
-    int nbRayOnLight=((LrEntityLight*)(*itObjs))->getNbRay();
+    int nbRayOnLight=((LrLight*)(*itObjs))->getNbRay();
     for(int i=0;i<nbRayOnLight;i++)
     {
         //vecteur du point d'impact vers la lumiere
-        LrVector vectorLight(tmpOrig, ((LrEntityLight*)(*itObjs))->getPos());
+        LrVector vectorLight(tmpOrig, ((LrLight*)(*itObjs))->getPos());
         Real dist = vectorLight.getNorme();
         LrColor colorTmp = LrColor::BLACK;
         vectorLight.normalize();
@@ -225,7 +225,7 @@ LrColor LrSceneRayTracing::computeFromSource(const LrRay &ray, LrHit &hit)
             LrHit hitShadow;
             if (m_binder->getIntersection(rayLight, &hitShadow, 0.0f, dist) == false)
             {
-                colorTmp += (((LrEntityLight*)(*itObjs))->getColor())*
+                colorTmp += (((LrLight*)(*itObjs))->getColor())*
                             hit.optic->compute(rayLight,-ray.getDirection(),
                                                 hit.normal,hit.tangent,
                                                 hit.u,hit.v);
@@ -237,7 +237,7 @@ LrColor LrSceneRayTracing::computeFromSource(const LrRay &ray, LrHit &hit)
                 { 
                     LrColor optic = ((LrOpticElementary*)(hitShadow.optic))->getPertColor(hitShadow.u,
                                       hitShadow.v, hitShadow.point)->getColor(hitShadow.u, hitShadow.v, hitShadow.point);
-                    colorTmp += optic * (((LrEntityLight*)(*itObjs))->getColor()) * transp;
+                    colorTmp += optic * (((LrLight*)(*itObjs))->getColor()) * transp;
                 }
             }
         }

LrSceneRayTracing.h

@@ -20,7 +20,7 @@
 #include "LrScene.h"
 #include "LrRay.h"
 #include "LrHit.h"
-#include "LrEntityLight.h"
+#include "LrLight.h"
 #include "LrVector.h"
 
 /**
@@ -57,7 +57,7 @@ public :
      * intersection avec un objet
      */
     LrSceneRayTracing(const LrEntityList &entities,
-                      const LrEntityList &lights,