causticsphotontracer.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 "causticsphotontracer.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 CausticsPhotonTracer::trace_photon(const Context &context,
                                        PhotonMap *photonmap,
                                        const Scene *scene,
                                        Ray ray,
                                        Color3 power) const
{
    assert(photonmap);
    assert(scene);

    bool specularbounce = false;

    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() && specularbounce) {
            ++context.m_statistics->m_cpm_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
                );
        }

        if(!shadingdata.m_bdf->IsSpecular())
            break;

        specularbounce = true;

        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;
    }
}

---