include/VR3ShadowController.h

Go to the documentation of this file.

// Copyright (C) 2010  Daniele Giannetti
//
// This file is part of VR3Lib.
// The VR3Lib is free software, but is distributed in the static precompiled 
// version as it is NOT open source. The VR3Lib may be used in any virtual 
// reality application free of charge, but it must be clearly stated that this 
// library is used in the application EULA and distribution license 
// (for both free and proprietary applications).

#ifndef __VR3SHADOWCONTROLLER_H__
#define __VR3SHADOWCONTROLLER_H__

// C++0x hash set include
#include <unordered_set>


struct VR3ShadowShaderParams {
    GLint numactivesources;
    GLfloat projmat[16*VR3SDOW_NUM_SOURCES];
    GLfloat viewmat[16*VR3SDOW_NUM_SOURCES];
    GLfloat znear[VR3SDOW_NUM_SOURCES];
    GLfloat zfar[VR3SDOW_NUM_SOURCES];
    GLfloat intensity[VR3SDOW_NUM_SOURCES];
    GLfloat minvariance[VR3SDOW_NUM_SOURCES];
    GLfloat bleedred[VR3SDOW_NUM_SOURCES];
    GLfloat depthscale[VR3SDOW_NUM_SOURCES];
};


class VR3ShadowController {
    friend class VR3Scene;
    friend class VR3Obj;


    int m_mode;

    static VR3ShadowController* ms_activecontroller;


    struct ShadowSource {
        


        bool init;
        bool active;
        



        GLuint shadFBO;
        GLuint depthRBO;
        GLuint shadTex;
        GLuint blurFBO;
        GLuint blurTex;




        GLfloat viewmat[16];
        GLfloat projmatfetch[16];
        GLfloat projmat[16];
        GLfloat znear;
        GLfloat zfar;

        GLfloat vfvertices[8][3];




        GLsizei width;
        GLsizei height;
        GLfloat mapsize[2];




        GLint filtersize;
        GLfloat intensity;
        GLfloat minvariance;
        GLfloat bleedred;
        GLfloat depthscale;



        GLfloat clearcolor[4];
    };
    
    ShadowSource m_sources[VR3SDOW_NUM_SOURCES];


    std::unordered_set<VR3Obj*> m_receivers;


    std::unordered_set<VR3Obj*> m_casters;


    GLuint m_shadowmap_program;
    const GLint* m_shadowmap_unilocs;

    GLuint m_blur_programs[2];
    const GLint* m_blur_unilocs[2];

    GLuint m_VAO;
    GLuint m_VBO;

    VR3ShadowShaderParams m_shadparams;


    const GLfloat* m_cursrcviewmat;


    const GLfloat* m_cursrcprojmat;


    int m_meshcounter;


    bool m_face_culling;
    bool m_vf_culling;
    bool m_source_culling;

    VR3ShadowController(const VR3ShadowController&);
    VR3ShadowController& operator = (const VR3ShadowController&);

//------------------- VAO and VBOs Preparation Function ---------------------//




    void PrepareVAO();


//------------------- Source Visibility Testing Function ---------------------//




    bool SourceVisibilityTest(const ShadowSource* src);


// ---------------------- Shadow Map Drawing Method --------------------------//




    void DrawShadowMaps();


public:

//------------------- Active Shadow Controller Management --------------------//


    

    static VR3ShadowController* GetActiveController() 
        { return ms_activecontroller; }


    void Activate();


    void Deactivate();


//----------------------- Constructor and Destructor -------------------------//




    VR3ShadowController(int mode = VR3SDOWCTRL_AUTOMATIC);


    ~VR3ShadowController();


//--------------- Casters and Receivers Management Functions -----------------//



private:


    void AutoCastShadows(VR3Obj* obj, bool cast);


    void AutoReceiveShadows(VR3Obj* obj, bool receive);

public:


    void CastShadows(VR3Obj* obj, bool cast);


    void ReceiveShadows(VR3Obj* obj, bool receive);


    bool InCasters(VR3Obj* obj) 
        { return (m_casters.find(obj)!=m_casters.end()); }


    bool InReceivers(VR3Obj* obj) 
        { return (m_receivers.find(obj)!=m_receivers.end()); }


//---------------------- Sources Management Functions ------------------------//




    void InitSource( int id,
                     GLfloat srcposX, GLfloat srcposY, GLfloat srcposZ,
                     GLfloat srcupX, GLfloat srcupY, GLfloat srcupZ,
                     GLfloat srctargetX, GLfloat srctargetY, GLfloat srctargetZ,
                     GLfloat fovy,
                     GLfloat aspect,
                     GLfloat znear,
                     GLfloat zfar,
                     GLsizei width,
                     GLsizei height,
                     GLint filtersize = VR3SDOW_DEF_FILTERSIZE,
                     GLfloat intensity = VR3SDOW_DEF_INTENSITY,
                     GLfloat minvariance = VR3SDOW_DEF_MINVARIANCE,
                     GLfloat bleedred = VR3SDOW_DEF_BLEEDREDUCTION,
                     GLfloat depthscale = VR3SDOW_DEF_DEPTHSCALE );


    void DeinitSource(int id);


    void SetFrustumParam( int id, 
                          GLfloat srcposX, GLfloat srcposY, GLfloat srcposZ,
                          GLfloat srcupX, GLfloat srcupY, GLfloat srcupZ,
                          GLfloat srctargetX, GLfloat srctargetY, GLfloat srctargetZ,
                          GLfloat fovy,
                          GLfloat aspect,
                          GLfloat znear,
                          GLfloat zfar );


    void SetMapParam( int id, 
                      GLsizei width,
                      GLsizei height );


    void SetAlgorithmParam( int id, 
                            GLint filtersize = VR3SDOW_DEF_FILTERSIZE,
                            GLfloat intensity = VR3SDOW_DEF_INTENSITY,
                            GLfloat minvariance = VR3SDOW_DEF_MINVARIANCE,
                            GLfloat bleedred = VR3SDOW_DEF_BLEEDREDUCTION,
                            GLfloat depthscale = VR3SDOW_DEF_DEPTHSCALE );

//---------------------- Enable and Disable Components -----------------------//




    void Enable(int feature, int optional_param = 0);


    void Disable(int feature, int optional_param = 0);


    bool IsEnabled(int feature, int optional_param = 0);


    bool CheckVFCulling()
        { return m_vf_culling; }


//---- Shadow Properties Discovery Functions and Controller Notification -----//




    const VR3ShadowShaderParams* FetchParameters()
        { return &m_shadparams; }


    const GLfloat* FetchViewMat()
        { return m_cursrcviewmat; }


    const GLfloat* FetchProjMat()
        { return m_cursrcprojmat; }


    void IncMeshCounter()
        { m_meshcounter++; }


//--------------------------- Uniform Locations ------------------------------//




    const GLint* GetUniforms()
        { return m_shadowmap_unilocs; }

};

#endif