--no commit message

--no commit message

LrPertColor3DPBasic.cpp

@@ -37,8 +37,9 @@ LrPertColor3DPBasic::LrPertColor3DPBasic(const LrPertColor3DPBasic &source)
 }
 
 LrPertColor3DPBasic::LrPertColor3DPBasic(const LrColor &c1, const LrColor &c2, const LrColor &c3, 
-                                                             Real intensite, int level, Real multiplicateur, int typeInterpol)
-:   LrPertColorTxtPrc3DPerlin(c1, c2, c3, intensite, level, multiplicateur, typeInterpol)
+                                         Real intensite, int level, Real multiplicateur, 
+                                         int typeInterpol, bool lissage)
+:   LrPertColorTxtPrc3DPerlin(c1, c2, c3, intensite, level, multiplicateur, typeInterpol, lissage)
 {
 
 }
@@ -85,7 +86,8 @@ 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 ++)
     {
-        noise += fabsf((m_perlin.f_noise(tmp.x, tmp.y, tmp.z)));
+        if(m_lissage) noise += fabsf((lissage(tmp.x, tmp.y, tmp.z)));
+        else noise += fabsf((m_perlin.f_noise(tmp.x, tmp.y, tmp.z)));
      }
     noise *= m_intensity;
     if(m_interpolation == COS) return interpolCos(C1, C2, noise);

LrPertColor3DPBasic.h

