source: GTP/trunk/App/Demos/Vis/FriendlyCulling/src/SsaoShader.cpp @ 2884

#include "SsaoShader.h"
#include "FrameBufferObject.h"
#include "RenderState.h"
#include "SampleGenerator.h"
#include "Vector3.h"
#include "Camera.h"
#include "shaderenv.h"


using namespace std;

static GLenum mymrt[] = {GL_COLOR_ATTACHMENT0_EXT, GL_COLOR_ATTACHMENT1_EXT, GL_COLOR_ATTACHMENT2_EXT, GL_COLOR_ATTACHMENT3_EXT};

namespace CHCDemoEngine
{

static CGprogram sCgSsaoProgram = NULL;
static CGprogram sCgGiProgram = NULL;

static CGprogram sCgDeferredProgram = NULL;
static CGprogram sCgAntiAliasingProgram = NULL;

static CGparameter sColorsTexCombineParam;
static CGparameter sSsaoTexCombineParam;

static CGparameter sColorsTexDeferredParam;
static CGparameter sPositionsTexDeferredParam;
static CGparameter sNormalsTexDeferredParam;


static CGprogram sCgCombinedSsaoProgram = NULL;
static CGprogram sCgCombinedIllumProgram = NULL;

///////////////////////////////////////7


static CGparameter sColorsTexParam;
static CGparameter sPositionsTexParam;
static CGparameter sNormalsTexParam;

static CGparameter sOldModelViewProjMatrixParam;
static CGparameter sMaxDepthParam;
static CGparameter sSamplesParam; 
static CGparameter sOldTexParam;
static CGparameter sNoiseTexParam;
static CGparameter sNoiseMultiplierParam;
static CGparameter sExpFactorParam;



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


static CGparameter sColorsTexGiParam;
static CGparameter sPositionsTexGiParam;
static CGparameter sNormalsTexGiParam;


static CGparameter sOldModelViewProjMatrixGiParam;
static CGparameter sMaxDepthGiParam;
static CGparameter sSamplesGiParam; 
static CGparameter sOldSsaoTexGiParam;
static CGparameter sOldIllumTexGiParam;
static CGparameter sNoiseTexGiParam;
static CGparameter sNoiseMultiplierGiParam;
static CGparameter sExpFactorGiParam;


static CGparameter sColorsTexCombinedIllumParam;
static CGparameter sSsaoTexCombinedIllumParam;
static CGparameter sIllumTexCombinedIllumParam;

static CGparameter sColorsTexCombinedSsaoParam;
static CGparameter sSsaoTexCombinedSsaoParam;


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

static CGparameter sColorsTexAntiAliasingParam;
static CGparameter sNormalsTexAntiAliasingParam;

static GLuint noiseTex = 0;

// ssao random spherical samples
static Sample2 samples[NUM_SAMPLES];


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);
        }
}


/** Generate poisson disc distributed sample points on the unit disc
*/
static void GenerateSamples()
{
        static PoissonDiscSampleGenerator poisson(NUM_SAMPLES, 1.0f);
        poisson.Generate((Sample2 *)samples);
}


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

        for (int i = 0; i < w * h * 3; i += 3)
        {
                // create random samples on a circle
                const float rx = RandomValue(0, 1);
                const float theta = 2.0f * acos(sqrt(1.0f - rx));

                //randomNormals[i + 0] = (GLubyte)((cos(theta) * 0.5f + 0.5f) * 255.0f);
                //randomNormals[i + 1] = (GLubyte)((sin(theta) * 0.5f + 0.5f) * 255.0f);
                randomNormals[i + 0] = cos(theta);
                randomNormals[i + 1] = sin(theta);
                randomNormals[i + 2] = 0;
        }

        glEnable(GL_TEXTURE_2D);
        glGenTextures(1, &noiseTex);
        glBindTexture(GL_TEXTURE_2D, noiseTex);
                
        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_RGB8, w, h, 0, GL_RGB, GL_UNSIGNED_BYTE, randomNormals);
        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");
}


