PathTracing.cc

Go to the documentation of this file.

#include <gra/reflection/PathTracing.h>
#include <assert.h>

using namespace gra;

void PathTracing::_cast_the_ray(PointEnv&      surr,
                                unsigned       actDepth,
                                bool           firstObjHit,
                                Color3f&       contrib,
                                const Vector3& nDir,
                                const Vector3& refl)
{
    PointEnv* pNewSurr = _cast_ray(surr.intersection, nDir);
    
    if (!pNewSurr) {
        contrib.add(_background);
        return;
    }

    pNewSurr->energy.set(surr.energy);
    pNewSurr->energy.x *= refl.x;
    pNewSurr->energy.y *= refl.y;
    pNewSurr->energy.z *= refl.z;
    pNewSurr->mask |= ENV_HAVE_ENERGY;
        
    if (((pNewSurr->energy.x +
          pNewSurr->energy.y +
          pNewSurr->energy.z) / 3.) > _minRayWeight)
    {
        _illuminate(*pNewSurr, actDepth+1, firstObjHit, contrib);
    }
    
    delete pNewSurr;
}

void PathTracing::_cast_secondary_rays(PointEnv&   surr,
                                       unsigned    actDepth,
                                       bool        firstObjHit,
                                       Color3f&    contribution,
                                       MatVisitor& matVisitor)
{
    Vector3       nDir;
    Color3f       contrib(0.,0.,0);
    double        avgRefl;
    Vector3       refl;
    DiffuseBRDF*  pDiffBRDF     = surr.pVisitableObj->diffuseBRDF();
    SpecularBRDF* pSpecBRDF     = surr.pVisitableObj->specularBRDF();
    double        avgReflection = matVisitor.avgReflection();
    double        avgTransp     = matVisitor.avgTransparency();
    double        avgSpecular   = 0.;
    double        avgDiffuse    = 0.;

    if (!pDiffBRDF) pDiffBRDF   = _pDiffuseBRDF;
    if (!pSpecBRDF) pSpecBRDF   = _pSpecularBRDF;
    if (pDiffBRDF)  avgDiffuse  = matVisitor.avgDiffuse();
    if (pSpecBRDF)  avgSpecular = matVisitor.avgSpecular();

    for (unsigned i = 0; i < _photonsPerSurface; i++) {

        /*
         * Russian roulette
         */

        double r1 = ESG_DBL_RAND;
        double rr = r1;
        avgRefl = 0.;
        
        // rescale the [0,1) random number to [0,max_reflection)
        //double avgRR = (pBRDF->avgReflectance(matVisitor) +
        //      matVisitor.avgReflection() +
        //      matVisitor.avgTransparency());
        //r1 *= avgRR;
        //r1 *= avgRR + _refraction;

        rr = r1;

        if ((rr -= avgDiffuse) < 0.) { // sample diffuse BRDF
            pDiffBRDF->importanceSample(matVisitor,
                                        surr.normal,
                                        r1,
                                        ESG_DBL_RAND, 
                                        nDir,
                                        NULL);
            refl.set(matVisitor.diffuse());
            refl.scale(1. / avgDiffuse);
            _cast_the_ray(surr, actDepth, true, contrib, nDir, refl);
        } else if ((rr -= avgSpecular) < 0.) { // sample specular BRDF
            Vector3 prDir;
            _reflection_dir(surr, prDir); // prefered dir.
            pSpecBRDF->importanceSample(matVisitor,
                                        prDir,
                                        r1,
                                        ESG_DBL_RAND, 
                                        nDir,
                                        NULL);
            refl.set(matVisitor.specular());
            refl.scale(1. / avgSpecular);
            _cast_the_ray(surr, actDepth, true, contrib, nDir, refl);
        } else if ((rr -= avgReflection) < 0.) { // sample mirror reflection
            _reflection_dir(surr, nDir);
            refl.set(matVisitor.reflection());
            refl.scale(1. / avgReflection);
            _cast_the_ray(surr, actDepth, true, contrib, nDir, refl);
        } else if ((rr -= avgTransp) < 0.) { // sample refraction
            bool foh = ((_refraction_dir(surr,
                                         matVisitor,
                                         firstObjHit,
                                         nDir)
                         == RayTracing::REFR_DIR_REFLECTION)
                        ? false
                        : !firstObjHit);
            refl.set(matVisitor.transparency());
            refl.scale(1. / avgTransp);
            _cast_the_ray(surr, actDepth, foh, contrib, nDir, refl);
        } 
    }
    
    contrib.scale(1./_photonsPerSurface);
    contribution.add(contrib);
}


// --------- public ----------------

---