Merge pull request 'brokenbullshit' (#12) from brokenbullshit into main

Reviewed-on: #12

CMakeLists.txt

@@ -18,17 +18,17 @@ include(cmake/CPM.cmake)
 
 CPMAddPackage(
     NAME J3ML
-    URL https://git.redacted.cc/josh/j3ml/archive/Release-2.2.zip
+    URL https://git.redacted.cc/josh/j3ml/archive/Release-3.1.zip
 )
 
 CPMAddPackage(
     NAME Event
-    URL https://git.redacted.cc/josh/Event/archive/Release-6.zip
+    URL https://git.redacted.cc/josh/Event/archive/Release-10.zip
 )
 
 CPMAddPackage(
         NAME jlog
-        URL https://git.redacted.cc/josh/jlog/archive/Prerelease-9.zip
+        URL https://git.redacted.cc/josh/jlog/archive/Prerelease-15.zip
 )
 
 find_package(OpenGL REQUIRED)
@@ -39,12 +39,14 @@ include_directories(${jlog_SOURCE_DIR}/include)
 
 file(GLOB_RECURSE HEADERS "include/*.h" "include/*.hpp")
 
+file(GLOB_RECURSE HEADERS "include/logger/*.h" "include/logger/*.hpp")
+
 if(UNIX AND NOT APPLE)
-    file(GLOB_RECURSE SOURCES "src/types/*.cpp" "src/platform/linux/*.cpp" "src/platform/shared/*.cpp")
+    file(GLOB_RECURSE SOURCES "src/types/*.cpp" "src/platform/linux/*.cpp" "src/platform/shared/*.cpp" "src/logger/*.cpp" )
 endif()
 
 if(WIN32)
-    file(GLOB_RECURSE SOURCES "src/types/*.cpp" "src/platform/windows/*.cpp" "src/platform/shared/*.cpp")
+    file(GLOB_RECURSE SOURCES "src/types/*.cpp" "src/platform/windows/*.cpp" "src/platform/shared/*.cpp" "src/logger/*.cpp")
 endif()
 
 include_directories("include")
@@ -63,7 +65,7 @@ target_include_directories(ReWindowLibrary PUBLIC ${Event_SOURCE_DIR}/include)
 set_target_properties(ReWindowLibrary PROPERTIES LINKER_LANGUAGE CXX)
 
 if(UNIX AND NOT APPLE)
-    target_link_libraries(ReWindowLibrary PUBLIC X11 J3ML Event jlog ${OPENGL_LIBRARIES})
+    target_link_libraries(ReWindowLibrary PUBLIC X11 Xrandr J3ML Event jlog ${OPENGL_LIBRARIES})
     target_link_libraries(ReWindowLibrary PUBLIC)
 
     add_executable(ReWindowLibraryDemo main.cpp)

README.md

@@ -12,7 +12,7 @@ Install dependencies
 
 ```bash
   dnf install cmake make gcc-g++ libX11 libX11-devel
-  apt-get install cmake make gcc g++ libx11-6 libx11-dev libgl-dev
+  apt-get install cmake make gcc g++ libx11-6 libx11-dev libgl-dev libxrandr-dev
 ```
 
 Clone the repository

include/rewindow/logger/logger.h

@@ -0,0 +1,10 @@
+#pragma once
+
+#include "jlog/Logger.hpp"
+
+namespace ReWindow::Logger {
+    using namespace jlog;
+
+    extern GenericLogger Fatal;
+    extern GenericLogger Debug;
+}

include/rewindow/types/display.h

@@ -0,0 +1,39 @@
+#pragma once
+#include <vector>
+#include <J3ML/J3ML.hpp>
+
+namespace ReWindow {
+    class FullscreenGraphicsMode;
+    class Display;
+}
+
+///A given graphics mode that a display supports.
+///Upon startup, We'll poll the display server for this.
+class ReWindow::FullscreenGraphicsMode {
+private:
+    u32 width;
+    u32 height;
+    short refresh_rate;
+public:
+    FullscreenGraphicsMode() = default;
+    FullscreenGraphicsMode(u32 width, u32 height, short refresh_rate);
+    [[nodiscard]] u32 getWidth() const;
+    [[nodiscard]] u32 getHeight() const;
+    [[nodiscard]] float getRefreshRate() const;
+};
+
+///Refers to a particular monitor the user has.
+class ReWindow::Display {
+private:
+    ///* The graphics mode of the display when our program was started. The primary use for this
+    ///* is so that if the user has selected a different mode in-game we can restore the old mode upon exit. *///
+    FullscreenGraphicsMode default_graphics_mode{};
+    ///All graphics modes that a given display supports.
+    std::vector<FullscreenGraphicsMode> graphics_modes;
+public:
+    Display() = default;
+    Display(const FullscreenGraphicsMode& default_graphics_mode, const std::vector<FullscreenGraphicsMode>& graphics_modes);
+    FullscreenGraphicsMode getDefaultGraphicsMode();
+    std::vector<FullscreenGraphicsMode> getGraphicsModes();
+    static std::vector<Display> getDisplaysFromWindowManager();
+};

include/rewindow/types/gamepadbutton.h

@@ -9,7 +9,7 @@
 /// @edit 2024-07-29
 
 #include <string>
-#include <J3ML/LinearAlgebra.h>
+#include <J3ML/LinearAlgebra.hpp>
 
 class GamepadButton {
 protected:

include/rewindow/types/key.h

@@ -8,9 +8,8 @@
 #include <string>
 #include <rewindow/data/X11Scancodes.h>
 #include <rewindow/data/WindowsScancodes.h>
-#include <J3ML/LinearAlgebra/Vector2.h>
+#include <J3ML/LinearAlgebra.hpp>
 
-using J3ML::LinearAlgebra::Vector2;
 
 class Key
 {

include/rewindow/types/window.h

@@ -2,12 +2,14 @@
 #include <cstdint>
 #include <vector>
 #include <Event.h>
+#include <EventConnection.h> // TODO: Fix this shit to where we don't need to include both files they should just be bundled together
 #include <map>
 #include <thread>
 #include <rewindow/types/key.h>
 #include <rewindow/types/cursors.h>
 #include <rewindow/types/mousebutton.h>
 #include <rewindow/types/gamepadbutton.h>
+#include <J3ML/LinearAlgebra.hpp>
 
 using namespace std::chrono_literals;
 using precision_clock = std::chrono::high_resolution_clock;
@@ -102,12 +104,16 @@ namespace ReWindow
 		class MouseButtonDownEvent : public MouseEvent {
 		public:
 			MouseButton Button;
+
+            MouseButtonDownEvent() = default;
 			MouseButtonDownEvent(MouseButton Button) : MouseEvent() {}
 		};
 
 		class MouseButtonUpEvent : public MouseEvent {
 		public:
 			MouseButton Button;
+            MouseButtonUpEvent() = default;
+			MouseButtonUpEvent(MouseButton Button) : MouseEvent() {}
 		};
 
 		class WindowResizeRequestEvent : public RWindowEvent
@@ -134,13 +140,13 @@ namespace ReWindow
 #pragma region Callbacks
 		/// Bindable Non-intrusive event handlers
 		/// Use these when you can't override the base window class
-		Event<> OnOpenEvent;
-        Event<> OnClosingEvent;
+		Event<int> OnOpenEvent;
+        Event<int> OnClosingEvent;
 		Event<RWindowEvent> OnFocusLostEvent;
 		Event<RWindowEvent> OnFocusGainEvent;
 		Event<float> OnRefreshEvent;
 		Event<WindowResizeRequestEvent> OnResizeRequestEvent;
-		Event<KeyDownEvent> OnKeyDownEvent;
+        Event<KeyDownEvent> OnKeyDownEvent;
 		Event<KeyUpEvent> OnKeyUpEvent;
 		Event<MouseMoveEvent> OnMouseMoveEvent;
 		Event<MouseButtonDownEvent> OnMouseButtonDownEvent;
@@ -196,30 +202,24 @@ namespace ReWindow
 		void MessageBox(); // TODO: Must be implemented from scratch as a Motif Window in x11
 
 		/// Returns whether the window currently has mouse and/or keyboard focus.
-		bool isFocused() const;
-		bool isFullscreen() const;
-		bool isResizable() const;
-		bool isVsyncEnabled() const;
+		[[nodiscard]] bool isFocused() const;
+		[[nodiscard]] bool isFullscreen() const;
+		[[nodiscard]] bool isResizable() const;
+		[[nodiscard]] bool isVsyncEnabled() const;
 
-		bool isAlive() const; // TODO: Always returns true.
+		[[nodiscard]] bool isAlive() const; // TODO: Always returns true.
 
-		/// Sets whether the mouse is visible when inside the window.
-		void setMouseVisible(bool visible);
-		void setMouseLocked();
-		void setMouseCenter();
-		void restoreMouseFromLastCenter(); // Feels nicer for users
-
-		bool isKeyDown(Key key) const;
-		bool isMouseButtonDown(MouseButton button) const;
+		[[nodiscard]] bool isKeyDown(Key key) const;
+		[[nodiscard]] bool isMouseButtonDown(MouseButton button) const;
 
 		void setFullscreen(bool fs);
 		void setResizable(bool resizable);
 		void setVsyncEnabled(bool);
 		void setTitle(const std::string& title);
-		std::string getTitle() const;
-		int getWidth() const;  // Honestly no idea if we'll keep these or still go with getSize.
-		int getHeight() const; // getSize wasn't working for me for logging. -maxine
-
+		[[nodiscard]] std::string getTitle() const;
+		[[nodiscard]] int getWidth() const;  // Honestly no idea if we'll keep these or still go with getSize.
+		[[nodiscard]] int getHeight() const; // getSize wasn't working for me for logging. -maxine
+		void setSizeWithoutEvent(const Vector2& size); //AAAAAHHHHHHHHH WINDOZE MAKING THINGS DIFFICULT :/ - Redacted.
 		// TODO: Move out of public API, consumers should use setFullscreen()
 		void fullscreen();
 		// TODO: Move out of public API, consumers should use setFullscreen()
@@ -266,11 +266,22 @@ namespace ReWindow
 		void setCursorStyle(CursorStyle style) const;
 		void setCursorCustomIcon() const;
 
+        void setCursorLocked();
+        void setCursorCenter();
+        void restoreCursorFromLastCenter(); // Feels nicer for users
+
+		///Hides the cursor when it's inside of our window.
+		///Useful for 3D game camera.
+		void setCursorVisible(bool cursor_enable);
+		bool getCursorVisible();
+
 		/// Calls OpenGL's SwapBuffers routine.
 		/// NOTE: This is only used when the underlying rendering API is set to OpenGL.
 		static void glSwapBuffers();
         Vector2 getLastKnownResize() const;
+		void setLastKnownWindowSize(const Vector2& size);
 	private:
+		bool cursor_visible = true;
 		Vector2 lastKnownWindowSize {0, 0};
 		bool flags[5];
 		std::vector<RWindowEvent> eventLog;
@@ -283,7 +294,5 @@ namespace ReWindow
 		RenderingAPI renderer;
 		bool open = false;
 		bool resizable;
-
-
     };
 }

main.cpp

@@ -1,6 +1,15 @@
 #include <iostream>
 #include <rewindow/types/window.h>
-#include <jlog/jlog.hpp>
+#include <rewindow/types/display.h>
+#include <rewindow/logger/logger.h>
+
+//aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa Windows :/
+#if _WIN32
+	#include <windows.h>
+#endif
+
+#include <GL/gl.h>
+
 
 
 Vector2 mouse_pos;
@@ -19,6 +28,8 @@ class MyWindow : public ReWindow::RWindow {
 	void OnKeyDown(const ReWindow::KeyDownEvent& e) override {}
 
 	void OnRefresh(float elapsed) override {
+            glClearColor(255, 0, 0, 255);
+            glClear(GL_COLOR_BUFFER_BIT);
 		glSwapBuffers();
 		auto pos = getCursorPos();
 		//std::cout << pos.x << ", " << pos.y << std::endl;
@@ -32,21 +43,46 @@ class MyWindow : public ReWindow::RWindow {
 
 int main() {
 	auto* window = new MyWindow("Test Window", 600, 480);
-	DEBUG(std::format("New window '{}' created. width={} height={}", window->getTitle(), window->getWidth(), window->getHeight()));
+	jlog::Debug(std::format("New window '{}' created. width={} height={}", window->getTitle(), window->getWidth(), window->getHeight()));
 
 	window->setRenderer(RenderingAPI::OPENGL);
-	DEBUG(std::format("Rendering API OPENGL set for window '{}'", window->getTitle()));
+	jlog::Debug(std::format("Rendering API OPENGL set for window '{}'", window->getTitle()));
 
 	window->Open();
-	DEBUG(std::format("Opened window '{}'", window->getTitle()));
+	jlog::Debug(std::format("Opened window '{}'", window->getTitle()));
 
 	// TODO: Cannot set flags until after window is open
 	// Make this work somehow
-	DEBUG("TODO: Cannot set flags until after window is open")
+	jlog::Debug("TODO: Cannot set flags until after window is open");
 	window->setFullscreen(false);
-	window->setVsyncEnabled(false);
+	window->setVsyncEnabled(true);
 	window->setResizable(true);
-	DEBUG(std::format("Window '{}' flags: IN_FOCUS={} FULLSCREEN={} RESIZEABLE={} VSYNC={} QUIT={}",
+	window->setCursorVisible(false);
+
+    std::vector<ReWindow::Display> d = ReWindow::Display::getDisplaysFromWindowManager();
+    for (ReWindow::Display& display : d) {
+
+        auto w = display.getDefaultGraphicsMode().getWidth();
+        auto h = display.getDefaultGraphicsMode().getHeight();
+        auto r = display.getDefaultGraphicsMode().getRefreshRate();
+
+        auto aspect = (float)w/(float)h;
+
+        std::cout << "Default: ";
+        std::cout << std::format("Mode ({},{}) @ {}hz Ratio {}", w, h, r, aspect) << std::endl;
+
+        for (ReWindow::FullscreenGraphicsMode& fgm : display.getGraphicsModes()) {
+            w =  fgm.getWidth();
+            h = fgm.getHeight();
+            r = fgm.getRefreshRate();
+
+            auto aspect = (float)w/(float)h;
+
+            std::cout << std::format("Mode ({},{}) @ {}hz Ratio {}", w, h, r, aspect) << std::endl;
+        }
+    }
+
+	ReWindow::Logger::Debug(std::format("Window '{}' flags: IN_FOCUS={} FULLSCREEN={} RESIZEABLE={} VSYNC={} QUIT={}",
 		window->getTitle(),
 		window->getFlag(RWindowFlags::IN_FOCUS),
 		window->getFlag(RWindowFlags::FULLSCREEN),
@@ -54,12 +90,14 @@ int main() {
 		window->getFlag(RWindowFlags::VSYNC),
 		window->getFlag(RWindowFlags::QUIT)));
 
+
 	window->OnKeyDownEvent += [&] (ReWindow::KeyDownEvent e) {
-        DEBUG(e.key.CharCode);
+        jlog::Debug(e.key.CharCode);
 	};
 
+
 	window->OnMouseButtonDownEvent += [&] (ReWindow::MouseButtonDownEvent e) {
-		DEBUG(e.Button.CharCode);
+		jlog::Debug(e.Button.CharCode);
 	};
 
 	while (window->isAlive()) {

src/logger/logger.cpp

@@ -0,0 +1,7 @@
+#include "rewindow/logger/logger.h"
+
+namespace ReWindow::Logger {
+    using namespace jlog;
+    GenericLogger Fatal {"ReWindow::fatal", GlobalLogFile, Colors::Reds::Crimson, Colors::Gray, Colors::Gray, Colors::Reds::Crimson, Colors::White};
+    GenericLogger Debug {"ReWindow::debug", GlobalLogFile, Colors::Purples::Purple, Colors::Gray, Colors::Gray, Colors::Purples::Purple, Colors::White};
+}

src/platform/linux/display.cpp

@@ -0,0 +1,74 @@
+#include <rewindow/types/display.h>
+#include <X11/X.h>
+#include <X11/Xlib.h>
+#include <X11/extensions/Xrandr.h>
+#include <stdexcept>
+
+using namespace ReWindow;
+
+std::vector<ReWindow::Display> ReWindow::Display::getDisplaysFromWindowManager() {
+    std::vector<ReWindow::Display> result;
+    _XDisplay* display = XOpenDisplay(nullptr);
+
+    if (!display)
+        throw std::runtime_error("There isn't an X11 root display????");
+
+    Window root_window = DefaultRootWindow(display);
+    XRRScreenResources* screen_resources = XRRGetScreenResources(display, root_window);
+
+    if (!screen_resources)
+        throw std::runtime_error("Failed to get screen resources.");
+
+    for (int i = 0; i < screen_resources->noutput; i++) {
+        RROutput output = screen_resources->outputs[i];
+        XRROutputInfo* output_info = XRRGetOutputInfo(display, screen_resources, output);
+
+        if (output_info->connection == RR_Connected) {
+            ReWindow::Display d;
+            XRRCrtcInfo* crtc_info = XRRGetCrtcInfo(display, screen_resources, output_info->crtc);
+
+            if (!crtc_info)
+                throw std::runtime_error("Failed to get CRT info.");
+
+            u32 default_width = (u32) crtc_info->width;
+            u32 default_height = (u32) crtc_info->height;
+            short default_refresh_rate = 0;
+
+            for (int k = 0; k < screen_resources->nmode; k++) {
+                if (screen_resources->modes[k].id == crtc_info->mode) {
+                    XRRModeInfo mode_info = screen_resources->modes[k];
+                    double refresh_rate;
+
+                    if (mode_info.hTotal > 0 && mode_info.vTotal > 0)
+                        refresh_rate = mode_info.dotClock / (double)(mode_info.hTotal * mode_info.vTotal),
+                        default_refresh_rate = (short)refresh_rate;
+
+                    d.default_graphics_mode = {default_width, default_height, default_refresh_rate};
+                    break;
+                }
+            }
+
+            for (int j = 0; j < output_info->nmode; j++) {
+                RRMode mode = output_info->modes[j];
+                for (int k = 0; k < screen_resources->nmode; k++) {
+                    if (screen_resources->modes[k].id == mode) {
+                        XRRModeInfo mode_info = screen_resources->modes[k];
+                        // Calculate refresh rate from the mode's dot clock
+                        double refresh_rate = 0.0;
+                        if (mode_info.hTotal > 0 && mode_info.vTotal > 0)
+                            refresh_rate = mode_info.dotClock / (double)(mode_info.hTotal * mode_info.vTotal);
+
+                        d.graphics_modes.emplace_back((u32) mode_info.width,(u32) mode_info.height,(short) refresh_rate);
+                    }
+                }
+            }
+            XRRFreeCrtcInfo(crtc_info);
+            result.push_back(d);
+        }
+        XRRFreeOutputInfo(output_info);
+    }
+
+    XRRFreeScreenResources(screen_resources);
+    XCloseDisplay(display);
+    return result;
+}

src/platform/linux/window.cpp

@@ -7,8 +7,8 @@
 #include <thread>
 #include <rewindow/types/window.h>
 #include <rewindow/types/cursors.h>
-#include <J3ML/J3ML.h>
-#include <jlog/jlog.hpp>
+#include <J3ML/J3ML.hpp>
+#include "rewindow/logger/logger.h"
 
 
 
@@ -30,24 +30,25 @@ Atom windowTypeAtom;
 Atom windowTypeUtilityAtom;
 XSizeHints hints;
 GLXContext glContext;
+Cursor invisible_cursor = 0;
 
 using namespace ReWindow;
 
 void RWindow::raise() const {
-    DEBUG(std::format("Raising window '{}'", this->title));
+    Logger::Debug(std::format("Raising window '{}'", this->title));
     XRaiseWindow(display, window);
 }
 
 void RWindow::lower() const
 {
-    DEBUG(std::format("Lowering window '{}'", this->title));
+    Logger::Debug(std::format("Lowering window '{}'", this->title));
     XLowerWindow(display, window);
 }
 
 void RWindow::destroyWindow() {
-    DEBUG(std::format("Destroying window '{}'", this->title));
+    Logger::Debug(std::format("Destroying window '{}'", this->title));
     XDestroySubwindows(display, window);
-    DEBUG(std::format("Destroyed window '{}'", title));
+    Logger::Debug(std::format("Destroyed window '{}'", this->title));
     XDestroyWindow(display, window);
     delete this;
 }
@@ -62,7 +63,24 @@ void RWindow::refresh() {
     auto eventData = MouseMoveEvent(mouse_coords);
     OnMouseMove(eventData);
     OnMouseMoveEvent(eventData);
-    std::this_thread::sleep_for(1ms);
+    //std::this_thread::sleep_for(1ms);
+}
+
+void RWindow::setCursorVisible(bool cursor_enable) {
+    cursor_visible = cursor_enable;
+
+    if (invisible_cursor == 0) {
+        Pixmap blank_pixmap = XCreatePixmap(display, window, 1, 1, 1);
+        XColor dummy; dummy.pixel = 0; dummy.red = 0; dummy.flags = 0;
+        invisible_cursor = XCreatePixmapCursor(display, blank_pixmap, blank_pixmap, &dummy, &dummy, 0, 0);
+        XFreePixmap(display, blank_pixmap);
+    }
+
+    if (!cursor_enable)
+        XDefineCursor(display, window, invisible_cursor);
+
+    if (cursor_enable)
+        XUndefineCursor(display, window);
 }
 
 void RWindow::setFlag(RWindowFlags flag, bool state) {
@@ -70,13 +88,13 @@ void RWindow::setFlag(RWindowFlags flag, bool state) {
     flags[(int) flag] = state;
     //Once you've done this you cannot make it resizable again.
     if (flag == RWindowFlags::RESIZABLE && !state) {
-        DEBUG("Once you've done this you cannot make it resizable again.");
+        Logger::Debug("Once you've done this you cannot make it resizable again.");
         hints.flags = PMinSize | PMaxSize;
         hints.min_width = hints.max_width = windowAttributes.width;
         hints.min_height = hints.max_height = windowAttributes.height;
         XSetWMNormalHints(display, window, &hints);
     }
-    DEBUG(std::format("Set flag '{}' to state '{}' for window '{}'", RWindowFlagToStr(flag), state, this->title));
+    Logger::Debug(std::format("Set flag '{}' to state '{}' for window '{}'", RWindowFlagToStr(flag), state, this->title));
 }
 
 void RWindow::pollEvents() {
@@ -84,271 +102,281 @@ void RWindow::pollEvents() {
         XNextEvent(display, &xev);
 
         if (xev.type == ClientMessage)
-            DEBUG(std::format("Recieved event '{}'", "ClientMessage"));
-            if (xev.xclient.message_type == XInternAtom(display, "WM_PROTOCOLS", False) && static_cast<Atom>(xev.xclient.data.l[0]) == wmDeleteWindow) {
-                destroyWindow();
-                system("xset r on");
-                exit(0);
-            }
+            Logger::Debug(std::format("Recieved event '{}'", "ClientMessage"));
+
+        if (xev.xclient.message_type == XInternAtom(display, "WM_PROTOCOLS", False) && static_cast<Atom>(xev.xclient.data.l[0]) == wmDeleteWindow) {
+            destroyWindow();
+            system("xset r on");
+            exit(0);
+        }
 
         if (xev.type == FocusIn) {
-            DEBUG(std::format("Recieved event '{}'", "FocusIn"));
+            Logger::Debug(std::format("Recieved event '{}'", "FocusIn"));
             XAutoRepeatOff(display);
             //focusGained.Invoke();
             RWindowEvent event {};
             OnFocusGain(event);
             OnFocusGainEvent(event);
             setFlag(RWindowFlags::IN_FOCUS, true);
+
+            if (!cursor_visible)
+                XDefineCursor(display, window, invisible_cursor);
         }
 
         if (xev.type == FocusOut) {
-            DEBUG(std::format("Recieved event '{}'", "FocusOut"));
-                XAutoRepeatOn(display);
-                //focusLost.Invoke();
-                RWindowEvent event {};
-                OnFocusLost(event);
-                OnFocusLostEvent(event);
-                setFlag(RWindowFlags::IN_FOCUS, false);
-            }
+            Logger::Debug(std::format("Recieved event '{}'", "FocusOut"));
+            XAutoRepeatOn(display);
+            //focusLost.Invoke();
+            RWindowEvent event {};
+            OnFocusLost(event);
+            OnFocusLostEvent(event);
+            setFlag(RWindowFlags::IN_FOCUS, false);
 
-            if (xev.type == KeyRelease) {
-                DEBUG(std::format("Recieved event '{}'", "KeyRelease"));
-                auto scancode = (X11Scancode) xev.xkey.keycode;
-                auto key = GetKeyFromX11Scancode(scancode);
-                OnKeyUpEvent(key);
-                OnKeyUp(key);
-                liftKey(key);
-            }
-
-            if (xev.type == KeyPress) {
-                DEBUG(std::format("Recieved event '{}'", "KeyPress"));
-                auto scancode = (X11Scancode) xev.xkey.keycode;
-                auto key = GetKeyFromX11Scancode(scancode);
-                OnKeyDownEvent(key);
-                OnKeyDown(key);
-                pressKey(key);
-                //eventLog.push_back(eventData);
-            }
-
-            if (xev.type == ButtonRelease) {
-                DEBUG(std::format("Recieved event '{}'", "ButtonRelease"));
-                MouseButton button = GetMouseButtonFromXButton(xev.xbutton.button);
-                auto eventData = MouseButtonUpEvent();
-                eventData.Button = button;
-
-                OnMouseButtonUpEvent(eventData);
-                OnMouseButtonUp(eventData);
-            }
-
-            if (xev.type == ButtonPress) {
-                DEBUG(std::format("Recieved event '{}'", "ButtonPress"));
-                MouseButton button = GetMouseButtonFromXButton(xev.xbutton.button);
-                auto eventData = MouseButtonDownEvent(button);
-                eventData.Button = button;
-
-                OnMouseButtonDownEvent(eventData);
-                OnMouseButtonDown(eventData);
-            }
-
-            if (xev.type == Expose)
-            {
-                DEBUG(std::format("Recieved event '{}'", "Expose"));
-            }
-
-            // NOTE: This event is functionally useless, as it only informs of the very beginning and end of a mouse movement.
-            if (xev.type == MotionNotify)
-            {
-                DEBUG("NOTE: This event is functionally useless, as it only informs of the very beginning and end of a mouse movement.");
-                DEBUG(std::format("Recieved event '{}'", "MotionNotify"));
-            }
-
-            if (xev.type == ResizeRequest) {
-                DEBUG(std::format("Recieved event '{}'", "ResizeRequest"));
-                auto eventData = WindowResizeRequestEvent();
-                eventData.Size = {(float)xev.xresizerequest.width, (float)xev.xresizerequest.height};
-                lastKnownWindowSize = eventData.Size;
-                OnResizeRequest(eventData);
-                OnResizeRequestEvent(eventData);
-            }
+            if (!cursor_visible)
+                XUndefineCursor(display, window);
         }
 
-        previousKeyboard = currentKeyboard;
-    }
-
-    // Might make the window go off the screen on some window managers.
- void RWindow::setSize(int newWidth, int newHeight) {
-        if (!getFlag(RWindowFlags::RESIZABLE)) return;
-
-        this->width = newWidth;
-        this->height = newHeight;
-        XResizeWindow(display, window, width, height);
-        DEBUG("Might make the window go off the screen on some window managers.");
-        DEBUG(std::format("Set size for window '{}'. width={} height={}", this->title, newWidth, newHeight));
-    }
-
-    Vector2 RWindow::getCursorPos() const {
-        Window root = XDefaultRootWindow(display);
-        Window root_return;
-        Window child_return;
-        int root_x_ret;
-        int root_y_ret;
-        int win_x_ret;
-        int win_y_ret;
-        uint32_t mask_return;
-        unsigned m;
-        bool mouseAvailable = XQueryPointer(display, window, &root_return, &child_return, &root_x_ret, &root_y_ret, &win_x_ret, &win_y_ret, &mask_return);
-
-        if (mouseAvailable) {
-            // TODO: process retrieved mouse coordinates
-            // TODO: normalize coordinates from displaySpace to windowSpace
-            // TODO: fire mouse movement event
-            //std::cout << win_x_ret << ", " << win_y_ret << std::endl;
-            // TODO: Compensate for height of window TitleBar + window border width
-            float window_border_width = 2;
-            float window_titlebar_height = 18;
-            Vector2 mouse_coords_raw = {(float)win_x_ret+window_border_width, (float)win_y_ret+window_titlebar_height};
-            auto window_pos = getPos();
-            return mouse_coords_raw - window_pos;
-        }
-        return Vector2::Zero;
-    }
-
-    // TODO: implement integer vector2/3 types
-    Vector2 RWindow::getSize() const {
-        XGetWindowAttributes(display,window,&windowAttributes);
-        return {(float)windowAttributes.width, (float)windowAttributes.height};
-    }
-
-    Vector2 RWindow::getLastKnownResize() const
-    {
-        return lastKnownWindowSize;
-    }
-
-    // TODO: implement integer vector2/3 types
-    Vector2 RWindow::getPos() const {
-        XGetWindowAttributes(display,window,&windowAttributes);
-        return {(float)windowAttributes.x, (float)windowAttributes.y};
-    }
-
-    void RWindow::setPos(int x, int y) {
-        XMoveWindow(display, window, x, y);
-    }
-
-    void RWindow::setPos(const Vector2& pos) {
-        this->setPos(pos.x, pos.y);
-    }
-
-
-    void RWindow::glSwapBuffers() {
-        glXSwapBuffers(display,window);
-    }
-
-    bool RWindow::isResizable() const {
-        return this->getFlag(RWindowFlags::RESIZABLE);
-    }
-
-    void RWindow::fullscreen() {
-        DEBUG(std::format("Fullscreening window '{}'", this->title));
-        fullscreenmode = true;
-
-        XEvent xev;
-        Atom wm_state   = XInternAtom(display, "_NET_WM_STATE", true);
-        Atom wm_fullscreen = XInternAtom(display, "_NET_WM_STATE_FULLSCREEN", true);
-
-        XChangeProperty(display, window, wm_state, XA_ATOM, 32, PropModeReplace, (unsigned char *)&wm_fullscreen, 1);
-        memset(&xev, 0, sizeof(xev));
-        xev.type = ClientMessage;
-        xev.xclient.window = window;
-        xev.xclient.message_type = wm_state;
-        xev.xclient.format = 32;
-        xev.xclient.data.l[0] = 1; // _NET_WM_STATE_ADD
-        xev.xclient.data.l[1] = fullscreenmode;
-        xev.xclient.data.l[2] = 0;
-        XSendEvent(display, DefaultRootWindow(display), False, SubstructureNotifyMask | SubstructureRedirectMask, &xev);
-        DEBUG(std::format("Fullscreened window '{}'", this->title));
-    }
-
-    void RWindow::restoreFromFullscreen() {
-        DEBUG(std::format("Restoring window '{}' from fullscreen", this->title));
-        fullscreenmode = false;
-        XEvent xev;
-        Atom wm_state = XInternAtom(display, "_NET_WM_STATE", False);
-        Atom fullscreen = XInternAtom(display, "_NET_WM_STATE_FULLSCREEN", False);
-        memset(&xev, 0, sizeof(xev));
-        xev.type = ClientMessage;
-        xev.xclient.window = window;
-        xev.xclient.message_type = wm_state;
-        xev.xclient.format = 32;
-        xev.xclient.data.l[0] = 0; // _NET_WM_STATE_REMOVE
-        xev.xclient.data.l[1] = fullscreenmode;
-        xev.xclient.data.l[2] = 0;
-        XSendEvent(display, DefaultRootWindow(display), False, SubstructureNotifyMask | SubstructureRedirectMask, &xev);
-        DEBUG(std::format("Restored window '{}' from fullscreen", this->title));
-    }
-
-    void RWindow::setVsyncEnabled(bool b) {
-        PFNGLXSWAPINTERVALEXTPROC glXSwapIntervalEXT;
-        glXSwapIntervalEXT = (PFNGLXSWAPINTERVALEXTPROC)glXGetProcAddressARB((const GLubyte*)"glXSwapIntervalEXT");
-        glXSwapIntervalEXT(display, window, b);
-    }
-
-    bool RWindow::isFullscreen() const {
-        return fullscreenmode;
-    }
-
-    void RWindow::setCursorStyle(CursorStyle style) const {
-        u32 x11_cursor_resolved_enum = static_cast<u32>(style.X11Cursor);
-        Cursor c = XCreateFontCursor(display, x11_cursor_resolved_enum);
-        XDefineCursor(display, window, c);
-    }
-
-    void RWindow::Open() {
-        xSetWindowAttributes.border_pixel = BlackPixel(display, defaultScreen);
-        xSetWindowAttributes.background_pixel = BlackPixel(display, defaultScreen);
-        xSetWindowAttributes.override_redirect = True;
-        xSetWindowAttributes.event_mask = ExposureMask;
-        //setVsyncEnabled(vsync);
-        if (renderer == RenderingAPI::OPENGL) {
-            GLint glAttributes[] = {GLX_RGBA, GLX_DEPTH_SIZE, 24, GLX_DOUBLEBUFFER, None};
-            visual = glXChooseVisual(display, defaultScreen, glAttributes);
-            glContext = glXCreateContext(display, visual, nullptr, GL_TRUE);
+        if (xev.type == KeyRelease) {
+            Logger::Debug(std::format("Recieved event '{}'", "KeyRelease"));
+            auto scancode = (X11Scancode) xev.xkey.keycode;
+            auto key = GetKeyFromX11Scancode(scancode);
+            OnKeyUpEvent(key);
+            OnKeyUp(key);
+            liftKey(key);
         }
 
-        xSetWindowAttributes.colormap = XCreateColormap(display, RootWindow(display, defaultScreen), visual->visual, AllocNone);
+        if (xev.type == KeyPress) {
+            Logger::Debug(std::format("Recieved event '{}'", "KeyPress"));
+            auto scancode = (X11Scancode) xev.xkey.keycode;
+            auto key = GetKeyFromX11Scancode(scancode);
+            OnKeyDownEvent(key);
+            OnKeyDown(key);
+            pressKey(key);
+            //eventLog.push_back(eventData);
+        }
 
-        window = XCreateWindow(display, RootWindow(display, defaultScreen), 0, 0, width, height, 0, visual->depth,
-                               InputOutput, visual->visual, CWBackPixel | CWColormap | CWBorderPixel | NoEventMask,
-                               &xSetWindowAttributes);
-	// Set window to floating because fucking tiling WMs
-	windowTypeAtom = XInternAtom(display, "_NET_WM_WINDOW_TYPE", False);
-	windowTypeUtilityAtom = XInternAtom(display, "_NET_WM_WINDOW_TYPE_UTILITY", False);
-        XChangeProperty(display, window, windowTypeAtom, XA_ATOM, 32, PropModeReplace,
+        if (xev.type == ButtonRelease) {
+            Logger::Debug(std::format("Recieved event '{}'", "ButtonRelease"));
+            MouseButton button = GetMouseButtonFromXButton(xev.xbutton.button);
+            auto eventData = MouseButtonUpEvent();
+            eventData.Button = button;
+
+            OnMouseButtonUpEvent(eventData);
+            OnMouseButtonUp(eventData);
+        }
+
+        if (xev.type == ButtonPress) {
+            Logger::Debug(std::format("Recieved event '{}'", "ButtonPress"));
+            MouseButton button = GetMouseButtonFromXButton(xev.xbutton.button);
+            auto eventData = MouseButtonDownEvent(button);
+            eventData.Button = button;
+
+            OnMouseButtonDownEvent(eventData);
+            OnMouseButtonDown(eventData);
+        }
+
+        if (xev.type == Expose)
+        {
+            Logger::Debug(std::format("Recieved event '{}'", "Expose"));
+        }
+
+        // NOTE: This event is functionally useless, as it only informs of the very beginning and end of a mouse movement.
+        if (xev.type == MotionNotify)
+        {
+            Logger::Debug(std::format("Recieved event '{}'", "MotionNotify"));
+        }
+
+        if (xev.type == ResizeRequest) {
+            Logger::Debug(std::format("Recieved event '{}'", "ResizeRequest"));
+            this->width = xev.xresizerequest.width;
+            this->height = xev.xresizerequest.height;
+            auto eventData = WindowResizeRequestEvent();
+            eventData.Size = {(float)xev.xresizerequest.width, (float)xev.xresizerequest.height};
+            lastKnownWindowSize = eventData.Size;
+            OnResizeRequest(eventData);
+            OnResizeRequestEvent(eventData);
+            glViewport(0, 0, (GLsizei)xev.xresizerequest.width, (GLsizei)xev.xresizerequest.height);
+        }
+    }
+    previousKeyboard = currentKeyboard;
+}
+
+
+// Might make the window go off the screen on some window managers.
+void RWindow::setSize(int newWidth, int newHeight) {
+    if (!getFlag(RWindowFlags::RESIZABLE)) return;
+
+    this->width = newWidth;
+    this->height = newHeight;
+    XResizeWindow(display, window, newWidth, newHeight);
+    XFlush(display);
+    glViewport(0, 0, width, height);
+    Logger::Debug(std::format("Set size for window '{}'. width={} height={}", this->title, newWidth, newHeight));
+}
+
+Vector2 RWindow::getCursorPos() const {
+    Window root = XDefaultRootWindow(display);
+    Window root_return;
+    Window child_return;
+    int root_x_ret;
+    int root_y_ret;
+    int win_x_ret;
+    int win_y_ret;
+    uint32_t mask_return;
+    unsigned m;
+    bool mouseAvailable = XQueryPointer(display, window, &root_return, &child_return, &root_x_ret, &root_y_ret, &win_x_ret, &win_y_ret, &mask_return);
+
+    if (mouseAvailable) {
+        // TODO: process retrieved mouse coordinates
+        // TODO: normalize coordinates from displaySpace to windowSpace
+        // TODO: fire mouse movement event
+        //std::cout << win_x_ret << ", " << win_y_ret << std::endl;
+        // TODO: Compensate for height of window TitleBar + window border width
+        float window_border_width = 2;
+        float window_titlebar_height = 18;
+        Vector2 mouse_coords_raw = {(float)win_x_ret+window_border_width, (float)win_y_ret+window_titlebar_height};
+        auto window_pos = getPos();
+        return mouse_coords_raw - window_pos;
+    }
+    return Vector2::Zero;
+}
+
+// TODO: implement integer vector2/3 types
+Vector2 RWindow::getSize() const {
+    XGetWindowAttributes(display,window,&windowAttributes);
+    return {(float)windowAttributes.width, (float)windowAttributes.height};
+}
+
+Vector2 RWindow::getLastKnownResize() const
+{
+    return lastKnownWindowSize;
+}
+
+// TODO: implement integer vector2/3 types
+Vector2 RWindow::getPos() const {
+    XGetWindowAttributes(display,window,&windowAttributes);
+    return {(float)windowAttributes.x, (float)windowAttributes.y};
+}
+
+void RWindow::setPos(int x, int y) {
+    XMoveWindow(display, window, x, y);
+}
+
+void RWindow::setPos(const Vector2& pos) {
+    this->setPos(pos.x, pos.y);
+}
+
+
+void RWindow::glSwapBuffers() {
+    glXSwapBuffers(display,window);
+}
+
+bool RWindow::isResizable() const {
+    return this->getFlag(RWindowFlags::RESIZABLE);
+}
+
+void RWindow::fullscreen() {
+    Logger::Debug(std::format("Fullscreening window '{}'", this->title));
+    fullscreenmode = true;
+
+    XEvent xev;
+    Atom wm_state   = XInternAtom(display, "_NET_WM_STATE", true);
+    Atom wm_fullscreen = XInternAtom(display, "_NET_WM_STATE_FULLSCREEN", true);
+
+    XChangeProperty(display, window, wm_state, XA_ATOM, 32, PropModeReplace, (unsigned char *)&wm_fullscreen, 1);
+    memset(&xev, 0, sizeof(xev));
+    xev.type = ClientMessage;
+    xev.xclient.window = window;
+    xev.xclient.message_type = wm_state;
+    xev.xclient.format = 32;
+    xev.xclient.data.l[0] = 1; // _NET_WM_STATE_ADD
+    xev.xclient.data.l[1] = fullscreenmode;
+    xev.xclient.data.l[2] = 0;
+    XSendEvent(display, DefaultRootWindow(display), False, SubstructureNotifyMask | SubstructureRedirectMask, &xev);
+    Logger::Debug(std::format("Fullscreened window '{}'", this->title));
+}
+
+void RWindow::restoreFromFullscreen() {
+    Logger::Debug(std::format("Restoring window '{}' from fullscreen", this->title));
+    fullscreenmode = false;
+    XEvent xev;
+    Atom wm_state = XInternAtom(display, "_NET_WM_STATE", False);
+    Atom fullscreen = XInternAtom(display, "_NET_WM_STATE_FULLSCREEN", False);
+    memset(&xev, 0, sizeof(xev));
+    xev.type = ClientMessage;
+    xev.xclient.window = window;
+    xev.xclient.message_type = wm_state;
+    xev.xclient.format = 32;
+    xev.xclient.data.l[0] = 0; // _NET_WM_STATE_REMOVE
+    xev.xclient.data.l[1] = fullscreenmode;
+    xev.xclient.data.l[2] = 0;
+    XSendEvent(display, DefaultRootWindow(display), False, SubstructureNotifyMask | SubstructureRedirectMask, &xev);
+    Logger::Debug(std::format("Restored window '{}' from fullscreen", this->title));
+}
+
+void RWindow::setVsyncEnabled(bool b) {
+    PFNGLXSWAPINTERVALEXTPROC glXSwapIntervalEXT;
+    glXSwapIntervalEXT = (PFNGLXSWAPINTERVALEXTPROC)glXGetProcAddressARB((const GLubyte*)"glXSwapIntervalEXT");
+    glXSwapIntervalEXT(display, window, b);
+}
+
+bool RWindow::isFullscreen() const {
+    return fullscreenmode;
+}
+
+void RWindow::setCursorStyle(CursorStyle style) const {
+    u32 x11_cursor_resolved_enum = static_cast<u32>(style.X11Cursor);
+    Cursor c = XCreateFontCursor(display, x11_cursor_resolved_enum);
+    XDefineCursor(display, window, c);
+}
+
+void RWindow::Open() {
+    xSetWindowAttributes.border_pixel = BlackPixel(display, defaultScreen);
+    xSetWindowAttributes.background_pixel = BlackPixel(display, defaultScreen);
+    xSetWindowAttributes.override_redirect = True;
+    xSetWindowAttributes.event_mask = ExposureMask;
+    //setVsyncEnabled(vsync);
+    if (renderer == RenderingAPI::OPENGL) {
+        GLint glAttributes[] = {GLX_RGBA, GLX_DEPTH_SIZE, 24, GLX_DOUBLEBUFFER, None};
+        visual = glXChooseVisual(display, defaultScreen, glAttributes);
+        glContext = glXCreateContext(display, visual, nullptr, GL_TRUE);
+    }
+
+    xSetWindowAttributes.colormap = XCreateColormap(display, RootWindow(display, defaultScreen), visual->visual, AllocNone);
+
+    window = XCreateWindow(display, RootWindow(display, defaultScreen), 0, 0, width, height, 0, visual->depth,
+                           InputOutput, visual->visual, CWBackPixel | CWColormap | CWBorderPixel | NoEventMask,
+                           &xSetWindowAttributes);
+    // Set window to floating because fucking tiling WMs
+    windowTypeAtom = XInternAtom(display, "_NET_WM_WINDOW_TYPE", False);
+    windowTypeUtilityAtom = XInternAtom(display, "_NET_WM_WINDOW_TYPE_UTILITY", False);
+    XChangeProperty(display, window, windowTypeAtom, XA_ATOM, 32, PropModeReplace,
                     (unsigned char *)&windowTypeUtilityAtom, 1);
-	//
-        XSelectInput(display, window,
-                     ExposureMask | KeyPressMask | KeyReleaseMask | ButtonPressMask | ButtonReleaseMask |
-                     PointerMotionMask |
-                     PointerMotionHintMask | FocusChangeMask | StructureNotifyMask | SubstructureRedirectMask |
-                     SubstructureNotifyMask | CWColormap | ResizeRequest | ResizeRedirectMask);
-        XMapWindow(display, window);
-        XStoreName(display, window, title.c_str());
-        wmDeleteWindow = XInternAtom(display, "WM_DELETE_WINDOW", False);
-        XSetWMProtocols(display, window, &wmDeleteWindow, 1);
+    //
+    XSelectInput(display, window,
+                 ExposureMask | KeyPressMask | KeyReleaseMask | ButtonPressMask | ButtonReleaseMask |
+                 PointerMotionMask |
+                 PointerMotionHintMask | FocusChangeMask | StructureNotifyMask | SubstructureRedirectMask |
+                 SubstructureNotifyMask | CWColormap | ResizeRequest);
+    XMapWindow(display, window);
+    XStoreName(display, window, title.c_str());
+    wmDeleteWindow = XInternAtom(display, "WM_DELETE_WINDOW", False);
+    XSetWMProtocols(display, window, &wmDeleteWindow, 1);
 
-        if (renderer == RenderingAPI::OPENGL)
-            glXMakeCurrent(display, window, glContext);
-        open = true;
-    }
+    if (renderer == RenderingAPI::OPENGL)
+        glXMakeCurrent(display, window, glContext);
+    open = true;
+}
 
-    void RWindow::setTitle(const std::string &title) {
-        this->title = title;
-        XStoreName(display, window, title.c_str());
-    }
+void RWindow::setTitle(const std::string &title) {
+    this->title = title;
+    XStoreName(display, window, title.c_str());
+}
 
-    // TODO: Implement MouseButton map
-    bool RWindow::isMouseButtonDown(MouseButton button) const {
-        return false;
-    }
+// TODO: Implement MouseButton map
+bool RWindow::isMouseButtonDown(MouseButton button) const {
+    return false;
+}
 
 
 

src/platform/shared/display.cpp

@@ -0,0 +1,34 @@
+#include <rewindow/types/display.h>
+
+using namespace ReWindow;
+
+FullscreenGraphicsMode::FullscreenGraphicsMode(u32 width, u32 height, short refresh_rate) {
+    this->width = width;
+    this->height = height;
+    this->refresh_rate = refresh_rate;
+}
+
+u32 FullscreenGraphicsMode::getWidth() const {
+    return width;
+}
+
+u32 FullscreenGraphicsMode::getHeight() const {
+    return height;
+}
+
+float FullscreenGraphicsMode::getRefreshRate() const {
+    return refresh_rate;
+}
+
+FullscreenGraphicsMode Display::getDefaultGraphicsMode() {
+    return default_graphics_mode;
+}
+
+std::vector<FullscreenGraphicsMode> Display::getGraphicsModes() {
+    return graphics_modes;
+}
+
+Display::Display(const FullscreenGraphicsMode& default_graphics_mode, const std::vector<FullscreenGraphicsMode>& graphics_modes) {
+    this->default_graphics_mode = default_graphics_mode;
+    this->graphics_modes = graphics_modes;
+}

src/platform/shared/window.cpp

@@ -1,5 +1,5 @@
 #include <rewindow/types/window.h>
-#include <jlog/jlog.hpp>
+#include "rewindow/logger/logger.h"
 std::string RWindowFlagToStr(RWindowFlags flag) {
     switch (flag) {
         case RWindowFlags::IN_FOCUS: return "IN_FOCUS";
@@ -9,7 +9,6 @@ std::string RWindowFlagToStr(RWindowFlags flag) {
         case RWindowFlags::QUIT: return "QUIT";
         case RWindowFlags::MAX_FLAG: return "MAX_FLAG";
         default:
-            FATAL("")
             return "unimplemented flag";
     }
 };
@@ -37,7 +36,9 @@ Vector2 RWindow::GetMouseCoordinates() const {
     return getCursorPos();
 }
 
-bool RWindow::getFlag(RWindowFlags flag) const {return flags[(int)flag];}
+bool RWindow::getFlag(RWindowFlags flag) const {
+    return flags[(int) flag];
+}
 
 bool RWindow::isAlive() const {
     return true;
@@ -57,7 +58,7 @@ void RWindow::setFullscreen(bool fs) {
 
 void RWindow::liftKey(Key key) {
     currentKeyboard.PressedKeys[key] = false;
-    auto event = ReWindow::WindowEvents::KeyUpEvent(key);
+    auto event = KeyUpEvent(key);
     OnKeyUp(event);
 }
 
@@ -83,6 +84,14 @@ int RWindow::getHeight() const
     return this->height;
 }
 
+void RWindow::setSizeWithoutEvent(const Vector2& size) {
+    width = size.x;
+    height = size.y;
+}
+
+void RWindow::setLastKnownWindowSize(const Vector2& size) {
+    lastKnownWindowSize = size;
+}
 
 void RWindow::setRenderer(RenderingAPI api) {
     renderer = api;
@@ -108,7 +117,4 @@ void RWindow::pressKey(Key key) {
 }
 
 
-void RWindow::Close()
-{
-    
-}
+void RWindow::Close() {}

src/platform/windows/window.cpp

@@ -6,7 +6,7 @@ using namespace ReWindow;
 
 bool fullscreenmode = false;
 bool open = false;
-HINSTANCE hInstance = GetModuleHandle(NULL);
+HINSTANCE hInstance = GetModuleHandle(nullptr);
 HWND hwnd;
 HDC hdc;
 HGLRC glContext;
@@ -48,6 +48,15 @@ Vector2 RWindow::getCursorPos() const {
     return { (float)point.x, (float)point.y };
 }
 
+void RWindow::setCursorVisible(bool cursor_enable) {
+    cursor_visible = cursor_enable;
+}
+
+bool RWindow::getCursorVisible() {
+    return cursor_visible;
+}
+
+
 Vector2 RWindow::getSize() const {
     RECT rect;
     GetClientRect(hwnd, &rect);
@@ -76,8 +85,7 @@ void RWindow::restoreFromFullscreen() {
 
 void RWindow::setVsyncEnabled(bool b) {
     typedef BOOL(WINAPI* PFNWGLSWAPINTERVALEXTPROC)(int interval);
-    PFNWGLSWAPINTERVALEXTPROC wglSwapIntervalEXT = nullptr;
-    wglSwapIntervalEXT = (PFNWGLSWAPINTERVALEXTPROC) wglGetProcAddress("wglSwapIntervalEXT");
+    auto wglSwapIntervalEXT = (PFNWGLSWAPINTERVALEXTPROC) wglGetProcAddress("wglSwapIntervalEXT");
 
     if (wglSwapIntervalEXT)
         wglSwapIntervalEXT(b ? 1 : 0);
@@ -90,39 +98,182 @@ bool RWindow::isFullscreen() const {
 RWindow* eWindow = nullptr;
 KeyboardState* pKeyboard = nullptr;
 KeyboardState* cKeyboard = nullptr;
+
 //Event loop.
 LRESULT CALLBACK WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) {
     switch (uMsg) {
-        case WM_CLOSE:
-            DestroyWindow(hwnd);
-        case WM_DESTROY:
-            exit(0);
-        case WM_SIZE:
-                break;
-        case WM_KEYDOWN: {
-            auto key = GetKeyFromWindowsScancode((WindowsScancode) wParam);
-            //Key repeat fix.
-            if (!pKeyboard->PressedKeys[key]) {
-                eWindow->OnKeyDownEvent(key);
-                eWindow->OnKeyDown(key);
-                eWindow->pressKey(key);
+            case WM_CLOSE: {
+                    DestroyWindow(hwnd);
             }
-            break;
-        }
-        case WM_KEYUP: {
-            auto key = GetKeyFromWindowsScancode((WindowsScancode) wParam);
-            eWindow->OnKeyUpEvent(key);
-            eWindow->OnKeyUp(key);
-            eWindow->liftKey(key);
-            break;
-        }
-        case WM_LBUTTONDOWN:
-                break;
-        case WM_LBUTTONUP:
+
+            case WM_DESTROY: {
+                    exit(0);
+            }
+
+            case WM_SIZE: {
+                    eWindow->setSizeWithoutEvent({(float) LOWORD(lParam), (float) HIWORD(lParam)});
+                    auto eventData = WindowResizeRequestEvent();
+                    eventData.Size = {(float) eWindow->getWidth(), (float) eWindow->getHeight()};
+                    eWindow->setLastKnownWindowSize({(float) eWindow->getWidth(), (float) eWindow->getHeight()});
+                    eWindow->OnResizeRequest(eventData);
+                    eWindow->OnResizeRequestEvent(eventData);
+                    //Just to be absolutely sure the OpenGL viewport resizes along with the window.
+                    glViewport(0, 0, eWindow->getWidth(), eWindow->getHeight());
+                    break;
+                }
+
+            case WM_SETFOCUS: {
+                    RWindowEvent event {};
+                    eWindow->OnFocusGain(event);
+                    eWindow->OnFocusGainEvent(event);
+
+                    eWindow->setFlag(RWindowFlags::IN_FOCUS, true);
+                    break;
+            }
+
+            case WM_KILLFOCUS: {
+                    RWindowEvent event {};
+                    eWindow->OnFocusLost(event);
+                    eWindow->OnFocusLostEvent(event);
+
+                    eWindow->setFlag(RWindowFlags::IN_FOCUS, false);
+                    break;
+            }
+
+            case WM_SETCURSOR: {
+                    if (LOWORD(lParam) == HTCLIENT && eWindow->getCursorVisible() == false)
+                        SetCursor(nullptr);
                 break;
+            }
+
+            case WM_KEYDOWN: {
+                    auto key = GetKeyFromWindowsScancode((WindowsScancode) wParam);
+                    //Key repeat fix.
+                    if (!pKeyboard->PressedKeys[key]) {
+                        eWindow->OnKeyDownEvent(key);
+                        eWindow->OnKeyDown(key);
+                        eWindow->pressKey(key);
+                    }
+                    break;
+            }
+
+            case WM_KEYUP: {
+                    auto key = GetKeyFromWindowsScancode((WindowsScancode) wParam);
+                    eWindow->OnKeyUpEvent(key);
+                    eWindow->OnKeyUp(key);
+                    eWindow->liftKey(key);
+                    break;
+            }
+
+            //Mouse Buttons.
+            case WM_MOUSEWHEEL: {
+                    auto eventData = MouseButtonDownEvent();
+                    int wheel_delta = GET_WHEEL_DELTA_WPARAM(wParam);
+
+                    //If the wheel delta is positive it's MWheelUp, Negative is MWheelDown.
+                    if (wheel_delta > 0)
+                        eventData.Button = MouseButtons::MWheelUp,
+                        eWindow->OnMouseButtonDownEvent(eventData),
+                        eWindow->OnMouseButtonDown(eventData);
+
+                    else
+                        eventData.Button = MouseButtons::MWheelDown,
+                        eWindow->OnMouseButtonDownEvent(eventData),
+                        eWindow->OnMouseButtonDown(eventData);
+                    break;
+            }
+
+            case WM_LBUTTONDOWN: {
+                    auto eventData = MouseButtonDownEvent();
+                    eventData.Button = MouseButtons::Left;
+
+                    eWindow->OnMouseButtonDownEvent(eventData);
+                    eWindow->OnMouseButtonDown(eventData);
+                    break;
+            }
+
+            case WM_LBUTTONUP: {
+                    auto eventData = MouseButtonUpEvent();
+                    eventData.Button = MouseButtons::Left;
+
+                    eWindow->OnMouseButtonUpEvent(eventData);
+                    eWindow->OnMouseButtonUp(eventData);
+                    break;
+            }
+
+            case WM_RBUTTONDOWN: {
+                    auto eventData = MouseButtonDownEvent();
+                    eventData.Button = MouseButtons::Right;
+
+                    eWindow->OnMouseButtonDownEvent(eventData);
+                    eWindow->OnMouseButtonDown(eventData);
+                    break;
+            }
+
+            case WM_RBUTTONUP: {
+                    auto eventData = MouseButtonUpEvent();
+                    eventData.Button = MouseButtons::Right;
+
+                    eWindow->OnMouseButtonUpEvent(eventData);
+                    eWindow->OnMouseButtonUp(eventData);
+                    break;
+            }
+
+            case WM_MBUTTONDOWN: {
+                    auto eventData = MouseButtonDownEvent();
+                    eventData.Button = MouseButtons::Middle;
+
+                    eWindow->OnMouseButtonDownEvent(eventData);
+                    eWindow->OnMouseButtonDown(eventData);
+                    break;
+            }
+
+            case WM_MBUTTONUP: {
+                    auto eventData = MouseButtonUpEvent();
+                    eventData.Button = MouseButtons::Middle;
+
+                    eWindow->OnMouseButtonUpEvent(eventData);
+                    eWindow->OnMouseButtonUp(eventData);
+                    break;
+            }
+
+            case WM_XBUTTONDOWN: {
+                    WORD button = GET_XBUTTON_WPARAM(wParam);
+                    auto eventData = MouseButtonDownEvent();
+
+                    if (button == XBUTTON1)
+                        eventData.Button = MouseButtons::Mouse4,
+                        eWindow->OnMouseButtonDownEvent(eventData),
+                        eWindow->OnMouseButtonDown(eventData);
+
+                    if (button == XBUTTON2)
+                        eventData.Button = MouseButtons::Mouse5,
+                        eWindow->OnMouseButtonDownEvent(eventData),
+                        eWindow->OnMouseButtonDown(eventData);
+                    break;
+            }
+
+            case WM_XBUTTONUP: {
+                    WORD button = GET_XBUTTON_WPARAM(wParam);
+                    auto eventData = MouseButtonUpEvent();
+
+                    if (button == XBUTTON1)
+                        eventData.Button = MouseButtons::Mouse4,
+                        eWindow->OnMouseButtonUpEvent(eventData),
+                        eWindow->OnMouseButtonUp(eventData);
+
+                    if (button == XBUTTON2)
+                        eventData.Button = MouseButtons::Mouse5,
+                        eWindow->OnMouseButtonUpEvent(eventData),
+                        eWindow->OnMouseButtonUp(eventData);
+                    break;
+        }
+
+        //This is the same as "Motion Notify" in the X Window System.
         case WM_MOUSEMOVE:
-                break;
+            break;
     }
+
     if (pKeyboard != nullptr && cKeyboard != nullptr)
         pKeyboard = cKeyboard;
     
@@ -196,5 +347,4 @@ void RWindow::refresh() {
 
     auto eventData = MouseMoveEvent(mouse_coords);
     OnMouseMove(eventData);
-    std::this_thread::sleep_for(1ms);
 }

src/types/key.cpp

@@ -1,5 +1,5 @@
 #include <rewindow/types/key.h>
-#include <jlog/jlog.hpp>
+//#include <rewindow/logger.h>
 //std::vector<Key> Key::keyboard = {};
 
 std::vector<Key> Key::GetKeyboard() { return keyboard; }
@@ -29,7 +29,7 @@ bool Key::operator<(const Key &rhs) const {
 
 
 Key GetKeyFromX11Scancode(X11Scancode code) {
-    for (auto& key : Key::GetKeyboard())
+    for (const auto& key : Key::GetKeyboard())
         if (key.x11ScanCode == code)
             return key;
     std::cout << "Unavaliable Scancode: " + std::to_string((int)code) << std::endl;

src/types/mousebutton.cpp

@@ -1,6 +1,6 @@
 #include <rewindow/types/mousebutton.h>
 #include <string>
-#include <jlog/jlog.hpp>
+#include "rewindow/logger/logger.h"
 
 MouseButton::MouseButton() {
 }
@@ -26,7 +26,7 @@ MouseButton GetMouseButtonFromXButton(unsigned int button) {
         case 8: return MouseButtons::Mouse4;
         case 9: return MouseButtons::Mouse5;
         default: {
-            FATAL("Undefined XButtonCode: " + std::to_string((int) button));
+            ReWindow::Logger::Fatal("Undefined XButtonCode: " + std::to_string((int) button));
             return MouseButtons::Unimplemented;
         }
     }