SsaoShader::SsaoShader(int w, int h, Camera *cam, float scaleFactor):
mWidth(w), mHeight(h), 
mCamera(cam),
mScaleFactor(scaleFactor),
mUseTemporalCoherence(true),
mUseGlobIllum(false)
{
        // create noise texture for ssao
        CreateNoiseTex2D(w, h);

        ///////////
        //-- the flip-flop fbos

        mNewFbo = new FrameBufferObject(w, h, FrameBufferObject::DEPTH_NONE);
        
        mNewFbo->AddColorBuffer(ColorBufferObject::BUFFER_FLOAT_32, ColorBufferObject::WRAP_CLAMP_TO_EDGE, ColorBufferObject::FILTER_LINEAR, false);
        mNewFbo->AddColorBuffer(ColorBufferObject::BUFFER_FLOAT_32, ColorBufferObject::WRAP_CLAMP_TO_EDGE, ColorBufferObject::FILTER_LINEAR, false);
        

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

        mOldFbo = new FrameBufferObject(w, h, FrameBufferObject::DEPTH_NONE);
        
        mOldFbo->AddColorBuffer(ColorBufferObject::BUFFER_FLOAT_32, ColorBufferObject::WRAP_CLAMP_TO_EDGE, ColorBufferObject::FILTER_LINEAR, false);
        mOldFbo->AddColorBuffer(ColorBufferObject::BUFFER_FLOAT_32, ColorBufferObject::WRAP_CLAMP_TO_EDGE, ColorBufferObject::FILTER_LINEAR, false);
        
        //mFbo = new FrameBufferObject(w, h, FrameBufferObject::DEPTH_NONE);
        //mFbo->AddColorBuffer(ColorBufferObject::BUFFER_FLOAT_32, ColorBufferObject::WRAP_CLAMP_TO_EDGE, ColorBufferObject::FILTER_LINEAR, false);*/
}


SsaoShader::~SsaoShader() 
{
        if (sCgSsaoProgram)     cgDestroyProgram(sCgSsaoProgram);
        if (sCgDeferredProgram) cgDestroyProgram(sCgDeferredProgram);
        if (sCgSsaoProgram)     cgDestroyProgram(sCgSsaoProgram);
        if (sCgGiProgram) cgDestroyProgram(sCgGiProgram);
        if (sCgAntiAliasingProgram) cgDestroyProgram(sCgAntiAliasingProgram);

        DEL_PTR(mNewFbo);
        DEL_PTR(mOldFbo);
        //DEL_PTR(mFbo);

        glDeleteTextures(1, &noiseTex);
}


void SsaoShader::SetUseGlobIllum(bool useGlobIllum)
{
        mUseGlobIllum = useGlobIllum;
}


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


