source: GTP/trunk/App/Demos/Vis/FriendlyCulling/src/DeferredRenderer.cpp @ 3222

#include "DeferredRenderer.h"
#include "FrameBufferObject.h"
#include "RenderState.h"
#include "SampleGenerator.h"
#include "Vector3.h"
#include "Camera.h"
#include "shaderenv.h"
#include "Halton.h"
#include "ShadowMapping.h"
#include "Light.h"
#include "ShaderManager.h"
#include "Texture.h"

#include <math.h>

#include <IL/il.h>
#include <assert.h>


#ifdef _CRT_SET
        #define _CRTDBG_MAP_ALLOC
        #include <stdlib.h>
        #include <crtdbg.h>

        // redefine new operator
        #define DEBUG_NEW new(_NORMAL_BLOCK, __FILE__, __LINE__)
        #define new DEBUG_NEW
#endif


using namespace std;


static void startil()
{
        ilInit();
        assert(ilGetError() == IL_NO_ERROR);
}


static void stopil()
{
        ilShutDown();
        assert(ilGetError() == IL_NO_ERROR);
}


namespace CHCDemoEngine
{

static ShaderProgram *sCgSsaoProgram = NULL;
static ShaderProgram *sCgGiProgram = NULL;

static ShaderProgram *sCgDeferredProgram = NULL;
static ShaderProgram *sCgAntiAliasingProgram = NULL;
static ShaderProgram *sCgDeferredShadowProgram = NULL;

static ShaderProgram *sCgCombineSsaoProgram = NULL;
static ShaderProgram *sCgCombineIllumProgram = NULL;
static ShaderProgram *sCgLogLumProgram = NULL;
static ShaderProgram *sCgToneProgram = NULL;
static ShaderProgram *sCgDownSampleProgram = NULL;
static ShaderProgram *sCgScaleDepthProgram = NULL;
static ShaderProgram *sCgPrepareSsaoProgram = NULL;
static ShaderProgram *sCgLenseFlareProgram = NULL;


static GLuint noiseTex2D = 0;
static GLuint noiseTex1D = 0;


// ssao random spherical samples
static Sample2 samples2[NUM_SAMPLES];
// number of pcf tabs
static Sample2 pcfSamples[NUM_PCF_TABS];


static float ssaoFilterOffsets[NUM_SSAO_FILTER_SAMPLES * 2];
static float ssaoFilterWeights[NUM_SSAO_FILTER_SAMPLES];

static Texture *sHaloTex[5];

int DeferredRenderer::colorBufferIdx = 0;




/** Helper method that computes the view vectors in the corners of the current view frustum.
*/
static void ComputeViewVectors(PerspectiveCamera *cam, Vector3 &bl, Vector3 &br, Vector3 &tl, Vector3 &tr)
{
        Vector3 ftl, ftr, fbl, fbr, ntl, ntr, nbl, nbr;
        cam->ComputePoints(ftl, ftr, fbl, fbr, ntl, ntr, nbl, nbr);

        bl = Normalize(nbl - fbl);
        br = Normalize(nbr - fbr);
        tl = Normalize(ntl - ftl);
        tr = Normalize(ntr - ftr);
}


static float GaussianDistribution(float x, float y, float rho)
{
        float g = 1.0f / sqrtf(2.0f * M_PI * rho * rho);
    g *= expf( -(x * x + y * y) / (2.0f * rho * rho));

    return g;
}


static void PrintGLerror(char *msg)
{
        GLenum errCode;
        const GLubyte *errStr;
        
        if ((errCode = glGetError()) != GL_NO_ERROR) 
        {
                errStr = gluErrorString(errCode);
                fprintf(stderr,"OpenGL ERROR: %s: %s\n", errStr, msg);
        }
}


static Sample2 UnitTest(float x, float y, int wi, int he)
{
        Sample2 s;

        s.x = float(floor(x * (float)wi - 0.5f) + 1.0f) / (float)wi;
        s.y = float(floor(y * (float)he - 0.5f) + 1.0f) / (float)he;

        return s;
}


static void ComputeSampleOffsets(float *sampleOffsets, 
                                                                 int imageW, int imageH,
                                                                 float width, 
                                                                 int samples)
{
        const float xoffs = width / (float)imageW;
        const float yoffs = width / (float)imageH;
        
        const int numSamples = (int)sqrt((float)samples);
        const int startSamples = -numSamples / 2;
        const int endSamples = numSamples + startSamples - 1;
        //cout << startSamples << " " << endSamples << endl;

        int idx = 0;

        for (int x = startSamples; x <= endSamples; ++ x)
        {
                for (int y = startSamples; y <= endSamples; ++ y)
                {
                        sampleOffsets[idx + 0] = (float)x * xoffs;
                        sampleOffsets[idx + 1] = (float)y * yoffs;
                        idx += 2;
                }
        }
}


void DeferredRenderer::FlipFbos(FrameBufferObject *fbo)
{
        fbo->Bind();
        colorBufferIdx = 3 - colorBufferIdx;
        glDrawBuffers(1, mrt + colorBufferIdx);
}


void DeferredRenderer::DrawQuad(ShaderProgram *p)
{
        if (p) p->Bind();

        // interpolate the view vector
        Vector3 bl = mCornersView[0];
        Vector3 br = mCornersView[1];
        Vector3 tl = mCornersView[2];
        Vector3 tr = mCornersView[3];

        // note: slightly larger texture could hide ambient occlusion error on border but costs resolution
        glBegin(GL_QUADS);

        glTexCoord2f(0, 0); glMultiTexCoord3fARB(GL_TEXTURE1_ARB, bl.x, bl.y, bl.z); glVertex2f( .0f,  .0f);
        glTexCoord2f(1, 0); glMultiTexCoord3fARB(GL_TEXTURE1_ARB, br.x, br.y, br.z); glVertex2f(1.0f,  .0f);
        glTexCoord2f(1, 1); glMultiTexCoord3fARB(GL_TEXTURE1_ARB, tr.x, tr.y, tr.z); glVertex2f(1.0f, 1.0f);
        glTexCoord2f(0, 1); glMultiTexCoord3fARB(GL_TEXTURE1_ARB, tl.x, tl.y, tl.z); glVertex2f( .0f, 1.0f);

        glEnd();
}


/** Generate poisson disc distributed sample points on the unit disc
*/
static void GenerateSamples(int sampling)
{
        switch (sampling)
        {
        case DeferredRenderer::SAMPLING_POISSON:
                {
                        PoissonDiscSampleGenerator2 poisson(NUM_SAMPLES, 1.0f);
                        poisson.Generate((float *)samples2);
                }
                break;
        case DeferredRenderer::SAMPLING_QUADRATIC:
                {
                        QuadraticDiscSampleGenerator2 g(NUM_SAMPLES, 1.0f);
                        g.Generate((float *)samples2);
                }
                break;
        default: // SAMPLING_DEFAULT
                {
                        RandomSampleGenerator2 g(NUM_SAMPLES, 1.0f);
                        g.Generate((float *)samples2);
                }
        }
}


static void CreateNoiseTex2D(int w, int h)
{
        //GLubyte *randomNormals = new GLubyte[mWidth * mHeight * 3];
        float *randomNormals = new float[w * h * 3];

        static HaltonSequence halton;
        float r[2];

        for (int i = 0; i < w * h * 3; i += 3)
        {
                // create random samples on a circle
                r[0] = RandomValue(0, 1);
                //halton.GetNext(1, r);

                const float theta = 2.0f * acos(sqrt(1.0f - r[0]));
                
                randomNormals[i + 0] = cos(theta);
                randomNormals[i + 1] = sin(theta);
                randomNormals[i + 2] = 0;
        }

        glEnable(GL_TEXTURE_2D);
        glGenTextures(1, &noiseTex2D);
        glBindTexture(GL_TEXTURE_2D, noiseTex2D);
                
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);

        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA16F_ARB, w, h, 0, GL_RGB, GL_FLOAT, randomNormals);

        glBindTexture(GL_TEXTURE_2D, 0);
        glDisable(GL_TEXTURE_2D);

        delete [] randomNormals;

        cout << "created noise texture" << endl;

        PrintGLerror("noisetexture");
}


