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

#include "SsaoShader.h"
#include "FrameBufferObject.h"
#include "RenderState.h"
#include "SampleGenerator.h"


using namespace std;

GLenum mrt[] = {GL_COLOR_ATTACHMENT0_EXT, GL_COLOR_ATTACHMENT1_EXT, GL_COLOR_ATTACHMENT2_EXT};

namespace CHCDemoEngine
{

static CGprogram sCgSsaoProgram = NULL;

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;


#define NUM_SAMPLES 16

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


SsaoShader::SsaoShader(int w, int h, float expFactor, float scaleFactor):
mWidth(w), mHeight(h), mExpFactor(expFactor), mScaleFactor(scaleFactor)
{}


void SsaoShader::Init(CGcontext context)
{
        
        ///////////////

        sCgSsaoProgram = 
                cgCreateProgramFromFile(context, 
                                                                CG_SOURCE,
                                                                "src/shaders/deferred.cg", 
                                                                RenderState::sCgFragmentProfile,
                                                                "main_ssao",
                                                                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");

                sSamplesParam = cgGetNamedParameter(sCgSsaoProgram, "samples");
                sOldTexParam = cgGetNamedParameter(sCgSsaoProgram, "oldTex");  

                // generate samples for ssao kernel
                GenerateSamples(); 
                cgGLSetParameterArray2f(sSamplesParam, 0, NUM_SAMPLES, (const float *)samples);
        }
        else
                cerr << "ssao program failed to load" << endl;

        PrintGLerror("init");
}


void SsaoShader::Render(FrameBufferObject *fbo, FrameBufferObject *fbo2)
{
        FirstPass(fbo, fbo2);
        SecondPass(fbo, fbo2);
}


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

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

        glDrawBuffers(1, mrt);

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

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

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

        const float offs = 0.5f;

        glOrtho(-offs, offs, -offs, offs, 0, 1);

        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(sNoiseMultiplierParam, RandomValue(3.0f, 17.0f));
        
        cgGLSetParameter1f(sMaxDepthParam, mScaleFactor);
        cgGLSetParameter1f(sExpFactorParam, mExpFactor);


        GenerateSamples(); 
        cgGLSetParameterArray2f(sSamplesParam, 0, NUM_SAMPLES, (const float *)samples);

        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
        //float offs2 = 0.55f;
        float offs2 = 0.5f;

        glColor3f(bl.x, bl.y, bl.z); glTexCoord2f(0, 0); glVertex3f(-offs2, -offs2, -0.5f);
        glColor3f(br.x, br.y, br.z); glTexCoord2f(1, 0); glVertex3f( offs2, -offs2, -0.5f);
        glColor3f(tr.x, tr.y, tr.z); glTexCoord2f(1, 1); glVertex3f( offs2,  offs2, -0.5f);
        glColor3f(tl.x, tl.y, tl.z); glTexCoord2f(0, 1); glVertex3f(-offs2,  offs2, -0.5f);

        glEnd();

        cgGLDisableTextureParameter(sColorsTexParamSsao);
        cgGLDisableTextureParameter(sPositionsTexParamSsao);
        cgGLDisableTextureParameter(sNormalsTexParamSsao);
        cgGLDisableTextureParameter(sNoiseTexParamSsao);
        cgGLDisableTextureParameter(sOldTexParamSsao);

        cgGLDisableProfile(RenderState::sCgFragmentProfile);

        glEnable(GL_LIGHTING);
        glDisable(GL_TEXTURE_2D);

        glMatrixMode(GL_PROJECTION);
        glPopMatrix();

        glMatrixMode(GL_MODELVIEW);
        glPopMatrix();

        glPopAttrib();

        PrintGLerror("displaytexture");

        glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);


        PrintGLerror("ssao first pass");
}


void SsaoShader::SecondPass(FrameBufferObject *fbo, FrameBufferObject *fbo2)
{
        glEnable(GL_TEXTURE_2D);

        glBindTexture(GL_TEXTURE_2D, fbo2->GetColorBuffer(0)->GetTexture());

        glDisable(GL_LIGHTING);
        
        glMatrixMode(GL_PROJECTION);
        glPushMatrix();
        glLoadIdentity();

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

        const float offs = 0.5f;
        glOrtho(-offs, offs, -offs, offs, 0, 1);
        
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

        glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
        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();

        glEnable(GL_LIGHTING);
        glDisable(GL_TEXTURE_2D);
        
        glMatrixMode(GL_PROJECTION);
        glPopMatrix();

        glMatrixMode(GL_MODELVIEW);
        glPopMatrix();

        PrintGLerror("ssao second pass");
}



} // namespace