device.h

#ifndef OE_CORE_DEVICE_H
#define OE_CORE_DEVICE_H
 
#include "../common.h"
#include <string>
#include <chrono>
#include <glm/vec2.hpp>
#include "event_handler.h"
 
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 double getDeltaTime() const noexcept
            {
                return _last_delta_time;
            }
 
            void setSwapInterval(const int32_t interval);
 
            void setMaxFps(const int max_fps)
            {
                minimum_frame_time = std::chrono::milliseconds(static_cast<int32_t>(1000.f / max_fps));
            }
 
            void limitFps();
 
            const std::vector<Window*> getWindows() const
            {
                return _windows;
            }
 
            int32_t addWindow(const glm::ivec2& dimensions, const std::string& title, bool is_visible = true);
 
            Window& getWindow(const int32_t id = 0);
 
            const Window& getWindow(const int32_t id = 0) const;
 
            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:
            double _last_time_for_delta = 0.0;
            double _last_delta_time = 0.0;
 
            std::chrono::time_point<std::chrono::steady_clock> _start_frame;
 
            std::vector<Window*> _windows;
    };
}
 
#endif