src/rcrt/bxdf/CookTorrance.cpp

Go to the documentation of this file.

#include "CookTorrance.h"
#include <stdexcept>
#include "../loaders/conversion.hpp"

using namespace std;

namespace rcrt
{

CookTorrance::CookTorrance(const RGBColor& diff, const RGBColor& spec, const float& rough, const std::complex<float>& indOR)
        :BXDF(spec, diff, 0, BXDFType(REFLECTIVE)),ior(indOR),roughness(rough)
{
        
}

CookTorrance::~CookTorrance()
{
}

RGBColor CookTorrance::eval(const Vec3D& wOut, const Vec3D& wInc, const Vec3D& normal) const
{
        return kd/M_PI + evalSpecular(wOut,wInc,normal);        
}

RGBColor CookTorrance::evalDiffuse(const Vec3D& wOut, const Vec3D& wInc, const Vec3D& normal) const
{
        return kd/M_PI;
}

RGBColor CookTorrance::evalSpecular(const Vec3D& wOut, const Vec3D& wInc, const Vec3D& normal) const
{
        Vec3D v;
        
        if(wInc == wOut * -1)//somehow this happens sometimes..
                v = Vec3D(wInc.x()+0.00001,wInc.y()+0.00001,wInc.z()+0.00001);
        else
                v = wInc;
        
        float nv = normal * wOut;
        float nl = normal * v;

        Vec3D h((wOut + v).normalize());
                
        float vh = v * h;

        float nh = normal * h;
        //fixing very small values that may lead to division by zero
        if(nh < numeric_limits<float>::epsilon())
                nh = numeric_limits<float>::epsilon();
        if(nl < numeric_limits<float>::epsilon())
                nl = numeric_limits<float>::epsilon();
        if(nv < numeric_limits<float>::epsilon())
                nv = numeric_limits<float>::epsilon();
        if(vh < numeric_limits<float>::epsilon())
                vh = numeric_limits<float>::epsilon();

        // geometric term
        const float G = min(min(1.0f, (2.0f*nh*nv)/vh), (2.0f*nh*nl)/vh);

        float nh2 = nh * nh;
        if(nh2 < numeric_limits<float>::epsilon())
                nh2 = numeric_limits<float>::epsilon();
        const float tan2alpha = 1.0f/nh2 - 1.0f;

        // Beckmann distribution function
        const float rough2 = roughness*roughness;
        const float D = exp(-tan2alpha/rough2) / (rough2 * (nh2 * nh2));

        const float F = fresnelTerm(vh, ior);

        // specular reflectance
        const float Rs = (F / M_PI) * (D / nl) * (G / nv);
        
        return ks * Rs;
}


bool CookTorrance::specular() const
{
        return true;
}

bool CookTorrance::glossy() const
{
        return true;
}

bool CookTorrance::diffuse() const
{
        return true;
}

bool CookTorrance::fresnel() const
{
        return true;
}

float CookTorrance::pdf(const Vec3D& wOut, const Vec3D& wInc, const Vec3D& normal) const
{
        //Using Ward's sampling scheme, especially found in: 
        //Kelemen and Szirmay-Kalos: Microfacet Based BRDF Model
        float cosO = wOut * normal;
        if(cosO < 0) return 0;
                
        Vec3D h((wOut + wInc).normalize());
        float calpha = normal * h;
        float r2 = roughness * roughness;
        //probability for the halfway vector
        float ph = 1.0f / (r2 * M_PI * powf(calpha, 3)) * exp(-powf(tan(calpha),2)/r2);
        float cbeta = h * wOut;
        //cout << " ph " << ph << " cbeta " << cbeta << endl;
        return ph / ( 4 * cbeta);       
}

}

---