static void CreateNoiseTex1D(int w)
{
        float *randomValues = new float[w * 3];

        static HaltonSequence halton;
        
        randomValues[0] = randomValues[1] = randomValues[2] = 0;

        for (int i = 3; i < w * 3; i += 3)
        {
                // create random samples on a circle
                randomValues[i + 0] = 20.0f * RandomValue(0, 1) / 512.0f;
                randomValues[i + 1] = 20.0f * RandomValue(0, 1) / 384.0f;
                randomValues[i + 2] = 0;
        }

        glEnable(GL_TEXTURE_2D);
        glGenTextures(1, &noiseTex1D);
        glBindTexture(GL_TEXTURE_2D, noiseTex1D);
                
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);

        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA16F_ARB, w, 1, 0, GL_RGB, GL_FLOAT, randomValues);

        glBindTexture(GL_TEXTURE_2D, 0);
        glDisable(GL_TEXTURE_2D);

        delete [] randomValues;

        cout << "created noise texture 1D" << endl;

        PrintGLerror("noisetexture 1D");
}


static void PrepareLenseFlare()
{
        string textures[] = {"flare4.tga", "lens2.jpg", "lens3.jpg", "lens4.jpg", "lens1.jpg"};

        for (int i = 0; i < 5; ++ i)
        {
                sHaloTex[i] = new Texture(model_path + textures[i]);

                sHaloTex[i]->SetBoundaryModeS(Texture::BORDER);
                sHaloTex[i]->SetBoundaryModeT(Texture::BORDER);

                sHaloTex[i]->Create();
        }

        cout << "prepared lense flare textures" << endl;

        PrintGLerror("prepare lense flare");
}


DeferredRenderer::DeferredRenderer(int w, int h, 
                                                                   PerspectiveCamera *cam,
                                                                   bool ssaoUseFullResolution):
mWidth(w), mHeight(h), 
mCamera(cam),
mUseTemporalCoherence(true),
mRegenerateSamples(true),
mSamplingMethod(SAMPLING_POISSON),
mShadingMethod(DEFAULT),
mIllumFboIndex(0),
mSortSamples(true),
mKernelRadius(1e-8f),
mSsaoFilterRadius(12.0f),
mSampleIntensity(0.2f),
mSunVisiblePixels(0),
mSavedFrameNumber(-1),
mSavedFrameSuffix("")
{
        ///////////
        //-- the flip-flop fbos

        int downSampledWidth, downSampledHeight;

        if (ssaoUseFullResolution)
        {
                downSampledWidth = w; downSampledHeight = h;
                cout << "using full resolution ssao" << endl;
        }
        else
        {
                downSampledWidth = w / 2; downSampledHeight = h / 2;
                cout << "using half resolution ssao" << endl;
        }

        mIllumFbo = new FrameBufferObject(downSampledWidth, downSampledHeight, FrameBufferObject::DEPTH_NONE);
        //mIllumFbo = new FrameBufferObject(w, h, FrameBufferObject::DEPTH_NONE);

        mFBOs.push_back(mIllumFbo);

        for (int i = 0; i < 4; ++ i)
        {
                mIllumFbo->AddColorBuffer(ColorBufferObject::RGBA_FLOAT_32, ColorBufferObject::WRAP_CLAMP_TO_EDGE, ColorBufferObject::FILTER_LINEAR);
                FrameBufferObject::InitBuffer(mIllumFbo, i);
        }


        ///////////////
        //-- the downsampled ssao + color bleeding textures: 
        //-- as GI is mostly low frequency, we can use lower resolution toimprove performance

        mDownSampleFbo = new FrameBufferObject(downSampledWidth, downSampledHeight, FrameBufferObject::DEPTH_NONE);
        // the downsampled color + depth buffer
        mDownSampleFbo->AddColorBuffer(ColorBufferObject::RGBA_FLOAT_32, ColorBufferObject::WRAP_CLAMP_TO_EDGE, ColorBufferObject::FILTER_LINEAR);
        // downsample buffer for the normal texture
        mDownSampleFbo->AddColorBuffer(ColorBufferObject::RGB_FLOAT_16, ColorBufferObject::WRAP_CLAMP_TO_EDGE, ColorBufferObject::FILTER_LINEAR);


        for (int i = 0; i < 2; ++ i)
        {
                FrameBufferObject::InitBuffer(mDownSampleFbo, i);
        }

        mFBOs.push_back(mDownSampleFbo);

        // create noise texture for ssao
        // for performance reasons we use a smaller texture and repeat it over the screen
        CreateNoiseTex2D(mIllumFbo->GetWidth() / 4, mIllumFbo->GetWidth() / 4);
        
        mProjViewMatrix = IdentityMatrix();
        mOldProjViewMatrix = IdentityMatrix();

        for (int i = 0; i < 4; ++ i)
        {
                mCornersView[i] = mOldCornersView[i] = Vector3::UNIT_X();
        }

        mEyePos = mOldEyePos = Vector3::ZERO();

        PrepareLenseFlare();

        InitCg();
}


