source: GTP/trunk/App/Demos/Vis/FriendlyCulling/src/DeferredRenderer.h @ 3212

#ifndef _DEFERREDRENDERER_H__
#define _DEFERREDRENDERER_H__

#include "common.h"
#include "Matrix4x4.h"
#include "Vector3.h"

namespace CHCDemoEngine 
{ 

class FrameBufferObject;
class Vector3;
class PerspectiveCamera;
class Matrix4x4;
class ShadowMap;
class DirectionalLight;




/** This class implements a deferred shading algorithm that takes
        a frame buffer object as input and outputs an image in the given size
*/
class DeferredRenderer
{
public:
        /** Constructor for a deferred shader taking the requested output image size,
                the current camera;
        */
        DeferredRenderer(int w, int h, PerspectiveCamera *cam);
        /** The algorithm renders the scene given an fbo consists of 1 color buffer, 
                1 position buffer, and 1 normal buffer.
                We also need the  projection view matrix of the last frame for reprojection, and
                a smoothing factor for temporal coherence
        */

        ~DeferredRenderer();

        void Render(FrameBufferObject *fbo, 
                                float tempCohFactor, 
                                DirectionalLight *light,
                                bool useToneMapping,
                                bool useAntiAliasing,
                                ShadowMap *shadowMap = NULL
                                );

        
        void SetUseTemporalCoherence(bool temporal);

        enum SAMPLING_METHOD {SAMPLING_POISSON, SAMPLING_QUADRATIC, SAMPLING_DEFAULT};
        enum SHADING_METHOD {DEFAULT, SSAO, GI};
        /** Set the samplig method for the indirect illumination
        */
        void SetSamplingMethod(SAMPLING_METHOD s);
        /** Set the shading method (SSAO, SSAO + color bleeding
        */
        void SetShadingMethod(SHADING_METHOD s);

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

        void SetSampleIntensity(float sampleIntensity);

        void SetKernelRadius(float kernelRadius);


        // hack: store the color buffer idx for the currently used flip flop-MRT here
        // TODO matt: make this less hacky
        static int colorBufferIdx;


protected:

        void ComputeSsao(FrameBufferObject *fbo, float tempCohFactor);

        void ComputeGlobIllum(FrameBufferObject *fbo, float tempCohFactor);

        void FirstPass(FrameBufferObject *fbo, DirectionalLight *light);

        void FirstPassShadow(FrameBufferObject *fbo, DirectionalLight *light, ShadowMap *shadowMap);

        void ComputeToneParameters(FrameBufferObject *fbo, 
                                                           DirectionalLight *light,
                                                           float &imageKey, 
                                                           float &whiteLum,
                                                           float &middleGrey);

        void ToneMap(FrameBufferObject *fbo, float imageKey, float whiteLum, float middleGrey);


        void CombineSsao(FrameBufferObject *fbo);
        void CombineIllum(FrameBufferObject *fbo);

        void AntiAliasing(FrameBufferObject *fbo, DirectionalLight *light);
        /** Downsample buffer of fbo to buffer of downSampleFbo. The downSampleFbo must have half the
                resolution of fbo.
        */
        void DownSample(FrameBufferObject *fbo,
                                        int bufferIdx,
                                        FrameBufferObject *downSampleFbo,
                                        int downSampleBufferIdx,
                                        ShaderProgram *program);

        void DrawQuad(ShaderProgram *p);

        void Output(FrameBufferObject *fbo);

        /** Initialises the deferred shader and loads the required shaders:
                This function has to be called only once.
        */
        void InitCg();
        /** Is called once per render call and sets the most important parameters.
        */
        void InitFrame();

        void FlipFbos(FrameBufferObject *fbo);

        void PrepareSsao(FrameBufferObject *fbo);

        void SortSamples();


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

        int mWidth;
        int mHeight;

        PerspectiveCamera *mCamera;

        bool mUseTemporalCoherence;

        int mSamplingMethod;

        int mShadingMethod;

        bool mRegenerateSamples;

        int mIllumFboIndex;
        // the fbo for indirect illumination (ssao + color bleeding)
        FrameBufferObject *mIllumFbo;

        FrameBufferObject *mDownSampleFbo;

        FBOContainer mFBOs;

        static ShaderContainer sShaders;

        Matrix4x4 mProjViewMatrix;
        Matrix4x4 mOldProjViewMatrix;

        Vector3 mCornersView[4];
        Vector3 mOldCornersView[4];

        Vector3 mEyePos;
        Vector3 mOldEyePos;

        bool mSortSamples;

        float mKernelRadius;
        float mSampleIntensity;
};


} // namespace 

#endif // _SsaoShader_H__