manager.h

#ifndef OE_RENDER_MANAGER_H
#define OE_RENDER_MANAGER_H
 
#include <cstdint>
#include <span>
#include <utility>
#include <vector>
#include <variant>
#include <atomic>
 
#include "passes.h"
#include "mesh.h"
#include "shader_base.h"
 
#include "mesh_renderer.h"
#include "mesh_skinned_renderer.h"
 
namespace oe::render
{
    struct RenderManagerSettings
    {
        using RenderNodeId = uint32_t;
 
        struct RenderNode
        {
            RenderNodeId id;
            std::variant<MeshRenderer, MeshSkinnedRenderer> mesh_renderer;
        };
 
        template <typename T>
        using Container = std::vector<T>;
    };

    template <typename SettingsType = RenderManagerSettings>
    struct GenericRenderManager
    {
        using RenderNodeId = SettingsType::RenderNodeId;
        using RenderNode = SettingsType::RenderNode;
        using NodeContainerType = SettingsType::template Container<RenderNode>;

        NodeContainerType opaque_nodes;

        NodeContainerType blend_nodes;

        NodeContainerType refractive_nodes;
 
        RenderNode* getNodeById(const RenderNodeId id_node, std::span<const NodeContainerType> nodes)
        {
            auto it = find_if(nodes.begin(), nodes.end(), [&id_node](const NodeContainerType& node)
            {
                return node.id == id_node;
            });
 
            if (it != nodes.end())
            {
                return nullptr;
            }
 
            return &(*it);
        }
 
        void deleteNodeById(const RenderNodeId id_node)
        {
            auto node_lists = {&opaque_nodes, &blend_nodes, &refractive_nodes};
 
            for (auto& node_list_ptr : node_lists)
            {
                auto& node_list = *node_list_ptr;
 
                node_list.erase(std::remove_if(node_list.begin(), node_list.end(),
                    [id_node](auto& node) {
                        return node.id == id_node;
                    }), node_list.end()
                );
            }
        }
 
        template <typename T>
        RenderNodeId addOpaqueNode(T&& component)
        {
            RenderNodeId id_node = _next_node_id++;
 
            opaque_nodes.emplace_back(id_node, std::move(component));
 
            return id_node;
        }
 
        template <typename T>
        RenderNodeId addBlendNode(T&& component, bool is_glass = false)
        {
            RenderNodeId id_node = _next_node_id++;
 
            if (is_glass)
            {
                refractive_nodes.emplace_back(id_node, std::move(component));
            }
            else
            {
                blend_nodes.emplace_back(id_node, std::move(component));
            }
 
            return id_node;
        }

        template <typename RenderNodeType, typename F>
        void renderNode(RenderNodeType& renderer, const oe::scene::Camera& camera, const oe::render::RenderingPass render_pass, F&& fill_shader)
        {
            // Todo: be gentle with memory: first loop to get all "render_commands" then second loop to render each meshes
            // Order each command by shader
 
            bool is_blending_pass = render_pass == oe::render::RenderingPass::FORWARD;
 
            std::vector<render::DrawCommand> render_commands;
            bool can_render = renderer.fillRenderCommands(camera, is_blending_pass, render_commands);
 
            if (!can_render)
            {
                return;
            }
 
            oe::render::Mesh& render_mesh = renderer.render_mesh;
            oe::render::GeometryPass geometry_pass = renderer.geometry_pass;
 
            for (auto &it : render_commands)
            {
                auto* material = it.material;
                oe::render::ShaderBase* shader = material->shader;
 
                shader->bind(geometry_pass, render_pass);
 
                renderer.fillShader(shader, camera);
 
                shader->fillTextures(material->textures);
                shader->fillFromCamera(camera);
                shader->fillFromMaterial(material);
 
                fill_shader(shader);
 
                render_mesh.render(it.enabled_primitives);
            }
        }

        void renderOpaqueNodes(const oe::scene::Camera& camera, const oe::render::RenderingPass render_pass)
        {
            render(opaque_nodes, camera, render_pass);
        }

        template <typename F>
        void renderBlendNodes(const oe::scene::Camera& camera, const oe::render::RenderingPass render_pass, F&& fill_shader)
        {
            render(blend_nodes, camera, render_pass, fill_shader);
        }

        template <typename F>
        void render(std::span<RenderNode> nodes, const oe::scene::Camera& camera, const oe::render::RenderingPass render_pass, F&& fill_shader)
        {
            for (auto& render_node : nodes)
            {
                std::visit([&](auto& mesh_renderer)
                {
                    renderNode(mesh_renderer, camera, render_pass, fill_shader);
                }, render_node.mesh_renderer);
            }
        }

        void render(std::span<RenderNode> nodes, const oe::scene::Camera& camera, const oe::render::RenderingPass render_pass)
        {
            for (auto& render_node : nodes)
            {
                std::visit([&](auto& mesh_renderer)
                {
                    renderNode(mesh_renderer, camera, render_pass, [](void*) {});
                }, render_node.mesh_renderer);
            }
        }

        std::atomic<uint64_t> _next_node_id = 1;
    };

    using RenderManager = GenericRenderManager<RenderManagerSettings>;
}
 
#endif