DeferredRenderer::~DeferredRenderer() 
{
        CLEAR_CONTAINER(mFBOs);

        glDeleteTextures(1, &noiseTex2D);
        glDeleteTextures(1, &noiseTex1D);
}


void DeferredRenderer::InitCg()
{       
        ShaderManager *sm = ShaderManager::GetSingleton();

        sCgDeferredProgram = sm->CreateFragmentProgram("deferred", "main", "DeferredFrag");
        sCgDeferredShadowProgram = sm->CreateFragmentProgram("deferred", "main_shadow", "DeferredFragShadow");
        sCgSsaoProgram = sm->CreateFragmentProgram("ssao", "main", "SsaoFrag");
        sCgGiProgram = sm->CreateFragmentProgram("globillum", "main", "GiFrag");
        sCgCombineIllumProgram = sm->CreateFragmentProgram("globillum", "combine", "CombineGi");
        sCgCombineSsaoProgram = sm->CreateFragmentProgram("combineSsao", "CombineSsaoHalfRes", "CombineSsao");
        sCgAntiAliasingProgram = sm->CreateFragmentProgram("antialiasing", "main", "AntiAliasing");
        sCgToneProgram = sm->CreateFragmentProgram("tonemap", "ToneMap", "ToneMap");
        sCgDownSampleProgram = sm->CreateFragmentProgram("deferred", "Output", "Output");
        sCgScaleDepthProgram = sm->CreateFragmentProgram("deferred", "ScaleDepth", "ScaleDepth");
        sCgLogLumProgram = sm->CreateFragmentProgram("tonemap", "CalcAvgLogLum", "AvgLogLum");
        sCgPrepareSsaoProgram = sm->CreateFragmentProgram("deferred", "PrepareSsao", "PrepareSsao");
        sCgLenseFlareProgram = sm->CreateFragmentProgram("lenseFlare", "LenseFlare", "LenseFlare");


        ///////////////////
        //-- initialize program parameters

        string ssaoParams[] = 
                {"colors", "normals", "oldTex", "noiseTex", "temporalCoherence", 
                 "samples", "bl", "br", "tl", "tr", 
                 "modelViewProj", "oldModelViewProj", "oldEyePos", "oldbl", "oldbr", 
                 "oldtl", "oldtr", "attribsTex", "kernelRadius", "sampleIntensity"};
        sCgSsaoProgram->AddParameters(ssaoParams, 0, 20);
        
        string giParams[] = 
                {"colors", "normals", "noiseTex", "oldSsaoTex", "oldIllumTex", 
                 "temporalCoherence", "samples", "bl", "br", "tl", 
                 "tr", "oldModelViewProj", "modelViewProj"};
        sCgGiProgram->AddParameters(giParams, 0, 13);

        string toneParams[] = {"colors", "imageKey", "whiteLum", "middleGrey"};
        sCgToneProgram->AddParameters(toneParams, 0, 4);


        ////////////////

        string deferredShadowParams[] = 
                {"colors", "normals", "shadowMap", "noiseTex", "shadowMatrix", 
                 "sampleWidth", "lightDir", "eyePos", "samples", "weights"};
        
        sCgDeferredShadowProgram->AddParameters(deferredShadowParams, 0, 10);
        
        ////////////////

        string combineIllumParams[] = {"colorsTex", "ssaoTex", "illumTex"};
        sCgCombineIllumProgram->AddParameters(combineIllumParams, 0, 3);

        ////////////////

        string combineSsaoParams[] = 
                {"colorsTex", "normalsTex", "ssaoTex", "filterOffs", "filterWeights", 
                "ssaoFilterRadius", "modelViewProj", "bl", "br", "tl", 
                "tr", "w", "h"};
        sCgCombineSsaoProgram->AddParameters(combineSsaoParams, 0, 13);

        //////////////

        string deferredParams[] = {"colors", "normals", "lightDir"};
        sCgDeferredProgram->AddParameters(deferredParams, 0, 3);

        ///////////////////

        string aaParams[] = {"colors", "normals", "offsets"};
        sCgAntiAliasingProgram->AddParameters(aaParams, 0, 3);

        /////////////////////

        string downSampleParams[] = {"colors"};
        sCgDownSampleProgram->AddParameters(downSampleParams, 0, 1);

        /////////////////////

        string scaleDepthParams[] = {"colors"};
        sCgScaleDepthProgram->AddParameters(scaleDepthParams, 0, 1);

        ////////////

        sCgLogLumProgram->AddParameter("colors", 0);

        ////////////////

        
        string prepareSsaoParams[] = 
                {"colorsTex", "normalsTex", "diffVals", "oldTex", 
                 "oldEyePos", "modelViewProj", "oldModelViewProj",
                 "oldbl", "oldbr", "oldtl", "oldtr"};

        sCgPrepareSsaoProgram->AddParameters(prepareSsaoParams, 0, 11);


        ////////////////

        
        string lenseFlareParams[] = 
                {"colorsTex", "flareTex1", "flareTex2", "flareTex3", "flareTex4", 
                 "flareTex5", "vectorToLight", "distanceToLight", "sunVisiblePixels"};

        sCgLenseFlareProgram->AddParameters(lenseFlareParams, 0, 9);


        ////////////////
        //-- prepare filters for ssao

        PrepareSsaoFilter();


        /////////
        //-- pcf tabs for shadowing

        float filterWeights[NUM_PCF_TABS];
        PoissonDiscSampleGenerator2 poisson2(NUM_PCF_TABS, 1.0f);
        poisson2.Generate((float *)pcfSamples);

        for (int i = 0; i < NUM_PCF_TABS; ++ i)
        {
                filterWeights[i] = GaussianDistribution(pcfSamples[i].x, pcfSamples[i].y, 1.0f);
        }

        sCgDeferredShadowProgram->SetArray2f(8, (float *)pcfSamples, NUM_PCF_TABS);
        sCgDeferredShadowProgram->SetArray1f(9, (float *)filterWeights, NUM_PCF_TABS);

        PrintGLerror("init");
}


