OcularEngine.hpp

#ifndef __H__OCULAR_ENGINE__H__
#define __H__OCULAR_ENGINE__H__

#include "Common.hpp"

#include "Logger/Logger.hpp"
#include "Time/Clock.hpp"
#include "Events/EventManager.hpp"
#include "Input/InputHandler.hpp"
#include "Renderer/Window/WindowManager.hpp"
#include "Utilities/HashGenerator.hpp"
#include "Utilities/StringUtils.hpp"
#include "Utilities/Config.hpp"
#include "Resources/ResourceManager.hpp"
#include "Performance/Profiler.hpp"
#include "Scene/SceneManager.hpp"
#include "Scene/Camera/CameraManager.hpp"
#include "Scene/Light/LightManager.hpp"
#include "Graphics/GraphicsDriver.hpp"
#include "Threads/ThreadManager.hpp"

//------------------------------------------------------------------------------------------

namespace Ocular
{
    class Engine : public Core::AEventListener
    {
    public:

        static Engine& get();
        ~Engine();

        bool initialize(Graphics::GraphicsDriver* driver);

        bool shutdown();

        bool isRunning() const;

        bool run();

        //----------------------------------------------------------------------------------
        // Core Subsystem Retrieval

        std::shared_ptr<Core::Logger> Logger() const;

        std::shared_ptr<Core::Clock> Clock() const;

        std::shared_ptr<Core::EventManager> EventManager() const;

        std::shared_ptr<Core::WindowManager> WindowManager() const;

        std::shared_ptr<Core::ThreadManager> ThreadManager() const;
        
        std::shared_ptr<Utils::HashGenerator> HashGenerator() const;
        
        std::shared_ptr<Utils::String> StringUtils() const;
        
        std::shared_ptr<Utils::Config> Config() const;

        std::shared_ptr<Core::ResourceManager> ResourceManager() const;

        std::shared_ptr<Core::SceneManager> SceneManager() const;

        std::shared_ptr<Core::CameraManager> CameraManager() const;

        std::shared_ptr<Core::LightManager> LightManager() const;

        std::shared_ptr<Core::Profiler> Profiler() const;

        std::shared_ptr<Core::InputHandler> Input() const;

        std::shared_ptr<Graphics::GraphicsDriver> GraphicsDriver() const;

        //----------------------------------------------------------------------------------
        
    protected:

        virtual bool onEvent(std::shared_ptr<Core::AEvent> event);

    private:

        Engine();
        Engine(Engine const&) = delete;
        void operator=(Engine const&) = delete;

        // Running

        void update();
        void render();

        // Setup

        void setupLogger();
        void setupEvents();
        void setupConfig();
        void createDefaultConfig();

        void shutdownWindowManager();
        
        //--------------------------------------------

        std::shared_ptr<Core::Clock>              m_Clock;
        std::shared_ptr<Core::EventManager>       m_EventManager;
        std::shared_ptr<Core::InputHandler>       m_InputHandler;
        std::shared_ptr<Core::Logger>             m_Logger;
        std::shared_ptr<Core::ResourceManager>    m_ResourceManager;
        std::shared_ptr<Core::SceneManager>       m_SceneManager;
        std::shared_ptr<Core::CameraManager>      m_CameraManager;
        std::shared_ptr<Core::LightManager>       m_LightManager;
        std::shared_ptr<Core::WindowManager>      m_WindowManager;
        std::shared_ptr<Core::ThreadManager>      m_ThreadManager;
        std::shared_ptr<Utils::HashGenerator>     m_HashGenerator;
        std::shared_ptr<Utils::String>            m_StringUtils;
        std::shared_ptr<Utils::Config>            m_Config;
        std::shared_ptr<Core::Profiler>           m_Profiler;
        std::shared_ptr<Graphics::GraphicsDriver> m_GraphicsDriver;

        bool m_IsRunning;
    };
}
#define OcularEngine    Ocular::Engine::get()
#define OcularLogger    OcularEngine.Logger()
#define OcularClock     OcularEngine.Clock()
#define OcularScene     OcularEngine.SceneManager()
#define OcularCameras   OcularEngine.CameraManager()
#define OcularLights    OcularEngine.LightManager()
#define OcularEvents    OcularEngine.EventManager()
#define OcularInput     OcularEngine.Input()
#define OcularResources OcularEngine.ResourceManager()
#define OcularWindows   OcularEngine.WindowManager()
#define OcularThreads   OcularEngine.ThreadManager()
#define OcularProfiler  OcularEngine.Profiler()
#define OcularGraphics  OcularEngine.GraphicsDriver()
#define OcularString    OcularEngine.StringUtils()
#define OcularConfig    OcularEngine.Config()

#define OCULAR_INTERNAL_LOG(a,b) " [", a, "::", b, " @ ", __LINE__, "]"
// Example usage:
// OcularLogger->error("Some error message", OCULAR_INTERNAL_LOG("ClassWithError", "MethodWithError"));
// Outputs: "Some error message [ClassWithError::MethodWithError @ 220]"

#endif