src/rcrt/tracing/PhotonTracer.cpp

Go to the documentation of this file.

#include "PhotonTracer.h"
#include "../materials/Material.h"
#include "../bxdf/fresnel.hpp"

using namespace std;

namespace rcrt
{

PhotonTracer::PhotonTracer(Scene* s, PhotonMap* photonM, const int& noPhotG, const int& noPhotC):
        TracingStrategy(s), photonMap(photonM), noGPhotons(noPhotG), noCPhotons(noPhotC)
{
        
}

PhotonTracer::~PhotonTracer()
{
}

RGBColor PhotonTracer::directLight(Intersection& is, const Vec3D& rayDir) const
{
        RGBColor result(0);
        Material* mat = is.getPrimitive()->getParent()->getMaterial();
        vector<Light*>* const lights = scene->getLights();
        for(unsigned int i = 0; i < lights->size(); i++){
                Light* const light = lights->at(i);
                RGBColor Lr(0);
                std::vector<LightSample> samples;
                if(light->hasSampler())
                        //use a more specialized sampling strategy for lighting
                        light->getSampler()->sample(is.getPosition(), is.getSNormalW(), samples, light->getMinSamples(), scene);
                else
                        //get a number of light samples from the light
                        light->illuminate(is.getPosition(), is.getSNormalW(), samples, light->getMinSamples());
                
                for(unsigned int s = 0; s < samples.size(); s++){
                        const LightSample& sample = samples[s];
                        
                        if(sample.weight() == 0)
                                continue;
                        //only cast shadows for manually sampled lights
                        //light samplers should check for shadows themselves
                        if(!light->hasSampler() && scene->castShadows() && 
                                        scene->isOccluded(is.getPosition(), sample.dirToLight(), sample.dist())){
                                continue;
                        }
                        const Vec3D dirFromLight = (sample.dirToLight()*-1).normalize();
                        //get the reflectance value from the material
                        RGBColor fr = mat->sample(rayDir*-1,dirFromLight, is);
                        float angle = dirFromLight*is.getSNormalW();
                        RGBColor power = sample.power();
                        float weight = sample.weight();
                        //compute this samples contribution
                        Lr = Lr + power * fr * fabs(angle) * weight;
                }
                result = result + Lr;
        }
        return result;
}

RGBColor PhotonTracer::trace(Ray& r) const
{
        static const float MAXRAYDEPTH = 7;
        static const float THRESHOLD = 0.00001f;
        if(r.getDepth() > MAXRAYDEPTH)
                return RGBColor::BLACK;
        
        Intersection is = scene->intersect(r);
        if(is.isValid())//setting distance for beer's law
                r.setCurrDist(is.getDistance());                

        RGBColor result(0);
        
        if(is.isValid()){
                Material* mat = is.getPrimitive()->getParent()->getMaterial();
                Vec3D normal(mat->getShadingNormal(is));
                if(!is.backSide()){
                        //get emitted light
                        result = result + mat->getEmitted(r.dir()*-1, is);
                        
                        //get direct light contribution
                        RGBColor direct(directLight(is, r.dir()));
                        
                        result = result + direct;
                        
                        //get radiance estimate
                        RGBColor radiance(photonMap->getRadiance(r.dir()*-1, noGPhotons, noCPhotons, is));
                        
                        result = result + radiance;
                        
                        if(false){
                                RGBColor indir(0);
                                for(int i = 0; i < 1; i++){
                                        float xi1 = float(rand()) / float(RAND_MAX);
                                        float xi2 = float(rand()) / float(RAND_MAX);
                                        float z2 = xi2 * 2.0f * M_PI;
                                        Vec3D u;
                                        Vec3D v;
                                        normal.getCS(u, v);
                                        Vec3D sampleDir(u * cos(z2) + v * sin(z2) * sqrt(1-xi1) + normal * sqrt(xi1));
                                        sampleDir.normalize();
                                        RGBColor fr = mat->sample(r.dir()*-1,sampleDir*-1,is);
                                        float weight = fr.avg() * r.getWeight();
                                        Ray indRay(is.getPosition(),sampleDir,r.getDepth()+1,weight);
                                        RGBColor sample = trace(indRay);
                                        indir = indir + fr * sample / (4 * M_PI * indRay.currDist() * indRay.currDist());
                                }
                                result = result + indir;
                        }
                        
                        //trace specular reflection
                        if(mat->hasSpecular()){
                                //compute reflection
                                Vec3D reflDir(r.dir().reflect(normal));
                                RGBColor fr = mat->sampleSpecular(r.dir()*-1,reflDir*-1,is);
                                float weight = fr.avg()*r.getWeight();
                                //do not trace further reflections if
                                //it doesn't change that much
                                if(weight > THRESHOLD && r.getDepth()+1 <= MAXRAYDEPTH){
                                        Ray reflRay(is.getPosition(),reflDir,r.getDepth()+1,weight);
                                        RGBColor reflColor = trace(reflRay);                    
                                        result = result + reflColor * fr;
                                }
                        }
                        
                }
                
                //trace fresnel refraction
                if(mat->refracts()){
                        float etaT = mat->getRealIORPart();
                        float etaI = r.getLastIOR().real();
                        bool leaving = false;
                        if(is.backSide()){
                                //ray is leaving the object again
                                etaT = 1;//we always assume we're leaving to vaccuum
                                leaving = true;
                        }
                        //compute direction based on Snells law
                        float eta = etaI / etaT;
                        float cosI = r.dir() * normal;
                        float cosT = 1.0 - (eta * eta) * (1.0 - cosI * cosI);
                        
                        if (leaving && cosT <= 0.0f) {
                                //total internal reflection
                                //TODO may not work yet, look into this
                                /*
                                Vec3D reflDir(r.dir().reflect(is.getSNormalW()));                               
                                cosT = reflDir * normal;
                                float fresnel = frRDielectric(cosI, cosT, etaI, etaT);
                                float weight = fresnel * r.getWeight();
                                if(weight > THRESHOLD && r.getDepth()+1 <= MAXRAYDEPTH){
                                        Ray reflRay(is.getPosition(),reflDir,r.getDepth()+1,weight);
                                        reflRay.setLastIOR(r.getLastIOR());
                                        reflRay.setLastObject(r.getLastObject());
                                        RGBColor reflColor = trace(reflRay);
                                        RGBColor absorb(mat->getAbsorbance());
                                        float dist = reflRay.currDist();
                                        if(dist < std::numeric_limits<float>::infinity() && dist > 0){
                                                absorb = RGBColor(exp(-dist * absorb.r()),
                                                                exp(-dist * absorb.g()),
                                                                exp(-dist * absorb.b()));
                                        }
                                
                                        result = result + reflColor * absorb * fresnel;
                                        
                                }
                                return result;
                                */
                        }
                        cosT = sqrt(cosT);
                        float k = eta * cosI + cosT;
                        
                        Vec3D refrDir = r.dir() * eta + normal * -k;
                        cosT = refrDir * normal;
                        
                        float fresnel(frTDielectric(cosI, cosT,
                                        r.getLastIOR().real(), etaT));
                        //do not trace further refractions if
                        //it doesn't change that much
                        float weight = fresnel *r.getWeight();
                        if(weight > THRESHOLD && r.getDepth()+1 <= MAXRAYDEPTH){
                                //cout << "[SimpleTracer] getting refraction" << endl;
                                Ray refrRay(is.getPosition()+refrDir * 0.0001f,refrDir,r.getDepth()+1, weight);
                                if(leaving)
                                        refrRay.setLastObject(0);
                                else
                                        refrRay.setLastObject(is.getPrimitive()->getParent());
                                
                                refrRay.setLastIOR(complex<float>(etaT,0));             

                                RGBColor refrColor = trace(refrRay);
                                
                                float dist = refrRay.currDist();
                        
                                RGBColor absorb(mat->getAbsorbance());
                                if(dist < std::numeric_limits<float>::infinity() && dist > 0){
                                        absorb = RGBColor(exp(-dist * absorb.r()),
                                                        exp(-dist * absorb.g()),
                                                        exp(-dist * absorb.b()));
                                }
                                
                                result = result + refrColor * absorb * fresnel;
                        }
                }
        }
                
        return result.clamped();
        
}

}

---