void DeferredRenderer::Render(FrameBufferObject *fbo, 
                                                          float tempCohFactor,
                                                          DirectionalLight *light,
                                                          bool useToneMapping,
                                                          bool useAntiAliasing,
                                                          ShadowMap *shadowMap
                                                          )
{
        InitFrame();

        if (shadowMap)
                FirstPassShadow(fbo, light, shadowMap);
        else
                FirstPass(fbo, light);

        if (mShadingMethod != 0)
        {
                PrepareSsao(fbo); // downsample fbo buffers
        }

        // q: use antialiasing before or after ssao?
        //if (useAntiAliasing) AntiAliasing(fbo, light);

        switch (mShadingMethod)
        {
        case SSAO:
                ComputeSsao(fbo, tempCohFactor);
                CombineSsao(fbo);
                break;
        case GI:
                ComputeGlobIllum(fbo, tempCohFactor);
                CombineIllum(fbo);
                break;
        default:
                // do nothing: standard deferred shading
                break;
        }

        if (useToneMapping)
        {
                float imageKey, whiteLum, middleGrey;

                ComputeToneParameters(fbo, light, imageKey, whiteLum, middleGrey);
                ToneMap(fbo, imageKey, whiteLum, middleGrey);
        }

        /// compute lense flare
        LenseFlare(fbo, light);

        const bool saveFrame = (mSavedFrameNumber != -1);
        const bool displayAfterAA = !saveFrame;

        // multisampling is difficult / costly with deferred shading
        // at least do some edge blurring 
        if (useAntiAliasing) AntiAliasing(fbo, light, displayAfterAA); 
        
        /// store the current frame
        if (saveFrame) SaveFrame(fbo);

        // if it hasn't been done yet => just output the latest buffer
        if (!useAntiAliasing || !displayAfterAA)
                Output(fbo); 

        glEnable(GL_LIGHTING);
        glDisable(GL_TEXTURE_2D);

        glMatrixMode(GL_PROJECTION);
        glPopMatrix();

        glMatrixMode(GL_MODELVIEW);
        glPopMatrix();

        // viewport
        glPopAttrib();

        FrameBufferObject::Release();
        ShaderManager::GetSingleton()->DisableFragmentProfile();
}


void DeferredRenderer::PrepareSsaoFilter()
{
        const float filterWidth = 1.0f;

        PoissonDiscSampleGenerator2 poisson(NUM_SSAO_FILTER_SAMPLES, 1.0f);
        poisson.Generate((float *)ssaoFilterOffsets);

        const float xoffs = (float)filterWidth / mWidth;
        const float yoffs = (float)filterWidth / mHeight;

        for (int i = 0; i < NUM_SSAO_FILTER_SAMPLES; ++ i)
        {
                float x = ssaoFilterOffsets[2 * i + 0];
                float y = ssaoFilterOffsets[2 * i + 1];

                ssaoFilterWeights[i] = GaussianDistribution(x, y, 1.0f);
                //ssaoFilterWeights[i] = 1.0f;

                ssaoFilterOffsets[2 * i + 0] *= xoffs;
                ssaoFilterOffsets[2 * i + 1] *= yoffs;
        }
}


static inline float SqrMag(const Sample2 &s)
{
        return (s.x * s.x + s.y * s.y);
}


static inline float SqrDist(const Sample2 &a, const Sample2 &b)
{
        float x = a.x - b.x;
        float y = a.y - b.y;
        
        return x * x + y * y;
}


static inline bool lt(const Sample2 &a, const Sample2 &b)
{
        return SqrMag(a) < SqrMag(b);
}


void DeferredRenderer::SortSamples()
{
        static Sample2 tempSamples[NUM_SAMPLES];
        static bool checked[NUM_SAMPLES];

        for (int i = 0; i < NUM_SAMPLES; ++ i)
                checked[i] = false;

        Sample2 currentSample;
        currentSample.x = 0; currentSample.y = 0;
        int ns = 0; // the next sample index

        for (int i = 0; i < NUM_SAMPLES; ++ i)
        {
                float minLen = 1e20f;

                for (int j = 0; j < NUM_SAMPLES; ++ j)
                {
                        if (checked[j]) continue;

                        Sample2 s = samples2[j];
                        const float len = SqrDist(s, currentSample);

                        if (len < minLen) 
                        {
                                minLen = len;
                                ns = j;
                        }
                }

                tempSamples[i] = samples2[ns];
                currentSample = samples2[ns];
                checked[ns] = true;
        }

        for (int i = 0; i < NUM_SAMPLES; ++ i)
                samples2[i] = tempSamples[i];
}


void DeferredRenderer::ComputeSsao(FrameBufferObject *fbo, float tempCohFactor)
{
        GLuint colorsTex, normalsTex, attribsTex;

        if (0)
        {
                colorsTex = fbo->GetColorBuffer(colorBufferIdx)->GetTexture();
                normalsTex = fbo->GetColorBuffer(1)->GetTexture();
        }
        else
        {
                normalsTex = mDownSampleFbo->GetColorBuffer(1)->GetTexture();
                colorsTex = mDownSampleFbo->GetColorBuffer(0)->GetTexture();
        }

        attribsTex = fbo->GetColorBuffer(2)->GetTexture();

        // flip flop between illumination buffers
        GLuint oldTex = mIllumFbo->GetColorBuffer(2 - mIllumFboIndex)->GetTexture();

        glPushAttrib(GL_VIEWPORT_BIT);
        glViewport(0, 0, mIllumFbo->GetWidth(), mIllumFbo->GetHeight());

        // read the second buffer, write to the first buffer
        mIllumFbo->Bind();
        glDrawBuffers(1, mrt + mIllumFboIndex);

        int i = 0;

        sCgSsaoProgram->SetTexture(i ++, colorsTex);
        sCgSsaoProgram->SetTexture(i ++, normalsTex);
        sCgSsaoProgram->SetTexture(i ++, oldTex);
        sCgSsaoProgram->SetTexture(i ++, noiseTex2D);

        sCgSsaoProgram->SetValue1f(i ++, (mUseTemporalCoherence && !mRegenerateSamples) ? tempCohFactor : 0);
        
        if (mUseTemporalCoherence || mRegenerateSamples)
        {
                mRegenerateSamples = false;

                // q: should we generate new samples or only rotate the old ones?
                // in the first case, the sample patterns look nicer, but the kernel
                // needs longer to converge
                GenerateSamples(mSamplingMethod);

                //if (mSortSamples) { SortSamples(); }
                sCgSsaoProgram->SetArray2f(i, (float *)samples2, NUM_SAMPLES);
        }
        
        ++ i;

        for (int j = 0; j < 4; ++ j, ++ i)
                sCgSsaoProgram->SetValue3f(i, mCornersView[j].x, mCornersView[j].y, mCornersView[j].z);

        sCgSsaoProgram->SetMatrix(i ++, mProjViewMatrix);
        sCgSsaoProgram->SetMatrix(i ++, mOldProjViewMatrix);

        Vector3 de;
        de.x = mOldEyePos.x - mEyePos.x;
        de.y = mOldEyePos.y - mEyePos.y; 
        de.z = mOldEyePos.z - mEyePos.z;

        sCgSsaoProgram->SetValue3f(i ++, de.x, de.y, de.z);

        for (int j = 0; j < 4; ++ j, ++ i)
        {
                sCgSsaoProgram->SetValue3f(i, mOldCornersView[j].x, mOldCornersView[j].y, mOldCornersView[j].z);
        }

        sCgSsaoProgram->SetTexture(i ++, attribsTex);
        sCgSsaoProgram->SetValue1f(i ++, mKernelRadius);
        sCgSsaoProgram->SetValue1f(i ++, mSampleIntensity);


        DrawQuad(sCgSsaoProgram);

        glPopAttrib();

        PrintGLerror("ssao first pass");
}