void SsaoShader::Init(CGcontext context)
{       
        sCgDeferredProgram = 
                cgCreateProgramFromFile(context, 
                                                                CG_SOURCE,
                                                                "src/shaders/deferred.cg", 
                                                                RenderState::sCgFragmentProfile,
                                                                "main",
                                                                NULL);

        if (sCgDeferredProgram != NULL)
        {
                cgGLLoadProgram(sCgDeferredProgram);

                // we need size of texture for scaling
                sPositionsTexDeferredParam = cgGetNamedParameter(sCgDeferredProgram, "positions");  
                sColorsTexDeferredParam = cgGetNamedParameter(sCgDeferredProgram, "colors");  
                sNormalsTexDeferredParam = cgGetNamedParameter(sCgDeferredProgram, "normals"); 
        }
        else
                cerr << "deferred program failed to load" << endl;


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

        sCgSsaoProgram = 
                cgCreateProgramFromFile(context, 
                                                                CG_SOURCE,
                                                                "src/shaders/ssao.cg", 
                                                                RenderState::sCgFragmentProfile,
                                                                "main",
                                                                NULL);

        if (sCgSsaoProgram != NULL)
        {
                cgGLLoadProgram(sCgSsaoProgram);

                // we need size of texture for scaling
                sPositionsTexParam = cgGetNamedParameter(sCgSsaoProgram, "positions");  
                sColorsTexParam = cgGetNamedParameter(sCgSsaoProgram, "colors");  
                sNormalsTexParam = cgGetNamedParameter(sCgSsaoProgram, "normals");  
                sNoiseTexParam = cgGetNamedParameter(sCgSsaoProgram, "noiseTexture");
                sNoiseMultiplierParam = cgGetNamedParameter(sCgSsaoProgram, "noiseMultiplier");
                
                sOldModelViewProjMatrixParam = cgGetNamedParameter(sCgSsaoProgram, "oldModelViewProj");
                sMaxDepthParam = cgGetNamedParameter(sCgSsaoProgram, "maxDepth");
                sExpFactorParam = cgGetNamedParameter(sCgSsaoProgram, "expFactor");

                sOldTexParam = cgGetNamedParameter(sCgSsaoProgram, "oldTex");  
                
                cgGLSetParameter1f(sNoiseMultiplierParam, RandomValue(3.0f, 17.0f));

                // generate samples for ssao kernel
                GenerateSamples(); 

                sSamplesParam = cgGetNamedParameter(sCgSsaoProgram, "samples");
                //cgSetArraySize(sSamplesParam, NUM_SAMPLES);
                //cgCompileProgram(sCgSsaoProgram);
                
                cgGLSetParameterArray2f(sSamplesParam, 0, NUM_SAMPLES, (const float *)samples);
        }
        else
                cerr << "ssao program failed to load" << endl;

        sCgGiProgram = 
                cgCreateProgramFromFile(context, 
                                                                CG_SOURCE,
                                                                "src/shaders/globillum.cg", 
                                                                RenderState::sCgFragmentProfile,
                                                                "main",
                                                                NULL);

        if (sCgGiProgram != NULL)
        {
                cgGLLoadProgram(sCgGiProgram);

                // we need size of texture for scaling
                sPositionsTexGiParam = cgGetNamedParameter(sCgGiProgram, "positions");  
                sColorsTexGiParam = cgGetNamedParameter(sCgGiProgram, "colors");  
                sNormalsTexGiParam = cgGetNamedParameter(sCgGiProgram, "normals");  
                sNoiseTexGiParam = cgGetNamedParameter(sCgGiProgram, "noiseTexture");
                sNoiseMultiplierGiParam = cgGetNamedParameter(sCgGiProgram, "noiseMultiplier");
                
                sOldModelViewProjMatrixGiParam = cgGetNamedParameter(sCgGiProgram, "oldModelViewProj");
                sMaxDepthGiParam = cgGetNamedParameter(sCgGiProgram, "maxDepth");
                sExpFactorGiParam = cgGetNamedParameter(sCgGiProgram, "expFactor");

                sSamplesGiParam = cgGetNamedParameter(sCgGiProgram, "samples");
                
                sOldSsaoTexGiParam = cgGetNamedParameter(sCgGiProgram, "oldSsaoTex");  
                sOldIllumTexGiParam = cgGetNamedParameter(sCgGiProgram, "oldIllumTex");  

                // generate samples for ssao kernel
                GenerateSamples(); 
                cgGLSetParameterArray2f(sSamplesGiParam, 0, NUM_SAMPLES, (const float *)samples);

                cgGLSetParameter1f(sNoiseMultiplierGiParam, RandomValue(3.0f, 17.0f));
        }
        else
                cerr << "globillum program failed to load" << endl;

        sCgCombinedIllumProgram = 
                cgCreateProgramFromFile(context, 
                                                                CG_SOURCE,
                                                                "src/shaders/globillum.cg", 
                                                                RenderState::sCgFragmentProfile,
                                                                "combine",
                                                                NULL);

        if (sCgCombinedIllumProgram != NULL)
        {
                cgGLLoadProgram(sCgCombinedIllumProgram);

                sColorsTexCombinedIllumParam = cgGetNamedParameter(sCgCombinedIllumProgram, "colors");  
                sSsaoTexCombinedIllumParam = cgGetNamedParameter(sCgCombinedIllumProgram, "ssaoTex");
                sIllumTexCombinedIllumParam = cgGetNamedParameter(sCgCombinedIllumProgram, "illumTex");
        }
        else
                cerr << "combined illum program failed to load" << endl;


        sCgCombinedSsaoProgram = 
                cgCreateProgramFromFile(context, 
                                                                CG_SOURCE,
                                                                "src/shaders/ssao.cg", 
                                                                RenderState::sCgFragmentProfile,
                                                                "combine",
                                                                NULL);

        if (sCgCombinedSsaoProgram != NULL)
        {
                cgGLLoadProgram(sCgCombinedSsaoProgram);

                sColorsTexCombinedSsaoParam = cgGetNamedParameter(sCgCombinedSsaoProgram, "colors");  
                sSsaoTexCombinedSsaoParam = cgGetNamedParameter(sCgCombinedSsaoProgram, "ssaoTex");
        }
        else
                cerr << "combied illum program failed to load" << endl;

        
        sCgAntiAliasingProgram = 
                cgCreateProgramFromFile(context, 
                                                                CG_SOURCE,
                                                                "src/shaders/antialiasing.cg", 
                                                                RenderState::sCgFragmentProfile,
                                                                "main",
                                                                NULL);

        if (sCgAntiAliasingProgram != NULL)
        {
                cgGLLoadProgram(sCgAntiAliasingProgram);

                sColorsTexAntiAliasingParam = cgGetNamedParameter(sCgAntiAliasingProgram, "colors");  
                sNormalsTexAntiAliasingParam = cgGetNamedParameter(sCgAntiAliasingProgram, "normals");
        }
        else
                cerr << "antialiasing program failed to load" << endl;

        PrintGLerror("init");
}


