pointlight.cpp

Go to the documentation of this file.

/*
    toxic - A Global Illumination Renderer
    Copyright (C) 2003-2004 Francois Beaune
    Contact: http://toxicengine.sourceforge.net/

    This file is part of toxic.

    toxic is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    toxic is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with toxic; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/

#include "pointlight.h" // include first
#include "hit.h"
#include "scene.h"
#include "statistics.h"

#include <cassert>
#include <cmath>

using namespace sheep;
using namespace toxic;

PointLight::PointLight(const Matrix4 &m,
                       const Color3 &power,
                       bool cast_shadows /*= true*/) :
    Basis(m),
    ILight(cast_shadows),
    m_power(power),
    m_scaled_power(power / (4.0 * PI)),
    m_origin(TransformToWorld(Point3(0.0)))
{
}

void PointLight::ComputeIrradiance(const Context &context,
                                   const Scene *scene,
                                   const Point3 &point,
                                   const Vector3 &geometric_normal,
                                   const Vector3 &shading_normal,
                                   const ISurfaceSampler::SampleVector &/*input*/,
                                   IrradianceSampleVector *output) const
{
    assert(scene);
    assert(geometric_normal.IsUnitLength());
    assert(shading_normal.IsUnitLength());
    assert(output);

    Vector3 incoming = m_origin - point;
    const Real inv_distance2 = 1.0 / incoming.SquareNorm();

    // Normalize the incoming vector.
    incoming *= sqrt(inv_distance2);
    assert(incoming.IsUnitLength());

    const Real cos_theta = shading_normal * incoming;

    if(cos_theta <= 0.0) {
        // The surface is not directed toward the light.
        output->push_back(IrradianceSample(Color3(0.0), incoming));
        return;
    }

    if(m_cast_shadows) {
        ++context.m_statistics->m_shadow_rays;

        if(!scene->ArePointsMutuallyVisible(
            context,
            point,
            geometric_normal,
            m_origin,
            Ray::SHADOW_RAY))
        {
            // Point is in shadow.
            output->push_back(IrradianceSample(Color3(0.0), incoming));
            return;
        }
    }

    const Color3 irradiance = (cos_theta * inv_distance2) * m_scaled_power;

    output->push_back(IrradianceSample(irradiance, incoming));
}

---