static void SetVertex(float x, float y, float x_offs, float y_offs)
{
        glMultiTexCoord2fARB(GL_TEXTURE0_ARB, x, y); // center
        glMultiTexCoord2fARB(GL_TEXTURE1_ARB, x - x_offs, y + y_offs); // left top
        glMultiTexCoord2fARB(GL_TEXTURE2_ARB, x + x_offs, y - y_offs); // right bottom
        glMultiTexCoord2fARB(GL_TEXTURE3_ARB, x + x_offs, y + y_offs); // right top
        glMultiTexCoord2fARB(GL_TEXTURE4_ARB, x - x_offs, y - y_offs); // left bottom

        glMultiTexCoord4fARB(GL_TEXTURE5_ARB, x - x_offs, y, x + x_offs, y); // left right
        glMultiTexCoord4fARB(GL_TEXTURE6_ARB, x, y + y_offs, x, y - y_offs); // top bottom

        //glVertex3f(x - 0.5f, y - 0.5f, -0.5f);
        glVertex2f(x, y);
}


void DeferredRenderer::AntiAliasing(FrameBufferObject *fbo, 
                                                                        DirectionalLight *light, 
                                                                        bool displayFrame)
{
        ColorBufferObject *colorBuffer = fbo->GetColorBuffer(colorBufferIdx);
        GLuint colorsTex = colorBuffer->GetTexture();
        GLuint normalsTex = fbo->GetColorBuffer(1)->GetTexture();

        // read the second buffer, write to the first buffer
        if (!displayFrame)
                FlipFbos(fbo);
        else
                // end of the pipeline => just draw image to screen
                FrameBufferObject::Release();

        // the neighbouring texels
        float xOffs = 1.0f / fbo->GetWidth();
        float yOffs = 1.0f / fbo->GetHeight();

        sCgAntiAliasingProgram->SetTexture(0, colorsTex);
        sCgAntiAliasingProgram->SetTexture(1, normalsTex);

        float offsets[16];
        int i = 0;

        offsets[i] = -xOffs; offsets[i + 1] =  yOffs; i += 2; // left top
        offsets[i] =  xOffs; offsets[i + 1] = -yOffs; i += 2; // right bottom
        offsets[i] =  xOffs; offsets[i + 1] =  yOffs; i += 2; // right top
        offsets[i] = -xOffs; offsets[i + 1] = -yOffs; i += 2; // left bottom
        offsets[i] = -xOffs; offsets[i + 1] =    .0f; i += 2; // left
        offsets[i] =  xOffs; offsets[i + 1] =    .0f; i += 2; // right
        offsets[i] =    .0f; offsets[i + 1] =  yOffs; i += 2; // top
        offsets[i] =    .0f; offsets[i + 1] = -yOffs; i += 2; // bottom

        sCgAntiAliasingProgram->SetArray2f(2, offsets, 8);

        DrawQuad(sCgAntiAliasingProgram);

        PrintGLerror("antialiasing");
}


void DeferredRenderer::FirstPass(FrameBufferObject *fbo, DirectionalLight *light)
{
        GLuint colorsTex = fbo->GetColorBuffer(colorBufferIdx)->GetTexture();
        GLuint normalsTex = fbo->GetColorBuffer(1)->GetTexture();

        FlipFbos(fbo);

        const Vector3 lightDir = -light->GetDirection();

        sCgDeferredProgram->SetTexture(0, colorsTex);
        sCgDeferredProgram->SetTexture(1, normalsTex);
        sCgDeferredProgram->SetValue3f(2, lightDir.x, lightDir.y, lightDir.z);
        
        DrawQuad(sCgDeferredProgram);

        PrintGLerror("deferred shading");
}