void SsaoShader::Render(FrameBufferObject *fbo, 
                                                const Matrix4x4 &oldProjViewMatrix,
                                                float expFactor)
{
        
        // 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
        swap(mNewFbo, mOldFbo); 

        FrameBufferObject::Release();

        cgGLEnableProfile(RenderState::sCgFragmentProfile);

        glDisable(GL_ALPHA_TEST);
        glDisable(GL_TEXTURE_2D);
        glDisable(GL_LIGHTING);

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

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

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

        const float offs = 0.5f;
        glOrtho(-offs, offs, -offs, offs, 0, 1);

        FirstPass(fbo);
        
        if (!mUseGlobIllum)
        {
                ComputeSsao(fbo, expFactor, oldProjViewMatrix);
                CombineSsao(fbo);
        }
        else
        {
                ComputeGlobIllum(fbo, expFactor, oldProjViewMatrix);
                CombineIllum(fbo);
        }

        AntiAliasing(fbo);

        glEnable(GL_LIGHTING);
        glDisable(GL_TEXTURE_2D);

        glMatrixMode(GL_PROJECTION);
        glPopMatrix();

        glMatrixMode(GL_MODELVIEW);
        glPopMatrix();

        glPopAttrib();

        cgGLDisableProfile(RenderState::sCgFragmentProfile);
}


