src/CookTorranceShader.h

Go to the documentation of this file.

#ifndef COOKTORRANCESHADER_H
#define COOKTORRANCESHADER_H

#include "Shader.h"

class CookTorranceShader : public Shader
{
  public:
    CookTorranceShader(Scene * scene,
                       RGBAColor color,
                       float ka,
                       float kd,
                       float ks,
                       float slope  = 0.12f,
                       float lambda = 0.2f    )
        : Shader(scene),
          mColor(color),
          mKa(ka),
          mKd(kd),
          mKs(ks),
          mSlope(slope),
          mLambda(lambda)
          {
          }

    virtual RGBAColor shade(const Ray & ray) const
    {
        typedef Vec3f Color;
        
        const Vec3f origin = ray.org() + ray.t() * ray.dir();
        Vec3f normal = this->normal(ray);
        if (ray.dir().dot(normal) > 0.0f)
            normal = -normal;
       

        const Vec3f ViewDir = (-ray.dir() ).normal();
        const Color ambientColor = mKa * mColor.rgb();
        const Color ambientIntensity(1,1,1);

        Color result = ambientColor.scaled(ambientIntensity);
 
        for(unsigned int i = 0; i < mScene->lightsCount(); i++)
        {
            for (unsigned int j = 0; j < mScene->getLight(i)->numberOfRays(); j++)
            {
                Vec3f LightDir;  //light dir
                const RGBAColor intensity = mScene->getLight(i)->illuminate(LightDir,origin,j);
                const Vec3f Halfway = ( LightDir + ViewDir).normal();
                
                const float cosLightNormal = LightDir.dot(normal);
                if(cosLightNormal <= 0)
                    continue;
                
                //Color rhod = mColor.rgb().scaled(1/M_PI);

                float rhos;
                const float D = distribution(normal, Halfway);
                
                const float G = geometry(normal, Halfway, LightDir, ViewDir);
                
                const float F = fresnel(Halfway, LightDir);
                rhos = ( F * D * G ) / ( M_PI * normal.dot(ViewDir) * normal.dot(LightDir) );
            
                if(isnan(rhos))
                {
                    LOG("RHOS IS NAN. Most likely Fresnel term is NAN, change the nue_lambda term");
                    rhos = 0.0f;
                }
                //Color addto = intensity.rgb().scaled(cosLightNormal * (kd * color + ks * rhos));
                //result += addto;
                result += intensity.rgb().scaled(cosLightNormal * (mKd * mColor.rgb()  + mKs * rhos));
            }
        }
        
        // add Textures
        RGBAColor texturing(result,1.0f);
        std::vector<Texture*>::const_iterator it = mTextures.begin();
        for(; it!=mTextures.end(); ++it)
        {
            // get texture color
            const RGBAColor tex = (*it)->texel(ray.hit()->texCoord(ray));
            
            // combine texture color with the computed result
            texturing.scale(tex);
        }
        return texturing;

    }

  private:
    const float distribution(const Vec3f & normal, const Vec3f & Halfway) const
    {
        const float beta = acosf( normal.dot(Halfway) );
        const float firstterm = (1.0f/ ( 4.0f * powf(mSlope,2) * powf(cosf(beta),4) ) );
        const float secondterm = exp( - powf(tanf(beta) / mSlope  ,2));
        return firstterm * secondterm;
    }

    const float geometry(const Vec3f & normal, const Vec3f & Halfway, const Vec3f & LightDir, const Vec3f & ViewDir) const
    {
            const float G_b = ( 2.0f* normal.dot(Halfway)* normal.dot(ViewDir) ) / ( ViewDir.dot(Halfway) );
            const float G_s = ( 2.0f* normal.dot(Halfway)* normal.dot(LightDir) ) / ( ViewDir.dot(Halfway) );
            return std::min(1.0f, std::min(G_b, G_s) );
    }

    const float fresnel(const Vec3f & Halfway, const Vec3f & LightDir) const
    {


        const float theta_i = acosf(LightDir.dot(Halfway));
        const float theta_t = asinf(mLambda * sinf(theta_i) );
        const float firstterm = 0.5f * (powf(sinf(theta_i - theta_t),2) ) / (powf(sinf(theta_i + theta_t),2) );
        const float secondterm = 1.0f + ( powf(cosf(theta_i + theta_t),2) / (powf(cosf(theta_i - theta_t),2)));

   
        return firstterm * secondterm;


/*        const float c = LightDir.dot(Halfway);
        const float g = sqrtf( powf(nue_lambda,2) + powf(c,2) - 1.0f);
        const float F_lambda_firstterm = 0.5f * (powf(g-c, 2) / powf(g+c, 2) );
        const float F_lambda_secondterm = 1 + ( powf(c * (g+c) - 1.0f, 2) / powf(c * (g-c) - 1.0f, 2) );
        const float F_lambda = F_lambda_firstterm * F_lambda_secondterm;
        return F_lambda;
*/
    }


    RGBAColor mColor;
    float mKa;
    float mKd;
    float mKs;
    float mSlope;
    float mLambda;
};

#endif

---