engine.hpp

Go to the documentation of this file.

#pragma once

#include "Engine/api.hpp"
#include "Engine/Window/Window.hpp"
#include "Engine/Input/InputManager.hpp"
#include "Engine/Renderer/Renderer.hpp"
#include "Engine/Camera/Camera.hpp"
#include "Engine/Utility/Time.hpp"
#include "Engine/Entity/EntitySystem.hpp"
#include "Engine/Resources/ResourceManager.hpp"
#include "Engine/Collision/CollisionSystem.hpp"
#include "Engine/Utility/Random.hpp"

#include <ThirdParty/cereal/include/cereal/cereal.hpp>

namespace Engine
{
    struct EngineInitializationData
    {
        int windowWidth = 640;
        int windowHeight = 480;
        std::string windowTitle = "";

        //Need to keep the lowecase s due to the way cereal works
        template <class Archive>
        void serialize(Archive& ar);
    };

    class ENGINE_API Engine
    {
    public:
        static eastl::weak_ptr<Engine> InitializeEngine(bool isPlaying = true) noexcept;

        static eastl::weak_ptr<Engine> GetEngine() noexcept;

        eastl::weak_ptr<Window> GetWindow() noexcept;

        template<typename WindowType>
        eastl::weak_ptr<WindowType> GetWindow();

        eastl::weak_ptr<Window> CreateAndReturnWindow(int width, int height, const char* title) noexcept;

        eastl::weak_ptr<InputManager> GetInputManager() noexcept;

        eastl::weak_ptr<Renderer> GetRenderer() noexcept;

        template<typename RendererType>
        eastl::weak_ptr<RendererType> GetRenderer();

        eastl::weak_ptr<Camera> GetCamera() noexcept;

        eastl::weak_ptr<Time> GetTime() noexcept;

        eastl::weak_ptr<EntitySystem> GetEntitySystem() const noexcept;

        eastl::weak_ptr<ResourceManager> GetResourceManager() const noexcept;

        eastl::weak_ptr<CollisionSystem> GetCollisionSystem() const noexcept;

        eastl::weak_ptr<Random> GetRandom();

        void Update() noexcept;

        void Destroy() noexcept;

        void SetIsPlaying(bool isPlaying);
        bool GetIsPlaying();

    private:
        explicit Engine() = default;
    public:
        ~Engine() = default;
    private:

        EngineInitializationData LoadEngineSettings();
        void SaveEngineSettings();

        void Render() noexcept;

        static eastl::shared_ptr<Engine> instance;
        eastl::shared_ptr<Window> window;
        eastl::shared_ptr<InputManager> inputManager;
        eastl::shared_ptr<Renderer> renderer;
        eastl::shared_ptr<Camera> camera;
        eastl::shared_ptr<Time> time;
        eastl::shared_ptr<EntitySystem> entitySystem;
        eastl::shared_ptr<ResourceManager> resourceManager;
        eastl::shared_ptr<CollisionSystem> collisionSystem;
        eastl::shared_ptr<Random> random;
        bool isPlaying;
    };

    template <class Archive>
    void EngineInitializationData::serialize(Archive& ar)
    {
        ar(CEREAL_NVP(windowWidth),
            CEREAL_NVP(windowHeight),
            CEREAL_NVP(windowTitle));
    }

    template <typename WindowType>
    eastl::weak_ptr<WindowType> Engine::GetWindow()
    {
        if (instance->window == nullptr)
            GetWindow();

        if (dynamic_cast<WindowType*>(instance->window.get()))
            return eastl::static_pointer_cast<WindowType>(instance->window);
        return eastl::weak_ptr<WindowType>();
    }

    template <typename RendererType>
    eastl::weak_ptr<RendererType> Engine::GetRenderer()
    {
        if (instance->renderer == nullptr)
            GetRenderer();

        if (dynamic_cast<RendererType*>(instance->renderer.get()))
            return eastl::static_pointer_cast<RendererType>(instance->renderer);
        return eastl::shared_ptr<RendererType>();
    }

} //namespace Engine