Engine.hpp

Go to the documentation of this file.

 
// Windows specific bugs (why they are there? because i visit this file unlike ErrorUtils or other stuff):
// @todo (Windows only) Fix building in editor fails but succeds with cli ProjectBuilder.exe
// @todo (Windows only) Fix console doubling every line
// @todo (Windows only) Fix editor being vsynced despite vsync disabled but only when app started with vsync i think LMAO
 
#pragma once
 
#if defined(_WIN32)
  #define NOMINMAX
#endif
 
#include <cstdint>
#include <memory>
#define SDL_MAIN_HANDLED
#include <SDL3/SDL.h>
#include "components/ECS/ECS.hpp"
 
#include "components/ResolutionManager.hpp"
#include "components/GameInfo.hpp"
#include "components/ImGUIWrapper.hpp"
#include "components/GameComponents/BasicComponents.hpp"
#include "components/InputSystem.hpp"
#include "components/Environment.hpp"
#include "components/UI/VexUI.hpp"
#include "components/PhysicsSystem.hpp"
#include "components/AudioSystem.hpp"
#include "components/DebugConsole.hpp"
 
#include "VEX/VEX_export.h"
 
namespace vex {
 
class Window;
class Interface;
class VirtualFileSystem;
class SceneManager;
 
struct SkipInit {};

class VEX_EXPORT Engine {
public:
    static const char* GetBuildHash();

    static int GetVersionMajor();

    static int GetVersionMinor();

    static int GetVersionPatch();

    static const char* GetVersionString();

    Engine(const char* title, int width, int height, GameInfo gInfo);
    ~Engine();

    virtual bool IsEditor() { return false; }

    void run(std::function<void()> onUpdateLoop = nullptr);

    vex::Entity getCamera() {
        vex::Entity cameraEntity = vex::NULL_ENTITY;
        vex::View<CameraComponent> view(m_registry);
        view.each([&cameraEntity](vex::Entity e, CameraComponent&) {
            if (cameraEntity == vex::NULL_ENTITY) {
                cameraEntity = e;
            }
        });
        return cameraEntity;
    }

    void setResolutionMode(ResolutionMode mode);

    void setPaused(bool paused) { m_paused = paused; }

    bool isPaused() const { return m_paused; }

    ResolutionMode getResolutionMode() const { return m_resolutionManager->getCurrentMode(); }

    ResolutionManager* getResolutionManager() const { return m_resolutionManager.get(); }

    void setInputMode(InputMode mode) { m_inputSystem->setInputMode(mode); }

    InputMode getInputMode() const { return m_inputSystem->getInputMode(); }

    void setEnvironmentSettings(environment settings);

    environment getEnvironmentSettings();

    Interface* getInterface();

    std::shared_ptr<VirtualFileSystem> getFileSystem() { return m_vfs; }

    vex::Registry& getRegistry() { return m_registry; }

    PhysicsSystem* getPhysicsSystem() { return m_physicsSystem.get(); }

    SceneManager* getSceneManager();

    std::shared_ptr<VexUI> createVexUI();

    int GetCurrentFrame() { return m_frame; }

    void setRenderPhysicsDebug(bool value) { m_renderPhysicsDebug = value; }

    virtual void setFullscreen(bool enabled, bool exclusive = false);

    bool isFullscreen();

    std::vector<std::string> getLastLoadedScenes() { return lastLoadedScenes; }

    void prepareScenesForHotReload();

    virtual void processEvent(const SDL_Event& event, float deltaTime);

    virtual void beginGame();

    virtual void update(float deltaTime);

    virtual void render();

    virtual void refreshForObject() {
        log("Editor use only");
    }

    void quit(){ m_running = false; }

    void WaitForGpu();

    void setFrameLimit(int fps);
    int getFrameLimit() const { return m_targetFps; }

    void setVSync(bool enabled);

    bool getVSync() const;

    float getDeltaTime() const { return m_deltaTime; }

    std::shared_ptr<AudioSystem> getAudioSystem() const { return m_audioSystem; }
 
protected:

    Engine(SkipInit);
 
    std::shared_ptr<Window> m_window;
    std::shared_ptr<VirtualFileSystem> m_vfs;
    std::shared_ptr<AudioSystem> m_audioSystem;
 
    std::unique_ptr<Interface> m_interface;
    std::unique_ptr<ResolutionManager> m_resolutionManager;
    std::unique_ptr<ImGUIWrapper> m_imgui;
    std::unique_ptr<InputSystem> m_inputSystem;
    std::unique_ptr<PhysicsSystem> m_physicsSystem;
    std::unique_ptr<SceneManager> m_sceneManager;
 
    vex::Registry m_registry;
 
    bool m_running = true;
    bool m_paused = false;
    bool m_internally_paused = false; // to pause if the window is in the background.
    bool m_renderPhysicsDebug = false;
    int m_frame = 0;
 
    int m_targetFps = 0;
    bool m_vsyncEnabled = false;
 
    float m_deltaTime = 0.016f;
 
    #ifdef __linux__
        bool m_isWayland = false;
    #endif
 
    GameInfo m_gameInfo;
    std::vector<std::string> lastLoadedScenes;
};
}