DeferredRenderer.hpp

#pragma once
 
#include "DeferredLight.hpp"
#include "ForwardLight.hpp"
 
#include "renderers/DebugLightRenderer.hpp"
 
#include "scene/Scene.hpp"
#include "renderers/Renderer.hpp"
#include "renderers/Culler.hpp"
 
#include "resources/Texture.hpp"
#include "input/ControllableCamera.hpp"
 
#include "processing/SSAO.hpp"
 
#include "Common.hpp"
 
class DeferredRenderer final : public Renderer {
 
public:
    explicit DeferredRenderer(const glm::vec2 & resolution, bool ssao, const std::string & name);
 
    void setScene(const std::shared_ptr<Scene> & scene);
 
    void draw(const Camera & camera, Texture* dstColor, Texture* dstDepth, uint layer = 0) override;
 
    void resize(uint width, uint height) override;
 
    void interface() override;
 
    Texture& sceneDepth();
 
private:
 
    void renderOpaque(const Culler::List & visibles, const glm::mat4 & view, const glm::mat4 & proj);
 
    void renderTransparent(const Culler::List & visibles, const glm::mat4 & view, const glm::mat4 & proj);
    
    void renderBackground(const glm::mat4 & view, const glm::mat4 & proj, const glm::vec3 & pos);
 
    Texture _sceneAlbedo;                           
    Texture _sceneNormal;                           
    Texture _sceneEffects;                          
    Texture _sceneDepth;                            
    Texture _lighting;                              
    Texture _indirectLighting;                      
    Texture _depthCopy;                             
    std::unique_ptr<SSAO> _ssaoPass;                
    std::unique_ptr<DeferredLight> _lightRenderer;  
    std::unique_ptr<DeferredProbe> _probeRenderer;  
    std::unique_ptr<ForwardLight> _fwdLightsGPU;    
    std::unique_ptr<ForwardProbe> _fwdProbesGPU;    
 
    Program * _objectProgram;       
    Program * _parallaxProgram;     
    Program * _clearCoatProgram;    
    Program * _anisotropicProgram;  
    Program * _sheenProgram;        
    Program * _iridescentProgram;   
    Program * _subsurfaceProgram;   
    Program * _emissiveProgram;     
    Program * _transparentProgram;  
    Program * _transpIridProgram;   
    Program * _probeNormalization;  
 
    Program * _skyboxProgram; 
    Program * _bgProgram;       
    Program * _atmoProgram;   
 
    const Texture * _textureBrdf; 
 
    std::shared_ptr<Scene> _scene;  
    std::unique_ptr<Culler> _culler;    
 
    bool _applySSAO          = true;  
};