globalphotontracer.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 "globalphotontracer.h" // include first
#include "common/math/point3.h"
#include "common/math/real.h"
#include "common/math/vector3.h"
#include "color3.h"
#include "context.h"
#include "hit.h"
#include "ibdf.h"
#include "ilight.h"
#include "isurfaceshader.h"
#include "photonmap.h"
#include "ray.h"
#include "scene.h"
#include "statistics.h"
#include "surfacebasis.h"
#include "utilities.h"

#include <cassert>

using namespace sheep;
using namespace toxic;

void GlobalPhotonTracer::trace_photon(const Context &context,
                                      PhotonMap *photonmap,
                                      const Scene *scene,
                                      Ray ray,
                                      Color3 power) const
{
    assert(photonmap);
    assert(scene);

    bool directillum = true;

    while(true) {
        Hit hit;

        ++context.m_statistics->m_photon_rays;

        assert(ray.m_direction.IsUnitLength());

        if(!scene->Trace(context, ray, &hit)) {
            // Holes in the scene are modelled as totally absorptive surfaces.
            break;
        }

        // Extract intersection data.
        Point3 point;
        Vector3 geometric_normal;
        hit.ExtractIntersection(ray, &point, &geometric_normal, 0);
        const ISurfaceShader *surface_shader = hit.m_object->GetSurfaceShader();

        const SurfaceBasis surfacebasis(geometric_normal);

        ShadingData shadingdata;
        surface_shader->Shade(hit, &shadingdata);

        if(shadingdata.m_bdf->IsDiffuse()) {
            // Photons coming directly from the light source are not stored
            // into the global photon map.
            if(!directillum) {
                ++context.m_statistics->m_gpm_photons;
                photonmap->StorePhoton(
                    point,              // world space
                    power,
                    -ray.m_direction    // world space (away from surface)
#ifdef ENABLE_RADIANCES_PRECOMPUTATION
                    , geometric_normal          // world space
#endif  // ENABLE_RADIANCES_PRECOMPUTATION
                    );
            }
        }

        // Absorption.
        const Real scattering_prob = shadingdata.m_reflectance.Average();   //!\todo Use surface albedo instead.
        if(context.m_rng->RandomReal1() > scattering_prob)
            break;
        power /= scattering_prob;

        directillum = false;

        const Vector3 local_incoming = surfacebasis.TransformToLocal(-ray.m_direction);

        Vector3 scattereddir;
        Real prob;
        Real bsdf_value;

        shadingdata.m_bdf->Sample(
            context,
            local_incoming,
            &scattereddir,
            &prob,
            &bsdf_value);

        const Vector3 world_scattereddir = surfacebasis.TransformToWorld(scattereddir);

        power *= bsdf_value * shadingdata.m_reflectance * (world_scattereddir * geometric_normal) / prob;

        // Replace the current ray by the reflected ray.
        ray.NewId();
        ray.m_origin = point + 1.0e-8 * geometric_normal;   // shift ray origin to avoid false intersections
        ray.m_direction = world_scattereddir;
    }
}

---