engine.h

Go to the documentation of this file.

#pragma once
 
#include "core/engine_config.h"
#include "core/io/file_system.h"
#include "systems/audio_manager.h"
#include "systems/input_manager.h"
#include "systems/time_manager.h"
 
#pragma region ENGINE_SYSTEMS
#include "core/systems/physics_sys.h"
#include "core/systems/thread_pool.h"
#pragma endregion
#include <random>
 
class Renderer;
class OpenglShader;
class OpenglRenderer;
 
 
constexpr float PIXELS_PER_METER = 32.0f;
constexpr float METERS_PER_PIXEL = 1.0f / PIXELS_PER_METER;
 
class Engine {
public:
    Engine();
 
    struct {
        float width                 = 0;
        float height                = 0;
        const SDL_DisplayMode* data = nullptr;
        int bbWidth = 0, bbHeight = 0; // backbuffer
        SDL_Window* handle{};
    } Window;
 
    EngineConfig Config{};
 
    struct {
        SDL_AudioDeviceID device_id = 0;
        SDL_AudioSpec spec{};
        float global_volume = 1.f;
    } Audio;
 
    Ember_VFS VirtualFileSystem{};
 
    bool is_running = false;
 
    void resize_window(int w, int h);
 
    [[nodiscard]] Renderer* get_renderer() const;
 
    [[nodiscard]] InputManager* input_manager() const;
 
    [[nodiscard]] TimeManager* time_manager() const;
 
    void shutdown();
 
 
    void set_vsync(bool enabled);
 
    bool initialize(int width, int height, Backend type, Uint64 flags = 0);
 
    void update(double delta_time = 0);
 
    [[nodiscard]] b2WorldId get_physics_world() const;
 
    template <typename T>
    T* get_system();
 
private:
    double _physics_accumulator = 0.0;
 
    std::vector<std::unique_ptr<EngineManager>> _systems{};
 
    Renderer* _renderer          = nullptr;
    InputManager* _input_manager = nullptr;
    TimeManager* _time_manager   = nullptr;
 
    b2WorldId _world;
 
    Renderer* _create_renderer_internal(SDL_Window* window, int view_width, int view_height, Backend type);
 
    Renderer* _create_renderer_gl(SDL_Window* window, int view_width, int view_height);
 
    Renderer* _create_renderer_metal(SDL_Window* window, int view_width, int view_height);
};
 
template <typename T>
T* Engine::get_system() {
 
    for (auto& sys : _systems) {
        if (T* casted = dynamic_cast<T*>(sys.get())) {
            return casted;
        }
    }
 
    return nullptr;
}
 
// Global engine instance
extern std::unique_ptr<Engine> GEngine;
 
// Global audio engine instance (Miniaudio)
extern ma_engine audio_engine;
 
b2Vec2 pixels_to_world(const glm::vec2& pixel_pos);
 
glm::vec2 world_to_pixels(const b2Vec2& world_pos);
 
template <typename T>
T random(T min, T max) {
    static std::random_device rd;
    static std::mt19937 gen(rd());
    if constexpr (std::is_integral_v<T>) {
        std::uniform_int_distribution<T> dist(min, max);
        return dist(gen);
    } else if constexpr (std::is_floating_point_v<T>) {
        std::uniform_real_distribution<T> dist(min, max);
        return dist(gen);
    } else {
        static_assert("Unsupported type for random function");
    }
 
    return T{0};
}