MicroTrace.cpp

Go to the documentation of this file.

#ifdef MT_OPENMP
#include <omp.h>
#endif

#include <sstream>
#include <iostream>

#include "Image.h"

#include "Object.h"
#include "Scene.h"
#include "Sphere.h"

#include "PerspectiveCamera.h"
#include "CylindricCamera.h"
#include "DepthOfFieldCamera.h"

#include "PointLight.h"
#include "QuadAreaLight.h"

#include "Texture2D.h"
#include "FlatShader.h"
#include "DebugShader.h"
#include "EdgeShader.h"
#include "FlatTransparentShader.h"
#include "MirrorShader.h"
#include "EyeLightShader.h"
#include "PhongShader.h"
#include "CloudShader.h"
#include "PlasmaShader.h"
#include "MarbleShader.h"
#include "BumpMappedDebugShader.h"
#include "BumpMappedPhongShader.h"
#include "BumpMappedMarblePhongShader.h"
#include "TransparentShader.h"
#include "UniAxialCrystalShader.h"
#include "MixShader.h"
#include "MapShader.h"
#include "WoodShader.h"
#include "BumpMappedWoodPhongShader.h"
#include "GoldShader.h"
#include "SilverShader.h"
#include "SteelShader.h"
#include "CopperShader.h"

#include "SampleGenerator.h"
#include "RegularSampleGenerator.h"
#include "RandomSampleGenerator.h"
#include "StratifiedSampleGenerator.h"
#include "PoissonDiskSampleGenerator.h"

using namespace std;

Object* AddObject(char* fileName, Scene& scene, bool useAcc = true, const Object::PrimitiveFactory& factory = Object::TriangleFactory() )
{
    Object* obj = new Object(useAcc);
    obj->ParseOBJ(fileName, factory);
    obj->setColor(ColorRGBA(1,1,1));
    obj->BuildAccelStructure();

    scene.AddObject(obj);

    return obj;
}

Object* AddSphere(Sphere* sphere, Scene& scene, bool useAcc = true)
{
    Object* obj = new Object(useAcc);
    obj->Add(sphere);
    obj->setColor(Vector3D(1,1,1));
    obj->BuildAccelStructure();

    scene.AddObject(obj);

    return obj;
}

void RenderFrame (Scene* scene, string prefix,
                  Vector3D pos, Vector3D dir, float angle,
                  int resX, int resY) 
{
    // compute filename
    stringstream s;
    s << prefix << scene->timer.GetTime() << ".png";

    // print some debug info
    printf("render %s (%dx%d)\n", s.str().c_str(), resX, resY);

    // setup image
    Image img(resX, resY);

    // setup camera
    PerspectiveCamera camera(pos, dir, Vector3D(0,1,0), angle, resX, resY);

#ifdef MT_OPENMP
#pragma omp parallel
{
#pragma omp for schedule(dynamic) nowait
#endif

    // now render the scene
    for (int y=0; y < resY; y++) {
    for (int x=0; x < resX; x++) {
        // primary ray to trace
        Ray ray = camera.InitRay(x, y);

        // ray trace one pixel 
            ColorRGBA color = scene->RayTrace(ray);
            color.normalize();
            img.setPixel(color, x, y);
    }
    }

#ifdef MT_OPENMP
}
#endif

    // write final image
    img.WritePNG(s.str().c_str());
}

void RenderSupersampledFrame(Scene* scene, string prefix, 
                             Vector3D pos, Vector3D dir, float angle,
                             int resX, int resY, 
                             const SampleGenerator& sampler = SampleGenerator(), int sampleCount = 1)
{    
    // compute filename
    stringstream s;
    s << prefix << scene->timer.GetTime() << ".png";

    // print some debug info
    printf("render supersampled %s (%dx%d)\n", s.str().c_str(), resX, resY);

    // setup image
    Image img(resX, resY);

    // setup camera
    PerspectiveCamera camera(pos, dir, Vector3D(0,1,0), angle, resX, resY);

#ifdef MT_OPENMP
#pragma omp parallel
{
#endif

    // prepare for supersampling 
    float* xv = new float[sampleCount];
    float* yv = new float[sampleCount];
    float* weight = new float[sampleCount];

#ifdef MT_OPENMP
#pragma omp for schedule(dynamic) nowait
#endif

// now render the scene
    for (int y=0; y < resY; y++) {
    for (int x=0; x < resX; x++) {
        ColorRGBA color(0,0,0);
        sampler.GetSamples(sampleCount, xv, yv, weight);
        for (int s=0; s < sampleCount; s++) {
            // primary ray to trace
        Ray ray = camera.InitRay(x + xv[s], y + yv[s]);

        // ray trace one pixel (supersampled)
        color = color + weight[s] * scene->RayTrace(ray);
        }
        color.normalize(); 
        img.setPixel(color, x, y);
    }
    }

    // cleanup
    delete [] xv;
    delete [] yv;
    delete [] weight;

#ifdef MT_OPENMP
}
#endif

    // write final image
    img.WritePNG(s.str().c_str());
}

