window.h

#pragma once
#include <glad/glad.h>
#include <GLFW/glfw3.h>
#include "../io-management/ioHandler.h"
 
namespace Aire {
 
    class Window {
    public:
        Window(int width, int height, const char* title, bool fullscreen = false);
 
        // Delete copy constructor and assignment operator
        Window(const Window&) = delete;
        Window& operator=(const Window&) = delete;
 
        GLFWwindow* getInternalPtr();
 
        const char* getTitle() const;
 
        IOHandler* getIOHandler() const;
 
        int getWidth() const;
 
        int getHeight() const;
 
        void getFramebufferSize(int& width, int& height) const;
 
        float getAspectRatio() const;
 
        bool isFullscreen() const;
 
        bool isMinimized() const;
 
        bool shouldClose() const;
 
        bool toggleFullscreen();
 
        void attachIOHandler(IOHandler& handler);
 
        void setAsCurrentRenderWindow();
 
        void update();
 
        void close();
 
        ~Window();
 
    private:
        GLFWwindow* window;
        const char* title;
        IOHandler* ioHandler;
 
        // Store the size and position of the window before entering 
        // fullscreen mode so they can be properly restored afterwards.
        // DO NOT read these values for other purposes because
        // they are not kept in sync with the current window size
        // and position.
        int prevWidth;
        int prevHeight;
        int prevXPos;
        int prevYPos;
 
        bool fullscreen;//< true if in fullscreen mode and false otherwise
 
        static int numWindows;//< support for multiple windows
    };
 
    //##########################################//
    //######## INLINE DEFINITIONS BELOW ########//
    //##########################################//
 
    inline GLFWwindow* Window::getInternalPtr() {
        return window;
    }
 
    inline const char* Window::getTitle() const {
        return title;
    }
 
    inline IOHandler* Window::getIOHandler() const {
        return ioHandler;
    }
 
    inline int Window::getWidth() const {
        int width = 0;
        glfwGetWindowSize(window, &width, nullptr);
        return width;
    }
 
    inline int Window::getHeight() const {
        int height = 0;
        glfwGetWindowSize(window, nullptr, &height);
        return height;
    }
 
    inline void Window::getFramebufferSize(int& width, int& height) const {
        glfwGetFramebufferSize(window, &width, &height);
    }
 
    inline float Window::getAspectRatio() const {
        int width = 0;
        int height = 0;
        getFramebufferSize(width, height);
        return float(width) / float(height);
    }
 
    inline bool Window::isFullscreen() const {
        return fullscreen;
    }
 
    inline bool Window::isMinimized() const {
        return glfwGetWindowAttrib(window, GLFW_ICONIFIED);
    }
 
    inline bool Window::shouldClose() const {
        return glfwWindowShouldClose(window);
    }
 
    inline void Window::setAsCurrentRenderWindow() {
        glfwMakeContextCurrent(window);
    }
 
    inline void Window::close() {
        glfwSetWindowShouldClose(window, GLFW_TRUE);
    }
}