void SsaoShader::ComputeSsao(FrameBufferObject *fbo, 
                                                         float expFactor,
                                                         const Matrix4x4 &oldProjViewMatrix
                                                         )
{
        cgGLSetMatrixParameterfc(sOldModelViewProjMatrixParam, (const float *)oldProjViewMatrix.x);

        GLuint colorsTex = fbo->GetColorBuffer(3)->GetTexture();
        GLuint positionsTex = fbo->GetColorBuffer(1)->GetTexture();
        GLuint normalsTex = fbo->GetColorBuffer(2)->GetTexture();

        if (1)
        {
                // generate mip map levels for position texture
                glBindTexture(GL_TEXTURE_2D, positionsTex);
                glGenerateMipmapEXT(GL_TEXTURE_2D);
        }


        // read the second buffer, write to the first buffer
        mNewFbo->Bind();
        glDrawBuffers(1, mymrt);


        GLuint oldTex = mOldFbo->GetColorBuffer(0)->GetTexture();

        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

        cgGLEnableProfile(RenderState::sCgFragmentProfile);
        cgGLBindProgram(sCgSsaoProgram);

        cgGLSetTextureParameter(sPositionsTexParam, positionsTex);
        cgGLEnableTextureParameter(sPositionsTexParam);

        cgGLSetTextureParameter(sColorsTexParam, colorsTex);
        cgGLEnableTextureParameter(sColorsTexParam);

        cgGLSetTextureParameter(sNormalsTexParam, normalsTex);
        cgGLEnableTextureParameter(sNormalsTexParam);

        cgGLSetTextureParameter(sNoiseTexParam, noiseTex);
        cgGLEnableTextureParameter(sNoiseTexParam);

        cgGLSetTextureParameter(sOldTexParam, oldTex);
        cgGLEnableTextureParameter(sOldTexParam);
        
        cgGLSetParameter1f(sMaxDepthParam, mScaleFactor);
        
        if (mUseTemporalCoherence)
        {
                cgGLSetParameter1f(sNoiseMultiplierParam, RandomValue(3.0f, 17.0f));
                cgGLSetParameter1f(sExpFactorParam, expFactor);


                // 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(); 
                cgGLSetParameterArray2f(sSamplesParam, 0, NUM_SAMPLES, (const float *)samples);
        }
        else
        {
                        cgGLSetParameter1f(sExpFactorParam, 1.0f);
        }

        Vector3 tl, tr, bl, br;
        ComputeViewVectors(tl, tr, bl, br);

        glColor3f(1.0f, 1.0f, 1.0f);

        glBegin(GL_QUADS);

        // note: slightly larger texture hides ambient occlusion error on border but costs resolution
        //const float new_offs = 0.55f;
        const float new_offs = 0.5f;
        
        glColor3f(bl.x, bl.y, bl.z); glTexCoord2f(0, 0); glVertex3f(-new_offs, -new_offs, -0.5f);
        glColor3f(br.x, br.y, br.z); glTexCoord2f(1, 0); glVertex3f( new_offs, -new_offs, -0.5f);
        glColor3f(tr.x, tr.y, tr.z); glTexCoord2f(1, 1); glVertex3f( new_offs,  new_offs, -0.5f);
        glColor3f(tl.x, tl.y, tl.z); glTexCoord2f(0, 1); glVertex3f(-new_offs,  new_offs, -0.5f);

        glEnd();

        cgGLDisableTextureParameter(sColorsTexParam);
        cgGLDisableTextureParameter(sPositionsTexParam);
        cgGLDisableTextureParameter(sNormalsTexParam);
        cgGLDisableTextureParameter(sNoiseTexParam);
        cgGLDisableTextureParameter(sOldTexParam);


        FrameBufferObject::Release();

        PrintGLerror("ssao first pass");
}


void SsaoShader::ComputeViewVectors(Vector3 &tl, Vector3 &tr, Vector3 &bl, Vector3 &br)
{
        Vector3 ftl, ftr, fbl, fbr, ntl, ntr, nbl, nbr;

        mCamera->ComputePoints(ftl, ftr, fbl, fbr, ntl, ntr, nbl, nbr);

#if 1 // matT: debug this!!
        
        bl = -Normalize(nbl - fbl);
        br = -Normalize(nbr - fbr);
        tl = -Normalize(ntl - ftl);
        tr = -Normalize(ntr - ftr);

#else // just take camera direction
        
        bl = -Normalize(mCamera->GetDirection());
        br = -Normalize(mCamera->GetDirection());
        tl = -Normalize(mCamera->GetDirection());
        tr = -Normalize(mCamera->GetDirection());

#endif

        // normalize to 0 .. 1
        bl = bl * 0.5f + 0.5f;
        br = br * 0.5f + 0.5f;
        tl = tl * 0.5f + 0.5f;
        tr = tr * 0.5f + 0.5f;
}



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);
}


