source: GTP/trunk/App/Demos/Vis/FriendlyCulling/src/ShadowMapping.cpp @ 2911

#include "ShadowMapping.h"
#include "FrameBufferObject.h"
#include "RenderState.h"
#include "RenderTraverser.h"
#include "Light.h"
#include "Polygon3.h"
#include "Polyhedron.h"

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


using namespace std;


namespace CHCDemoEngine
{


static Polyhedron *polyhedron = NULL;


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 CGprogram sCgShadowProgram;
static CGparameter sShadowParam;


static void GrabDepthBuffer(float *data, GLuint depthTexture)
{
        glEnable(GL_TEXTURE_2D);
        glBindTexture(GL_TEXTURE_2D, depthTexture);

        glGetTexImage(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT, GL_FLOAT, data);

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


static void ExportDepthBuffer(float *data, int size)
{
        ilInit();
        assert(ilGetError() == IL_NO_ERROR);

        ILstring filename = ILstring("shadow.tga");
        ilRegisterType(IL_FLOAT);

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

        if (!ilTexImage(size, size, depth, bpp, IL_LUMINANCE, IL_FLOAT, data))
        {
                cerr << "IL error " << ilGetError() << endl;
        
                ilShutDown();
                assert(ilGetError() == IL_NO_ERROR);

                return;
        }

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

        ilShutDown();
        assert(ilGetError() == IL_NO_ERROR);

        cout << "exported depth buffer" << endl;
}



ShadowMap::ShadowMap(Light *light, int size, const AxisAlignedBox3 &sceneBox, Camera *cam):
mSceneBox(sceneBox), mSize(size), mCamera(cam), mLight(light)
{
        mFbo = new FrameBufferObject(size, size, FrameBufferObject::DEPTH_32, true);
        // the diffuse color buffer
        mFbo->AddColorBuffer(ColorBufferObject::BUFFER_UBYTE, ColorBufferObject::WRAP_CLAMP_TO_EDGE, ColorBufferObject::FILTER_LINEAR, false);

        mShadowCam = new Camera(mSceneBox.Size().x * 0.5f, mSceneBox.Size().y * 0.5f);
        mShadowCam->SetOrtho(true);
}


ShadowMap::~ShadowMap()
{
        DEL_PTR(mFbo);
        DEL_PTR(mShadowCam);
}


void ShadowMap::DrawPolys()
{
        if (!polyhedron) return;

        cout << "here3" << endl;

        for (size_t i = 0; i < polyhedron->NumPolygons(); ++ i)
        {
                float r = (float)i / polyhedron->NumPolygons();
                float g = 1;
                float b = 1;

                glColor3f(r, g, b);

                glBegin(GL_LINE_LOOP);

                Polygon3 *poly = polyhedron->GetPolygons()[i];

                for (size_t j = 0; j < poly->mVertices.size(); ++ j)
                {
                        Vector3 v = poly->mVertices[j];
                        glVertex3d(v.x, v.y, v.z);
                }

                glEnd();
        }
}


void ShadowMap::CalcFocussedFrustum(const Matrix4x4 &camProjView, 
                                                                        const Matrix4x4 &lightProjView, 
                                                                        Matrix4x4 &focussed)
{
        ///////////////////
        //-- First step: calc clipped frustum

        DEL_PTR(polyhedron);
        polyhedron = mCamera->CalcClippedFrustum(mSceneBox);

        if (polyhedron)
        {
                // second step: focus light frustum on clipped frustum
                Frustum lightFrustum(lightProjView);

                for (int i = 0; i < 6; ++ i)
                {
                        // the clipping planes look outward the frustum,
                        // so distances > 0 mean that a point is outside
                        const float invLength = 1.0f / Magnitude(lightFrustum.mClipPlanes[i].mNormal);

                        lightFrustum.mClipPlanes[i].mD *= invLength;
                        lightFrustum.mClipPlanes[i].mNormal *= invLength;
                }

                //lightFrustum.EnclosePolyhedron(*polyhedron);
                lightFrustum.ExtractTransformation(focussed);
        }
}


void ShadowMap::ComputeShadowMap(RenderTraverser *renderer, const Matrix4x4 &projView)
{
        const float xlen = Magnitude(mSceneBox.Diagonal() * 0.5f);
        const float ylen = Magnitude(mSceneBox.Diagonal() * 0.5f);
        
        mShadowCam->SetDirection(mLight->GetDirection());
        
        // set position so that we can see the whole scene
        Vector3 pos = mSceneBox.Center();

        Matrix4x4 camView;
        mCamera->GetModelViewMatrix(camView);

        pos -= mLight->GetDirection() * Magnitude(mSceneBox.Diagonal() * 0.5f);
        //mShadowCam->SetPosition(pos);

        mFbo->Bind();
        
        glDrawBuffers(1, mrt);

        glPushAttrib(GL_VIEWPORT_BIT);
        glViewport(0, 0, mSize, mSize);

        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

        glDisable(GL_LIGHTING);
        glDisable(GL_TEXTURE_2D);
        glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);

        glPolygonOffset(1.0f, 2000.0f);
        glEnable(GL_POLYGON_OFFSET_FILL);

        glShadeModel(GL_FLAT);
        glEnable(GL_DEPTH_TEST);

        glMatrixMode(GL_PROJECTION);
        glPushMatrix();
        glLoadIdentity();
        
        // setup projection
        glOrtho(+xlen, -xlen, +ylen, -ylen, 0.0f, Magnitude(mSceneBox.Diagonal())); 
        

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

        // setup shadow camera
        mShadowCam->SetupCameraView();


        //////////////
        //-- compute texture matrix

        Matrix4x4 lightView, lightProj;

        mShadowCam->GetModelViewMatrix(lightView);
        mShadowCam->GetProjectionMatrix(lightProj);

        Matrix4x4 oldLightProjView = lightView * lightProj;
        Matrix4x4 newLightProj;

        CalcFocussedFrustum(projView, lightProj, newLightProj);
        //CalcFocussedFrustum(projView, oldLightProjView, newLightProj);

        Matrix4x4 dummyMat;
        glGetFloatv(GL_PROJECTION_MATRIX, (float *)dummyMat.x);


        cout << "old:\n" << dummyMat << endl;


        glMatrixMode(GL_PROJECTION);
        glLoadMatrixf((float *)newLightProj.x);
        
        glMatrixMode(GL_MODELVIEW);
        //glLoadIdentity();

        Matrix4x4 dummyMat3;
        glGetFloatv(GL_PROJECTION_MATRIX, (float *)dummyMat3.x);

        cout << "new:\n" << newLightProj << endl;

        lightView = camView;
        mLightProjView = lightView * newLightProj;
        //mLightProjView = newLightProj;

        //cout << "old: \n" << oldLightProjView << " new: \n " << mLightProjView << endl;
        

        static Matrix4x4 biasMatrix(0.5f, 0.0f, 0.0f, 0.5f,
                                                                0.0f, 0.5f, 0.0f, 0.5f,
                                                                0.0f, 0.0f, 0.5f, 0.5f,
                                                                0.0f, 0.0f, 0.0f, 1.0f);

        mTextureMatrix = mLightProjView * biasMatrix; 
        //mTextureMatrix = oldLightProjView * biasMatrix; 




        /////////////
        //-- render scene into shadow map

        renderer->RenderScene();

        
        glDisable(GL_POLYGON_OFFSET_FILL);
        glMatrixMode(GL_MODELVIEW);
        glPopMatrix();

        glMatrixMode(GL_PROJECTION);
        glPopMatrix();

        glPopAttrib();
        /*
        float *data = new float[mSize * mSize];

        GrabDepthBuffer(data, mFbo->GetDepthTex());
        ExportDepthBuffer(data, mSize);

        delete [] data;
        
        PrintGLerror("shadow map");
*/
        FrameBufferObject::Release();
}


void ShadowMap::GetTextureMatrix(Matrix4x4 &m) const
{
        m = mTextureMatrix;
}

 
unsigned int ShadowMap::GetShadowTexture() const
{
        return mFbo->GetDepthTex();
}


} // namespace