src/PhongShader.h

Go to the documentation of this file.

#ifndef PHONGSHADER_H
#define PHONGSHADER_H


#include <cassert>

#include "Shader.h"
#include "Vec3f.h"
#include "Ray.h"
#include "Scene.h"


class PhongShader : public Shader
{
public:
    PhongShader(Scene *     scene,
                RGBAColor   color,
                float ka,
                float kd,
                float ks,
                float ke)
        : Shader(scene),
            mColor(color),
            mKa(ka),
            mKd(kd),
            mKs(ks),
            mKe(ke)
    {
    }

    virtual RGBAColor shade(const Ray & ray) const
    {
        assert(ray.hit());
        assert(ray.obj());

        typedef Vec3f Color;

        const Color La(1,1,1);
        const Color ca = mColor.rgb();
        //const Color cd(0.8f, 0.7f, 0.6f);  //this is right, but the graphic guys want it wrong
        const Color cd = ca;
        const Color cs(1,1,1);

        Vec3f normal = this->normal(ray);
        // turn normal to the front
        if (ray.dir().dot(normal) > 0.0f)
            normal = -normal;
        const Vec3f reflectdir = ray.dir() - 2* ( normal.dot(ray.dir()) * normal );
        
        Color firstterm = mKa*ca.scaled(La);
        
        Color secondterm(0,0,0);
        Color thirdterm(0,0,0);
        for(unsigned int i = 0; i < mScene->lightsCount(); i++)
        {
            Vec3f dir;
            for (unsigned int j = 0; j < mScene->getLight(i)->numberOfRays(); j++)
            {
                RGBAColor intensity = mScene->getLight(i)->illuminate(dir, ray.hitPoint(-EPSILON), j);
                float cosLightNormal = dir.dot( normal );
                if (cosLightNormal <= 0)
                    continue;
                secondterm  += intensity.rgb() * cosLightNormal;
                float cosLightReflect = dir.dot( reflectdir );
                if (cosLightReflect <= 0)
                    continue;
                thirdterm   += intensity.rgb() * powf( cosLightReflect, mKe ); 
            }
        }
        secondterm.scale(mKd * cd);
        thirdterm.scale(mKs * cs);
        RGBAColor result = RGBAColor(firstterm + secondterm + thirdterm, 1.0f);
        
        // add Textures
        if (textureCount() <= 0)
            return result;

        std::vector<Texture*>::const_iterator it = mTextures.begin();
        RGBAColor texes = (*it)->texel(ray.hit()->texCoord(ray));
        ++it;
        for(; it!=mTextures.end(); ++it)
        {
            // get texture color
            const RGBAColor tex = (*it)->texel(ray.hit()->texCoord(ray));

            // combine texture color with the computed result
            texes = RGBAColor(lerp(texes.rgb(), tex.rgb(), tex.a()));
        }

        // add lighting
        return result.scaled(texes);
    }

private:
    RGBAColor   mColor;

    float       mKa;

    float       mKd;

    float       mKs;

    float       mKe;
};

#endif

---