src/rcrt/lights/AreaLight.h

Go to the documentation of this file.

#ifndef AREALIGHT_H_
#define AREALIGHT_H_

#include "Light.h"
#include "../primitives/AABB.h"
#include "../primitives/Triangle.h"
#include "../objects/AffineObject.h"
#include "../materials/LightMaterial.h"

namespace rcrt
{

class AreaLight : public rcrt::Light
{
        friend class AreaLightSampler;
        
protected:
        Point3D base;
        Vec3D span1;
        Vec3D span2;
        Vec3D normal;
        float area;
        AffineObject object;
        LightMaterial material;
        Triangle tri1;
        Triangle tri2;
        std::vector<Primitive*> triList;
        float aspect;
        
        
        Point3D getRandomPosition() const;
        LightSample getSample(const Point3D& p, const Vec3D& no, const Point3D& pos, Scene* s = 0) const;
        LightSample getSample(const Point2D& uv, const Vec3D& no, const Point3D& pos, Scene* s = 0) const;
        
public:
        AreaLight(const RGBColor& p, const Point3D& pos,
                        const Vec3D& dir1, const Vec3D& dir2, const Vec3D& no = Vec3D(0));
        virtual ~AreaLight();
        
        /* Light methods */
        virtual LightSample illuminate(const Point3D& p, const Vec3D& no) const;
        virtual void illuminate(const Point3D& p, const Vec3D& no, std::vector<LightSample>& samples,
                        const int& noSamples, Scene* s = 0 ) const;
        virtual RGBColor getEmitted(const Vec3D& dir, const Point3D& pos) const;
        
        virtual Object* getObject();

        virtual void emitPhoton(Photon* photon) const;
};

inline LightSample AreaLight::getSample(const Point3D& p, const Vec3D& no, 
                const Point3D& loc, Scene* s) const
{
        Vec3D dir(loc-p);
        if(s != 0 && s->castShadows()){
                if(s->isOccluded(p, dir.normalized(), dir.norm()))
                        return LightSample(0,0,0,0);
        }
        
        float length = dir.norm();
        dir.normalize();
        // compute attenuation factor 
        float att = 1.0f / (length * length);

        // sample light 
        float cosN = -(dir * normal);
        if (cosN < std::numeric_limits<float>::epsilon()){
                return LightSample(0,0,0,0);
        }
        // compute intensity based on the area of the light source
        return LightSample(1,dir, length, power * att * area * cosN);
}

inline LightSample AreaLight::getSample(const Point2D& uv, const Vec3D& no, 
                const Point3D& p, Scene* s) const
{
        return getSample(p, no, base+uv.x()*span1+uv.y()*span2, s);
}

}

#endif /*AREALIGHT_H_*/

---