void DeferredRenderer::ComputeGlobIllum(FrameBufferObject *fbo, 
                                                                                float tempCohFactor)
{
#if 0
        GLuint colorsTex = fbo->GetColorBuffer(colorBufferIdx)->GetTexture();
        GLuint normalsTex = fbo->GetColorBuffer(1)->GetTexture();
#else
        GLuint colorsTex = mDownSampleFbo->GetColorBuffer(0)->GetTexture();
        GLuint normalsTex = mDownSampleFbo->GetColorBuffer(1)->GetTexture();
#endif

        glPushAttrib(GL_VIEWPORT_BIT);
        glViewport(0, 0, mIllumFbo->GetWidth(), mIllumFbo->GetHeight());

        // read the second buffer, write to the first buffer
        mIllumFbo->Bind();

        glDrawBuffers(2, mrt + mIllumFboIndex);

        GLuint oldSsaoTex = mIllumFbo->GetColorBuffer(2 - mIllumFboIndex)->GetTexture();
        GLuint oldIllumTex = mIllumFbo->GetColorBuffer(2 - mIllumFboIndex + 1)->GetTexture();

        int i = 0;

        sCgGiProgram->SetTexture(i ++, colorsTex);
        sCgGiProgram->SetTexture(i ++, normalsTex);
        sCgGiProgram->SetTexture(i ++, noiseTex2D);
        sCgGiProgram->SetTexture(i ++, oldSsaoTex);
        sCgGiProgram->SetTexture(i ++, oldIllumTex);

        sCgGiProgram->SetValue1f(i ++, 
                (mUseTemporalCoherence && !mRegenerateSamples) ? tempCohFactor : 0);

        if (mUseTemporalCoherence || mRegenerateSamples)
        {
                mRegenerateSamples = false;

                // q: should we generate new samples or only rotate the old ones?
                // in the first case, the sample patterns look nicer, but the kernel
                // needs longer to converge
                GenerateSamples(mSamplingMethod); 

                sCgGiProgram->SetArray2f(i ++, (float *)samples2, NUM_SAMPLES);
        }

        Vector3 bl = mCornersView[0];
        Vector3 br = mCornersView[1];
        Vector3 tl = mCornersView[2];
        Vector3 tr = mCornersView[3];

        sCgGiProgram->SetValue3f(i ++, bl.x, bl.y, bl.z);
        sCgGiProgram->SetValue3f(i ++, br.x, br.y, br.z);
        sCgGiProgram->SetValue3f(i ++, tl.x, tl.y, tl.z);
        sCgGiProgram->SetValue3f(i ++, tr.x, tr.y, tr.z);

        sCgGiProgram->SetMatrix(i ++, mOldProjViewMatrix);
        sCgGiProgram->SetMatrix(i ++, mProjViewMatrix);


        DrawQuad(sCgGiProgram);

        glPopAttrib();

        PrintGLerror("globillum first pass");
}


void DeferredRenderer::CombineIllum(FrameBufferObject *fbo)
{
        GLuint colorsTex = fbo->GetColorBuffer(colorBufferIdx)->GetTexture();

        GLuint ssaoTex = mIllumFbo->GetColorBuffer(mIllumFboIndex)->GetTexture();
        GLuint illumTex = mIllumFbo->GetColorBuffer(mIllumFboIndex + 1)->GetTexture();

        FlipFbos(fbo);

        sCgCombineIllumProgram->SetTexture(0, colorsTex);
        sCgCombineIllumProgram->SetTexture(1, ssaoTex);
        sCgCombineIllumProgram->SetTexture(2, illumTex);
        
        DrawQuad(sCgCombineIllumProgram);

        PrintGLerror("combine");
}


void DeferredRenderer::CombineSsao(FrameBufferObject *fbo)
{
        GLuint colorsTex = fbo->GetColorBuffer(colorBufferIdx)->GetTexture();
        GLuint normalsTex = fbo->GetColorBuffer(1)->GetTexture();
        GLuint ssaoTex = mIllumFbo->GetColorBuffer(mIllumFboIndex)->GetTexture();
        
        FlipFbos(fbo);

        int i = 0;

        sCgCombineSsaoProgram->SetTexture(i ++, colorsTex);
        sCgCombineSsaoProgram->SetTexture(i ++, normalsTex);
        sCgCombineSsaoProgram->SetTexture(i ++, ssaoTex);

        sCgCombineSsaoProgram->SetArray2f(i ++, (float *)ssaoFilterOffsets, NUM_SSAO_FILTER_SAMPLES);
        sCgCombineSsaoProgram->SetArray1f(i ++, (float *)ssaoFilterWeights, NUM_SSAO_FILTER_SAMPLES);
        sCgCombineSsaoProgram->SetValue1f(i ++, mSsaoFilterRadius);

        sCgCombineSsaoProgram->SetMatrix(i++, mProjViewMatrix);

        for (int j = 0; j < 4; ++ j, ++ i)
                sCgCombineSsaoProgram->SetValue3f(i, mCornersView[j].x, mCornersView[j].y, mCornersView[j].z);

        sCgCombineSsaoProgram->SetValue1f(i ++, mIllumFbo->GetColorBuffer(mIllumFboIndex)->GetWidth());
        sCgCombineSsaoProgram->SetValue1f(i ++, mIllumFbo->GetColorBuffer(mIllumFboIndex)->GetHeight());

        DrawQuad(sCgCombineSsaoProgram);
        
        PrintGLerror("combine ssao");
}


void DeferredRenderer::FirstPassShadow(FrameBufferObject *fbo, 
                                                                           DirectionalLight *light, 
                                                                           ShadowMap *shadowMap)
{
        GLuint colorsTex = fbo->GetColorBuffer(colorBufferIdx)->GetTexture();
        GLuint normalsTex = fbo->GetColorBuffer(1)->GetTexture();

        GLuint shadowTex = shadowMap->GetDepthTexture();

        Matrix4x4 shadowMatrix;
        shadowMap->GetTextureMatrix(shadowMatrix);


        FlipFbos(fbo);

        sCgDeferredShadowProgram->SetTexture(0, colorsTex);
        sCgDeferredShadowProgram->SetTexture(1, normalsTex);
        sCgDeferredShadowProgram->SetTexture(2, shadowTex);
        sCgDeferredShadowProgram->SetTexture(3, noiseTex2D);
        sCgDeferredShadowProgram->SetMatrix(4, shadowMatrix);
        sCgDeferredShadowProgram->SetValue1f(5, 2.0f / shadowMap->GetSize());

        const Vector3 lightDir = -light->GetDirection();
        sCgDeferredShadowProgram->SetValue3f(6, lightDir.x, lightDir.y, lightDir.z);
        sCgDeferredShadowProgram->SetValue3f(7, mEyePos.x, mEyePos.y, mEyePos.z);

        DrawQuad(sCgDeferredShadowProgram);

        PrintGLerror("deferred shading + shadows");
}


