get.h

#pragma once

#include "util/shared_ptr.h"
#include "util/weak_ptr.h"

namespace blowbox
{
    class GLFWManager;
    class BlowboxCore;
    class Window;
    class ForwardRenderer;
    class DeferredRenderer;
    class CommandManager;
    class CommandContextManager;
    class Device;
    class SwapChain;
    class DescriptorHeap;
    class ImGuiManager;
    class SceneManager;
    class DebugMenu;
    class Console;
    class Time;
    class PerformanceProfiler;
    class MemoryProfiler;
    class FrameStats;
    class MemoryStats;

    class Get
    {
        friend class BlowboxCore;
    protected:
        Get();

        ~Get();

        void Finalize();

    public:
        static BlowboxCore* BlowboxCore();

        static SharedPtr<GLFWManager> GLFWManager();

        static SharedPtr<Window> MainWindow();

        static SharedPtr<ForwardRenderer> ForwardRenderer();

        static SharedPtr<DeferredRenderer> DeferredRenderer();

        static SharedPtr<CommandContextManager> CommandContextManager();

        static SharedPtr<CommandManager> CommandManager();

        static SharedPtr<Device> Device();

        static SharedPtr<DescriptorHeap> RtvHeap();

        static SharedPtr<DescriptorHeap> DsvHeap();

        static SharedPtr<DescriptorHeap> CbvSrvUavHeap();

        static SharedPtr<SwapChain> SwapChain();

        static SharedPtr<ImGuiManager> ImGuiManager();

        static SharedPtr<SceneManager> SceneManager();

        static SharedPtr<DebugMenu> DebugMenu();

        static SharedPtr<Console> Console();

        static SharedPtr<Time> Time();

        static SharedPtr<PerformanceProfiler> PerformanceProfiler();

        static SharedPtr<MemoryProfiler> MemoryProfiler();

        static SharedPtr<FrameStats> FrameStats();

        static SharedPtr<MemoryStats> MemoryStats();
        
    protected:
        void Set(blowbox::BlowboxCore* blowbox_core);

        void Set(SharedPtr<blowbox::GLFWManager> glfw_manager);

        void Set(SharedPtr<blowbox::Window> main_window);

        void Set(SharedPtr<blowbox::ForwardRenderer> forward_renderer);

        void Set(SharedPtr<blowbox::DeferredRenderer> deferred_renderer);

        void Set(SharedPtr<blowbox::CommandContextManager> command_context_manager);

        void Set(SharedPtr<blowbox::CommandManager> command_manager);

        void Set(SharedPtr<blowbox::Device> device);

        void SetRtvHeap(SharedPtr<blowbox::DescriptorHeap> heap);

        void SetDsvHeap(SharedPtr<blowbox::DescriptorHeap> heap);

        void SetCbvSrvUavHeap(SharedPtr<blowbox::DescriptorHeap> heap);

        void Set(SharedPtr<blowbox::SwapChain> swap_chain);

        void Set(SharedPtr<blowbox::ImGuiManager> imgui_manager);

        void Set(SharedPtr<blowbox::SceneManager> scene_manager);

        void Set(SharedPtr<blowbox::DebugMenu> debug_menu);

        void Set(SharedPtr<blowbox::Console> console);

        void Set(SharedPtr<blowbox::Time> time);

        void Set(SharedPtr<blowbox::PerformanceProfiler> instance);

        void Set(SharedPtr<blowbox::MemoryProfiler> instance);

        void Set(SharedPtr<blowbox::FrameStats> instance);

        void Set(SharedPtr<blowbox::MemoryStats> instance);

        static Get* instance_;                                              

    private:
        bool finalized_;                                                    
        blowbox::BlowboxCore* blowbox_core_;                                
        WeakPtr<blowbox::GLFWManager> glfw_manager_;                        
        WeakPtr<blowbox::Window> main_window_;                              
        WeakPtr<blowbox::ForwardRenderer> forward_renderer_;                
        WeakPtr<blowbox::DeferredRenderer> deferred_renderer_;              
        WeakPtr<blowbox::CommandContextManager> command_context_manager_;   
        WeakPtr<blowbox::CommandManager> command_manager_;                  
        WeakPtr<blowbox::Device> device_;                                   
        WeakPtr<blowbox::DescriptorHeap> rtv_descriptor_heap_;              
        WeakPtr<blowbox::DescriptorHeap> dsv_descriptor_heap_;              
        WeakPtr<blowbox::DescriptorHeap> cbv_srv_uav_descriptor_heap_;      
        WeakPtr<blowbox::SwapChain> swap_chain_;                            
        WeakPtr<blowbox::ImGuiManager> imgui_manager_;                      
        WeakPtr<blowbox::SceneManager> scene_manager_;                      
        WeakPtr<blowbox::DebugMenu> debug_menu_;                            
        WeakPtr<blowbox::Console> console_;                                 
        WeakPtr<blowbox::Time> time_;                                       
        WeakPtr<blowbox::PerformanceProfiler> performance_profiler_;        
        WeakPtr<blowbox::MemoryProfiler> memory_profiler_;                  
        WeakPtr<blowbox::FrameStats> frame_stats_;                          
        WeakPtr<blowbox::MemoryStats> memory_stats_;                        
    };
}