fin d'implémentation des perturbation de normal avec le bruit de perlin

Probleme du segfault dans la binder réglé

LrGeometryFacet.cpp

@@ -224,8 +224,7 @@ LrGeometryFacet::getIntersection(const LrRay &ray, LrHit *hit, int fragment,
 
     // si on arrive par l'arrière ou qu'on est parallèle à la facette
     // il n'y a pas d'intersection
-    if (N * ray.getDirection() > 0)
-        return false;
+    if (N * ray.getDirection() > 0) return false;
 
     // distance avec le point d'impact sur le plan
     LrVector OA(ray.getOrigin(), A);

LrOpticPhong.cpp

@@ -102,7 +102,7 @@ LrColor LrOpticPhong::compute(const LrRay &rayIn, const LrVector &rayOut,
                               const LrVector &normal, const LrVector &tangeante, 
                               Real u, Real v) const
 {
-    LrVector normalPert = m_pertNormal->getNormal(u, v, tangeante, normal);
+    LrVector normalPert = m_pertNormal->getNormal(u, v, tangeante, normal, rayIn.getOrigin());
    //voir cour page 88
   //(rayIn*normal) == cos entre la normal et rayIn
     Real angleLamb = normalPert*rayIn.getDirection();

LrPerlin.cpp

@@ -94,3 +94,22 @@ double LrPerlin::d_noise(double x, double y, double z)
 		   grad(p[BB+1], x-1, y-1, z-1))));
 }
 /*****************************************************************************/
+Real LrPerlin::lissage(Real x, Real y, Real z)
+{
+    Real corners = ( f_noise(x-1, y-1, z-1) 
+                    + f_noise(x+1, y-1, z-1)
+                    + f_noise(x-1, y+1, z+1)
+                    + f_noise(x+1, y+1, z+1) ) / 16;
+    
+    Real sides   = ( f_noise(x-1, y, z)  
+                    + f_noise(x+1, y, z)  
+                    + f_noise(x, y-1, z)  
+                    + f_noise(x, y+1, z) 
+                    + f_noise(x, y, z-1)  
+                    + f_noise(x, y, z+1) ) /  8;
+    
+    Real center  =  f_noise(x, y, z) / 4;
+
+    return corners + sides + center;
+
+}

LrPerlin.h

@@ -10,6 +10,7 @@ class LrPerlin
 
         /** version de d_noise avec des float */
         Real f_noise(Real x, Real y, Real z);
+        Real lissage(Real x, Real y, Real z);
 
       private :
          /** matrice du bruit de perlin pour la texture en calcule */

LrPertColor3DPBasic.cpp

@@ -86,7 +86,7 @@ LrColor LrPertColor3DPBasic::getColor(Real u, Real v, LrPoint &point) const
     LrVector tmp(m_mult*point.x, m_mult*point.y,  m_mult*point.z);
     for (int i = 0; i < m_level; i ++)
     {
-        if(m_lissage) noise += fabsf((lissage(tmp.x, tmp.y, tmp.z)));
+        if(m_lissage) noise += fabsf((m_perlin.lissage(tmp.x, tmp.y, tmp.z)));
         else noise += fabsf((m_perlin.f_noise(tmp.x, tmp.y, tmp.z)));
      }
     noise *= m_intensity;

LrPertColor3DPBois.cpp

@@ -87,7 +87,7 @@ LrColor LrPertColor3DPBois::getColor(Real u, Real v, LrPoint &point) const
     LrPoint tmp(m_mult*point.x, m_mult*point.y,  m_mult*point.z);
     for (int i = 0; i < m_level; i ++)
     {
-                if(m_lissage) t += 20 * (lissage(tmp.x, tmp.y, tmp.z));
+                if(m_lissage) t += 20 * (m_perlin.lissage(tmp.x, tmp.y, tmp.z));
                 else t += 20 * (m_perlin.f_noise(tmp.x, tmp.y, tmp.z));
     }
     noise = fabsf(t - floor(t));

LrPertColor3DPMarbre.cpp

@@ -86,7 +86,7 @@ LrColor LrPertColor3DPMarbre::getColor(Real u, Real v, LrPoint &point) const
     for (int i = 0; i < m_level; i ++)
     {
                 Real f = pow(2,i);
-                if(m_lissage) noise += fabsf((1.0f /f ) * (lissage(f * tmp.x, f * tmp.y, f * tmp.z)));
+                if(m_lissage) noise += fabsf((1.0f /f ) * (m_perlin.lissage(f * tmp.x, f * tmp.y, f * tmp.z)));
                 else noise += fabsf((1.0f /f ) * (m_perlin.f_noise(f * tmp.x, f * tmp.y, f * tmp.z)));
      }
 

LrPertColor3DPTurbulence.cpp

@@ -87,7 +87,7 @@ LrColor LrPertColor3DPTurbulence::getColor(Real u, Real v, LrPoint &point) const
     for (int i = 0; i < m_level; i ++)
     {
                 Real f = pow(2,i);
-                if(m_lissage) noise += fabsf((1/f) * (lissage(f * tmp.x, f * tmp.y, f * tmp.z)));
+                if(m_lissage) noise += fabsf((1/f) * (m_perlin.lissage(f * tmp.x, f * tmp.y, f * tmp.z)));
                 else noise += fabsf((1/f) * (m_perlin.f_noise(f * tmp.x, f * tmp.y, f * tmp.z)));
      }
     noise *= m_intensity;