void RenderDepthOfFieldFrame(Scene* scene, string prefix, 
                             Vector3D pos, Vector3D dir, float angle,
                             int resX, int resY, 
                             float lensRadius, float focalDistance,
                             const SampleGenerator& sampler = SampleGenerator(), int sampleCount = 1)
{    
    // compute filename
    stringstream s;
    s << prefix << scene->timer.GetTime() << ".png";

    // print some debug info
    printf("render %s (%dx%d)\n", s.str().c_str(), resX, resY);

    // setup image
    Image img(resX, resY);

#ifdef MT_OPENMP
#pragma omp parallel
{
#endif

    // prepare for supersampling 
    float* xv = new float[sampleCount];
    float* yv = new float[sampleCount];
    float* weight = new float[sampleCount];

#ifdef MT_OPENMP
#pragma omp for schedule(dynamic) nowait
#endif

    // now render the scene
    for (int y=0; y < resY; y++) {
    for (int x=0; x < resX; x++) {
        ColorRGBA color(0,0,0);
        sampler.GetSamples(sampleCount, xv, yv, weight);
        for (int s=0; s < sampleCount; s++) {
                // setup camera
                DepthOfFieldCamera camera(pos, dir, Vector3D(0,1,0), angle, resX, resY, lensRadius, focalDistance, xv[s], yv[s]);

            // primary ray to trace
        Ray ray = camera.InitRay(x, y);

        // ray trace one pixel (supersampled)
        color = color + weight[s] * scene->RayTrace(ray);
        }
        color.normalize(); 
        img.setPixel(color, x, y);
    }
    }

    // cleanup
    delete [] xv;
    delete [] yv;
    delete [] weight;

#ifdef MT_OPENMP
}
#endif

    // write final image
    img.WritePNG(s.str().c_str());
}


void RenderLinearFramePath (Scene* scene, string prefix,
                            Vector3D pos, Vector3D dir, float angle,
                            int resX, int resY, 
                            Vector3D path, int times)
{
    // setup image
    Image img(resX, resY);

    for (int i=0; i < times; i++) {
        // compute filename
        stringstream s;
        s << prefix << scene->timer.GetTime() << ".png";

        // print some debug info
        printf("render %s (%dx%d)\n", s.str().c_str(), resX, resY);

        // setup camera
        PerspectiveCamera camera(pos + i * path, dir, Vector3D(0,1,0), angle, resX, resY);

#ifdef MT_OPENMP
#pragma omp parallel
{
#pragma omp for schedule(dynamic) nowait
#endif

        // now render the scene
        for (int y=0; y < resY; y++) {
        for (int x=0; x < resX; x++) {
            // primary ray to trace
                Ray ray = camera.InitRay(x, y);
    
            // ray trace one pixel 
                ColorRGBA color = scene->RayTrace(ray);
                color.normalize();
                img.setPixel(color, x, y);
            }
        }

#ifdef MT_OPENMP
}
#endif

    // write final image
    img.WritePNG(s.str().c_str());
    
    // next tick
    scene->timer.Tick();
    }
}
    