@@ -44,7 +44,7 @@ class LrPertColor3DPBasic : public LrPertColorTxtPrc3DPerlin
         * @param dimension dimension des damiers
         */
         LrPertColor3DPBasic(const LrColor &c1, const LrColor &c2, const LrColor &c3, Real intensite, 
-                                      int level, Real multiplicateur, int typeInterpol);
+                            int level, Real multiplicateur, int typeInterpol, bool lissage);
     
     
         /**

LrPertColor3DPBois.cpp

@@ -37,8 +37,9 @@ LrPertColor3DPBois::LrPertColor3DPBois(const LrPertColor3DPBois &source)
 }
 
 LrPertColor3DPBois::LrPertColor3DPBois(const LrColor &c1, const LrColor &c2, const LrColor &c3, 
-                                                 Real intensite, int level, Real multiplicateur, int typeInterpol)
-:   LrPertColorTxtPrc3DPerlin(c1, c2, c3, intensite, level, multiplicateur, typeInterpol)
+                                       Real intensite, int level, Real multiplicateur, 
+                                       int typeInterpol, bool lissage)
+:   LrPertColorTxtPrc3DPerlin(c1, c2, c3, intensite, level, multiplicateur, typeInterpol, lissage)
 {
 
 }
@@ -86,7 +87,8 @@ 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 ++)
     {
-                t += 20 * (m_perlin.f_noise(tmp.x, tmp.y, tmp.z));
+                if(m_lissage) t += 20 * (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));
     noise *= m_intensity;

LrPertColor3DPBois.h

@@ -43,7 +43,7 @@ class LrPertColor3DPBois : public LrPertColorTxtPrc3DPerlin
         * @param dimension dimension des damiers
         */
         LrPertColor3DPBois(const LrColor &c1, const LrColor &c2, const LrColor &c3, Real intensite, 
-                                int level, Real multiplicateur, int typeInterpol);
+                                int level, Real multiplicateur, int typeInterpol, bool lissage);
     
     
         /**

LrPertColor3DPMarbre.cpp

@@ -36,8 +36,9 @@ LrPertColor3DPMarbre::LrPertColor3DPMarbre(const LrPertColor3DPMarbre &source)
 }
 
 LrPertColor3DPMarbre::LrPertColor3DPMarbre(const LrColor &c1, const LrColor &c2, const LrColor &c3, 
-                                                     Real intensite, int level, Real multiplicateur, int typeInterpol)
-:   LrPertColorTxtPrc3DPerlin(c1, c2, c3, intensite, level, multiplicateur,typeInterpol)
+                                           Real intensite, int level, Real multiplicateur, 
+                                           int typeInterpol, bool lissage)
+:   LrPertColorTxtPrc3DPerlin(c1, c2, c3, intensite, level, multiplicateur,typeInterpol,lissage)
 {
 
 }
@@ -85,10 +86,11 @@ LrColor LrPertColor3DPMarbre::getColor(Real u, Real v, LrPoint &point) const
     for (int i = 0; i < m_level; i ++)
     {
                 Real f = pow(2,i);
-                noise += ((1.0f /f ) * ((m_perlin.f_noise(f * tmp.x, f * tmp.y, f * tmp.z))));
+                if(m_lissage) noise += fabsf((1.0f /f ) * (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)));
      }
 
-    noise =  fabsf(cos(tmp.x+tmp.y+noise));
+    noise =  fabsf(sin(tmp.x + tmp.y + tmp.z +noise));
     noise *= m_intensity;
     if(m_interpolation == COS) return interpolCos(C1, C2, noise);
     else  return interpolLinear(C1, C2, noise);

LrPertColor3DPMarbre.h

@@ -43,7 +43,7 @@ class LrPertColor3DPMarbre : public LrPertColorTxtPrc3DPerlin
         * @param dimension dimension des damiers
         */
         LrPertColor3DPMarbre(const LrColor &c1, const LrColor &c2, const LrColor &c3, 
-                                   Real intensite, int level, Real multiplicateur, int typeInterpol);
+                                   Real intensite, int level, Real multiplicateur, int typeInterpol, bool lissage);
     
     
         /**

LrPertColor3DPTurbulence.cpp

@@ -37,8 +37,9 @@ LrPertColor3DPTurbulence::LrPertColor3DPTurbulence(const LrPertColor3DPTurbulenc
 }
 
 LrPertColor3DPTurbulence::LrPertColor3DPTurbulence(const LrColor &c1, const LrColor &c2, const LrColor &c3, 
-                                                             Real intensite, int level, Real multiplicateur, int typeInterpol)
-:   LrPertColorTxtPrc3DPerlin(c1, c2, c3, intensite, level, multiplicateur, typeInterpol)
+                                                   Real intensite, int level, Real multiplicateur, 
+                                                   int typeInterpol, bool lissage)
+:   LrPertColorTxtPrc3DPerlin(c1, c2, c3, intensite, level, multiplicateur, typeInterpol, lissage)
 {
 
 }
@@ -82,13 +83,12 @@ bool operator != (const LrPertColor3DPTurbulence &lhs, const LrPertColor3DPTurbu
 LrColor LrPertColor3DPTurbulence::getColor(Real u, Real v, LrPoint &point) const
 {
     Real noise = 0.0;
-    LrPoint tmp(point.x, point.y,  point.z);
+    LrPoint tmp(m_mult * point.x, m_mult * point.y,  m_mult * point.z);
     for (int i = 0; i < m_level; i ++)
     {
                 Real f = pow(2,i);
-                Real a = pow(m_mult,i);
-                //noise += fabsf((1.0f /f ) * ((m_perlin.f_noise(f * tmp.x, f * tmp.y, f * tmp.z))));
-                noise += fabsf(a * ((m_perlin.f_noise(f * tmp.x, f * tmp.y, f * tmp.z))));
+                if(m_lissage) noise += fabsf((1/f) * (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;
     if(m_interpolation == COS) return interpolCos(C1, C2, noise);

LrPertColor3DPTurbulence.h

@@ -44,7 +44,7 @@ class LrPertColor3DPTurbulence : public LrPertColorTxtPrc3DPerlin
         * @param dimension dimension des damiers
         */
         LrPertColor3DPTurbulence(const LrColor &c1, const LrColor &c2, const LrColor &c3, Real intensite, 
-                                      int level, Real multiplicateur, int typeInterpol);
+                                      int level, Real multiplicateur, int typeInterpol, bool lissage);
     
     
         /**

LrPertColorTxtPrc3DPerlin.cpp

@@ -27,7 +27,8 @@ LrPertColorTxtPrc3DPerlin::LrPertColorTxtPrc3DPerlin()
     m_intensity(0.0),
     m_level(1),
     m_mult(1),
-    m_interpolation(LIN)
+    m_interpolation(LIN),
+    m_lissage(false)
 {
 
 }
@@ -37,19 +38,22 @@ LrPertColorTxtPrc3DPerlin::LrPertColorTxtPrc3DPerlin(const LrPertColorTxtPrc3DPe
     m_intensity(source.m_intensity),
     m_level(source.m_level),
     m_mult(source.m_mult),
-    m_interpolation(source.m_interpolation)
+    m_interpolation(source.m_interpolation),
+    m_lissage(source.m_lissage)
 {
 
 }
 
 LrPertColorTxtPrc3DPerlin::LrPertColorTxtPrc3DPerlin(const LrColor &c1, const LrColor &c2, const LrColor &c3, 
-                                             Real intensite, int level, Real multiplicateur, int typeInterpol)
+                                                     Real intensite, int level, Real multiplicateur, 
+                                                     int typeInterpol, bool lissage)
 :   LrPertColorTextProc3D(c1, c2, c3),
     m_perlin(),
     m_intensity(intensite),
     m_level(level),
     m_mult(multiplicateur),
-    m_interpolation(typeInterpol)
+    m_interpolation(typeInterpol),
+    m_lissage(lissage)
 {
     if(m_mult == 0) m_mult=1;
 }
@@ -78,6 +82,25 @@ 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)                                                   *
  *---------------------------------------------------------------------------*/
