src/Renderer.cpp

Go to the documentation of this file.

#include <pthread.h>
#include <string>
#include <sstream>
#include <iostream>
#include <iomanip>

#include "Renderer.h"

#include "Camera.h"
#include "MirrorShader.h"
#include "Object.h"
#include "PNGImage.h"
#include "PerspectiveCamera.h"
#include "PhongShader.h"
#include "PointLight.h"
#include "QuadAreaLight.h"
#include "RGBAColor.h"
#include "StratifiedSampleGenerator.h"
#include "Texture2D.h"
#include "TransparentShader.h"
#include "CloudShader.h"
#include "WoodShader.h"
#include "CombineShader.h"
#include "defines.h"
#include "SceneBuilder.h"
#include "OBJObject.h"
#include "CameraAnimator.h"


#include "DepthOfFieldCamera.h"

pthread_mutex_t mMutexImage;

Renderer::Renderer(const std::string & filename)
    :mCamera(NULL),
     mSupersampled(false),
     mSampleCount(1),
     mSampler(NULL),
     mFileName(filename),
     mCameraAnimator(NULL)
{
    //this shouldn't hurt
    srand(time(0));
    srand48(time(0));
}

Renderer::~Renderer()
{
    if (!mCameraAnimator)
        delete mCamera;
    delete mSampler;
    delete mCameraAnimator;
}

void Renderer::buildScene()
{
    buildTestScene();
}

void Renderer::render()
{
    std::cout << "Rendering...\n" << std::endl;
    PNGImage img(mCamera->resX(), mCamera->resY());
    
    int result;
    pthread_attr_t attribute;
    pthread_attr_init(&attribute);
    pthread_attr_setdetachstate(&attribute, PTHREAD_CREATE_JOINABLE);


    pthread_t threads[NUMBER_OF_THREADS+1];      //+1 here for safety, if we didn't catch every y (see the following if)
    ThreadArgs threadargs[NUMBER_OF_THREADS+1];
    pthread_mutex_init(&mMutexImage, NULL);

    const int ratio = (mCamera->resY()  ) / NUMBER_OF_THREADS;
    int start = 0;
    int stop = ratio;


//start threads
    for(int i=0; i<NUMBER_OF_THREADS; i++)
    {
        LOG("Threading Debug: start " << start << " stop: " << stop);
        threadargs[i].mStartY = start;
        threadargs[i].mStopY = stop;
        threadargs[i].mSupersampled = mSupersampled;
        threadargs[i].mSampleCount = mSampleCount;
        threadargs[i].mImage = &img;
        threadargs[i].mCamera = mCamera;
        threadargs[i].mScene = &mScene;
        threadargs[i].mSampler = mSampler;

        void* args = static_cast<void*>(&threadargs[i]);
        LOG("starting thread " << i );
        result = pthread_create(&threads[i], &attribute, &Renderer::renderFromTo, args );
        if(result)
            LOG("Some error in thread create");

        start += ratio;
        stop +=ratio;

    }
    stop -=ratio;
    bool notall = (stop!=mCamera->resY() );
    LOG("b: " << notall<<" " << stop << " c: " << mCamera->resY() );
    int realnumberofthreads = NUMBER_OF_THREADS;
    if(notall)
    {
        assert(false);
//TODO if we really need this we have to reconsider why there is a lag between the difference between the lines threads do and the lines thread not do
//perhaps this just happens on uneven numbers
/*        realnumberofthreads++;

        threadargs[NUMBER_OF_THREADS+1].mStartY = start;
        threadargs[NUMBER_OF_THREADS+1].mStopY = mCamera->resY();
        threadargs[NUMBER_OF_THREADS+1].mSupersampled = mSupersampled;
        threadargs[NUMBER_OF_THREADS+1].mSampleCount = mSampleCount;
        threadargs[NUMBER_OF_THREADS+1].mImage = &img;
        threadargs[NUMBER_OF_THREADS+1].mCamera = mCamera;
        threadargs[NUMBER_OF_THREADS+1].mScene = &mScene;
        threadargs[NUMBER_OF_THREADS+1].mSampler = mSampler;

        void* args = static_cast<void*>(&threadargs[0]);
        result = pthread_create(&threads[0], 0,&Renderer::renderFromTo, args );
        if(result)
            LOG("Some error in thread create");
*/
    }


//joining
    for(int i=0; i<realnumberofthreads; i++)
    {
        LOG("Thread Debug: Joining thread " << i);
        result = pthread_join(threads[i],0);
        if(result)
            LOG("Something wrong with joining");
    }

    LOG("writing file");
    pthread_mutex_destroy(&mMutexImage);

    std::cout << "Writing to \"" << mFileName << "\"\n" << std::endl;
    img.write(mFileName);
}

