bsdf.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 "bsdf.h"   // include first
#include "context.h"

#include <cassert>

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

BSDF::BSDF() :
    m_total_weight(0.0)
{
}

void BSDF::Insert(const IBRDF *brdf, Real weight) {
    assert(brdf);
    assert(weight >= 0.0 && weight <= 1.0);

    m_brdfs.push_back(make_pair(brdf, weight));

    if(brdf->IsSpecular())
        m_specular_brdfs.push_back(make_pair(brdf, weight));

    m_total_weight += weight;
    assert(m_total_weight <= 1.0);
}

void BSDF::Insert(const IBTDF *btdf, Real weight) {
    assert(btdf);
    assert(weight >= 0.0 && weight <= 1.0);

    m_btdfs.push_back(make_pair(btdf, weight));

    if(btdf->IsSpecular())
        m_specular_btdfs.push_back(make_pair(btdf, weight));

    m_total_weight += weight;
    assert(m_total_weight <= 1.0);
}

Real BSDF::Evaluate(const Context &context,
                    const Vector3 &incoming,
                    const Vector3 &outgoing) const
{
    assert(incoming.m_y > 0.0);
    assert(incoming.IsUnitLength());
    assert(outgoing.m_y > 0.0);
    assert(outgoing.IsUnitLength());

    Real value = 0.0;

    if(incoming.m_y * outgoing.m_y >= 0.0) {
        // Same hemisphere: evaluate BRDFs.
        for(brdf_vector_const_it i = m_brdfs.begin(), e = m_brdfs.end(); i != e; ++i)
            value += i->second * i->first->Evaluate(context, incoming, outgoing);
    } else {
        // Opposite hemispheres: evaluate BTDFs.
        for(btdf_vector_const_it i = m_btdfs.begin(), e = m_btdfs.end(); i != e; ++i)
            value += i->second * i->first->Evaluate(context, incoming, outgoing);
    }

//  assert(value <= 1.0);

    return value;
}

Real BSDF::EvaluateSpecular(const Context &context,
                            const Vector3 &incoming,
                            Vector3 *outgoing) const
{
    assert(incoming.m_y > 0.0);
    assert(incoming.IsUnitLength());
    assert(outgoing);

    // Uniformly choose amongst available specular BRDFs and BTDFs.
    //!\todo Sample according to the albedo or the weight of the component.
    const int index = context.m_rng->RandomInt(0, m_specular_brdfs.size() + m_specular_btdfs.size() - 1);
    const IBDF *chosen_bdf;
    Real chosen_bdf_weight;
    if(index < m_specular_brdfs.size()) {
        chosen_bdf = m_specular_brdfs[index].first;
        chosen_bdf_weight = m_specular_brdfs[index].second;
    } else {
        chosen_bdf = m_specular_btdfs[index - m_specular_brdfs.size()].first;
        chosen_bdf_weight = m_specular_btdfs[index - m_specular_brdfs.size()].second;
    }

    // Sample according to the chosen BDF.
    return chosen_bdf_weight * chosen_bdf->EvaluateSpecular(context, incoming, outgoing);
}

void BSDF::Sample(const Context &context,
                  const Vector3 &incoming,
                  Vector3 *outgoing,
                  Real *prob,
                  Real *value) const
{
    assert(incoming.m_y > 0.0);
    assert(incoming.IsUnitLength());
    assert(outgoing);
    assert(prob);
    assert(value);

    // Uniformly choose amongst available BRDFs and BTDFs.
    //!\todo Sample according to the albedo or the weight of the component.
    const int index = context.m_rng->RandomInt(0, m_brdfs.size() + m_btdfs.size() - 1);
    const IBDF *chosen_bdf;
    if(index < m_brdfs.size())
        chosen_bdf = m_brdfs[index].first;
    else chosen_bdf = m_btdfs[index - m_brdfs.size()].first;

    // Sample according to the chosen BDF.
    chosen_bdf->Sample(context, incoming, outgoing, prob, value);

    // We're using multiple importance sampling here.

    for(brdf_vector_const_it i = m_brdfs.begin(), e = m_brdfs.end(); i != e; ++i) {
        if(i->first != chosen_bdf)
            *prob += i->first->ComputeScatteringProbability(incoming, *outgoing);
    }

    for(btdf_vector_const_it i = m_btdfs.begin(), e = m_btdfs.end(); i != e; ++i) {
        if(i->first != chosen_bdf)
            *prob += i->first->ComputeScatteringProbability(incoming, *outgoing);
    }

    //!\todo Precompute the division.
    *prob /= m_brdfs.size() + m_btdfs.size();

    assert(*prob <= 1.0);
}

Real BSDF::ComputeScatteringProbability(const Vector3 &incoming,
                                        const Vector3 &outgoing) const
{
    // We're using multiple importance sampling here.

    Real scatteringprob = 0.0;

    for(brdf_vector_const_it i = m_brdfs.begin(), e = m_brdfs.end(); i != e; ++i)
        scatteringprob += i->first->ComputeScatteringProbability(incoming, outgoing);

    for(btdf_vector_const_it i = m_btdfs.begin(), e = m_btdfs.end(); i != e; ++i)
        scatteringprob += i->first->ComputeScatteringProbability(incoming, outgoing);

    //!\todo Precompute the division.
    scatteringprob /= m_brdfs.size() + m_btdfs.size();

    assert(scatteringprob <= 1.0);

    return scatteringprob;
}

Real BSDF::ComputeReflectance(const Context &context) const {
    Real reflectance = 0.0;

    for(brdf_vector_const_it i = m_brdfs.begin(), e = m_brdfs.end(); i != e; ++i)
        reflectance += i->second * i->first->ComputeReflectance(context);

    for(btdf_vector_const_it i = m_btdfs.begin(), e = m_btdfs.end(); i != e; ++i)
        reflectance += i->second * i->first->ComputeReflectance(context);

    return reflectance;
}

Real BSDF::ComputeReflectance(const Context &context,
                              const Vector3 &incoming) const
{
    assert(incoming.m_y > 0.0);
    assert(incoming.IsUnitLength());

    Real reflectance = 0.0;

    for(brdf_vector_const_it i = m_brdfs.begin(), e = m_brdfs.end(); i != e; ++i)
        reflectance += i->second * i->first->ComputeReflectance(context, incoming);

    for(btdf_vector_const_it i = m_btdfs.begin(), e = m_btdfs.end(); i != e; ++i)
        reflectance += i->second * i->first->ComputeReflectance(context, incoming);

    return reflectance;
}

---