@@ -99,7 +122,8 @@ bool operator == (const LrPertColorTxtPrc3DPerlin &lhs, const LrPertColorTxtPrc3
     return (LrPertColorTextProc3D&)lhs==(LrPertColorTextProc3D&)rhs && (lhs.m_intensity == rhs.m_intensity)
                                                                     && (lhs.m_level == rhs.m_level)
                                                                     && (lhs.m_mult == rhs.m_mult)
-                                                                    && (lhs.m_interpolation == rhs.m_interpolation);
+                                                                    && (lhs.m_interpolation==rhs.m_interpolation)
+                                                                    && (lhs.m_lissage == rhs.m_lissage);
 
 }
 

LrPertColorTxtPrc3DPerlin.h

@@ -19,6 +19,7 @@
 
 #include "LrPertColorTextProc3D.h"
 #include "LrPerlin.h"
+#include "LrPoint.h"
 
 #define LIN 1
 #define COS 2
@@ -46,11 +47,13 @@ class LrPertColorTxtPrc3DPerlin : public LrPertColorTextProc3D
         * @param c3 couleur 3 de la texture
         * @param intensite intensite du bruit de perlin
         * @param level nombre de sommation pour le calcul du bruit.
-        * @param multiplicateur coefficient d'attenuation ou d'augmentation à definir suivant l'image désirée
+        * @param multiplicateur coefficient d'attenuation ou d'augmentation à definir suivant 
+        * la distance de l'objet, plus la distance est eloigné et plus les valeurs du point doivent etre atténué
+        * revient au mm principe que de normaliser un vecteur
         * @param typeInterpol le type d'interpolation désiré (cosinusoidale ou lineaire)
         */
         LrPertColorTxtPrc3DPerlin(const LrColor &c1, const LrColor &c2, const LrColor &c3, Real intensite, 
-                                  int level, Real multiplicateur, int typeInterpol);
+                                  int level, Real multiplicateur, int typeInterpol, bool lissage);
     
     
         /**
@@ -86,6 +89,8 @@ class LrPertColorTxtPrc3DPerlin : public LrPertColorTextProc3D
         int getLevel() const;
         void setIntensity(Real intensite);
         void setLevel(int level);
+
+        
  
     protected :
 
@@ -94,6 +99,9 @@ class LrPertColorTxtPrc3DPerlin : public LrPertColorTextProc3D
         int  m_level;
         Real m_mult;
         int m_interpolation;
+        bool m_lissage;
+
+        Real lissage(Real x, Real y, Real z) const;
 
 };
 

LrPertNormalPerlin.cpp

@@ -79,7 +79,9 @@ LrVector LrPertNormalPerlin::getNormal(Real u, Real v,
     x = m_perlin.f_noise(N.x - m_bump, N.y, N.z) - m_perlin.f_noise(N.x + m_bump, N.y, N.z);
     y = m_perlin.f_noise(N.x, N.y - m_bump, N.z) - m_perlin.f_noise(N.x, N.y + m_bump, N.z);
     z = m_perlin.f_noise(N.x, N.y, N.z - m_bump) - m_perlin.f_noise(N.x, N.y, N.z + m_bump);
-    return LrVector(N.x+x, N.y+y, N.z+z);	
+    LrVector n(N.x+x, N.y+y, N.z+z);
+    n.normalize();
+    return n;	
 
 }