src/RefractiveShader.h

Go to the documentation of this file.

#ifndef REFRACTIVESHADER_H
#define REFRACTIVESHADER_H

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


class RefractiveShader : public Shader
{
public:
    RefractiveShader(   Scene *             scene,
                        const RGBAColor &   color,
                        float               refractionIdx );

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

        // adaptive recursion termination
        if (ray.influence() < MIN_INFLUENCE || ray.recDeep() > MAX_RECURSION_DEEP)
        {
            // let rays with small influence out of the refractive object
            Ray newray;
            newray.init(ray.hitPoint(EPSILON), ray.dir());
            newray.updateInfluence(ray);
            return mScene->rayTrace(newray);
//            return RGBAColor(0, 1, 0);  // DEBUG
        }

        // normal of the surface
        Vec3f n = normal(ray);

        // compute cosine of incident ray
        float cosIncident = n.dot(-ray.dir());
        bool fromOutside = cosIncident >= 0;
        // use inverted refraction index for rays coming from outside
        float refIdx = mRefractionIndex;
        if (fromOutside)
            refIdx = mInvRefractionIndex;
        // cosine of refracted ray with Snell's law
        float sqrCosRefracted = 1.0f - refIdx*refIdx*(1.0f - cosIncident*cosIncident);

        // reflected vector
        Vec3f reflected = ray.dir() + 2*cosIncident*n;
        Ray newray;

        // Fresnel coefficients
        float R  = 1.0f;

        Vec3f refractedCol;
        if (sqrCosRefracted >= 0.0f)
        {
            // refraction
            float cosRefracted = sqrtf(sqrCosRefracted);
            // Fresnel coefficients
            float Rs = 0.0f;
            float Rp = 0.0f;
            // refracted vector
            Vec3f v = refIdx*ray.dir();
            if (fromOutside)
            {
                v += (refIdx*cosIncident - cosRefracted)*n;
            }
            else
            {
                cosIncident = - cosIncident;
                v -= (refIdx*cosIncident - cosRefracted)*n;
            }

            Rs = (cosIncident - mRefractionIndex*cosRefracted)/(cosIncident + mRefractionIndex*cosRefracted);
            Rp = (cosRefracted - mRefractionIndex*cosIncident)/(cosRefracted + mRefractionIndex*cosIncident);
            // reflection coefficient for unpolarised light
            R = (Rs*Rs + Rp*Rp)*0.5;

            // trace in the refracted direction
            newray.init(ray.hitPoint(EPSILON), v);
            newray.updateInfluence(ray, 1.0f - R);
            refractedCol = mScene->rayTrace(newray).rgb();
            if (fromOutside)
            {
                float shading = powf(1.0f - mColor.a(), newray.t());    // shade with material thickness
                refractedCol = lerp(mColor.rgb(), refractedCol, shading);
            }
        }
        // else total reflection
        assert(0 <= R && R <= 1);

        // trace in the reflected direction
        newray.init(ray.hitPoint(-EPSILON), reflected);
        newray.updateInfluence(ray, R);
        Vec3f reflectedCol = mScene->rayTrace(newray).rgb();
        if (!fromOutside)
        {
            float shading = powf(1.0f - mColor.a(), newray.t());    // material thickness
            reflectedCol = lerp(mColor.rgb(), reflectedCol, shading);
        }

        // interpolate resulted color
        return RGBAColor(lerp(refractedCol, reflectedCol, R));
    }

private:
    RGBAColor   mColor;

    float       mRefractionIndex;

    float       mInvRefractionIndex;
};


#endif

---