src/QuadAreaLight.h

Go to the documentation of this file.

#ifndef AREALIGHT_H
#define AREALIGHT_H


#include "Light.h"
#include "Ray.h"


class QuadAreaLight : public Light
{
public:
    QuadAreaLight(  const RGBAColor &   power,
                    const Vec3f &       pos,
                    const Vec3f &       d1,
                    const Vec3f &       d2)
        : Light(),
            mPower(power),
            mP0(pos),
            mE1(d1),
            mE2(d2),
            mRaycount(1)
    {
        // compute normal by computing the cross product of both expansion vectors
        mNormal = mE1.cross(mE2);

        // the area of a quad is the length of the cross product vector
        mArea = mNormal.length();

        // we have always to normalize the normal
        mNormal.normalize();

        // precalculate power
        mPower *= mArea;
    }

    unsigned int numberOfRays() const { return mRaycount; }

    void setNumberOfRays(unsigned int i) { mRaycount = i; }

    RGBAColor illuminate(Vec3f & dir, const Vec3f & org, unsigned int /*index = 0*/) const
    {
        // compute random position of a point light on the quad
        float xi1 = frand();
        float xi2 = frand();
        Vec3f pos = mP0 + xi1 * mE1 + xi2 * mE2;

        // the new ray direction is the direction to this point
        Ray ray;
        dir = pos - org;
        float length = dir.length();
        dir.normalize();
        ray.init(org, dir, length);

        // check for occlusion
        if (mScene->castShadows() && mScene->intersect(ray) && ray.hit()->castShadows() && ray.t() > EPSILON)
            return RGBAColor(0.0f);

        // compute attenuation factor
        float att = 1.0f / (length * length * mRaycount);
        
        // sample quad light
        float cosN = - dir.dot(mNormal);
        if (cosN < EPSILON)
            return RGBAColor(0.0f);
        
        // compute intensity based on the area of the light source
        return att * cosN * mPower;
    }

    const Vec3f & normal() const
    {
        return mNormal;
    }


private:
    RGBAColor       mPower;

    Vec3f           mP0;

    Vec3f           mE1;

    Vec3f           mE2;

    float           mArea;

    Vec3f           mNormal;

    unsigned int    mRaycount;
};

#endif

---