Window.hpp

#ifndef MYGL_WINDOW
#define MYGL_WINDOW
 
#include "mygl_export.h"
 
#include <glad/gl.h>
#define GLFW_INCLUDE_NONE
#include <GLFW/glfw3.h>
 
#include "Camera.hpp"
#include "Color.hpp"
#include "Cursor.hpp"
#include "Drawable/AbstractShape.hpp"
#include "Event.hpp"
#include "Image.hpp"
 
#include <chrono>
#include <deque>
#include <unordered_map>
 
namespace my
{
    enum WindowFlag : unsigned int {
        none = 0,
        resizable = 1 << 0,
        floating = 1 << 1,
        transparent = 1 << 2,
        maximized = 1 << 3
    };
 
    class Window
    {
    private:
        static bool gladIsInitialized;
        static unsigned int instancesCount;
        static std::unordered_map<GLFWwindow*, Window*> windows;
        static my::Camera defaultCamera;
 
        glm::mat4 m_projection;
        my::Camera* p_camera;
        GLFWwindow* p_window;
        my::Cursor m_cursor;
        glm::ivec2 m_size;
        bool m_usable;
        std::chrono::microseconds m_frameDelay;
        mutable std::chrono::microseconds m_frametime;
        mutable std::chrono::time_point<std::chrono::steady_clock> m_chrono;
        std::deque<Event> m_eventQueue;
 
        static void keyCallback(GLFWwindow* window, int key, int scancode, int action, int mods);
        static void mouseButtonCallback(GLFWwindow* window, int button, int action, int mods);
        static void cursorPosCallback(GLFWwindow* window, double xpos, double ypos);
        static void cursorEnterCallback(GLFWwindow* window, int entered);
        static void scrollCallback(GLFWwindow* window, double xoffset, double yoffset);
        static void framebufferSizeCallback(GLFWwindow* window, int width, int height);
        static void windowCloseCallback(GLFWwindow* window);
    public:
        MYGL_EXPORT Window();
 
        MYGL_EXPORT Window(int width, int height, const std::string& title, unsigned int flags = my::WindowFlag::none, int antiAliasing = 0, int GLVersionMajor = 3,
          int GLVersionMinor = 3);
 
        MYGL_EXPORT ~Window();
 
        MYGL_EXPORT bool isRunning() const noexcept;
 
        MYGL_EXPORT void close();
 
        MYGL_EXPORT bool pollEvent(my::Event& e);
 
        MYGL_EXPORT void setActive() noexcept;
 
        MYGL_EXPORT void setFramerate(unsigned int limit);
 
        MYGL_EXPORT void enableVsync(bool enable);
 
        MYGL_EXPORT void clear(const my::Color& color) const;
 
        MYGL_EXPORT void setClipPlanes(float left, float right, float bottom, float top);
 
        MYGL_EXPORT void setViewport(int x, int y, int width, int height);
 
        MYGL_EXPORT void setCamera(my::Camera& camera) noexcept;
 
        MYGL_EXPORT my::Camera& getCamera() noexcept;
 
        MYGL_EXPORT void setSize(unsigned int width, unsigned int height, bool resizeViewport = false);
 
        MYGL_EXPORT glm::ivec2 getSize() const noexcept;
 
        MYGL_EXPORT void setIcon(const Image& icon);
 
        MYGL_EXPORT void setCursor(const Cursor& cursor) noexcept;
 
        MYGL_EXPORT void draw(my::AbstractShape& shape) const;
 
        MYGL_EXPORT void display() const;
 
        MYGL_EXPORT double getFrametime() const;
 
        static void* getGLProcAdress(const char* name);
    };
 
} // namespace my
 
#endif // MYGL_WINDOW