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

Go to the documentation of this file.

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

#ifndef __SP_DEFERRED_RENDERER_H__
#define __SP_DEFERRED_RENDERER_H__


#include "Base/spStandard.hpp"

#if defined(SP_COMPILE_WITH_DEFERREDRENDERER)


#include "RenderSystem/DeferredRenderer/spGBuffer.hpp"
#include "RenderSystem/DeferredRenderer/spShadowMapper.hpp"
#include "RenderSystem/PostProcessing/spBloomEffect.hpp"
#include "Base/spVertexFormatUniversal.hpp"

#include <boost/shared_ptr.hpp>


namespace sp
{

namespace scene
{
    class SceneGraph;
    class Camera;
}

namespace video
{


enum EDeferredRenderFlags
{
    DEFERREDFLAG_USE_TEXTURE_MATRIX         = 0x0001,
    DEFERREDFLAG_HAS_SPECULAR_MAP           = 0x0002,
    DEFERREDFLAG_HAS_LIGHT_MAP              = 0x0004,
    DEFERREDFLAG_ALLOW_OVERBLENDING         = 0x0008,
    
    DEFERREDFLAG_NORMAL_MAPPING             = 0x0010,
    DEFERREDFLAG_PARALLAX_MAPPING           = 0x0020,
    DEFERREDFLAG_NORMALMAP_XYZ_H            = 0x0040,
    DEFERREDFLAG_SHADOW_MAPPING             = 0x0080,
    DEFERREDFLAG_GLOBAL_ILLUMINATION        = 0x0100,
    DEFERREDFLAG_BLOOM                      = 0x0200,
    
    #if 0

    DEFERREDFLAG_TESSELLATION               = 0x0400,
    #endif
    
    DEFERREDFLAG_DEBUG_GBUFFER              = 0x1000,
    DEFERREDFLAG_DEBUG_GBUFFER_WORLDPOS     = 0x2000,
    DEFERREDFLAG_DEBUG_GBUFFER_TEXCOORDS    = 0x4000,
    DEFERREDFLAG_DEBUG_VIRTUALPOINTLIGHTS   = 0x8000,
};


class ShaderClass;


struct STextureLayerModel
{
    STextureLayerModel() :
        DiffuseMap  (TEXTURE_IGNORE),
        SpecularMap (TEXTURE_IGNORE),
        LightMap    (TEXTURE_IGNORE),
        NormalMap   (TEXTURE_IGNORE),
        HeightMap   (TEXTURE_IGNORE)
    {
    }
    ~STextureLayerModel()
    {
    }
    
    /* Functions */
    void clear()
    {
        DiffuseMap  = TEXTURE_IGNORE;
        SpecularMap = TEXTURE_IGNORE;
        LightMap    = TEXTURE_IGNORE;
        NormalMap   = TEXTURE_IGNORE;
        HeightMap   = TEXTURE_IGNORE;
    }
    
    /* Members */
    u8 DiffuseMap;  
    u8 SpecularMap; 
    u8 LightMap;    
    u8 NormalMap;   

    u8 HeightMap;
};


class SP_EXPORT DeferredRenderer
{
    
    public:
        
        DeferredRenderer();
        virtual ~DeferredRenderer();
        
        /* === Functions === */
        
        virtual bool generateResources(
            s32 Flags, s32 ShadowTexSize, u32 MaxPointLightCount, u32 MaxSpotLightCount, s32 MultiSampling = 0
        );
        
        virtual void renderScene(
            scene::SceneGraph* Graph, scene::Camera* ActiveCamera = 0,
            Texture* RenderTarget = 0, bool UseDefaultGBufferShader = true
        );
        
        /* === Inline functions === */
        
        inline bool generateResources(s32 Flags = 0)
        {
            return generateResources(Flags, 256, 8, 8);
        }
        
        inline const GBuffer* getGBuffer() const
        {
            return &GBuffer_;
        }
        inline GBuffer* getGBuffer()
        {
            return &GBuffer_;
        }
        
        inline const ShadowMapper* getShadowMapper() const
        {
            return &ShadowMapper_;
        }
        inline ShadowMapper* getShadowMapper()
        {
            return &ShadowMapper_;
        }
        
        inline const BloomEffect* getBloomEffect() const
        {
            return &BloomEffect_;
        }
        inline BloomEffect* getBloomEffect()
        {
            return &BloomEffect_;
        }
        
        inline ShaderClass* getGBufferShader() const
        {
            return GBufferShader_;
        }
        inline ShaderClass* getDeferredShader() const
        {
            return DeferredShader_;
        }
        
        inline const VertexFormatUniversal* getVertexFormat() const
        {
            return &VertexFormat_;
        }
        
