src/rcrt/materials/BSDFMaterial.cpp

Go to the documentation of this file.

#include "BSDFMaterial.h"
#include "../bxdf/fresnel.hpp"

using namespace std;

namespace rcrt
{

BSDFMaterial::BSDFMaterial(BSDF b, const std::complex<float>& ior):Material(ior),bsdf(b)
{
}

BSDFMaterial::~BSDFMaterial()
{
}

RGBColor BSDFMaterial::sample(const Vec3D& wOut, const Vec3D& wInc,
                                Intersection& is)
{
        return bsdf.eval(wOut,wInc,is.getGNormalW(), getShadingNormal(is));
}


bool BSDFMaterial::hasDiffuse() const
{
        return bsdf.hasDiffuse();
}

bool BSDFMaterial::hasSpecular() const
{
        return bsdf.hasSpecular();
}

bool BSDFMaterial::hasTransmissive() const
{
        return bsdf.hasTransmissive();
}

RGBColor BSDFMaterial::getEmitted(const Vec3D& wOut, Intersection& is)
{
        return 0;
}

RGBColor BSDFMaterial::sampleDiffuse(const Vec3D& wOut, const Vec3D& wInc, Intersection& is)
{
        return bsdf.evalDiffuse(wOut, wInc, is.getGNormalW(), getShadingNormal(is));
}

RGBColor BSDFMaterial::sampleSpecular(const Vec3D& wOut, const Vec3D& wInc, Intersection& is)
{
        return bsdf.evalSpecular(wOut, wInc, is.getGNormalW(), getShadingNormal(is));
}

ScatterEvent BSDFMaterial::scatterPhoton(Intersection& is, Photon* photon)
{
        Vec3D normal(getShadingNormal(is));
        const RGBColor Kd(bsdf.getKdiffuse());
        const RGBColor Ks(bsdf.getKspecular());
        const RGBColor Kt(bsdf.getKtransmit());
        const RGBColor& P = photon->getPower();
        const float sD = Kd.r()*P.r() + Kd.g()*P.g() + Kd.b()*P.b();
        const float sS = Ks.r()*P.r() + Ks.g()*P.g() + Ks.b()*P.b();
        const float sT = Kt.r()*P.r() + Kt.g()*P.g() + Kt.b()*P.b(); 
        const float IsAll = 1.0f/(sD + sS + sT);
        const float Pd = sD * IsAll;
        const float Ps = sS * IsAll;
        const float Pt = sT * IsAll;
        const float xi = float(rand()) / float(RAND_MAX); 
        if(xi <= Pd){
                photon->setPos(is.getPosition());
                //diffuse reflection
                photon->scalePower(Kd/Pd);
                //cout << " scaling " << Kd/Pd << endl;
                //get a random direction in the upper hemisphere
                float xi1 = float(rand()) / float(RAND_MAX);
                float xi2 = float(rand()) / float(RAND_MAX);
                float z2 = xi2 * 2.0f * M_PI;
                Vec3D u;
                Vec3D v;
                normal.getCS(u, v);
                Vec3D outDir(u * cos(z2) + v * sin(z2) * sqrt(1-xi1) + normal * sqrt(xi1));
                outDir.normalize();
                photon->setDir(outDir);
                return DIFFUSE;
        } else if(xi <= Ps+Pd) {
                photon->setPos(is.getPosition());
                //specular reflection
                photon->scalePower(Ks/Ps);
                Vec3D outDir(photon->getDir().reflect(normal));
                photon->setDir(outDir);
                return SPECULAR;
        } else if(xi <= Ps+Pd+Pt) {
                photon->setPos(is.getPosition());
                //if(float(rand()) / float(RAND_MAX) < (1.0f - Pt))
                        //return STORE;
                //refraction with snells law
                photon->scalePower(Kt/Pt);
                float etaI = is.getLastIOR().real();
                float etaT = 1.0;
                if(!is.backSide())//we are entering this material
                        etaT = ior.real();
                else {//we are leaving this material, we always assume to "air"
                        etaI = ior.real();
                }
                
                float eta = etaI / etaT;
                Vec3D wOut(snell(photon->getDir(), normal, eta));
                float cosT = wOut * normal;
                if(cosT <= 0.0f) {//total internal reflection
                        photon->setDir(photon->getDir().reflect(normal));
                        return SPECULAR;
                }
                photon->setDir(wOut);
                return REFRACTED;               
        } else {
                photon->setPos(is.getPosition());
                return STORE;
        }
        
}

bool BSDFMaterial::refracts() const
{
        return hasTransmissive();
}

}

---