void* Renderer::renderFromTo(void* threadargs)
{
    assert(threadargs!=0);

    ThreadArgs* args = static_cast<ThreadArgs*>(threadargs);
    Camera* camera = args->mCamera;
    Image* image = args->mImage;
    Scene* scene = args->mScene;
    SampleGenerator* sampler = args->mSampler;

    assert(camera!=0);
    assert(image!=0);
    assert(scene!=0);


    LOG("Threading Debug: Rendering in thread from: " << args->mStartY << " to:" << args->mStopY);
    if(!args->mSupersampled)
    {
        for(int y=args->mStartY; y < args->mStopY; y++)
        {
            for(int x=0; x<camera->resX(); x++)
            {
                RGBAColor colorvalue;
                for(int i=0; i<camera->depthSamples(); i++)
                {
                    Ray ray = camera->initRay(x, y);
                    colorvalue += min(max( scene->rayTrace(ray), RGBAColor(0)), RGBAColor(1) );
                }
                colorvalue = colorvalue / camera->depthSamples();

                pthread_mutex_lock(&mMutexImage);
                image->setPixel(min(max( colorvalue, RGBAColor(0, 0, 0, 1)), RGBAColor(1)), x, y);
                pthread_mutex_unlock(&mMutexImage);
            }
            if (y%100 == 99)
            {
                LOG(y+1 << " / " << camera->resY());
            }
        }
    }
    else
    {
        assert(sampler!=0);
        LOG("SUPERSAMPLED");
        //FIXME i think this is bad, but at the moment we don't have a const mSampleCount
        float * u = new float[args->mSampleCount];
        float * v = new float[args->mSampleCount];
        float * w = new float[args->mSampleCount];
        
        // render the scene
        for (int y=args->mStartY; y < args->mStopY ; y++)
        {
            for (int x=0; x < camera->resX(); x++)
            {
                // init samples
                sampler->samples(args->mSampleCount, u, v, w);
                RGBAColor color;
                for (int i=0; i<args->mSampleCount; i++)
                {
                    RGBAColor depthcolor;
                    for(int k=0; k<camera->depthSamples(); k++)
                    {
                        float xpos = static_cast<float>(x) + u[i] - 0.5f;
                        float ypos = static_cast<float>(y) + v[i] - 0.5f;
                        Ray ray = camera->initRay(xpos, ypos);
                        depthcolor += scene->rayTrace(ray);
                    }
                    depthcolor = depthcolor /  camera->depthSamples();
                    color += depthcolor * w[i];
                }
                pthread_mutex_lock(&mMutexImage);
                image->setPixel(min(max( color, RGBAColor(0, 0, 0, 1)), RGBAColor(1)), x, y);
                pthread_mutex_unlock(&mMutexImage);

            }
            if (y%50 == 49)
            {
                LOG(y+1 << " / " << camera->resY());
            }
        }

        delete [] u;
        delete [] v;
        delete [] w;
    }
    LOG("finished thread from " << args->mStartY << " to " << args->mStopY);
    pthread_exit(0);
}


void Renderer::renderAnimated()
{
    assert(mCameraAnimator!=0);
    std::string prefix = "vid/";
    for(unsigned int i=0;i<mStartFrame;i++)
    {
        LOG("skipping frame: " << i);
        // apply animations
        mCameraAnimator->animate();
        mScene.step();
    }
    delete mCamera;
    for(unsigned int i=mStartFrame;i<mEndFrame;i++)
    {
        LOG("rendering frame: " << i);
        std::stringstream stream;
        stream << prefix << std::setw(5) << std::setfill('0') << i << ".png";
        mFileName = stream.str();

        // apply camera animation
        Camera* newcam = mCameraAnimator->animate();
        mCamera = newcam;

        // apply physics and object animations
        mScene.step();

        LOG("Frame " << i << " ...");
        render();
    }
}


//if more than once called we have memory leaks
void Renderer::buildTestScene()
{
    const bool depthoffield     = false;    // depth of field test scene
    const bool bumpmapping      = false;    // bump mapping test scene
    const bool cooktorrance     = false;    // cook torrance test scene
    const bool woodshader       = false;    // wood shader test scene
    const bool gun              = false;    // gun for sah testing
    const bool supersampling    = false;    // for super-sampling
    const bool buddha           = false;    // happy Buddha model for sah benching
    const bool refractive       = true;    // refractive shader test scene
    const bool terrain          = false;    // scene from MicroTrace05
    const bool balls            = false;    // test scene for balls
    const bool table            = true;     // blubb
    //super sampling
    if (supersampling || terrain)
    {
        setupSupersampling(9);
    }

    if (depthoffield)
    {
        buildScene("scene/depthoffield.scene");
        return;
    }

    if (bumpmapping)
    {
        buildScene("scene/bumpmapping.scene");
        return;
    }

    if (cooktorrance)
    {
        buildScene("scene/cooktorrance.scene");
        return;
    }

    if (woodshader)
    {
        buildScene("scene/woodshader.scene");
        return;
    }

    if (gun)
    {
        buildScene("scene/gun-54642-tris.scene");
        return;
    }

    if (buddha)
    {
        buildScene("scene/happy-buddha.scene");
        return;
    }

    if (refractive)
    {
        buildScene("scene/refractive.scene");
        return;
    }

    if (terrain)
    {
        buildScene("scene/terrain.scene");
        return;
    }

    if (balls)
    {
        buildScene("scene/ballstest.scene");
        return;
    }

    if (table)
    {
        buildScene("scene/billiard-table.scene");
        return;
    }

    // normal cow
    buildScene("scene/test.scene");
}


void Renderer::buildScene(const std::string & sceneFile)
{
    std::cout << "Building scene \"" << sceneFile << "\"\n" << std::endl;
    SceneBuilder builder;
    delete mCamera;
    mCamera = NULL;
    builder.load(mScene, mCamera, sceneFile);
}


void Renderer::setupAnimation(std::string filename, unsigned int startframe, unsigned int endframe)
{
    mCameraAnimator = new CameraAnimator(filename);
    mStartFrame = startframe;
    mEndFrame = endframe;
}


int Renderer::setupSupersampling(int samples)
{
    delete mSampler;
    if (samples >= 4)
    {
        mSampler        = new StratifiedSampleGenerator();
        mSupersampled   = true;
        mSampleCount    = static_cast<int>(floorf(sqrtf(samples)));
        mSampleCount    *= mSampleCount;
    }
    else
    {
        mSampler        = NULL;
        mSupersampled   = false;
        mSampleCount    = 1;
    }
    return mSampleCount;
}

---