manager.h

#ifndef OE_RENDER_MANAGER_H
#define OE_RENDER_MANAGER_H
 
#include <vector>
#include <map>
#include "common.h"
#include "texture_manager.h"
#include "../scene/manager.h"
#include "../scene/node/renderable.h"
#include "../render/node.h"
 
namespace oe::render
{
    class Shader;
    class Skybox;
    class Mesh;
 
    class Manager
    {
        public:
            explicit Manager(scene::Manager& scene_manager);
 
            Manager(scene::Manager& scene_manager, TextureManager& texture_manager);
 
            ~Manager();
 
            void draw(const RenderingPass pass, const bool draw_skybox = true);
 
            void drawSkybox() const;
 
            void bindSceneNode(scene::Node& node, const RenderingPass pass, const bool recursion = false);
 
            void removeRenderNode(scene::RenderableNode* node);
 
            std::shared_ptr<oe::render::ShaderBase> getOverrideShader() const noexcept
            {
                return _override_shader;
            }
 
            void setOverrideShader(std::shared_ptr<oe::render::ShaderBase> shader) noexcept
            {
                _override_shader = shader;
            }
 
            std::shared_ptr<oe::render::Skybox> getSkybox() const noexcept
            {
                return _skybox;
            }
 
            void setSkybox(std::shared_ptr<oe::render::Skybox> skybox) noexcept
            {
                _skybox = skybox;
            }
 
 
            void setCubicSkybox(std::shared_ptr<oe::render::Cubemap> cubemap) noexcept;
 
            scene::Manager& getSceneManager() const noexcept
            {
                return _scene_manager;
            }
 
            TextureManager& getTextureManager()
            {
                return _texture_manager;
            }
 
        private:
            scene::Manager& _scene_manager;
 
            TextureManager _texture_manager;
 
            //Draw specified scene node
            void _drawNode(scene::RenderableNode& node, const RenderingPass pass);
 
            //
            std::map<scene::RenderableNode*, std::unique_ptr<render::Node>> _scene_node_to_render;
 
            std::map<RenderingPass, std::vector<scene::RenderableNode*>> _nodes_by_pass;
 
            // Avoid genrate a new mesh on GPU is multiple nodes uses the same
            std::map<scene::RenderableNode*, render::Mesh*> _mesh_to_render;
 
            std::shared_ptr<oe::render::ShaderBase> _override_shader = nullptr;
            std::shared_ptr<oe::render::Skybox> _skybox = nullptr;
 
 
            // // Todo replace by a factory ?
            std::unique_ptr<render::Node> _generateRenderNodeFromNode(scene::RenderableNode* node);
    };
}
 
#endif