iarealight.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 "iarealight.h" // include first
#include "common/math/real.h"
#include "context.h"
#include "hit.h"
#include "iedf.h"
#include "isurfaceshader.h"
#include "ray.h"
#include "scene.h"
#include "settings.h"
#include "statistics.h"
#include "surfacebasis.h"
#include "utilities.h"

#include <cassert>
#include <cmath>
#include <vector>

using namespace sheep;
using namespace std;
using namespace toxic;

IAreaLight::IAreaLight(const Matrix4 &m,
                       const ISurfaceShader *surface_shader,
                       IntersectionMask intersection_mask /*= INTERSECT_ALL_RAYS*/) :
    IBoundedObject(m, surface_shader, intersection_mask),
    ILight(true)    // cast shadows
{
}

void IAreaLight::Finalize(const Context &context) {
    // Precompute object surface area.
    m_surface_area = ComputeSurfaceArea();

    // Precompute object emission power.
    m_power = m_surface_area * m_surface_shader->GetRadiantExitance();
}

Ray IAreaLight::GeneratePhotonRay(const Context &context) const {
    Ray ray(Ray::PHOTON_RAY);
    Vector3 normal;

    EvaluateSurface(
        Point2(context.m_rng->RandomReal1(), context.m_rng->RandomReal1()),
        &ray.m_origin,
        &normal);

    // Photon rays will be casted from a point that is slighty shifted along
    // the geometric normal to the light surface at the sample location. This
    // is necessary to avoid false intersections.
    ray.m_origin += 1.0e-8 * normal;

    Vector3 direction;
    Real prob;

    GetSurfaceShader()->GetEDF()->Sample(
        context,
        &direction,
        &prob);

    ray.m_direction = SurfaceBasis(normal).TransformToWorld(direction);

    //!\todo And what about prob?

    return ray;
}

void IAreaLight::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);

    for(ISurfaceSampler::SampleVector::const_iterator i = input.begin(), e = input.end(); i != e; ++i) {
        Point3 sample_point;
        Vector3 sample_geometric_normal;

        EvaluateSurface(*i, &sample_point, &sample_geometric_normal);

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

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

        //!\todo Not sure which normal to use.
        const Real cos_theta = shading_normal * incoming;

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

        const Real emitted_radiance = GetSurfaceShader()->GetEDF()->GetEmittedRadiance(
            context,
            sample_geometric_normal,
            -incoming);

        assert(emitted_radiance >= 0.0);

        if(emitted_radiance <= 0.0) {
            // The light surface element is not directed toward the point: next sample.
            output->push_back(IrradianceSample(Color3(0.0), incoming));
            continue;
        }

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

            const Point3 shifted_sample = sample_point + 1.0e-8 * sample_geometric_normal;

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

        const Color3 irradiance = (m_surface_area * cos_theta * emitted_radiance * inv_distance2) *
            m_surface_shader->GetRadiantExitance();

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

---