Engine.hpp

Go to the documentation of this file.

#pragma once
 
#include "NonCopyable.hpp"
#include "Types.hpp"
 
#include "Events.hpp"
#include "LuaManager.hpp"
#include "Registry.hpp"
#include "Renderer.hpp"
#include "ResourceManager.hpp"
#include "SceneManager.hpp"
#include "SystemManager.hpp"
#include "entt/entt.hpp"
#include "raylib.h"
 
#include "Systems/AudioSystem.hpp"
#include "Systems/InputSystem.hpp"
 
#ifndef __EMSCRIPTEN__
#include "Networking/AsyncNetwork.hpp"
#include "bsThreadPool/BS_thread_pool.hpp"
#endif
 
#include <string>

 
using Dispatcher = entt::dispatcher;
 
#define REGISTRY Engine::Get().registry
#define DISPATCHER Engine::Get().dispatcher
 
// Core
#define RENDERER Engine::Get().renderer
#define RESOURCE_MANAGER Engine::Get().resourceManager
#define SCENE_MANAGER Engine::Get().sceneManager
#define SYSTEM_MANAGER Engine::Get().systemManager
#define LUA_MANAGER Engine::Get().luaManager
 
#ifndef __EMSCRIPTEN__
#define NETWORK Engine::Get().network
#define THREAD_POOL Engine::Get().threadPool
#endif
 
// Systems
#define INPUT_SYSTEM SYSTEM_MANAGER.GetSystem<InputSystem>()
#define AUDIO_SYSTEM SYSTEM_MANAGER.GetSystem<AudioSystem>()

struct WindowInfo
{
    u32 width = 1280;
    u32 height = 720;
    std::string title;
 
    u32 virtualWidth = 1920;
    u32 virtualHeight = 1080;
 
    bool fullscreen = false;
    bool borderlessFullscreen = false;
    bool resizable = false;
    bool undecorated = false;
    bool topmost = false;
    bool alwaysRun = false;
    bool transparent = false;
    bool highDpi = false;
    bool msaa4x = false;
};

class Engine : public NonCopyable<>
{
public:

    Engine(const WindowInfo& windowInfo);
 
    ~Engine();

    template <typename T, typename... Args>
    void SetFirstScene(Args&&... args)
    {
        m_sceneManager.AddScene<T>(std::forward<Args>(args)...);
        m_sceneManager.ChangeScene<T>();
    }

    void Run(const u32 targetFps, const u32 updateFrequency, const u8 maxUpdatesPerFrame = 5);

    double GetUpdateTime() const;

    double GetDrawTime() const;

    static Engine& Get();

    Registry& registry = m_registry;

    Dispatcher& dispatcher = m_dispatcher;

    Renderer& renderer = m_renderer;

    ResourceManager& resourceManager = m_resourceManager;

    SceneManager& sceneManager = m_sceneManager;

    SystemManager& systemManager = m_systemManager;

    LuaManager& luaManager = m_luaManager;
 
#ifndef __EMSCRIPTEN__
    AsyncNetwork& network = m_network;

    BS::thread_pool<BS::tp::none> threadPool;
#endif
 
private:
 
    static void SetFlags(const WindowInfo& windowInfo);
 
    void RaylibResourceManager();
 
    // Event handling
    void OnCloseGameEvent(const Event::CloseGame& event);
 
    // Ecs
    Registry m_registry;
    Dispatcher m_dispatcher;
 
    // Core systems
    Renderer m_renderer;
    ResourceManager m_resourceManager;
    SceneManager m_sceneManager;
    SystemManager m_systemManager;
    LuaManager m_luaManager;
 
#ifndef __EMSCRIPTEN__
    AsyncNetwork m_network;
#endif
 
    // Timings
    double m_updateTime = 0;
    double m_drawTime = 0;
 
    // Canvas
    RenderTexture2D m_canvas;
    u32 m_virtualWidth = 0;
    u32 m_virtualHeight = 0;
 
    bool m_running = true;
 
    static inline Engine* s_engine = nullptr;
};