device.h

#ifndef OE_CORE_DEVICE_H
#define OE_CORE_DEVICE_H
 
#include "datatypes.h"
#include <string>
#include <chrono>
#include <glm/vec2.hpp>
 
namespace oe::core
{
    class Window;
 
    class Device
    {
        public:
            Device();
 
            Device(const std::string& title);
 
            Device(const glm::ivec2& dimensions, const std::string& title, bool is_visible = true);
 
            ~Device();
 
            bool canRun() const;
 
            void processEvents();
 
            double getTime() const;
 
            inline std::chrono::nanoseconds getDeltaTime() const noexcept
            {
                return _last_delta_time;
            }
 
            void setSwapInterval(const int32_t interval);
 
            void setMaxFps(const uint32_t max_fps)
            {
                minimum_frame_time = std::chrono::milliseconds(static_cast<int32_t>(1000.f / max_fps));
            }
 
            void limitFps();
 
            const auto& getWindows() const
            {
                return _windows;
            }
 
            size_t addWindow(const glm::ivec2& dimensions, const std::string& title, bool is_visible = true);
 
            void removeWindow(const size_t id);
 
            Window* getWindowById(const size_t id);
 
            const Window* getWindowById(const size_t id) const;
 
            Window& getWindow(const size_t id = 0)
            {
                return *getWindowById(id);
            }
 
            const Window& getWindow(const size_t id = 0) const
            {
                return *getWindowById(id);
            }
 
            const std::string getKeyName(const key_code_t& key) const noexcept;
 
            const std::string getScancodeName(const key_code_t& scancode) const noexcept;
 
            key_code_t getScanCodeFromKey(const key_code_t& key) const noexcept;
 
            std::chrono::duration<float> minimum_frame_time = std::chrono::milliseconds(4);
 
        private:
            void _init();
 
            std::chrono::nanoseconds _last_delta_time = {};
 
            std::chrono::time_point<std::chrono::steady_clock> _start_frame;
 
            std::vector<std::pair<size_t, Window*>> _windows;
 
            size_t _next_window_id = 0;
    };
}
 
#endif