Subversion Repositories gelsvn

#include "path_tracer.hpp"

using namespace CGLA;

path_tracer::path_tracer(int w, int h, bool explicit_direct, int subsamples)
: tracer(w, h)
{
    explicit_direct_ = explicit_direct;
    subsamples_ = subsamples;
}

CGLA::Vec3f path_tracer::trace(const ray& r, bool include_emitted)
{
    //intersect ray with
    hit_info hi;
    bool hit = scene_->intersect(r, hi);

    if (!hit)
        return Vec3f(0.f, 0.5f, 0.f);

    //Vec3f x, y, z = hi.shading_normal;
    //orthogonal(z, x, y);
    //return (Vec3f(hi.texcoords(0),hi.texcoords(1),0) + Vec3f(0.f)) / 1.f;

    //only include emitted light if requested
    CGLA::Vec3f Le(0.f);
    if (include_emitted)
        Le = hi.emitted;

    //compute reflectance for each bsdf component
    float rho_diffuse = intensity(hi.diffuse);
    float rho_glossy = intensity(hi.glossy);
    float rho_reflection = intensity(hi.reflection);
    float rho_refraction = intensity(hi.refraction);
    float rho_total = rho_diffuse+rho_glossy+rho_reflection+rho_refraction;
    assert(rho_total < 1.f);

    if (rho_total == 0.f)
        return Le;

    //compute direct lighting on hit point
    CGLA::Vec3f Ld(0.f);
    Vec3f wo = -r.direction;
    if (explicit_direct_ && rho_diffuse+rho_glossy>0.f)
    {
        size_t nlums = scene_->luminaires();
        for (size_t i=0; i<nlums; ++i)
        {
            const luminaire* lum = scene_->get_luminaire(i);
            int samples = lum->samples();

            Vec3f L(0.f);
            for (int j=0; j<samples; ++j)
            {
                Vec3f Li, wi;
                if (lum->sample(r, hi, Li, wi))
                {
                    float cost = std::max(dot(hi.shading_normal, wi),0.f);
                    L += Li * cost * bsdf_evaluate(hi, wi, wo);
                }

                Ld += L / float(samples);
            }
        }
    }

    //use russian roulette to terminate path
    float prussian = 1.f;
    float rr = mt_random();

    if (r.depth > 3)
    {
        prussian = rho_total;

        if (rr >= prussian)
            return Ld + Le;
    }

    //figure out which bXdf to sample
    float pdiffuse = rho_diffuse/rho_total;
    float pglossy = rho_glossy/rho_total;
    float preflection = rho_reflection/rho_total;
    float prefraction = rho_refraction/rho_total;

    Vec3f wi;
    float pwi;
    Vec3f fs;
    bool sample_emitted = !explicit_direct_;
    if (rr <= pdiffuse)
    {
        //sample diffuse
        float pwi = sample_lambertian(hi, wo, wi);
        fs = lambertian_brdf(hi, wi, wo) / (pwi * pdiffuse * prussian);
    }
    else if (rr <= pdiffuse+pglossy)
    {
        //sample glossy part
        float pwi = sample_phong(hi, wo, wi);

        if (dot(hi.shading_normal, wi) <= 0.f)
            return Le + Ld;

        fs = phong_brdf(hi, wi, wo) / (pwi * pglossy * prussian);
    }
    else if (rr <= pdiffuse+pglossy+preflection)
    {
        //sample perfect specular reflection
        wi = reflect(hi.shading_normal, wo);
        pwi = 1.f;
        float cost = dot(hi.shading_normal, wo);
        fs = hi.reflection / (pwi * preflection * cost);
        sample_emitted = true;
    }
    else if (rr <= pdiffuse+pglossy+preflection+prefraction)
    {
        //sample perfect specular refraction
        bool not_tir = refract(hi.shading_normal, wo, 1.f/hi.ior, wi);
        assert(not_tir);
        pwi = 1.f;
        float cost = std::abs(dot(hi.shading_normal, wi));
        fs = hi.refraction / (pwi * prefraction * cost);
        sample_emitted = true;
    }
    else
        assert(false);

    //create aux ray
    ray s;
    s.origin = hi.position + epsilon * wi;
    s.direction = wi;
    s.depth = r.depth + 1;
    s.distance = std::numeric_limits<float>::infinity();
    float cost = std::abs(dot(hi.shading_normal, wi));
    Vec3f Li = cost * fs * trace(s, sample_emitted);

    //returm sum of emitted + direct + indirect
    return Le + Ld + Li;
}

Vec3f path_tracer::compute_pixel(int w, int h)
{
    assert(scene_);

    //supersample
    Vec3f L(0.f);
    for (int j=0; j<subsamples_; ++j)
    {
        float y  = h + (j + 0.5f) / subsamples_;

        for (int i=0; i<subsamples_; ++i)
        {
            float x  = w + (i + 0.5f) / subsamples_;

            //ask camera for initial ray..
            Vec2f uv(x/width_, y/height_);
            ray r = scene_->get_camera()->generate(uv);

            //trace ray
            L += trace(r, true);
        }
    }

    return L / float(subsamples_ * subsamples_);
}

//02566 framework, Anders Wang Kristensen, awk@imm.dtu.dk, 2007