void DeferredRenderer::ComputeToneParameters(FrameBufferObject *fbo, 
                                                                                         DirectionalLight *light,
                                                                                         float &imageKey, 
                                                                                         float &whiteLum,
                                                                                         float &middleGrey)
{
        // hack: estimate value where sky burns out
        whiteLum = log(WHITE_LUMINANCE);
        
        ////////////////////
        //-- linear interpolate brightness key depending on the current sun position

        const float minKey = 0.09f;
        const float maxKey = 0.36f;

        const float lightIntensity = DotProd(-light->GetDirection(), Vector3::UNIT_Z());
        middleGrey = lightIntensity * maxKey + (1.0f - lightIntensity) * minKey;


        //////////
        //-- compute avg loglum

        ColorBufferObject *colorBuffer = fbo->GetColorBuffer(colorBufferIdx);
        GLuint colorsTex = colorBuffer->GetTexture();

        FlipFbos(fbo);
        
        sCgLogLumProgram->SetTexture(0, colorsTex);
        DrawQuad(sCgLogLumProgram);
        
        PrintGLerror("ToneMapParams");


        ///////////////////
        //-- compute avg loglum in scene using mipmapping

        glBindTexture(GL_TEXTURE_2D, fbo->GetColorBuffer(colorBufferIdx)->GetTexture());
        glGenerateMipmapEXT(GL_TEXTURE_2D);
}


static void ExportData(float *data, int w, int h)
{
        startil();

        cout << "w: " << w << " h: " << h << endl;
        ILstring filename = ILstring("downsample2.jpg");
        ilRegisterType(IL_FLOAT);

        const int depth = 1;
        const int bpp = 4;

        if (!ilTexImage(w, h, depth, bpp, IL_RGBA, IL_FLOAT, data))
        {
                cerr << "IL error " << ilGetError() << endl;
                stopil();
                return;
        }

        if (!ilSaveImage(filename))
        {
                cerr << "TGA write error " << ilGetError() << endl;
        }

        stopil();
}


void DeferredRenderer::PrepareSsao(FrameBufferObject *fbo)
{
        GLuint colorsTex = fbo->GetColorBuffer(colorBufferIdx)->GetTexture();
        GLuint normalsTex = fbo->GetColorBuffer(1)->GetTexture();
        GLuint diffVals = fbo->GetColorBuffer(2)->GetTexture();
        // flip flop between illumination buffers
        GLuint oldTex = mIllumFbo->GetColorBuffer(2 - mIllumFboIndex)->GetTexture();

        int i = 0;

        sCgPrepareSsaoProgram->SetTexture(i ++, colorsTex);
        sCgPrepareSsaoProgram->SetTexture(i ++, normalsTex);
        sCgPrepareSsaoProgram->SetTexture(i ++, diffVals);
        sCgPrepareSsaoProgram->SetTexture(i ++, oldTex);

        Vector3 de;
        de.x = mOldEyePos.x - mEyePos.x;
        de.y = mOldEyePos.y - mEyePos.y; 
        de.z = mOldEyePos.z - mEyePos.z;

        sCgPrepareSsaoProgram->SetValue3f(i ++, de.x, de.y, de.z);

        sCgPrepareSsaoProgram->SetMatrix(i ++, mProjViewMatrix);
        sCgPrepareSsaoProgram->SetMatrix(i ++, mOldProjViewMatrix);

        for (int j = 0; j < 4; ++ j, ++ i)
                sCgPrepareSsaoProgram->SetValue3f(i, mOldCornersView[j].x, mOldCornersView[j].y, mOldCornersView[j].z);

        glPushAttrib(GL_VIEWPORT_BIT);
        glViewport(0, 0, mDownSampleFbo->GetWidth(), mDownSampleFbo->GetHeight());
        
        mDownSampleFbo->Bind();

        // prepare downsampled depth and normal texture for ssao
        glDrawBuffers(2, mrt);

        DrawQuad(sCgPrepareSsaoProgram);
        
        glPopAttrib();
        PrintGLerror("prepareSsao");
}


void DeferredRenderer::DownSample(FrameBufferObject *fbo, 
                                                                  int bufferIdx,
                                                                  FrameBufferObject *downSampleFbo, 
                                                                  int downSampleBufferIdx,
                                                                  ShaderProgram *program)
{
        ColorBufferObject *buffer = fbo->GetColorBuffer(bufferIdx);
        GLuint tex = buffer->GetTexture();

        glPushAttrib(GL_VIEWPORT_BIT);
        glViewport(0, 0, downSampleFbo->GetWidth(), downSampleFbo->GetHeight());
        
        downSampleFbo->Bind();

        program->SetTexture(0, tex);
        glDrawBuffers(1, mrt + downSampleBufferIdx);

        DrawQuad(program);
        
        glPopAttrib();
        PrintGLerror("downsample");
}


void DeferredRenderer::ToneMap(FrameBufferObject *fbo,
                                                           float imageKey, 
                                                           float whiteLum,
                                                           float middleGrey)
{
        ColorBufferObject *colorBuffer = fbo->GetColorBuffer(colorBufferIdx);
        GLuint colorsTex = colorBuffer->GetTexture();
        //FrameBufferObject::Release();

        FlipFbos(fbo);

        sCgToneProgram->SetTexture(0, colorsTex);
        sCgToneProgram->SetValue1f(1, imageKey);
        sCgToneProgram->SetValue1f(2, whiteLum);
        sCgToneProgram->SetValue1f(3, middleGrey);

        DrawQuad(sCgToneProgram);

        PrintGLerror("ToneMap");
}


void DeferredRenderer::Output(FrameBufferObject *fbo)
{
        glPushAttrib(GL_VIEWPORT_BIT);
        glViewport(0, 0, fbo->GetWidth(), fbo->GetHeight());
        
        ColorBufferObject *colorBuffer = fbo->GetColorBuffer(colorBufferIdx);
        GLuint colorsTex = colorBuffer->GetTexture();

        sCgDownSampleProgram->SetTexture(0, colorsTex);

        FrameBufferObject::Release();
        DrawQuad(sCgDownSampleProgram);

        PrintGLerror("output");
}