void RenderStereoFrame (Scene* scene, string prefix,
                        Vector3D pos, Vector3D dir, float angle,
                        int resX, int resY,
                        float distance = 0.01f) 
{
    // compute filename
    stringstream s;
    s << prefix << scene->timer.GetTime() << ".png";

    // print some debug info
    printf("render %s (%dx%d)\n", s.str().c_str(), resX, resY);

    // setup image
    Image img(resX, resY);

    // setup cameras
    Vector3D greenpos = pos + Vector3D(distance,0,0);
    Vector3D greendir = (pos + dir) - greenpos;
    PerspectiveCamera red(pos, dir, Vector3D(0,1,0), angle, resX, resY);
    PerspectiveCamera green(greenpos, greendir, Vector3D(0,1,0), angle, resX, resY);
    
#ifdef MT_OPENMP
#pragma omp parallel
{
#pragma omp for schedule(dynamic) nowait
#endif

    // now render the scene
    for (int y=0; y < resY; y++) {
    for (int x=0; x < resX; x++) {
        // primary ray to trace
        Ray redray = red.InitRay(x, y);
        Ray greenray = green.InitRay(x, y);
        
            // ray trace one pixel 
            ColorRGBA color;
            color.red() = scene->RayTrace(redray).average();
            color.green() = scene->RayTrace(greenray).average();
            color.normalize();
            img.setPixel(color, x, y);
    }
    }
                         
#ifdef MT_OPENMP
}
#endif

    // write final image
    img.WritePNG(s.str().c_str());
}

void moveSphere(Sphere* sphere, float deltaRadius, float rotAngle, Vector3D posOffset)
{
    rotAngle *= M_PI / 180;
    sphere->ChangeRadius(deltaRadius);
    Vector3D pos = sphere->GetPosition();
    sphere->SetPosition(Vector3D(posOffset.x() + (cos(rotAngle)*pos.x() + sin(rotAngle)*pos.z()), posOffset.y() + pos.y(), posOffset.z() + (-sin(rotAngle)*pos.x() + cos(rotAngle)*pos.z())));
}

Vector3D rotateVec(Vector3D vec, float rotAngle)
{
    rotAngle *= M_PI / 180;
    return Vector3D((cos(rotAngle)*vec.x() + sin(rotAngle)*vec.z()), vec.y(), (-sin(rotAngle)*vec.x() + cos(rotAngle)*vec.z()));
}

void hideSphere(Sphere* sphere)
{
    sphere->SetRadius(0.0);
}
 
#define USE_KDTREE 1