void SsaoShader::AntiAliasing(FrameBufferObject *fbo)
{
        GLuint colorsTex = fbo->GetColorBuffer(0)->GetTexture();
        GLuint normalsTex = fbo->GetColorBuffer(2)->GetTexture();
        
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

        cgGLEnableProfile(RenderState::sCgFragmentProfile);
        cgGLBindProgram(sCgAntiAliasingProgram);
        
        cgGLSetTextureParameter(sColorsTexAntiAliasingParam, colorsTex);
        cgGLEnableTextureParameter(sColorsTexAntiAliasingParam);

        cgGLSetTextureParameter(sNormalsTexAntiAliasingParam, normalsTex);
        cgGLEnableTextureParameter(sNormalsTexAntiAliasingParam);

        glColor3f(1.0f, 1.0f, 1.0f);

        float offs2 = 0.5f;

        glBegin(GL_QUADS);

        // the neighbouring texels
        float x_offs = 1.0f / mWidth;
        float y_offs = 1.0f / mHeight;

        SetVertex(0, 0, x_offs, y_offs);
        SetVertex(1, 0, x_offs, y_offs);
        SetVertex(1, 1, x_offs, y_offs);
        SetVertex(0, 1, x_offs, y_offs);

        glEnd();

        cgGLDisableTextureParameter(sColorsTexAntiAliasingParam);
        cgGLDisableTextureParameter(sNormalsTexAntiAliasingParam);

        PrintGLerror("antialiasing");
}


void SsaoShader::FirstPass(FrameBufferObject *fbo)
{
        GLuint colorsTex = fbo->GetColorBuffer(0)->GetTexture();
        GLuint positionsTex = fbo->GetColorBuffer(1)->GetTexture();
        GLuint normalsTex = fbo->GetColorBuffer(2)->GetTexture();

        fbo->Bind();

        glDrawBuffers(1, mymrt + 3);

        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
        
        cgGLEnableProfile(RenderState::sCgFragmentProfile);

        cgGLBindProgram(sCgDeferredProgram);

        cgGLSetTextureParameter(sColorsTexDeferredParam, colorsTex);
        cgGLEnableTextureParameter(sColorsTexDeferredParam);

        cgGLSetTextureParameter(sPositionsTexDeferredParam, positionsTex);
        cgGLEnableTextureParameter(sPositionsTexDeferredParam);

        cgGLSetTextureParameter(sNormalsTexDeferredParam, normalsTex);
        cgGLEnableTextureParameter(sNormalsTexDeferredParam);
        
        glColor3f(1.0f, 1.0f, 1.0f);

        const float offs = 0.5f;

        glBegin(GL_QUADS);

        glTexCoord2f(0, 0); glVertex3f(-offs, -offs, -0.5f);
        glTexCoord2f(1, 0); glVertex3f( offs, -offs, -0.5f);
        glTexCoord2f(1, 1); glVertex3f( offs,  offs, -0.5f);
        glTexCoord2f(0, 1); glVertex3f(-offs,  offs, -0.5f);

        glEnd();

        cgGLDisableTextureParameter(sColorsTexDeferredParam);
        cgGLDisableTextureParameter(sPositionsTexDeferredParam);
        cgGLDisableTextureParameter(sNormalsTexDeferredParam);

        cgGLDisableProfile(RenderState::sCgFragmentProfile);

        FrameBufferObject::Release();

        PrintGLerror("deferred shading");
}


