Engine.hpp

Go to the documentation of this file.

//
//  CeresEngine - A game development framework
//
//  Created by Rogiel Sulzbach.
//  Copyright (c) 2018-2022 Rogiel Sulzbach. All rights reserved.
//
 
#pragma once
 
#include "CeresEngine/DataTypes.hpp"
#include "CeresEngine/Macros.hpp"
 
#include "CeresEngine/Foundation/IO/URLSession.hpp"
#include "CeresEngine/Foundation/Threading/ExecutionContext.hpp"
#include "CeresEngine/Foundation/Threading/ThreadPool.hpp"
 
#include "CeresEngine/Audio/AudioSystem.hpp"
#include "CeresEngine/Entity/EntityManager.hpp"
#include "CeresEngine/Entity/EventManager.hpp"
#include "CeresEngine/Entity/SystemManager.hpp"
#include "CeresEngine/Input/InputManager.hpp"
#include "CeresEngine/Input/InputSystem.hpp"
#include "CeresEngine/Network/NetworkSystem.hpp"
#include "CeresEngine/Physics/PhysicsSystem.hpp"
#include "CeresEngine/Platform/Platform.hpp"
#include "CeresEngine/Platform/PlatformWindow.hpp"
#include "CeresEngine/RenderAPI/RenderAPI.hpp"
#include "CeresEngine/Renderer/RenderingSystem.hpp"
#include "CeresEngine/Resource/ResourceManager.hpp"
#include "CeresEngine/Scene/Camera.hpp"
#include "CeresEngine/Scene/Scene.hpp"
#include "CeresEngine/Scripting/ScriptingSystem.hpp"
 
#include "CeresEngine/Audio/API/AudioAPI.hpp"
 
namespace CeresEngine {
 
    class CE_SCRIPT_EXPORT() Engine {
    public: // Services
        //        CE_SCRIPT_EXPORT(pass = "ref", readonly = true)
        UPtr<ExecutionContext> backgroundQueue;
 
        template<typename T> struct Service {
        private:
            UPtr<T> mService = nullptr;
 
        public:
            explicit Service() noexcept = default;
 
            Service(const Service&) noexcept = delete;
            Service& operator=(const Service&) noexcept = delete;
 
            Service(Service&&) noexcept = delete;
            Service& operator=(Service&&) noexcept = delete;
 
            ~Service() noexcept { CE_ASSERT(mService == nullptr && "Service being destroyed while still initialized."); }
 
            [[nodiscard]] bool has() const noexcept { return mService != nullptr; }
 
            [[nodiscard]] T& get() const noexcept {
                CE_ASSERT(mService != nullptr && "Trying to get an uninitialized service!");
                return *mService;
            }
 
            [[nodiscard]] T* getPointer() const noexcept { return mService.get(); }
 
            template<typename TT = T, typename... Args> TT& create(Args&&... args) {
                if constexpr(std::is_constructible_v<TT, Engine&, Args...>) {
                    assign(ce_unique_new<TT>(*this, std::forward<Args>(args)...));
                } else if constexpr(std::is_constructible_v<TT, Engine*, Args...>) {
                    assign(ce_unique_new<TT>(this, std::forward<Args>(args)...));
                } else {
                    assign(ce_unique_new<TT>(std::forward<Args>(args)...));
                }
                return static_cast<TT&>(get());
            }
 
            void destroy() noexcept { assign(nullptr); }
 
            void assign(UPtr<T>&& service) noexcept { mService = std::move(service); }
 
            template<typename TT> [[nodiscard]] bool is() const noexcept { return dynamic_cast<const TT*>(mService.get()) != nullptr; }
 
            [[nodiscard]] explicit operator bool() const noexcept { return has(); }
 
            [[nodiscard]] CE_EXPLICIT(false) operator T&() const { return get(); } // NOLINT
 
            [[nodiscard]] CE_EXPLICIT(false) operator T*() const { return getPointer(); } // NOLINT
 
            [[nodiscard]] T& operator*() const { return get(); }
 
            [[nodiscard]] T* operator->() const {
                CE_ASSERT(mService != nullptr && "Trying to get an uninitialized service!");
                return getPointer();
            }
 
            Service& operator=(UPtr<T>&& service) noexcept {
                assign(std::forward<decltype(service)>(service));
                return *this;
            }
        };
 
        Service<RunLoop> mainRunLoop;
 
        CE_SCRIPT_EXPORT(pass = "ref", readonly = true)
        Service<ResourceManager> resourceManager;
 
        CE_SCRIPT_EXPORT(pass = "ref", readonly = true)
        Service<RenderAPI> renderAPI;
 
        CE_SCRIPT_EXPORT(pass = "ref", readonly = true)
        Service<AudioAPI> audioAPI;
 
        Service<InputProvider> inputProvider;
 
        CE_SCRIPT_EXPORT(pass = "ref", readonly = true)
        Service<InputManager> inputManager;
 
        Service<SceneManager> sceneManager;
 
        Service<Renderer> renderer;
 
        CE_SCRIPT_EXPORT(pass = "ref", readonly = true)
        Service<Platform> platform;
 
        CE_SCRIPT_EXPORT(pass = "ref", readonly = true)
        Service<URLSession> urlSession;
 
    public:
        CE_SCRIPT_EXPORT(readonly = true)
        double lastSimulationTime = 0.0;
 
        CE_SCRIPT_EXPORT(readonly = true)
        double lastRenderTime = 0.0;
 
        UInt64 visibleObjects = 0;
 
    public:
        CE_SCRIPT_EXPORT()
        Engine();
 
        Engine(const Engine& engine) = delete;
        Engine& operator=(const Engine& engine) = delete;
 
        virtual ~Engine();
 
    public:
        [[nodiscard]] CE_SCRIPT_EXPORT(property = "getter", name = "shared")
        static Engine& shared() noexcept;
    };
 
    Engine& gEngine() noexcept;
 
} // namespace CeresEngine