Skip to content

L
lray
Commit 34c1338c authored by paps's avatar paps
Browse files
Options

Modification des noms de classe pour les texture perlin 

modification des constructeurs de ces classes pour prendre en compte 2 nouveaux parametre (le type d'interpolation et un coef )
ameloration des fractal perlin et ajout de la classe permettant de creer une texture de perlin basic ( avous de tester)
voir le fichier LrPertCOlorTxtPrc3DPerlin.h
parent 2d4a43a8
Hide whitespace changes
Inline Side-by-side
Showing with 427 additions and 128 deletions
LrPertColorTextProcDamier.cpp → LrPertColor3DDamier.cpp
View file @ 34c1338c
/**
* @brief PertColor : les perturbations de couleur d'une optic.
* @file LrPertColorTextProcDamier.cpp
* @file LrPertColor3DDamier.cpp
* @date Jeudi 14 Fevrier 2008
* @note
* @author Josselin Francois
......@@ -18,7 +18,7 @@
#include "config.h"
#endif
#include "LrPertColorTextProcDamier.h"
#include "LrPertColor3DDamier.h"
#include <math.h>
#include <stdlib.h>
......@@ -26,38 +26,38 @@
* constructors and destructor *
*---------------------------------------------------------------------------*/
LrPertColorTextProcDamier::LrPertColorTextProcDamier()
LrPertColor3DDamier::LrPertColor3DDamier()
: LrPertColorTextProc3D(),
dim(0.0)
{
}
LrPertColorTextProcDamier::LrPertColorTextProcDamier(const LrPertColorTextProcDamier &source)
LrPertColor3DDamier::LrPertColor3DDamier(const LrPertColor3DDamier &source)
: LrPertColorTextProc3D(source),
dim(source.dim)
{
}
LrPertColorTextProcDamier::LrPertColorTextProcDamier(const LrColor &c1, const LrColor &c2, Real dimension)
LrPertColor3DDamier::LrPertColor3DDamier(const LrColor &c1, const LrColor &c2, Real dimension)
: LrPertColorTextProc3D(c1, c2, c2),
dim(dimension)
{
}
LrPertColorTextProcDamier * LrPertColorTextProcDamier::clone() const
LrPertColor3DDamier * LrPertColor3DDamier::clone() const
{
return new LrPertColorTextProcDamier(*this);
return new LrPertColor3DDamier(*this);
}
LrPertColorTextProcDamier::~LrPertColorTextProcDamier()
LrPertColor3DDamier::~LrPertColor3DDamier()
{
}
/*---------------------------------------------------------------------------*
* assignement operator(s) *
*---------------------------------------------------------------------------*/
LrPertColorTextProcDamier& LrPertColorTextProcDamier::operator = (const LrPertColorTextProcDamier &source)
LrPertColor3DDamier& LrPertColor3DDamier::operator = (const LrPertColor3DDamier &source)
{
if (this == &source)
return *this;
......@@ -71,18 +71,18 @@ LrPertColorTextProcDamier& LrPertColorTextProcDamier::operator = (const LrPertCo
/*---------------------------------------------------------------------------*
* comparison operator(s) *
*---------------------------------------------------------------------------*/
bool operator == (const LrPertColorTextProcDamier &lhs, const LrPertColorTextProcDamier &rhs)
bool operator == (const LrPertColor3DDamier &lhs, const LrPertColor3DDamier &rhs)
{
return (LrPertColorTextProc3D&)lhs==(LrPertColorTextProc3D&)rhs && lhs.dim == rhs.dim ;
}
bool operator != (const LrPertColorTextProcDamier &lhs, const LrPertColorTextProcDamier &rhs)
bool operator != (const LrPertColor3DDamier &lhs, const LrPertColor3DDamier &rhs)
{
return (! (lhs == rhs));
}
LrColor LrPertColorTextProcDamier:: getColor(Real u, Real v, LrPoint &point) const
LrColor LrPertColor3DDamier:: getColor(Real u, Real v, LrPoint &point) const
{
int x = (int)(point.x / dim);
int y = (int)(point.y / dim);
......
LrPertColorTextProcDamier.h → LrPertColor3DDamier.h
View file @ 34c1338c
/**
* @brief PertColor : les perturbations de couleur d'une optic.
* @file LrPertColorTexture.h
* @file LrPertColor3DDamier.h
* @date Jeudi 14 Fevrier 2008
* @note
* @author Josselin Francois
......@@ -14,8 +14,8 @@
*
*/
#ifndef LRPERTCOLOR_TEXTURE_PROC_DAMIER_H
#define LRPERTCOLOR_TEXTURE_PROC_DAMIER_H
#ifndef LRPERTCOLOR_3D_DAMIER_H
#define LRPERTCOLOR_3D_DAMIER_H
#include "LrPertColorTextProc3D.h"
......@@ -24,16 +24,16 @@
*
* Classe représentant une perturbation de couleur par une texture procedurale
*/
class LrPertColorTextProcDamier : public LrPertColorTextProc3D
class LrPertColor3DDamier : public LrPertColorTextProc3D
{
public:
LrPertColorTextProcDamier();
LrPertColor3DDamier();
/**
* @brief LrPertColorTextProcDmaier copy constructor
* @param source LrPertColorTextProcDmaier object reference.
*/
LrPertColorTextProcDamier(const LrPertColorTextProcDamier &source);
LrPertColor3DDamier(const LrPertColor3DDamier &source);
/**
* @brief LrPertColorTextProcDmaier personnal constructor
......@@ -42,31 +42,31 @@ class LrPertColorTextProcDamier : public LrPertColorTextProc3D
* @param c3 couleur 3 de la texture.
* @param dimension dimension des damiers
*/
LrPertColorTextProcDamier(const LrColor &c1, const LrColor &c2, Real dimension);
LrPertColor3DDamier(const LrColor &c1, const LrColor &c2, Real dimension);
/**
* @brief LrPertColorTexture clone.
* @return LrPertColorTexture pointer object.
*/
LrPertColorTextProcDamier * clone() const;
LrPertColor3DDamier * clone() const;
/**
* @brief LrPertColorTexture destructor
*/
virtual ~LrPertColorTextProcDamier();
virtual ~LrPertColor3DDamier();
/**
* @brief assignement operator(s)
*/
LrPertColorTextProcDamier & operator = (const LrPertColorTextProcDamier &source);
LrPertColor3DDamier & operator = (const LrPertColor3DDamier &source);
/**
* @brief comparison operator(s)
*/
friend bool operator == (const LrPertColorTextProcDamier &lhs, const LrPertColorTextProcDamier &rhs);
friend bool operator != (const LrPertColorTextProcDamier &lhs, const LrPertColorTextProcDamier &rhs);
friend bool operator == (const LrPertColor3DDamier &lhs, const LrPertColor3DDamier &rhs);
friend bool operator != (const LrPertColor3DDamier &lhs, const LrPertColor3DDamier &rhs);
/**
* @brief accessors
......
LrPertColorTextProcMarbre.cpp → LrPertColor3DPBasic.cpp
View file @ 34c1338c
/**
* @brief PertColor : les perturbations de couleur d'une optic.
* @file LrPertColorTextProcMarbre.cpp
* @file LrPertColor3DPBasic.cpp
* @date Jeudi 14 Fevrier 2008
* @note
* @author Josselin Francois
......@@ -18,35 +18,36 @@
#include "config.h"
#endif
#include "LrPertColorTextProcMarbre.h"
#include "LrPertColor3DPBasic.h"
#include "LrVector.h"
/*---------------------------------------------------------------------------*
* constructors and destructor *
*---------------------------------------------------------------------------*/
LrPertColorTextProcMarbre::LrPertColorTextProcMarbre()
LrPertColor3DPBasic::LrPertColor3DPBasic()
: LrPertColorTxtPrc3DPerlin()
{
}
LrPertColorTextProcMarbre::LrPertColorTextProcMarbre(const LrPertColorTextProcMarbre &source)
LrPertColor3DPBasic::LrPertColor3DPBasic(const LrPertColor3DPBasic &source)
: LrPertColorTxtPrc3DPerlin(source)
{
}
LrPertColorTextProcMarbre::LrPertColorTextProcMarbre(const LrColor &c1, const LrColor &c2, const LrColor &c3,
Real intensite, int level)
: LrPertColorTxtPrc3DPerlin(c1, c2, c3, intensite, level)
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)
{
}
LrPertColorTextProcMarbre * LrPertColorTextProcMarbre::clone() const
LrPertColor3DPBasic * LrPertColor3DPBasic::clone() const
{
return new LrPertColorTextProcMarbre(*this);
return new LrPertColor3DPBasic(*this);
}
LrPertColorTextProcMarbre::~LrPertColorTextProcMarbre()
LrPertColor3DPBasic::~LrPertColor3DPBasic()
{
}
......@@ -54,7 +55,7 @@ LrPertColorTextProcMarbre::~LrPertColorTextProcMarbre()
/*---------------------------------------------------------------------------*
* assignement operator(s) *
*---------------------------------------------------------------------------*/
LrPertColorTextProcMarbre& LrPertColorTextProcMarbre::operator = (const LrPertColorTextProcMarbre &source)
LrPertColor3DPBasic& LrPertColor3DPBasic::operator = (const LrPertColor3DPBasic &source)
{
if (this == &source)
return *this;
......@@ -67,36 +68,28 @@ LrPertColorTextProcMarbre& LrPertColorTextProcMarbre::operator = (const LrPertCo
/*---------------------------------------------------------------------------*
* comparison operator(s) *
*---------------------------------------------------------------------------*/
bool operator == (const LrPertColorTextProcMarbre &lhs, const LrPertColorTextProcMarbre &rhs)
bool operator == (const LrPertColor3DPBasic &lhs, const LrPertColor3DPBasic &rhs)
{
return (LrPertColorTxtPrc3DPerlin&)lhs==(LrPertColorTxtPrc3DPerlin&)rhs;
}
bool operator != (const LrPertColorTextProcMarbre &lhs, const LrPertColorTextProcMarbre &rhs)
bool operator != (const LrPertColor3DPBasic &lhs, const LrPertColor3DPBasic &rhs)
{
return (! (lhs == rhs));
}
LrColor LrPertColorTextProcMarbre::getColor(Real u, Real v, LrPoint &point) const
LrColor LrPertColor3DPBasic::getColor(Real u, Real v, LrPoint &point) const
{
Real noise = 0.0;
LrPoint tmp(1 * point.x, 1 * point.y, 1 * point.z);
for (int i = 1; i <= m_level; i ++)
LrVector tmp(m_mult*point.x, m_mult*point.y, m_mult*point.z);
for (int i = 0; i < m_level; i ++)
{
noise += (1.0f / i ) * fabsf(m_perlin.f_noise(i * tmp.x ,
i * tmp.y ,
i * tmp.z));
noise += fabsf((m_perlin.f_noise(tmp.x, tmp.y, tmp.z)));
}
//calcul du coefficient de perlin
//noise = fabsf(sin(tmp.x+tmp.y+tmp.z + noise));
noise = fabsf(sin(tmp.x + noise));
noise *= m_intensity;
//return interpolCos(C1, C2, noise);
return interpolLinear(C1, C2, noise);
if(m_interpolation == COS) return interpolCos(C1, C2, noise);
else return interpolLinear(C1, C2, noise);
}
LrPertColorTextProcTurbulence.h → LrPertColor3DPBasic.h
View file @ 34c1338c
/**
* @brief PertColor : les perturbations de couleur d'une optic.
* @file LrPertColorTextProc.h
* @file LrPertColor3DPBasic.h
* @date Jeudi 14 Fevrier 2008
* @note
* @author Josselin Francois
......@@ -14,8 +14,8 @@
*
*/
#ifndef LRPERTCOLOR_TEXTURE_PROC_TURBULENCE_H
#define LRPERTCOLOR_TEXTURE_PROC_TURBULENCE_H
#ifndef LRPERTCOLOR_3DP_BASIC_H
#define LRPERTCOLOR_3DP_BASIC_H
#include "LrPertColorTxtPrc3DPerlin.h"
......@@ -25,16 +25,16 @@
*
* Classe représentant une perturbation de couleur par une texture procedurale
*/
class LrPertColorTextProcTurbulence : public LrPertColorTxtPrc3DPerlin
class LrPertColor3DPBasic : public LrPertColorTxtPrc3DPerlin
{
public:
LrPertColorTextProcTurbulence();
LrPertColor3DPBasic();
/**
* @brief LrPertColorTextProcDmaier copy constructor
* @param source LrPertColorTextProcDmaier object reference.
*/
LrPertColorTextProcTurbulence(const LrPertColorTextProcTurbulence &source);
LrPertColor3DPBasic(const LrPertColor3DPBasic &source);
/**
* @brief LrPertColorTextProcDmaier personnal constructor
......@@ -43,31 +43,32 @@ class LrPertColorTextProcTurbulence : public LrPertColorTxtPrc3DPerlin
* @param c3 couleur 3 de la texture.
* @param dimension dimension des damiers
*/
LrPertColorTextProcTurbulence(const LrColor &c1, const LrColor &c2, const LrColor &c3, Real intensite, int level);
LrPertColor3DPBasic(const LrColor &c1, const LrColor &c2, const LrColor &c3, Real intensite,
int level, Real multiplicateur, int typeInterpol);
/**
* @brief LrPertColorTexture clone.
* @return LrPertColorTexture pointer object.
*/
LrPertColorTextProcTurbulence * clone() const;
LrPertColor3DPBasic * clone() const;
/**
* @brief LrPertColorTexture destructor
*/
virtual ~LrPertColorTextProcTurbulence();
virtual ~LrPertColor3DPBasic();
/**
* @brief assignement operator(s)
*/
LrPertColorTextProcTurbulence & operator = (const LrPertColorTextProcTurbulence &source);
LrPertColor3DPBasic & operator = (const LrPertColor3DPBasic &source);
/**
* @brief comparison operator(s)
*/
friend bool operator == (const LrPertColorTextProcTurbulence &lhs, const LrPertColorTextProcTurbulence &rhs);
friend bool operator != (const LrPertColorTextProcTurbulence &lhs, const LrPertColorTextProcTurbulence &rhs);
friend bool operator == (const LrPertColor3DPBasic &lhs, const LrPertColor3DPBasic &rhs);
friend bool operator != (const LrPertColor3DPBasic &lhs, const LrPertColor3DPBasic &rhs);
/**
* @brief accessors
......@@ -77,3 +78,4 @@ class LrPertColorTextProcTurbulence : public LrPertColorTxtPrc3DPerlin
};
#endif
LrPertColorTextProcBois.cpp → LrPertColor3DPBois.cpp
View file @ 34c1338c
/**
* @brief PertColor : les perturbations de couleur d'une optic.
* @file LrPertColorTextProcBois.cpp
* @file LrPertColor3DPBois.cpp
* @date Jeudi 14 Fevrier 2008
* @note
* @author Josselin Francois
......@@ -18,35 +18,36 @@
#include "config.h"
#endif
#include "LrPertColorTextProcBois.h"
#include "LrPertColor3DPBois.h"
#include "LrVector.h"
/*---------------------------------------------------------------------------*
* constructors and destructor *
*---------------------------------------------------------------------------*/
LrPertColorTextProcBois::LrPertColorTextProcBois()
LrPertColor3DPBois::LrPertColor3DPBois()
: LrPertColorTxtPrc3DPerlin()
{
}
LrPertColorTextProcBois::LrPertColorTextProcBois(const LrPertColorTextProcBois &source)
LrPertColor3DPBois::LrPertColor3DPBois(const LrPertColor3DPBois &source)
: LrPertColorTxtPrc3DPerlin(source)
{
}
LrPertColorTextProcBois::LrPertColorTextProcBois(const LrColor &c1, const LrColor &c2, const LrColor &c3,
Real intensite, int level)
: LrPertColorTxtPrc3DPerlin(c1, c2, c3, intensite, level)
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)
{
}
LrPertColorTextProcBois * LrPertColorTextProcBois::clone() const
LrPertColor3DPBois * LrPertColor3DPBois::clone() const
{
return new LrPertColorTextProcBois(*this);
return new LrPertColor3DPBois(*this);
}
LrPertColorTextProcBois::~LrPertColorTextProcBois()
LrPertColor3DPBois::~LrPertColor3DPBois()
{
}
......@@ -54,7 +55,7 @@ LrPertColorTextProcBois::~LrPertColorTextProcBois()
/*---------------------------------------------------------------------------*
* assignement operator(s) *
*---------------------------------------------------------------------------*/
LrPertColorTextProcBois& LrPertColorTextProcBois::operator = (const LrPertColorTextProcBois &source)
LrPertColor3DPBois& LrPertColor3DPBois::operator = (const LrPertColor3DPBois &source)
{
if (this == &source)
return *this;
......@@ -67,35 +68,41 @@ LrPertColorTextProcBois& LrPertColorTextProcBois::operator = (const LrPertColorT
/*---------------------------------------------------------------------------*
* comparison operator(s) *
*---------------------------------------------------------------------------*/
bool operator == (const LrPertColorTextProcBois &lhs, const LrPertColorTextProcBois &rhs)
bool operator == (const LrPertColor3DPBois &lhs, const LrPertColor3DPBois &rhs)
{
return (LrPertColorTxtPrc3DPerlin&)lhs==(LrPertColorTxtPrc3DPerlin&)rhs;
}
bool operator != (const LrPertColorTextProcBois &lhs, const LrPertColorTextProcBois &rhs)
bool operator != (const LrPertColor3DPBois &lhs, const LrPertColor3DPBois &rhs)
{
return (! (lhs == rhs));
}
LrColor LrPertColorTextProcBois::getColor(Real u, Real v, LrPoint &point) const
LrColor LrPertColor3DPBois::getColor(Real u, Real v, LrPoint &point) const
{
Real t, noise;
t = 0.0;
//les seuils
Real v1= 0.25;
Real v2= 0.5;
Real v3 =0.75;
//point.normalize();
//calcul du coefficient de m_perlin a partir de la partie entiere
t = 20 * m_perlin.f_noise(point.x, point.y, point.z);
noise = t = 0.0;
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));
}
noise = fabsf(t - floor(t));
noise *= m_intensity;
if(m_interpolation == COS) return interpolCos(C1, C2, noise);
else return interpolLinear(C1, C2, noise);
/*Real v1= 0.25;
Real v2= 0.5;
Real v3 =0.75;
//calcul du coefficient de m_perlin a partir de la partie entiere
//t = 20 * (m_perlin.f_noise(point.x, point.y, point.z));
if(noise < v1) return C1;
if(v1 < noise && noise < v2) return interpolCos (C1, C2, noise);
if(v2 < noise && noise < v3) return interpolCos (C2, C3, noise);
if(noise > v3) return C3;
return C3;*/
}
......
LrPertColorTextProcBois.h → LrPertColor3DPBois.h
View file @ 34c1338c
/**
* @brief PertColor : les perturbations de couleur d'une optic.
* @file LrPertColorTextProc.h
* @file LrPertColor3DPBois.h
* @date Jeudi 14 Fevrier 2008
* @note
* @author Josselin Francois
......@@ -14,8 +14,8 @@
*
*/
#ifndef LRPERTCOLOR_TEXTURE_PROC_BOIS_H
#define LRPERTCOLOR_TEXTURE_PROC_BOIS_H
#ifndef LRPERTCOLOR_3DP_BOIS_H
#define LRPERTCOLOR_3DP_BOIS_H
#include "LrPertColorTxtPrc3DPerlin.h"
......@@ -24,16 +24,16 @@
*
* Classe représentant une perturbation de couleur par une texture procedurale
*/
class LrPertColorTextProcBois : public LrPertColorTxtPrc3DPerlin
class LrPertColor3DPBois : public LrPertColorTxtPrc3DPerlin
{
public:
LrPertColorTextProcBois();
LrPertColor3DPBois();
/**
* @brief LrPertColorTextProcDmaier copy constructor
* @param source LrPertColorTextProcDmaier object reference.
*/
LrPertColorTextProcBois(const LrPertColorTextProcBois &source);
LrPertColor3DPBois(const LrPertColor3DPBois &source);
/**
* @brief LrPertColorTextProcDmaier personnal constructor
......@@ -42,31 +42,32 @@ class LrPertColorTextProcBois : public LrPertColorTxtPrc3DPerlin
* @param c3 couleur 3 de la texture.
* @param dimension dimension des damiers
*/
LrPertColorTextProcBois(const LrColor &c1, const LrColor &c2, const LrColor &c3, Real intensite, int level);
LrPertColor3DPBois(const LrColor &c1, const LrColor &c2, const LrColor &c3, Real intensite,
int level, Real multiplicateur, int typeInterpol);
/**
* @brief LrPertColorTexture clone.
* @return LrPertColorTexture pointer object.
*/
LrPertColorTextProcBois * clone() const;
LrPertColor3DPBois * clone() const;
/**
* @brief LrPertColorTexture destructor
*/
virtual ~LrPertColorTextProcBois();
virtual ~LrPertColor3DPBois();
/**
* @brief assignement operator(s)
*/
LrPertColorTextProcBois & operator = (const LrPertColorTextProcBois &source);
LrPertColor3DPBois & operator = (const LrPertColor3DPBois &source);
/**
* @brief comparison operator(s)
*/
friend bool operator == (const LrPertColorTextProcBois &lhs, const LrPertColorTextProcBois &rhs);
friend bool operator != (const LrPertColorTextProcBois &lhs, const LrPertColorTextProcBois &rhs);
friend bool operator == (const LrPertColor3DPBois &lhs, const LrPertColor3DPBois &rhs);
friend bool operator != (const LrPertColor3DPBois &lhs, const LrPertColor3DPBois &rhs);
/**
* @brief accessors
......
LrPertColorTextProcTurbulence.cpp → LrPertColor3DPMarbre.cpp
View file @ 34c1338c
/**
* @brief PertColor : les perturbations de couleur d'une optic.
* @file LrPertColorTextProcTurbulence.cpp
* @file LrPertColor3DPMarbre.cpp
* @date Jeudi 14 Fevrier 2008
* @note
* @author Josselin Francois
......@@ -18,36 +18,35 @@
#include "config.h"
#endif
#include "LrPertColorTextProcTurbulence.h"
#include "LrVector.h"
#include "LrPertColor3DPMarbre.h"
/*---------------------------------------------------------------------------*
* constructors and destructor *
*---------------------------------------------------------------------------*/
LrPertColorTextProcTurbulence::LrPertColorTextProcTurbulence()
LrPertColor3DPMarbre::LrPertColor3DPMarbre()
: LrPertColorTxtPrc3DPerlin()
{
}
LrPertColorTextProcTurbulence::LrPertColorTextProcTurbulence(const LrPertColorTextProcTurbulence &source)
LrPertColor3DPMarbre::LrPertColor3DPMarbre(const LrPertColor3DPMarbre &source)
: LrPertColorTxtPrc3DPerlin(source)
{
}
LrPertColorTextProcTurbulence::LrPertColorTextProcTurbulence(const LrColor &c1, const LrColor &c2, const LrColor &c3,
Real intensite, int level)
: LrPertColorTxtPrc3DPerlin(c1, c2, c3, intensite, level)
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)
{
}
LrPertColorTextProcTurbulence * LrPertColorTextProcTurbulence::clone() const
LrPertColor3DPMarbre * LrPertColor3DPMarbre::clone() const
{
return new LrPertColorTextProcTurbulence(*this);
return new LrPertColor3DPMarbre(*this);
}
LrPertColorTextProcTurbulence::~LrPertColorTextProcTurbulence()
LrPertColor3DPMarbre::~LrPertColor3DPMarbre()
{
}
......@@ -55,7 +54,7 @@ LrPertColorTextProcTurbulence::~LrPertColorTextProcTurbulence()
/*---------------------------------------------------------------------------*
* assignement operator(s) *
*---------------------------------------------------------------------------*/
LrPertColorTextProcTurbulence& LrPertColorTextProcTurbulence::operator = (const LrPertColorTextProcTurbulence &source)
LrPertColor3DPMarbre& LrPertColor3DPMarbre::operator = (const LrPertColor3DPMarbre &source)
{
if (this == &source)
return *this;
......@@ -68,42 +67,42 @@ LrPertColorTextProcTurbulence& LrPertColorTextProcTurbulence::operator = (const
/*---------------------------------------------------------------------------*
* comparison operator(s) *
*---------------------------------------------------------------------------*/
bool operator == (const LrPertColorTextProcTurbulence &lhs, const LrPertColorTextProcTurbulence &rhs)
bool operator == (const LrPertColor3DPMarbre &lhs, const LrPertColor3DPMarbre &rhs)
{
return (LrPertColorTxtPrc3DPerlin&)lhs==(LrPertColorTxtPrc3DPerlin&)rhs;
}
bool operator != (const LrPertColorTextProcTurbulence &lhs, const LrPertColorTextProcTurbulence &rhs)
bool operator != (const LrPertColor3DPMarbre &lhs, const LrPertColor3DPMarbre &rhs)
{
return (! (lhs == rhs));
}
LrColor LrPertColorTextProcTurbulence::getColor(Real u, Real v, LrPoint &point) const
LrColor LrPertColor3DPMarbre::getColor(Real u, Real v, LrPoint &point) const
{
Real noise = 0.0;
LrVector tmp(1 * point.x,1 * point.y, 1 * point.z);
//tmp.normalize();
for (int i = 1; i <= m_level; i ++)
LrPoint tmp(m_mult*point.x, m_mult*point.y, m_mult*point.z);
for (int i = 0; i < m_level; i ++)
{
noise += (1.0f / i) * fabsf(m_perlin.f_noise(i * tmp.x,
i * tmp.y,
i * tmp.z));
Real f = pow(2,i);
noise += ((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 *= m_intensity;
return interpolLinear(C1,C2,noise);
/*//les seuils choisis, en dure pour l'instant
Real v1 = 0.1;
Real v2 = 0.2;
Real v3 = 0.4;
if(m_interpolation == COS) return interpolCos(C1, C2, noise);
else return interpolLinear(C1, C2, noise);
/*
Real v1 = 0.9999;
Real v2 = 0.99995;
Real v3 = 0.999998;
//calcul du coefficient de perlin
//noise = fabsf(m_perlin.f_noise(point.x, point.y, point.z));
noise *= intensity;
//Seuillage
if(noise < v1) return C1;
if(v1 < noise && noise < v2) return interpolBiLinear(C1,C2,noise, v1, v2);
if(v2 < noise && noise < v3) return interpolBiLinear(C2,C3,noise, v1, v2);
if(noise > v3) return C3;*/
return C3;*/
}
LrPertColorTextProcMarbre.h → LrPertColor3DPMarbre.h
View file @ 34c1338c
/**
* @brief PertColor : les perturbations de couleur d'une optic.
* @file LrPertColorTextProc.h
* @file LrPertColor3DPMarbre.h
* @date Jeudi 14 Fevrier 2008
* @note
* @author Josselin Francois
......@@ -14,8 +14,8 @@
*
*/
#ifndef LRPERTCOLOR_TEXTURE_PROC_MARBRE_H
#define LRPERTCOLOR_TEXTURE_PROC_MARBRE_H
#ifndef LRPERTCOLOR_3DP_MARBRE_H
#define LRPERTCOLOR_3DP_MARBRE_H
#include "LrPertColorTxtPrc3DPerlin.h"
......@@ -24,49 +24,50 @@
*
* Classe représentant une perturbation de couleur par une texture procedurale
*/
class LrPertColorTextProcMarbre : public LrPertColorTxtPrc3DPerlin
class LrPertColor3DPMarbre : public LrPertColorTxtPrc3DPerlin
{
public:
LrPertColorTextProcMarbre();
LrPertColor3DPMarbre();
/**
* @brief LrPertColorTextProcMarbre copy constructor
* @brief LrPertColor3DPMarbre copy constructor
* @param source LrPertColorTextProcDmaier object reference.
*/
LrPertColorTextProcMarbre(const LrPertColorTextProcMarbre &source);
LrPertColor3DPMarbre(const LrPertColor3DPMarbre &source);
/**
* @brief LrPertColorTextProcMarbre personnal constructor
* @brief LrPertColor3DPMarbre personnal constructor
* @param c1 couleur 1 de la texture
* @param c2 couleur 2 de la texture
* @param c3 couleur 3 de la texture.
* @param dimension dimension des damiers
*/
LrPertColorTextProcMarbre(const LrColor &c1, const LrColor &c2, const LrColor &c3, Real intensite, int level);
LrPertColor3DPMarbre(const LrColor &c1, const LrColor &c2, const LrColor &c3,
Real intensite, int level, Real multiplicateur, int typeInterpol);
/**
* @brief LrPertColorTextProcMarbre clone.
* @return LrPertColorTextProcMarbre pointer object.
* @brief LrPertColor3DPMarbre clone.
* @return LrPertColor3DPMarbre pointer object.
*/
LrPertColorTextProcMarbre * clone() const;
LrPertColor3DPMarbre * clone() const;
/**
* @brief LrPertColorTexture destructor
*/
virtual ~LrPertColorTextProcMarbre();
virtual ~LrPertColor3DPMarbre();
/**
* @brief assignement operator(s)