void SsaoShader::ComputeGlobIllum(FrameBufferObject *fbo, 
                                                                  float expFactor,
                                                                  const Matrix4x4 &oldProjViewMatrix
                                                                  )
{
        cgGLSetMatrixParameterfc(sOldModelViewProjMatrixGiParam, (const float *)oldProjViewMatrix.x);

        //GLuint colorsTex = mFbo->GetColorBuffer(0)->GetTexture();
        GLuint colorsTex = fbo->GetColorBuffer(3)->GetTexture();
        GLuint positionsTex = fbo->GetColorBuffer(1)->GetTexture();
        GLuint normalsTex = fbo->GetColorBuffer(2)->GetTexture();

        if (1)
        {
                // generate mip map levels for position texture
                glBindTexture(GL_TEXTURE_2D, positionsTex);
                glGenerateMipmapEXT(GL_TEXTURE_2D);

                // generate mip map levels for position texture
                glBindTexture(GL_TEXTURE_2D, colorsTex);
                glGenerateMipmapEXT(GL_TEXTURE_2D);
        }


        // read the second buffer, write to the first buffer
        mNewFbo->Bind();
        glDrawBuffers(2, mymrt);

        GLuint oldSsaoTex = mOldFbo->GetColorBuffer(0)->GetTexture();
        GLuint oldIllumTex = mOldFbo->GetColorBuffer(1)->GetTexture();

        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

        cgGLEnableProfile(RenderState::sCgFragmentProfile);
        cgGLBindProgram(sCgGiProgram);

        cgGLSetTextureParameter(sPositionsTexGiParam, positionsTex);
        cgGLEnableTextureParameter(sPositionsTexGiParam);

        cgGLSetTextureParameter(sColorsTexGiParam, colorsTex);
        cgGLEnableTextureParameter(sColorsTexGiParam);

        cgGLSetTextureParameter(sNormalsTexGiParam, normalsTex);
        cgGLEnableTextureParameter(sNormalsTexGiParam);

        cgGLSetTextureParameter(sNoiseTexGiParam, noiseTex);
        cgGLEnableTextureParameter(sNoiseTexGiParam);

        cgGLSetTextureParameter(sOldSsaoTexGiParam, oldSsaoTex);
        cgGLEnableTextureParameter(sOldSsaoTexGiParam);

        cgGLSetTextureParameter(sOldIllumTexGiParam, oldIllumTex);
        cgGLEnableTextureParameter(sOldIllumTexGiParam);

        cgGLSetParameter1f(sMaxDepthGiParam, mScaleFactor);


        if (mUseTemporalCoherence)
        {
                cgGLSetParameter1f(sNoiseMultiplierGiParam, RandomValue(3.0f, 17.0f));
                cgGLSetParameter1f(sExpFactorGiParam, expFactor);

                // 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(); 
                cgGLSetParameterArray2f(sSamplesGiParam, 0, NUM_SAMPLES, (const float *)samples);
        }
        else
        {
                        cgGLSetParameter1f(sExpFactorGiParam, 1.0f);
        }

        Vector3 tl, tr, bl, br;
        ComputeViewVectors(tl, tr, bl, br);

        glColor3f(1.0f, 1.0f, 1.0f);

        glBegin(GL_QUADS);

        // note: slightly larger texture hides ambient occlusion error on border but costs resolution
        //const float new_offs = 0.55f;
        const float new_offs = 0.5f;
        
        glColor3f(bl.x, bl.y, bl.z); glTexCoord2f(0, 0); glVertex3f(-new_offs, -new_offs, -0.5f);
        glColor3f(br.x, br.y, br.z); glTexCoord2f(1, 0); glVertex3f( new_offs, -new_offs, -0.5f);
        glColor3f(tr.x, tr.y, tr.z); glTexCoord2f(1, 1); glVertex3f( new_offs,  new_offs, -0.5f);
        glColor3f(tl.x, tl.y, tl.z); glTexCoord2f(0, 1); glVertex3f(-new_offs,  new_offs, -0.5f);

        glEnd();

        cgGLDisableTextureParameter(sColorsTexGiParam);
        cgGLDisableTextureParameter(sPositionsTexGiParam);
        cgGLDisableTextureParameter(sNormalsTexGiParam);
        cgGLDisableTextureParameter(sNoiseTexGiParam);
        cgGLDisableTextureParameter(sOldSsaoTexGiParam);
        cgGLDisableTextureParameter(sOldIllumTexGiParam);

        FrameBufferObject::Release();

        PrintGLerror("globillum first pass");
}


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

        GLuint ssaoTex = mNewFbo->GetColorBuffer(0)->GetTexture();
        GLuint illumTex = mNewFbo->GetColorBuffer(1)->GetTexture();

        fbo->Bind();

        // overwrite old color texture
        glDrawBuffers(1, mymrt);

        cgGLEnableProfile(RenderState::sCgFragmentProfile);

        cgGLBindProgram(sCgCombinedIllumProgram);

        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
        

        cgGLSetTextureParameter(sColorsTexCombinedIllumParam, colorsTex);
        cgGLEnableTextureParameter(sColorsTexCombinedIllumParam);

        cgGLSetTextureParameter(sSsaoTexCombinedIllumParam, ssaoTex);
        cgGLEnableTextureParameter(sSsaoTexCombinedIllumParam);

        cgGLSetTextureParameter(sIllumTexCombinedIllumParam, illumTex);
        cgGLEnableTextureParameter(sIllumTexCombinedIllumParam);
        
        glColor3f(1.0f, 1.0f, 1.0f);

        const float offs = 0.5f;

        glBegin(GL_QUADS);

        glTexCoord2f(0, 0); glVertex3f(-offs, -offs, -0.5f);
        glTexCoord2f(1, 0); glVertex3f( offs, -offs, -0.5f);
        glTexCoord2f(1, 1); glVertex3f( offs,  offs, -0.5f);
        glTexCoord2f(0, 1); glVertex3f(-offs,  offs, -0.5f);

        glEnd();

        cgGLDisableTextureParameter(sColorsTexCombinedIllumParam);
        cgGLDisableTextureParameter(sSsaoTexCombinedIllumParam);
        cgGLDisableTextureParameter(sIllumTexCombinedIllumParam);

        cgGLDisableProfile(RenderState::sCgFragmentProfile);

        FrameBufferObject::Release();

        PrintGLerror("combine");
}


