src/rcrt/tracing/RayCaster.cpp

Go to the documentation of this file.

#include "RayCaster.h"
#include "../Intersection.h"
#include "../objects/SolidObject.h"
#include "../lights/Light.h"
#include "../lights/LightSample.h"
#include "../materials/Material.h"
#include <vector>
#include <algorithm>

using namespace std;

namespace rcrt
{

RayCaster::RayCaster(Scene* s):TracingStrategy(s)
{
}

RayCaster::~RayCaster()
{
}

RGBColor RayCaster::trace(Ray& r) const
{
        Intersection is = scene->intersect(r);
        if(is.isValid()){
                vector<Light*>* const lights = scene->getLights();
                Material* mat = is.getPrimitive()->getParent()->getMaterial();
                RGBColor result(0);
                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()){
                                light->getSampler()->sample(is.getPosition(), is.getSNormalW(), samples, light->getMinSamples(), scene);
                        }else
                                light->illuminate(is.getPosition(), is.getSNormalW(), samples, light->getMinSamples(), scene);
                        
                        for(unsigned int s = 0; s < samples.size(); s++){
                                const LightSample& sample = samples[s];
                                //only cast shadows for manually sampled lights
                                if(!light->hasSampler() && scene->castShadows() &&
                                                scene->isOccluded(is.getPosition(), sample.dirToLight(), sample.dist())){
                                        continue;
                                }
                                const Vec3D dirFromLight = (sample.dirToLight() * -1).normalize();
                                RGBColor fr = mat->sample(r.dir()*-1,dirFromLight, is);
                                float angle = dirFromLight*is.getSNormalW();
                                Lr = Lr + sample.power() * fr * fabs(angle) * sample.weight();
                        }
                        //cout << "[RayCaster]: contribution of source "<< i <<" = "<<Lr<<endl;
                         
                        result = result + Lr;
                }
                return result;
                
        }
        return RGBColor::BLACK;
}

Image RayCaster::trace(Camera* cam, std::vector<Primitive*>* trList) const
{
        const int& resX = cam->getResolutionX();
        const int& resY = cam->getResolutionY();
        float triangles = 0;
        Image img(resX, resY);
        clock_t start = clock();
        double dif;
        for(int x=0; x < resX; x++){
                for(int y=0; y < resY; y++){
                        // primary ray to trace
            Ray r = cam->getRay(Point2D(x,y));
            
            // ray trace the list
            Intersection is;
            for(unsigned int i=0; i< trList->size(); i++){
                Intersection curr = trList->at(i)->intersect(r);
                if(curr.isValid() && curr.getDistance() <= is.getDistance()){
                                        is = curr;
                                }
            }
            
            if(is.isValid()){
                vector<Light*>* const lights = scene->getLights();
                        Material* mat = is.getPrimitive()->getParent()->getMaterial();
                        RGBColor result(0);
                        for(unsigned int i = 0; i < lights->size(); i++){
                                Light* const light = lights->at(i);
                                        RGBColor Lr(0);
                                        std::vector<LightSample> samples;
                                        light->illuminate(is.getPosition(), is.getSNormalW(), samples, light->getMinSamples(), 0);
                                        for(unsigned int s = 0; s < samples.size(); s++){
                                                const LightSample& sample = samples[i];
                                                if(scene->castShadows() && scene->isOccluded(is.getPosition(), sample.dirToLight(), sample.dist()))
                                                        continue;                               
                                                const Vec3D dirFromLight = (sample.dirToLight() * -1).normalize();
                                                //cout << "[RayCaster]: Incident light: " << col << endl; 
                                                RGBColor fr = mat->sample(r.dir()*-1,dirFromLight, is);
                                                //cout << "[RayCaster]: -reflectance: " << fr << endl;
                                                float angle = dirFromLight*is.getSNormalW();
                                                if(angle > 0)
                                                        Lr = Lr + sample.power() * fr * angle * sample.weight();
                                        }
                                //cout << "[RayCaster]: contribution of source "<< i <<" = "<<Lr<<endl;
                                 
                                result = result + Lr;
                        }
                        RGBColor resC(min(1.0f,result.r()),min(1.0f,result.g()),min(1.0f,result.b()));
                img.setPixel(resC, x, y);
            } else {
                img.setPixel(RGBAColor(0), x, y);
            }
            

            triangles += r.tris;
        }
        }
        clock_t end = clock();
        dif = end-start;
        float triPray = triangles/(resX*resY);
        std::cout << "Average Triangle-Intersections per ray: " << triPray << "Triangles intersected: " << triangles << " Time for tracing: "<< dif/CLOCKS_PER_SEC << std::endl;
    return img;
}

}

---