        inline const STextureLayerModel& getTextureLayerModel() const
        {
            return LayerModel_;
        }
        
        inline void setAmbientColor(const dim::vector3df &ColorVec)
        {
            AmbientColor_ = ColorVec;
        }
        inline dim::vector3df getAmbientColor() const
        {
            return AmbientColor_;
        }

        inline void setDebugVPL(bool Enable)
        {
            DebugVPL_.Enabled = Enable;
        }
        inline bool getDebugVPL() const
        {
            return DebugVPL_.Enabled;
        }
        
    protected:
        
        /* === Structures === */
        
        #if defined(_MSC_VER)
        #   pragma pack(push, packing)
        #   pragma pack(1)
        #   define SP_PACK_STRUCT
        #elif defined(__GNUC__)
        #   define SP_PACK_STRUCT __attribute__((packed))
        #else
        #   define SP_PACK_STRUCT
        #endif
        
        struct SP_EXPORT SLight
        {
            SLight();
            ~SLight();
            
            /* Members */
            dim::vector3df Position;
            f32 Radius;
            dim::vector3df Color;
            s32 Type;
            s32 ShadowIndex;
            s32 UsedForLightmaps;
            SShaderConstant Constants[5];
        }
        SP_PACK_STRUCT;
        
        struct SP_EXPORT SLightEx
        {
            SLightEx();
            ~SLightEx();
            
            /* Members */
            dim::matrix4f ViewProjection;
            dim::vector3df Direction;
            f32 SpotTheta;
            f32 SpotPhiMinusTheta;
            dim::matrix4f InvViewProjection;
            SShaderConstant Constants[5];
        }
        SP_PACK_STRUCT;
        
        #ifdef _MSC_VER
        #   pragma pack(pop, packing)
        #endif
        
        #undef SP_PACK_STRUCT
        
        struct SP_EXPORT SLightDesc
        {
            SShaderConstant LightCountConstant;
            SShaderConstant LightExCountConstant;
        };
        
        struct SP_EXPORT SDebugVPL
        {
            SDebugVPL();
            ~SDebugVPL();
            
            /* Functions */
            void load();
            void unload();
            
            /* Members */
            ShaderClass* ShdClass;
            VertexFormatUniversal* VtxFormat;
            MeshBuffer Model;
            MaterialStates Material;
            bool Enabled;
        };
        
        /* === Functions === */
        
        virtual void updateLightSources(scene::SceneGraph* Graph, scene::Camera* ActiveCamera);
        virtual void renderSceneIntoGBuffer(
            scene::SceneGraph* Graph, scene::Camera* ActiveCamera, bool UseDefaultGBufferShader
        );
        virtual void renderDeferredShading(Texture* RenderTarget);
        
        void renderDebugVirtualPointLights(scene::Camera* ActiveCamera);

        bool buildShader(
            const io::stringc &Name,
            
            ShaderClass* &ShdClass,
            VertexFormat* VertFmt,
            
            const std::list<io::stringc>* ShdBufferVertex,
            const std::list<io::stringc>* ShdBufferPixel,
            
            const io::stringc &VertexMain = "VertexMain",
            const io::stringc &PixelMain = "PixelMain",
            
            s32 Flags = SHADERBUILD_CG
        );
        
        void deleteShaders();
        void createVertexFormats();
        
        void setupCompilerOptions(
            std::list<io::stringc> &GBufferCompilerOp, std::list<io::stringc> &DeferredCompilerOp
        );
        
        void setupGBufferSampler(Shader* ShaderObj);
        void setupDeferredSampler(Shader* ShaderObj);
        void setupDebugVPLSampler(Shader* ShaderObj);
        
        void setupLightShaderConstants();
        void setupJitteredOffsets();
        void setupVPLOffsets(
            Shader* ShaderObj, const io::stringc &BufferName, u32 OffsetCount, s32 Rings = 5, s32 Rotations = 5
        );

        /* === Members === */
        
        GBuffer GBuffer_;
        ShadowMapper ShadowMapper_;
        BloomEffect BloomEffect_;
        
        ShaderClass* GBufferShader_;                
        ShaderClass* DeferredShader_;               
        ShaderClass* ShadowShader_;                 
        
        VertexFormatUniversal VertexFormat_;        
        VertexFormatUniversal ImageVertexFormat_;   
        
        s32 Flags_;
        STextureLayerModel LayerModel_;
        
        SLightDesc LightDesc_;
        std::vector<SLight> Lights_;
        std::vector<SLightEx> LightsEx_;
        
        dim::vector3df AmbientColor_;

        SDebugVPL DebugVPL_;                        
        
        //f32 RSMReflectivity_;
        
};


} // /namespace video

} // /namespace sp


#endif

#endif



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