PBRDemo.hpp

#pragma once
 
#include "DeferredRenderer.hpp"
#include "ForwardRenderer.hpp"
#include "PostProcessStack.hpp"
#include "DebugRenderer.hpp"
 
#include "Application.hpp"
#include "scene/Scene.hpp"
#include "renderers/Renderer.hpp"
#include "renderers/Probe.hpp"
#include "renderers/shadowmaps/ShadowMap.hpp"
#include "input/ControllableCamera.hpp"
#include "system/Query.hpp"
 
#include "Common.hpp"
 
class PBRDemo final : public CameraApp {
 
public:
    explicit PBRDemo(RenderingConfig & config, Window & window);
 
    void draw() override;
 
    void update() override;
 
    void physics(double fullTime, double frameTime) override;
 
    void resize() override;
 
private:
 
    enum class RendererMode : int {
        DEFERRED, FORWARD
    };
 
    void setScene(const std::shared_ptr<Scene> & scene);
 
    void createShadowMaps(ShadowMode mode);
 
    void updateMaps();
 
    std::vector<std::unique_ptr<ShadowMap>> _shadowMaps; 
    std::vector<std::unique_ptr<Probe>> _probes; 
    std::unique_ptr<DeferredRenderer> _defRenderer; 
    std::unique_ptr<ForwardRenderer> _forRenderer;   
    std::unique_ptr<PostProcessStack> _postprocess; 
    std::shared_ptr<DeferredRenderer> _probesRenderer; 
    std::unique_ptr<DebugRenderer> _debugRenderer;   
    Texture _finalRender;    
    Program * _finalProgram; 
    
    std::vector<std::shared_ptr<Scene>> _scenes; 
    std::vector<std::string> _sceneNames; 
 
    GPUQuery _shadowTime;      
    GPUQuery _probesTime;      
    GPUQuery _inteTime;        
    GPUQuery _copyTime;        
    GPUQuery _rendererTime;    
    GPUQuery _postprocessTime; 
    Query _copyTimeCPU;        
    Query _totalTime;          
 
    RendererMode _mode   = RendererMode::DEFERRED; 
    ShadowMode _shadowMode = ShadowMode::VARIANCE; 
    size_t _currentScene = 0; 
    const int _frameCount = 2;   
    int _frameID        = 0;     
 
    bool _paused        = false; 
    bool _showDebug     = false; 
};