LrPertColorTxtPrc3DPerlin.cpp

@@ -82,25 +82,6 @@ void LrPertColorTxtPrc3DPerlin::setLevel(int level)
     m_level = level;
 }
 
-Real LrPertColorTxtPrc3DPerlin::lissage(Real x, Real y, Real z) const
-{
-    Real corners = ( m_perlin.f_noise(x-1, y-1, z-1) 
-                    + m_perlin.f_noise(x+1, y-1, z-1)
-                    + m_perlin.f_noise(x-1, y+1, z+1)
-                    + m_perlin.f_noise(x+1, y+1, z+1) ) / 16;
-    
-    Real sides   = ( m_perlin.f_noise(x-1, y, z)  
-                    + m_perlin.f_noise(x+1, y, z)  
-                    + m_perlin.f_noise(x, y-1, z)  
-                    + m_perlin.f_noise(x, y+1, z) 
-                    + m_perlin.f_noise(x, y, z-1)  
-                    + m_perlin.f_noise(x, y, z+1) ) /  8;
-    
-    Real center  =  m_perlin.f_noise(x, y, z) / 4;
-
-    return corners + sides + center;
-
-}
 /*---------------------------------------------------------------------------*
  * assignement operator(s)                                                   *
  *---------------------------------------------------------------------------*/

LrPertColorTxtPrc3DPerlin.h

@@ -101,7 +101,6 @@ class LrPertColorTxtPrc3DPerlin : public LrPertColorTextProc3D
         int m_interpolation;
         bool m_lissage;
 
-        Real lissage(Real x, Real y, Real z) const;
 
 };
 

LrPertNormal.h

@@ -18,6 +18,7 @@
 #define LRPERTNORMAL_H
 
 #include "LrVector.h"
+#include "LrPoint.h"
 
 /**
  * @brief PertNormal : les perturbations de normal d'une optic.
@@ -64,8 +65,7 @@ public:
 
 
     /**
-     * @brief accessors
-     * Obtenir une normale prenant en compte une perturbation eventuel
+     * @brief Obtenir une normale prenant en compte une perturbation eventuel
      * @param u real coordonnee parametrique horizontale
      * @param v real coordonnee parametrique verticale
      * @param tangent LrVector la tangent fourni par la geometrie
@@ -73,7 +73,7 @@ public:
      */
     virtual LrVector getNormal(Real u, Real v,
                                const LrVector &tangent,
-                               const LrVector &N) const =0;
+                               const LrVector &N, const LrPoint &pointInter) const =0;
 
 
 };

LrPertNormalBasic.cpp

@@ -83,7 +83,7 @@ bool operator != (const LrPertNormalBasic &lhs, const LrPertNormalBasic &rhs)
  *---------------------------------------------------------------------------*/
 LrVector LrPertNormalBasic::getNormal(Real u, Real v,
                                       const LrVector &tangent,
-                                      const LrVector &N) const
+                                      const LrVector &N, const LrPoint &pointInter) const
 {
   //retourne une normal non perturbe
   return N;

LrPertNormalBasic.h

@@ -76,7 +76,7 @@ public:
      */
     virtual LrVector getNormal(Real u, Real v,
                                const LrVector &tangent,
-                               const LrVector &N) const;
+                               const LrVector &N, const LrPoint &pointInter) const;
 
 };
 

LrPertNormalPerlin.cpp

@@ -66,7 +66,7 @@ LrPertNormalPerlin::~LrPertNormalPerlin()
  *---------------------------------------------------------------------------*/
 LrVector LrPertNormalPerlin::getNormal(Real u, Real v,
                                       const LrVector &tangent,
-                                      const LrVector &N) const
+                                      const LrVector &N, const LrPoint &pointInter) const
 {
 
   //retourne une normal perturbe grace a l'appel a f_noise de perlin

LrPertNormalPerlin.h

@@ -70,7 +70,7 @@ public:
      */
     virtual LrVector getNormal(Real u, Real v,
                                const LrVector &tangent,
-                               const LrVector &N) const;
+                               const LrVector &N, const LrPoint &pointInter) const;
 
 private : 
 

LrVector.cpp

@@ -145,7 +145,11 @@ void LrVector::addXfois(const LrVector & vs, Real nbFois)
     (*this)+= vs;
   }
 }
-
+// ############################################################################
+LrPoint LrVector::convert()
+{
+    return LrPoint(z, y, z);
+}
 // ############################################################################
 
 LrVector & LrVector::operator = (const LrVector & source)

LrVector.h

@@ -132,6 +132,13 @@ public :
      */
     void normalize();
 
+    /**
+     * @brief obtenir le point correspondant à la translation du point d'origine
+     * @brief du vecteur avec sa direction.
+     * @return LrPoint le point obtenu grace au vecteur
+     */
+    LrPoint convert();
+
     /**
      * @brief Opérateur d'affectation
      * @param source LrVector modèle