Window.hpp

Go to the documentation of this file.

 
 
#ifndef GALAXY_CORE_WINDOW_HPP_
#define GALAXY_CORE_WINDOW_HPP_
 
#include <entt/signal/fwd.hpp>
#include <glad/glad.h>
#include <GLFW/glfw3.h>
 
#include "galaxy/core/WindowSettings.hpp"
#include "galaxy/input/Clipboard.hpp"
#include "galaxy/input/Cursor.hpp"
#include "galaxy/input/Keyboard.hpp"
#include "galaxy/input/Mouse.hpp"
 
namespace galaxy
{
    namespace core
    {
        class Window final
        {
        public:
            Window(const WindowSettings& settings);
 
            ~Window();
 
            [[nodiscard]]
            bool is_open() const;
 
            void close();
 
            void destroy();
 
            void poll_events();
 
            void resize(const int width, const int height);
 
            void request_attention();
 
            void focus() const;
 
            void maximize();
 
            void restore();
 
            void minimize() const;
 
            void fullscreen();
 
            void set_title(const std::string& title);
 
            void append_title(const std::string& append);
 
            void set_icon(const std::string& icon);
 
            void set_icon(std::span<std::uint8_t> buffer);
 
            void set_dispatcher(entt::dispatcher* dispatcher);
 
            [[nodiscard]]
            bool is_focused() const;
 
            [[nodiscard]]
            int window_width() const;
            [[nodiscard]]
            int window_height() const;
            [[nodiscard]]
            int frame_width() const;
            [[nodiscard]]
            int frame_height() const;
            [[nodiscard]]
            float aspect_ratio() const;
 
            template<meta::is_input_device Device>
            [[nodiscard]]
            Device& get_input();
 
            [[nodiscard]]
            const meta::vector<std::string>& get_drop_paths() const;
 
            [[nodiscard]]
            glm::ivec2 get_framebuffer_size();
 
            [[nodiscard]]
            glm::vec2 get_content_scale();
 
            [[nodiscard]]
            float get_content_scale_max();
 
            [[nodiscard]]
            GLFWwindow* handle();
 
        private:
            Window() = delete;
 
            Window(const Window&) = delete;
 
            Window(Window&&) = delete;
 
            Window& operator=(const Window&) = delete;
 
            Window& operator=(Window&&) = delete;
 
        private:
            std::string m_title;
 
            int m_window_width;
 
            int m_window_height;
 
            int m_frame_width;
 
            int m_frame_height;
 
            float m_aspect_ratio;
 
            GLFWwindow* m_window;
 
            entt::dispatcher* m_dispatcher;
 
            GLFWallocator m_glfw_allocator;
 
            input::Keyboard m_keyboard;
 
            input::Mouse m_mouse;
 
            input::Cursor m_cursor;
 
            input::Clipboard m_clipboard;
 
            meta::vector<std::string> m_drop_paths;
        };
 
        template<meta::is_input_device Device>
        inline Device& Window::get_input()
        {
            if constexpr (std::is_same<Device, input::Keyboard>::value)
            {
                return m_keyboard;
            }
            else if constexpr (std::is_same<Device, input::Mouse>::value)
            {
                return m_mouse;
            }
            else if constexpr (std::is_same<Device, input::Cursor>::value)
            {
                return m_cursor;
            }
            else if constexpr (std::is_same<Device, input::Clipboard>::value)
            {
                return m_clipboard;
            }
        }
    } // namespace core
} // namespace galaxy
 
#endif