#define USE_KDTREE 1
int main (int argc, char **argv)
{
    int resX, resY;
    if (argc > 2) {
        resX = atoi(argv[1]);
        resY = atoi(argv[2]);
    } else {
        resX = 320;
        resY = 256;
    }

//  place scene description here
//
    Scene* scene = new Scene();
    scene->setBgColor(Vector3D(0,0,0));
//  
//  setup lights
//
    QuadAreaLight* light1 = new QuadAreaLight(ColorRGBA(250.0,250.0,250.0), Vector3D(0.1, 10.03, -20.2), Vector3D(2.0,0,0), Vector3D(0,1.5,1.5));
    PointLight* light2 = new PointLight(Vector3D(0, 10, 0), ColorRGBA(25));

    light1->SetNumberOfRays(25);
    scene->AddLight(light1);
    scene->AddLight(light2);
    scene->castShadows = true;
//
//  setup cow 
//    
    Object* cow = AddObject("mesh/cow.obj", *scene, USE_KDTREE, Object::TexturedSmoothTriangleFactory());
    Texture* cowtex = new Texture2D("textures/cowspots.png");
    Shader* cowshader1 = new PhongShader(scene, Vector3D(0.8, 0.7, 0.6), 0, 0.8, 0.4, 12.0);
    cowshader1->addTexture(cowtex);
    Shader* cowshader2 = new BumpMappedWoodPhongShader(scene, ColorRGBA(0.9,0.9,1), 0, 1, 0, 0.5, cowtex, 0.2, Vector3D(0,0,0));
    Shader* cowshader3 = new PlasmaShader(scene);
    Shader* cowshader = new MixShader(scene, cowshader2, cowshader1);
    cow->setShader(cowshader1);
//
//  setup terrain
//
    Object* ground = AddObject("mesh/plane.obj", *scene, USE_KDTREE, Object::TexturedSmoothTriangleFactory());
    Texture* bumptex = new Texture2D("textures/bump.png");
    bumptex->setWrapMode(Texture::REPEAT);
    bumptex->setInterpolationMode(Texture::LINEAR);
    Texture* mixmap = new Texture2D("textures/mandala.png");
    mixmap->setWrapMode(Texture::REPEAT);
    mixmap->setInterpolationMode(Texture::LINEAR);
    Shader* groundshader3 = new GoldShader(scene); 
    Shader* groundshader2 = new PhongShader(scene, ColorRGBA(0.9,0.9,1), 0, 1, 0, 0.5); 
    Shader* groundshader1 = new BumpMappedMarblePhongShader(scene, ColorRGBA(0,0.4,0.25), 0, 1, 0, 0.5, bumptex, 0, Vector3D(0,0,0));
    Shader* groundshader = new MapShader(scene, groundshader3, groundshader1, mixmap);
    ground->setShader(groundshader1);
//
//  setup sky
//
    Object* sky = AddObject("mesh/skydome.obj", *scene, 0, Object::TexturedSmoothTriangleFactory());
//  Shader* skyshader = new PlasmaShader(scene);
    Shader* skyshader = new CloudShader(scene);
    sky->setShader(skyshader);
//
//  setup balls
//
    Object* b1 = AddSphere(Vector3D(-0.1,0.12,0.8), 0.05, *scene);
    Object* b2 = AddSphere(Vector3D(-0.1,0.11,0.6), 0.05, *scene);
    Object* b3 = AddSphere(Vector3D(-0.1,0.1,0.4), 0.05, *scene);
    Object* b4 = AddSphere(Vector3D(-0.1,0.065,0.2), 0.1, *scene);
    Object* b5 = AddSphere(Vector3D(-0.1,0.065,0.2), 0.05, *scene);
    Object* b6 = AddSphere(Vector3D(-0.1,0.05,-0.08), 0.05, *scene);
    Object* b7 = AddSphere(Vector3D(-0.1,0.04,-0.2), 0.05, *scene);
    Shader* s5 = new SilverShader(scene);
    Shader* s2 = new GoldShader(scene);
    Shader* s3 = new SteelShader(scene);
    Shader* s4 = new TransparentShader(scene, 1, 1.5);
    Shader* s1 = new BumpMappedWoodPhongShader(scene, ColorRGBA(0.9,0.9,1), 0, 1, 0, 0.5, bumptex, 0, Vector3D(0,0,0));
    Shader* s6 = new CopperShader(scene);
    Shader* s7 = new TransparentShader(scene, 1, 1.5);
    b1->setShader(s1);
    b2->setShader(s2);
    b3->setShader(s3);
    b4->setShader(s4);
    b5->setShader(s5);
    b6->setShader(s6);
    b7->setShader(s7);
//
//  end of scene description
   

//  actual rendering
//  RenderFrame(scene, "rf", Vector3D(0.35,0.1,-0.33), Vector3D(-0.1,-0.02,0.12), 60, resX, resY);
//  RenderFrame(scene, "map", Vector3D(0,3,0), Vector3D(0,-1,0), 60, resX, resY);
//  RenderSupersampledFrame(scene, "rssf", Vector3D(0.35,0.1,-0.33), Vector3D(-0.1,-0.02,0.12), 60, resX, resY, StratifiedSampleGenerator(), 16);
//  RenderStereoFrame(scene, "rsf", Vector3D(0.35,0.1,-0.33), Vector3D(-0.1,-0.02,0.12), 60, resX, resY);
    float fl = (cow->center - Vector3D(0.35,0.1,-0.33)).Length();
    RenderDepthOfFieldFrame(scene, "rdoff", Vector3D(0.35,0.1,-0.33), Vector3D(-0.1,-0.02,0.12), 60, resX, resY, 0.001, fl, RandomSampleGenerator(), 36);
//  RenderLinearFramePath(scene, "rlfp", Vector3D(0.35,0.1,-0.33), Vector3D(-0.1,-0.02,0.12), 60, resX, resY, Vector3D(0.01,0,0), 1000) ;


//  cleanup unused scene data
    delete cowtex;
    delete cowshader1;
    delete cowshader2;
    delete cowshader;
    delete bumptex;
    delete groundshader;
    delete skyshader;
    delete s1;
    delete s2;
    delete s3;
    delete scene;
}

---