Commit 972b8dac authored by paps's avatar paps

--no commit message

--no commit message
parent b3dd919e
......@@ -61,8 +61,7 @@ bool LrBinderSimple::getIntersection(const LrRay &ray, LrHit *hit, Real minbound
oneintersect=true;
if(hit != NULL)
maxbound = hit->distance;
else
break;
else break;
}
}
return oneintersect;
......
/**
* @brief GÉOMÉTRIE : Gestion d'un plan infini
* @file LrGeometryPlan.h
* @date Vendredi 7 mars 2008
* @note
* @author Josselin Francois
* @author Michael Nauge
* @author Axel Richard
* @author Hervé Souchaud
* @author Emeric Verschuur
*
* Ce fichier contient la classe qui gère une géométrie pour un plan infini.
*/
#if defined HAVE_CONFIG_H
#include "config.h"
#endif
#include <cstdlib>
#include "LrGeometryPlan.h"
LrGeometryPlan::LrGeometryPlan()
: LrGeometry(),
m_normale(LrVector::ZERO)
{
}
LrGeometryPlan::LrGeometryPlan(const LrGeometryPlan& src)
: LrGeometry(src),
m_normale(src.m_normale)
{
}
LrGeometryPlan::LrGeometryPlan(const LrVector &normale)
: LrGeometry(),
m_normale(normale)
{
}
LrGeometryPlan::~LrGeometryPlan()
{
}
LrGeometryPlan& LrGeometryPlan::operator = (const LrGeometryPlan& src)
{
if(this==&src)
return *this;
LrGeometry::operator = (src);
return *this;
}
bool operator == (const LrGeometryPlan& rhs, const LrGeometryPlan& lhs)
{
return (const LrGeometry&)rhs == (const LrGeometry&)lhs
/* and [...] */;
}
bool operator != (const LrGeometryPlan& rhs, const LrGeometryPlan& lhs)
{
return ! (rhs==lhs);
}
int LrGeometryPlan::getNbFragments() const
{
return 1;
}
bool LrGeometryPlan::getIntersection(const LrRay &ray, LrHit *hit, int fragment,
Real minBound, Real maxBound) const
{
Real coefAngle;
Real dist;
LrPoint originRay = ray.getOrigin();
LrVector tmpO(originRay.x, originRay.y, originRay.z);
//calcule de l'angle formé par le vecteur directeur du rayon et la normal du plan
coefAngle = m_normale * ray.getDirection();
if (coefAngle == 0.0) return false; //le rayon est parallele au plan
dist = -((m_normale * tmpO) / coefAngle);
if(dist < minBound || dist > maxBound) return false; //derriere l'origine du rayon
if (hit != NULL)
{
Real u, v;
LrVector normal;
LrVector tangent;
hit->point = ray.getPoint(dist);
hit->distance = dist;
// ca ressemblerait a un truc comme ca :
xyz2uv(hit->point, u, v);
hit->u = u;
hit->v = v;
//uv2xyz(u, v, NULL, &normal, &tangent);
if(coefAngle < 0.0) hit->normal = m_normale;
else hit->normal = -m_normale;
hit->normal = m_normale;
hit->tangent = tangent;
}
return true;
}
void LrGeometryPlan::getMinMax(LrPoint &min, LrPoint &max, int fragment) const{
min = LrPoint(-1.,-1.,-1.);
max = LrPoint(1.,1.,1.);
}
void LrGeometryPlan::xyz2uv(const LrPoint &point, Real &u, Real &v) const
{
// [...]
LrGeometry::xyz2uv(point, u, v);
}
void LrGeometryPlan::uv2xyz(Real u, Real v, LrPoint *point,
LrVector *normal, LrVector *tangent) const
{
// [...]
}
/**
* @brief GÉOMÉTRIE : Gestion d'un plan infini
* @file LrGeometryPlan.h
* @date Vendredi 7 mars 2008
* @note
* @author Josselin Francois
* @author Michael Nauge
* @author Axel Richard
* @author Hervé Souchaud
* @author Emeric Verschuur
*
* Ce fichier contient la classe qui gère une géométrie pour un plan infini.
*/
#ifndef LRGEOMETRYPLAN_H
#define LRGEOMETRYPLAN_H
#include "LrGeometry.h"
/**
* @brief GÉOMÉTRIE : Gestion d'une géométrie sphérique
*
* Cette classe gère une géométrie sphérique.
*/
class LrGeometryPlan : public LrGeometry
{
public:
/**
* @brief Constructeur.
* @param center Centre de la sphère.
* @param r Rayon de la sphère.
*/
LrGeometryPlan();
/**
* @brief Constructeur par copie.
* @param src Référence d'un objet LrGeometryPlan.
*/
LrGeometryPlan(const LrGeometryPlan& src);
/**
* @brief Constructeur personnel.
* @param normale la normale au plan
*/
LrGeometryPlan(const LrVector &normale);
/**
* @brief Destructeur.
*/
virtual ~LrGeometryPlan();
/**
* @brief Opérateur d'affectation.
* @param src Géométrie source.
* @return Une référence sur l'objet affecté.
*/
LrGeometryPlan& operator = (const LrGeometryPlan& src);
/**
* @brief Opérateur de test d'égalité.
* @return vrai ou faux.
*/
friend bool operator == (const LrGeometryPlan& rhs, const LrGeometryPlan& lhs);
/**
* @brief Opérateur de test d'inégalité.
* @return vrai ou faux.
*/
friend bool operator != (const LrGeometryPlan& rhs, const LrGeometryPlan& lhs);
/**
* @brief Donne le nombre de fragments de la géométrie.
* @return Un entier.
*/
virtual int getNbFragments() const;
/**
* @brief Donne d'intersection entre un rayon et la géométrie.
* @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 la géométrie
* 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, 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;
protected:
/**
* @brief Conversion de coordonnées absolues en paramétriques.
* @param point Point à convertir.
* @param u Réel u (paramètre out).
* @param v Réel v (paramètre out).
*/
virtual void xyz2uv(const LrPoint &point, Real &u, Real &v) const;
/**
* @brief Conversion de coordonnées paramétriques en absolues.
* @param u Réel u.
* @param v Réel v.
* @param point Point résultant (paramètre out).
* @param normal Normale à ce point (paramètre out).
* @param tangent Tangente à ce point (paramètre out).
*/
virtual void uv2xyz(Real u, Real v, LrPoint *point,
LrVector *normal, LrVector *tangent) const;
private:
LrVector m_normale;
};
#endif
......@@ -84,7 +84,7 @@ public:
* @param u coordonnée paramétriques.
* @param v coordonnée paramétriques.
*/
virtual LrColor compute(const LrVector &rayIn, const LrVector &rayOut,
virtual LrColor compute(const LrRay &rayIn, const LrVector &rayOut,
const LrVector &normal, const LrVector &tangeante,
Real u, Real v) const =0;
......
......@@ -80,11 +80,12 @@ bool operator != (const LrOpticBasic &lhs, const LrOpticBasic &rhs)
return (! (lhs == rhs));
}
LrColor LrOpticBasic:: compute(const LrVector &rayIn, const LrVector &rayOut,
LrColor LrOpticBasic:: compute(const LrRay &rayIn, const LrVector &rayOut,
const LrVector &normal,const LrVector &tangeante,
Real u, Real v) const
{
return m_pertColor->getColor(u,v);
LrColor colorPhong;
LrPoint point = rayIn.getOrigin();
colorPhong = m_pertColor->getColor(u, v, point);
}
......@@ -81,7 +81,7 @@ public:
* @param u coordonnée paramétriques.
* @param v coordonnée paramétriques.
*/
virtual LrColor compute(const LrVector &rayIn, const LrVector &rayOut,
virtual LrColor compute(const LrRay &rayIn, const LrVector &rayOut,
const LrVector &normal, const LrVector &tangeante,
Real u, Real v) const;
......
......@@ -139,7 +139,7 @@ void LrOpticElementary::setTransparency(Real transparency)
m_transparency = transparency;
}
LrPertColor* LrOpticElementary::getPertColor(Real u, Real v) const
LrPertColor* LrOpticElementary::getPertColor(Real u, Real v, LrPoint &pointInter) const
{
return m_pertColor;
}
......
......@@ -81,7 +81,7 @@ public:
virtual Real getTransparency(Real u, Real v) const;
virtual void setTransparency(Real transparency);
virtual LrPertColor* getPertColor(Real u, Real v) const;
virtual LrPertColor* getPertColor(Real u, Real v, LrPoint &pointInter) const;
virtual void setPertColor(LrPertColor *color);
virtual LrPertNormal* getPertNormal(Real u, Real v) const;
......
......@@ -98,34 +98,34 @@ void LrOpticPhong::setCoeffSpec(const int coeff_spec)
}
LrColor LrOpticPhong::compute(const LrVector &rayIn, const LrVector &rayOut,
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);
//voir cour page 88
//(rayIn*normal) == cos entre la normal et rayIn
Real angleLamb = normalPert*rayIn;
if(angleLamb <= 0.0) return LrColor::BLACK;
LrColor colorDiffuse((m_pertColor->getColor(u,v)) * (getDiffuse(u,v) *(angleLamb)));
//LrColor colorDiffuse(((m_pertColor->getColor(u,v)) * angleLamb));
//voir cour page 89
//calcul du vecteur bisecteur
//pour approximer pour la suite le cos alpha%2
//cos alpha%2 presque egal a (vBiscteur*normal)
LrVector vBiscteur=rayIn+rayOut;
vBiscteur.normalize();
Real angleLamb = normalPert*rayIn.getDirection();
if(angleLamb <= 0.0) return LrColor::BLACK;
LrColor colorSpecular((m_pertColor->getColor(u,v))*pow((vBiscteur*normal),m_n));
//WARNING il peut etre interessant de changer pow par une autre methode
return colorSpecular + colorDiffuse;
LrColor colorPhong(LrColor::BLACK);
LrPoint point = rayIn.getOrigin();
colorPhong = m_pertColor->getColor(u, v, point);
LrColor colorDiffuse(colorPhong * (getDiffuse(u,v) *(angleLamb)));
//LrColor colorDiffuse(((m_pertColor->getColor(u,v)) * angleLamb));
//voir cour page 89
//calcul du vecteur bisecteur
//pour approximer pour la suite le cos alpha%2
//cos alpha%2 presque egal a (vBiscteur*normal)
LrVector vBiscteur=rayIn.getDirection()+rayOut;
vBiscteur.normalize();
LrColor colorSpecular(colorPhong * pow((vBiscteur*normal),m_n));
//WARNING il peut etre interessant de changer pow par une autre methode
return colorSpecular + colorDiffuse;
}
......@@ -87,7 +87,7 @@ public:
* @param u coordonnée paramétriques.
* @param v coordonnée paramétriques.
*/
virtual LrColor compute(const LrVector &rayIn, const LrVector &rayOut,
virtual LrColor compute(const LrRay &rayIn, const LrVector &rayOut,
const LrVector &normal, const LrVector &tangeante,
Real u, Real v) const;
......
......@@ -18,7 +18,7 @@
#define LRPERTCOLOR_H
#include "LrColor.h"
#include "LrPoint.h"
/**
* @brief PertColor : les perturbations de couleur d'une optic.
......@@ -29,6 +29,7 @@ class LrPertColor
{
public:
/**
* @brief LrPertColor constructor.
*/
......@@ -68,7 +69,7 @@ public:
* @brief accessors
*/
virtual LrColor getColor(Real u, Real v) const =0;
virtual LrColor getColor(Real u, Real v, LrPoint &pointInter) const =0;
};
......
......@@ -92,7 +92,7 @@ bool operator != (const LrPertColorBasic &lhs, const LrPertColorBasic &rhs)
/*---------------------------------------------------------------------------*
* accessors *
*---------------------------------------------------------------------------*/
LrColor LrPertColorBasic::getColor(Real u, Real v)const
LrColor LrPertColorBasic::getColor(Real u, Real v, LrPoint &pointInter)const
{
//couleur uniforme sur toute la surface
return m_Color;
......
......@@ -77,7 +77,7 @@ public:
*/
virtual LrColor getColor(Real u, Real v) const;
virtual LrColor getColor(Real u, Real v, LrPoint &pointInter) const;
virtual void setColor(const LrColor &color);
......
......@@ -98,11 +98,9 @@ bool operator != (const LrPertColorDegradeU &lhs, const LrPertColorDegradeU &rhs
/*---------------------------------------------------------------------------*
* accessors *
*---------------------------------------------------------------------------*/
LrColor LrPertColorDegradeU::getColor(Real u, Real v)const
LrColor LrPertColorDegradeU::getColor(Real u, Real v, LrPoint &pointInter)const
{
//couleur degrade
return (((1-u)*m_Color1) + (u*m_Color2));
}
......
......@@ -77,7 +77,7 @@ public:
*/
virtual LrColor getColor(Real u, Real v) const;
virtual LrColor getColor(Real u, Real v, LrPoint &pointInter) const;
virtual void setColors(const LrColor &color1, const LrColor &color2);
......
/**
* @brief PertColor : les perturbations de couleur d'une optic.
* @file LrPertColorTextProc3D.cpp
* @date Jeudi 14 Fevrier 2008
* @note
* @author Josselin Francois
* @author Michael Nauge
* @author Axel Richard
* @author Hervé Souchaud
* @author Emeric Verschuur
*
*
* Classe représentant une perturbation de couleur par une texture
*
*/
#if defined HAVE_CONFIG_H
#include "config.h"
#endif
#include "LrPertColorTextProc3D.h"
/*---------------------------------------------------------------------------*
* constructors and destructor *
*---------------------------------------------------------------------------*/
LrPertColorTextProc3D::LrPertColorTextProc3D()
: LrPertColor(),
C1(),
C2(),
C3()
{
}
LrPertColorTextProc3D::LrPertColorTextProc3D(const LrPertColorTextProc3D &source)
: LrPertColor(source),
C1(),
C2(),
C3()
{
}
LrPertColorTextProc3D::LrPertColorTextProc3D(const LrColor &c1, const LrColor &c2, const LrColor &c3)
: LrPertColor(),
C1(c1),
C2(c2),
C3(c3)
{
}
LrPertColorTextProc3D::~LrPertColorTextProc3D()
{
}
void LrPertColorTextProc3D::setColor1(const LrColor &c)
{
C1 = c;
}
void LrPertColorTextProc3D::setColor2(const LrColor &c)
{
C2 = c;
}
void LrPertColorTextProc3D::setColor3(const LrColor &c)
{
C3 = c;
}
/*---------------------------------------------------------------------------*
* assignement operator(s) *
*---------------------------------------------------------------------------*/
LrPertColorTextProc3D& LrPertColorTextProc3D::operator = (const LrPertColorTextProc3D &source)
{
if (this == &source)
return *this;
LrPertColor::operator =(source);
C1 = source.C1;
C2 = source.C2;
C3 = source.C3;
return *this;
}
/*---------------------------------------------------------------------------*
* comparison operator(s) *
*---------------------------------------------------------------------------*/
bool operator == (const LrPertColorTextProc3D &lhs, const LrPertColorTextProc3D &rhs)
{
return (LrPertColor&)lhs==(LrPertColor&)rhs && (lhs.C1 == rhs.C1)
&& (lhs.C2 == rhs.C2)
&& (lhs.C3 == rhs.C3) ;
}
bool operator != (const LrPertColorTextProc3D &lhs, const LrPertColorTextProc3D &rhs)
{
return (! (lhs == rhs));
}
/*****************************************************************************/
LrColor LrPertColorTextProc3D::interpolBiLinear(const LrColor C1, const LrColor C2, Real coef, Real v1, Real v2) const
{
return (C1 * ( (coef-v1)/(v2-v1) )) + (C2 * ( (v2-coef)/(v2-v1) ) );
}
/*****************************************************************************/
LrColor LrPertColorTextProc3D::interpolLinear(const LrColor C1, const LrColor C2, Real coef) const
{
return (C1*(1-coef) + C2*coef);
}
/*****************************************************************************/
LrColor LrPertColorTextProc3D::interpolCos (const LrColor C1, const LrColor C2, Real coef) const
{
float ft,f;
ft = coef * M_PI;
f = (1 - cos(ft)) * 0.5;
return (C1*(1-f) + C2*f);
}
/*****************************************************************************/
/**
* @brief PertColor : les perturbations de couleur d'une optic.
* @file LrPertColorTextProc3D.h
* @date Jeudi 14 Fevrier 2008
* @note
* @author Josselin Francois
* @author Michael Nauge
* @author Axel Richard
* @author Hervé Souchaud
* @author Emeric Verschuur
*
*
* Classe représentant une perturbation de couleur par une texture procedurale
*
*/
#ifndef LRPERTCOLOR_TEXTURE_PROC3D_H
#define LRPERTCOLOR_TEXTURE_PROC3D_H
#include "LrPertColor.h"
#include "LrPoint.h"
/**
* @brief PertColor : les perturbations de couleur d'une optic.
*
* Classe représentant une perturbation de couleur par une texture procedurale
*/
class LrPertColorTextProc3D : public LrPertColor
{
public:
LrPertColorTextProc3D();
/**
* @brief LrPertColorTexture copy constructor
* @param source LrPertColorTexture object reference.
*/
LrPertColorTextProc3D(const LrPertColorTextProc3D &source);
/**
* @brief LrPertColorTexture personnal constructor
* @param c1 couleur 1 de la texture
* @param c2 couleur 2 de la texture
* @param c3 couleur 3 de la texture.
*/
LrPertColorTextProc3D(const LrColor &c1, const LrColor &c2, const LrColor &c3);
/**
* @brief LrPertColorTexture clone.
* @return LrPertColorTexture pointer object.
*/
LrPertColorTextProc3D * clone() const = 0;
/**
* @brief LrPertColorTexture destructor
*/
virtual ~LrPertColorTextProc3D();
/**
* @brief assignement operator(s)
*/
LrPertColorTextProc3D & operator = (const LrPertColorTextProc3D &source);
/**
* @brief comparison operator(s)
*/
friend bool operator == (const LrPertColorTextProc3D &lhs, const LrPertColorTextProc3D &rhs);
friend bool operator != (const LrPertColorTextProc3D &lhs, const LrPertColorTextProc3D &rhs);
/**
* @brief accessors
*/
virtual LrColor getColor(Real u, Real v, LrPoint &point) const = 0;
void setColor1(const LrColor &c);
void setColor2(const LrColor &c);
void setColor3(const LrColor &c);
LrColor interpolBiLinear(const LrColor C1, const LrColor C2, Real coef, Real v1, Real v2) const;
LrColor interpolLinear(const LrColor C1, const LrColor C2, Real coef) const;
LrColor interpolCos (const LrColor C1, const LrColor C2, Real coef) const;
protected :
LrColor C1;
LrColor C2;
LrColor C3;
};
#endif
/**
* @brief PertColor : les perturbations de couleur d'une optic.
* @file LrPertColorTextProcBois.cpp
* @date Jeudi 14 Fevrier 2008
* @note
* @author Josselin Francois
* @author Michael Nauge
* @author Axel Richard
* @author Hervé Souchaud
* @author Emeric Verschuur
*
*
* Classe représentant une perturbation de couleur par une texture
*
*/
#if defined HAVE_CONFIG_H
#include "config.h"
#endif
#include "LrPertColorTextProcBois.h"
/*---------------------------------------------------------------------------*
* constructors and destructor *
*---------------------------------------------------------------------------*/
LrPertColorTextProcBois::LrPertColorTextProcBois()
: LrPertColorTxtPrc3DPerlin()
{
}
LrPertColorTextProcBois::LrPertColorTextProcBois(const LrPertColorTextProcBois &source)
: LrPertColorTxtPrc3DPerlin(source)
{
}
LrPertColorTextProcBois::LrPertColorTextProcBois(const LrColor &c1, const LrColor &c2, const LrColor &c3,
Real intensite, int level)
: LrPertColorTxtPrc3DPerlin(c1, c2, c3, intensite, level)
{
}
LrPertColorTextProcBois * LrPertColorTextProcBois::clone() const
{
return new LrPertColorTextProcBois(*this);
}
LrPertColorTextProcBois::~LrPertColorTextProcBois()
{
}
/*---------------------------------------------------------------------------*
* assignement operator(s) *
*---------------------------------------------------------------------------*/