D:/SoftwareEntwicklung/C++/HLC/Tools/SoftPixelEngine/repository/sources/RenderSystem/DeferredRenderer/spShadowMapper.hpp

Go to the documentation of this file.

/*
 * Shadow mapper header
 * 
 * This file is part of the "SoftPixel Engine" (Copyright (c) 2008 by Lukas Hermanns)
 * See "SoftPixelEngine.hpp" for license information.
 */

#ifndef __SP_SHADOW_MAPPER_H__
#define __SP_SHADOW_MAPPER_H__


#include "Base/spStandard.hpp"
#include "Base/spDimension.hpp"
#include "RenderSystem/spTextureFlags.hpp"
#include "SceneGraph/spSceneCamera.hpp"


namespace sp
{

namespace scene
{
    class SceneGraph;
    class Light;
}

namespace video
{


class Texture;

class SP_EXPORT ShadowMapper
{
    
    public:
        
        ShadowMapper();
        virtual ~ShadowMapper();
        
        /* === Functions === */
        
        virtual bool createShadowMaps(
            s32 TexSize, u32 MaxPointLightCount, u32 MaxSpotLightCount, bool UseVSM = true, bool UseRSM = false
        );
        virtual void deleteShadowMaps();
        
        virtual bool renderShadowMap(
            scene::SceneGraph* Graph, scene::Camera* Cam, scene::Light* LightObj, u32 Index
        );
        
        virtual void bind(const s32 ShadowMapLayerBase);
        virtual void unbind(const s32 ShadowMapLayerBase);
        
        /* === Static functions === */
        
        static bool renderCubeMap(
            scene::SceneGraph* Graph, scene::Camera* Cam, Texture* Tex, const dim::vector3df &Position
        );
        
        static bool renderCubeMapDirection(
            scene::SceneGraph* Graph, scene::Camera* Cam, Texture* Tex,
            dim::matrix4f CamDir, const ECubeMapDirections Direction
        );
        
        static bool renderCubeMap(
            scene::SceneGraph* Graph, Texture* Tex, const dim::vector3df &Position
        );
        
        /* === Inline functions === */
        
        inline Texture* getSpotLightTexArray()
        {
            return ShadowMapArray_.getDepthMap();
        }
        inline Texture* getPointLightTexArray()
        {
            return ShadowCubeMapArray_.getDepthMap();
        }
        
    protected:
        
        /* === Macros === */
        
        static const dim::matrix4f CUBEMAP_ROTATIONS[6];
        
        /* === Structures === */
        
        struct SP_EXPORT SShadowMap
        {
            SShadowMap();
            ~SShadowMap();
            
            /* Functions */
            void clear();
            
            void createTexture(u32 Index, const STextureCreationFlags &CreationFlags);
            void createRSMs(STextureCreationFlags CreationFlags);
            
            bool setupRenderTargets(bool UseRSM);
            
            /* Inline functions */
            inline Texture* getDepthMap() const
            {
                return TexList[0];
            }
            inline Texture* getColorMap() const
            {
                return TexList[1];
            }
            inline Texture* getNormalMap() const
            {
                return TexList[2];
            }
            
            inline bool valid() const
            {
                return TexList[0] != 0 && TexList[1] != 0 && TexList[2] != 0;
            }
            
            /* Members */
            Texture* TexList[3];
        };
        
        /* === Functions === */
        
        bool renderPointLightShadowMap(
            scene::SceneGraph* Graph, scene::Camera* Cam, scene::Light* LightObj, u32 Index
        );
        bool renderSpotLightShadowMap(
            scene::SceneGraph* Graph, scene::Camera* Cam, scene::Light* LightObj, u32 Index
        );
        
        bool checkLightFrustumCulling(scene::Camera* Cam, scene::Light* LightObj) const;
        
        void renderSceneIntoDepthTexture(scene::SceneGraph* Graph, SShadowMap &ShadowMap, u32 Index);
        void renderSceneIntoGBuffer     (scene::SceneGraph* Graph, SShadowMap &ShadowMap, u32 Index);
        
        static void renderCubeMapDirection(
            scene::SceneGraph* Graph, Texture* Tex, const ECubeMapDirections Direction
        );
        
        /* === Members === */
        
        SShadowMap ShadowMapArray_;
        SShadowMap ShadowCubeMapArray_;
        
        scene::Camera DepthCam_;
        
        s32 TexSize_;
        
        u32 MaxPointLightCount_;
        u32 MaxSpotLightCount_;
        
        bool UseVSM_; 
        bool UseRSM_; 
        
        static scene::Camera ViewCam_;
        
};


} // /namespace video

} // /namespace sp


#endif



// ================================================================================