BumpMappedMarblePhongShader.h

Go to the documentation of this file.

#ifndef BUMPMAPPEDMARBLEPHONGSHADER_H
#define BUMPMAPPEDMARBLEPHONGSHADER_H BUMPMAPPEDMARBLEPHONGSHADER_H

#include "Shader.h"
#include "MarbleShader.h"

class BumpMappedMarblePhongShader : public Shader
{
public:
    ColorRGBA color; // base color
    float ka;    // ambient coefficient
    float kd;    // diffuse reflection coefficients
    float ks;    // specular refelection coefficients
    float ke;    // shininess exponent
   
    Texture* bumpmap;
    float bumpfactor;
    
    Shader* marble;

    BumpMappedMarblePhongShader(Scene *scene,
            ColorRGBA color, float ka,float kd, float ks, float ke, Texture* bumpmap, float bumpfactor, Vector3D center)
    : Shader(scene),color(color),ka(ka),kd(kd),ks(ks),ke(ke),bumpmap(bumpmap),bumpfactor(bumpfactor)
    {
        marble = new MarbleShader(scene, center, 0.7);
    };

    ~BumpMappedMarblePhongShader () {
        delete marble;
    }
    
    virtual ColorRGBA Shade(Ray &ray)
    {
        // get shading normal
        Vector3D normal = ray.hit->GetNormal(ray);
        
        // turn normal to front
        if (Dot(normal,ray.dir) > 0)
            normal = -normal;
       
        // get bump value, we need only one float between 0 and 1,
        // we use the greyscale
        float bump = bumpmap->GetTexel(ray.hit->GetUV(ray)).average();
        
        // compute new normal
        // see "Texturing & Modeling, a Modern Approach", chapter 2
        Vector3D p = ray.org + ray.t * ray.dir;
        Vector3D du = p + Cross(normal, normal + Vector3D(0,0,1)).Normalized();
        Vector3D dv = p + Cross(normal, du).Normalized();
        p += bumpfactor * bump * normal;
        du = p - du;
        dv = p - dv;
        normal = Cross(du, dv).Normalized();

        // turn normal to front
        if (Dot(normal,ray.dir) > 0)
            normal = -normal;
       
        // calculate reflection vector
        Vector3D reflect = ray.dir - 2*Dot(normal,ray.dir)*normal;
        
        // ambient term
        ColorRGBA ambientColor = ka * color;
        ColorRGBA result = ambientColor;
        
        // shadow ray (up to now only for the light direction)    
        Ray shadow;
        shadow.org = ray.org + ray.t * ray.dir;
        
        // iterate over all light sources
        for (unsigned int l=0; l < scene->mLights.size(); l++)
        {      
            // get direction to light, and intensity 
            ColorRGBA lightIntensity;
            ColorRGBA result_local = ColorRGBA(0.0);

            // check whenever the shader is computing area light source
            for(unsigned int s = 0; s < scene->mLights[l]->GetNumberOfRays(); s++)
            {
                // illuminate the ray by the light source
                if (scene->mLights[l]->Illuminate(shadow, lightIntensity, s))
                {   
                        // compute distance to the light source 
                        float distance = shadow.t;
        
                        // diffuse term, also used as a check if illuminating the front-side
                        float cosLightNormal = Dot(shadow.dir,normal);
                        if (cosLightNormal > 0)
                        {
                            // if the ray is occluded, hence there is a shadow
                            // we put this here to optimize all things, since we work only for in-front surfaces
                            if (scene->castShadows && scene->Intersect(shadow) && shadow.hit->castShadows())
                            {
                                // if the shadow ray intersects a surface which is near then the light source, then we 
                                // are in shadow
                                if (shadow.t < distance)
                                    continue;
                            }
        
                            // compute diffuse term             
                            ColorRGBA diffuseColor = kd * color;
                            result_local = result_local + (diffuseColor * cosLightNormal) * lightIntensity;
                
                            // specular term is computed only if shading the front-side
                            float cosLightReflect = Dot(shadow.dir,reflect);
                            if (cosLightReflect > 0)
                            {
                                ColorRGBA specularColor = ks * ColorRGBA(1,1,1); // white highlight;
                                result_local = result_local + (specularColor * powf(cosLightReflect,ke)) * lightIntensity;
                            }
                        }
                }
            }   
            
            result_local.red() /= float(scene->mLights[l]->GetNumberOfRays());
            result_local.green() /= float(scene->mLights[l]->GetNumberOfRays());
            result_local.blue() /= float(scene->mLights[l]->GetNumberOfRays());
            result += result_local;
        }
        
        // make surface marblesque
        result *= marble->Shade(ray);

        return result;
    };
};

#endif

---