DataflowRenderer.hpp

#pragma once
#include <Dataflow/RaDataflow.hpp>
 
#include <Core/Resources/Resources.hpp>
#include <Engine/Rendering/Renderer.hpp>
 
#include <Dataflow/Rendering/Renderer/RenderingGraph.hpp>
 
namespace globjects {
class Framebuffer;
}
namespace globjects {…}
 
namespace Ra {
namespace Dataflow {
namespace Rendering {
namespace Renderer {
 
extern int DataflowRendererMagic;
 
class RA_DATAFLOW_API DataflowRenderer : public Ra::Engine::Rendering::Renderer
{
 
  public:
    struct RA_DATAFLOW_API RenderGraphController : Ra::Core::Resources::ObservableVoid {
 
        RenderGraphController();
        virtual ~RenderGraphController()                                 = default;
        RenderGraphController( const RenderGraphController& )            = delete;
        RenderGraphController( const RenderGraphController&& )           = delete;
        RenderGraphController& operator=( RenderGraphController&& )      = delete;
        RenderGraphController& operator=( const RenderGraphController& ) = delete;
 
        virtual void configure( DataflowRenderer* renderer, int w, int h );
 
        virtual void resize( int w, int h );
 
        virtual void update( const Ra::Engine::Data::ViewingParameters& renderData );
 
        [[nodiscard]] virtual std::string getRendererName() const { return "Dataflow Renderer"; }
 
        void loadGraph( const std::string& filename );
        void saveGraph( const std::string& filename );
        void resetGraph();
        void defferedLoadGraph( const std::string& filename );
 
        std::unique_ptr<RenderingGraph> m_renderGraph { nullptr };
 
      private:
        int m_width { -1 };
        int m_height { -1 };
        Ra::Engine::Data::ShaderProgramManager* m_shaderMngr;
        std::string m_graphToLoad;
    };
    struct RA_DATAFLOW_API RenderGraphController : Ra::Core::Resources::ObservableVoid {…};
 
    explicit DataflowRenderer( RenderGraphController& controller );
 
    ~DataflowRenderer() override;
 
    [[nodiscard]] std::string getRendererName() const override { return m_name; }
 
    bool buildRenderTechnique( Ra::Engine::Rendering::RenderObject* ro ) const override;
 
    Ra::Engine::Scene::LightManager* getLightManager() { return m_lightmanagers[0]; }
 
    RenderGraphController& getController() { return m_controller; }
 
    // void setDisplayNode( DisplaySinkNode* displayNode );
 
    // void loadFromJson( const std::string& jsonFilePath );
 
    // const std::string& getJsonFilePath() { return m_jsonFilePath; }
 
    // void setJsonFilePath( const std::string& jsonFilePath ) { m_jsonFilePath = jsonFilePath; }
 
    // void compileRenderGraph();
 
    // void reloadRenderGraphFromJson();
 
    /*
    void signalReloadJson( bool resetPath = false ) {
        m_reloadJson = true;
        m_resetPath  = resetPath;
    }
    */
 
  protected:
    void initializeInternal() override;
    void resizeInternal() override;
    void updateStepInternal( const Ra::Engine::Data::ViewingParameters& renderData ) override;
    void renderInternal( const Ra::Engine::Data::ViewingParameters& renderData ) override;
    void postProcessInternal( const Ra::Engine::Data::ViewingParameters& renderData ) override;
    void debugInternal( const Ra::Engine::Data::ViewingParameters& renderData ) override;
    void uiInternal( const Ra::Engine::Data::ViewingParameters& renderData ) override;
 
    virtual void initResources();
 
  public:
    inline std::map<std::string, std::shared_ptr<Ra::Engine::Data::Texture>>& sharedTextures() {
        return m_sharedTextures;
    }
 
    inline globjects::Framebuffer* postprocessFbo() { return m_postprocessFbo.get(); }
 
    inline std::vector<RenderObjectPtr>* allRenderObjects() { return &m_fancyRenderObjects; }
 
    inline std::vector<const Ra::Engine::Scene::Light*>* getLights() { return &m_lights; }
 
  private:
    void graphChanged();
 
    bool m_graphChanged { false };
 
    std::map<std::string, std::shared_ptr<Ra::Engine::Data::Texture>> m_sharedTextures;
 
    std::unique_ptr<globjects::Framebuffer> m_postprocessFbo;
 
    RenderGraphController& m_controller;
 
    std::string m_name { "RenderGraph renderer" };
 
    Ra::Engine::Data::Texture* m_colorTexture { nullptr };
 
    std::vector<const Ra::Engine::Scene::Light*> m_lights;
 
    std::vector<Ra::Engine::Data::ViewingParameters> m_cameras;
};
class RA_DATAFLOW_API DataflowRenderer : public Ra::Engine::Rendering::Renderer {…};
 
} // namespace Renderer
} // namespace Rendering
} // namespace Dataflow
} // namespace Ra