void SsaoShader::CombineSsao(FrameBufferObject *fbo)
{
        GLuint colorsTex = fbo->GetColorBuffer(3)->GetTexture();
        GLuint ssaoTex = mNewFbo->GetColorBuffer(0)->GetTexture();

        fbo->Bind();

        // write into old color texture (not needed anymore)
        glDrawBuffers(1, mymrt);

        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
        
        cgGLEnableProfile(RenderState::sCgFragmentProfile);

        cgGLBindProgram(sCgCombinedSsaoProgram);

        cgGLSetTextureParameter(sColorsTexCombinedSsaoParam, colorsTex);
        cgGLEnableTextureParameter(sColorsTexCombinedSsaoParam);

        cgGLSetTextureParameter(sSsaoTexCombinedSsaoParam, ssaoTex);
        cgGLEnableTextureParameter(sSsaoTexCombinedSsaoParam);

        
        glColor3f(1.0f, 1.0f, 1.0f);

        const float offs = 0.5f;

        glBegin(GL_QUADS);

        glTexCoord2f(0, 0); glVertex3f(-offs, -offs, -0.5f);
        glTexCoord2f(1, 0); glVertex3f( offs, -offs, -0.5f);
        glTexCoord2f(1, 1); glVertex3f( offs,  offs, -0.5f);
        glTexCoord2f(0, 1); glVertex3f(-offs,  offs, -0.5f);

        glEnd();

        cgGLDisableTextureParameter(sColorsTexCombinedSsaoParam);
        cgGLDisableTextureParameter(sSsaoTexCombinedSsaoParam);

        cgGLDisableProfile(RenderState::sCgFragmentProfile);

        FrameBufferObject::Release();

        PrintGLerror("combine ssao");
}



} // namespace