void DeferredRenderer::InitFrame()
{
        for (int i = 0; i < 4; ++ i)
                mOldCornersView[i] = mCornersView[i];

        mOldProjViewMatrix = mProjViewMatrix;
        mOldEyePos = mEyePos;
        mEyePos = mCamera->GetPosition();

        // hack: temporarily change far to improve precision
        const float oldFar = mCamera->GetFar();
        const float oldNear = mCamera->GetNear();
        

        Matrix4x4 matViewing, matProjection;


        ///////////////////

        // use view orientation as we assume that the eye point is always in the center
        // of our coordinate system, this way we have the highest precision near the eye point
        mCamera->GetViewOrientationMatrix(matViewing);
        mCamera->GetProjectionMatrix(matProjection);

        mProjViewMatrix = matViewing * matProjection;
        ComputeViewVectors(mCamera, mCornersView[0], mCornersView[1], mCornersView[2], mCornersView[3]);
        

        // switch roles of old and new fbo
        // the algorihm uses two input fbos, where the one
        // contais the color buffer from the last frame, 
        // the other one will be written

        mIllumFboIndex = 2 - mIllumFboIndex;
        
        // enable fragment shading
        ShaderManager::GetSingleton()->EnableFragmentProfile();

        glDisable(GL_ALPHA_TEST);
        glDisable(GL_TEXTURE_2D);
        glDisable(GL_LIGHTING);
        glDisable(GL_BLEND);
        glDisable(GL_DEPTH_TEST);

        glPolygonMode(GL_FRONT, GL_FILL);

        glMatrixMode(GL_PROJECTION);
        glPushMatrix();
        glLoadIdentity();

        gluOrtho2D(0, 1, 0, 1);


        glMatrixMode(GL_MODELVIEW);
        glPushMatrix();
        glLoadIdentity();

        
        glPushAttrib(GL_VIEWPORT_BIT);
        glViewport(0, 0, mWidth, mHeight);

        // revert to old far and near plane
        mCamera->SetFar(oldFar);
        mCamera->SetNear(oldNear);
}


void DeferredRenderer::LenseFlare(FrameBufferObject *fbo,
                                                                  DirectionalLight *light                                                       
                                                                  )
{
        // light source not visible
        if (!mSunVisiblePixels) return;

        // the sun is a large distance in the reverse light direction
        // => extrapolate light pos
        const Vector3 lightPos = light->GetDirection() * -1e3f;

        float w;
        Vector3 projLightPos = mProjViewMatrix.Transform(w, lightPos, 1.0f);
        projLightPos /= w;
        projLightPos = projLightPos * 0.5f + Vector3(0.5f);

        // vector to light from screen center in texture space
        Vector3 vectorToLight = projLightPos - Vector3(0.5f);
        vectorToLight.z = .0f;

        const float distanceToLight = Magnitude(vectorToLight);
        vectorToLight /= distanceToLight;

        //cout << "dist " << distanceToLight << " v " << vectorToLight << endl;


        ColorBufferObject *colorBuffer = fbo->GetColorBuffer(colorBufferIdx);
        GLuint colorsTex = colorBuffer->GetTexture();
        
        FlipFbos(fbo);

        int i = 0;

        sCgLenseFlareProgram->SetTexture(i ++, colorsTex);
        sCgLenseFlareProgram->SetTexture(i ++, sHaloTex[0]->GetId());
        sCgLenseFlareProgram->SetTexture(i ++, sHaloTex[1]->GetId());
        sCgLenseFlareProgram->SetTexture(i ++, sHaloTex[2]->GetId());
        sCgLenseFlareProgram->SetTexture(i ++, sHaloTex[3]->GetId());
        sCgLenseFlareProgram->SetTexture(i ++, sHaloTex[4]->GetId());
        sCgLenseFlareProgram->SetValue2f(i ++, vectorToLight.x, vectorToLight.y);
        sCgLenseFlareProgram->SetValue1f(i ++, distanceToLight);
        sCgLenseFlareProgram->SetValue1f(i ++, (float)mSunVisiblePixels);

        DrawQuad(sCgLenseFlareProgram);

        PrintGLerror("LenseFlare");
}


void DeferredRenderer::SaveFrame(FrameBufferObject *fbo)
{
        ColorBufferObject *colorBuffer = fbo->GetColorBuffer(colorBufferIdx);
        GLuint colorsTex = colorBuffer->GetTexture();

        GLubyte *data = new GLubyte[mWidth * mHeight * 4];

        // grab texture data
        glEnable(GL_TEXTURE_2D);
        glBindTexture(GL_TEXTURE_2D, colorsTex);
        glGetTexImage(GL_TEXTURE_2D, 0, GL_RGBA, GL_UNSIGNED_BYTE, data);

        glBindTexture(GL_TEXTURE_2D, 0);
        glDisable(GL_TEXTURE_2D);

        /////////////////

        startil();

        static char imageName[200];
        sprintf(imageName, "%s_%05d.bmp", mSavedFrameSuffix.c_str(), mSavedFrameNumber);

        ILstring fileName = ILstring(imageName);
        ilRegisterType(IL_FLOAT);

        const int depth = 1;
        const int bpp = 4;

        if (!ilTexImage(mWidth, mHeight, depth, bpp, IL_RGBA, IL_UNSIGNED_BYTE, data))
        {
                cerr << "IL error " << ilGetError() << endl;
                stopil();
                return;
        }

        ilEnable(IL_FILE_OVERWRITE);

        if (!ilSaveImage(fileName))
        {
                cerr << "TGA write error " << ilGetError() << endl;
        }

        delete [] data;

        stopil();

        PrintGLerror("Store frame");
}


void DeferredRenderer::SetUseTemporalCoherence(bool temporal)
{
        mUseTemporalCoherence = temporal;
}


void DeferredRenderer::SetSamplingMethod(SAMPLING_METHOD s) 
{ 
        if (s != mSamplingMethod)
        {
                mSamplingMethod = s; 
                mRegenerateSamples = true;
        }
}


void DeferredRenderer::SetShadingMethod(SHADING_METHOD s)
{
        if (s != mShadingMethod)
        {
                mShadingMethod = s; 
                mRegenerateSamples = true;
        }
}


#if TODO

void DeferredRenderer::SetNumSamples(int numSamples)
{
        mNumSamples = numSamples;
}

#endif


void DeferredRenderer::SetSampleIntensity(float sampleIntensity)
{
        mSampleIntensity = sampleIntensity;
}


void DeferredRenderer::SetKernelRadius(float kernelRadius)
{
        mKernelRadius = kernelRadius;
}


void DeferredRenderer::SetSsaoFilterRadius(float ssaoFilterRadius)
{
        mSsaoFilterRadius = ssaoFilterRadius;
}


void DeferredRenderer::SetSortSamples(bool sortSamples) 
{
        mSortSamples = sortSamples; 
}


void DeferredRenderer::SetSunVisiblePixels(int pixels) 
{
        mSunVisiblePixels = pixels;
}


void DeferredRenderer::SetSaveFrame(const string &suffix, int frameNumber)
{
        mSavedFrameSuffix = suffix;
        mSavedFrameNumber = frameNumber;
}


} // namespace