Temp Work

Fix Mouse Button errors, implement MouseWheel events
2024-12-06 11:50:20 -05:00 · 2024-12-04 10:17:10 -05:00 · 2024-12-03 21:24:50 -05:00 · 2024-12-03 19:39:58 -05:00 · 2024-12-03 19:19:51 -05:00 · 2024-12-03 19:16:43 -05:00
40 changed files with 3224 additions and 1098 deletions
--- a/.gitea/workflows/buildtest.yml
+++ b/.gitea/workflows/buildtest.yml
@@ -0,0 +1,23 @@
+name: Run ReCI Build Test
+run-name: Run ReCI Build Test For ${{ gitea.repository }}.
+on: [push]
+
+jobs:
+  Explore-Gitea-Actions:
+    runs-on: ubuntu-22.04
+    env:
+      RECI_GIT: https://git.redacted.cc/maxine/ReCI
+      RECI: /RECI
+    steps:
+      - run: echo "The job was automatically triggered by a ${{ gitea.event_name }} event."
+      - run: echo "This job is now running on a ${{ runner.os }} server hosted by Gitea!"
+      - run: echo "The name of your branch is ${{ gitea.ref }} and your repository is ${{ gitea.repository }}."
+      - name: Check out repository code
+        uses: actions/checkout@v3
+      - run: echo "The ${{ gitea.repository }} repository has been cloned to the runner."
+      - run: echo "The workflow is now ready to run your tests on the runner."
+      - run: echo "Install toolchain and run ReCI build test"
+      - run: apt-get update && apt-get install -y lua5.3 git libxrandr-dev && git clone $RECI_GIT $RECI
+      - run: lua $RECI/reci.lua -f $RECI/scripts/buildtools.reci -f reci/scripts/builddeps.reci -f $RECI/scripts/buildtest.reci
+      - run: echo this exists so I can run the reci test
+      - run: echo "This job's status is ${{ job.status }}."
--- a/.gitignore
+++ b/.gitignore
@@ -1,2 +1,4 @@
 /cmake-build-debug
 /.idea
+build/*
+.vscode/*
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.20)
+cmake_minimum_required(VERSION 3.18..3.27)
 project(ReWindowLibrary
    VERSION 1.0
    LANGUAGES CXX
@@ -10,45 +10,55 @@ endif()

 set(CMAKE_CXX_STANDARD 20)

-if (WIN32)
-    set(CMAKE_CXX_FLAGS "-municode")
-endif()
-
 set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_CURRENT_SOURCE_DIR}/cmake")


 # Enable Package Managers
- include(cmake/CPM.cmake)
+include(cmake/CPM.cmake)

 CPMAddPackage(
-        NAME J3ML
-        URL https://git.redacted.cc/josh/j3ml/archive/Prerelease-18.zip
+    NAME J3ML
+    URL https://git.redacted.cc/josh/j3ml/archive/Release-3.2.zip
 )

 CPMAddPackage(
-        NAME Event
-        URL https://git.redacted.cc/josh/Event/archive/Release-1.zip
+    NAME Event
+    URL https://git.redacted.cc/josh/Event/archive/Release-12.zip
+)
+
+CPMAddPackage(
+        NAME jlog
+        URL https://git.redacted.cc/josh/jlog/archive/Prerelease-16.zip
 )

 find_package(OpenGL REQUIRED)
 include_directories(${OPENGL_INCLUDE_DIRS})
 include_directories(${J3ML_SOURCE_DIR}/include)
+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/rewindow/*.cpp" "src/linux/*.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/rewindow/*.cpp" "src/windows/*.cpp")
+    file(GLOB_RECURSE SOURCES "src/types/*.cpp" "src/platform/windows/*.cpp" "src/platform/shared/*.cpp" "src/logger/*.cpp")
 endif()

 include_directories("include")
-add_library(ReWindowLibrary SHARED ${SOURCES}
-        include/rewindow/types/cursors.h
-)
+
+if(UNIX)
+    add_library(ReWindowLibrary SHARED ${SOURCES})
+endif()
+
+if(WIN32)
+    add_library(ReWindowLibrary STATIC ${SOURCES})
+endif()

 target_include_directories(ReWindowLibrary PUBLIC ${Event_SOURCE_DIR}/include)

@@ -56,17 +66,16 @@ 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)
-    target_link_libraries(ReWindowLibrary PUBLIC ${OPENGL_LIBRARIES})
-
-    target_link_libraries(ReWindowLibrary PUBLIC J3ML)
-    target_link_libraries(ReWindowLibrary PUBLIC Event)
+    target_link_libraries(ReWindowLibrary PUBLIC X11 Xrandr J3ML Event jlog ${OPENGL_LIBRARIES})
+    target_link_libraries(ReWindowLibrary PUBLIC)

    add_executable(ReWindowLibraryDemo main.cpp)
-    #target_include_directories(ReWindowLibraryDemo PRIVATE  ${JGL_SOURCE_DIR}/include)
    target_link_libraries(ReWindowLibraryDemo PUBLIC ReWindowLibrary)
-    #target_link_libraries(ReWindowLibraryDemo PRIVATE JGL)
 endif()

 if(WIN32)
-endif()
+    target_compile_options(ReWindowLibrary PUBLIC /utf-8)
+    target_link_libraries(ReWindowLibrary PUBLIC J3ML Event jlog ${OPENGL_LIBRARIES})
+    add_executable(ReWindowLibraryDemo main.cpp)
+    target_link_libraries(ReWindowLibraryDemo PUBLIC ReWindowLibrary)
+endif()
--- a/README.md
+++ b/README.md
@@ -11,7 +11,8 @@ A library which allows easily creating and managing a window  and it's events ac
 Install dependencies

 ```bash
-  dnf install cmake make gcc-g++ libX11 libX11-devel
+Fedora/RHEL:  dnf install cmake make gcc-g++ libX11 libX11-devel mesa-libGL-devel
+Ubuntu/Debian:  apt-get install cmake make gcc g++ libx11-6 libx11-dev libgl-dev libxrandr-dev
 ```

 Clone the repository
@@ -30,4 +31,4 @@ Run it

 ```bash
  ./ReWindowDemo
-```
+```
--- a/include/rewindow/data/GamepadScancodes.h
+++ b/include/rewindow/data/GamepadScancodes.h
@@ -0,0 +1,57 @@
+// @file GamepadScancodes.h
+// @
+
+#pragma once
+
+/*
+ * These scancodes were obtained from some knockoff Xbox controller from PowerA.
+ * I expect these to be fairly generic, so it's a good base to start from.
+ * 
+ * Something to keep in mind is the seperation here. On Linux linux/joystick.h
+ * is used to read controller inputs. It's a generic driver/library/whatever the
+ * fuck it's called.
+ *
+ * 2 constants are defined in linux/joystick.h
+ *
+ * 	JS_EVENT_BUTTON
+ * 	JS_EVENT_AXIS
+ *
+ * This is why I made seperate enum classes. Both the Axis and the Button scancode
+ * count start from 0x00. Having this seperation is easier to work with.
+ *
+ * I may write a program in the future to let us harvest scancodes from controllers.
+ * I hacked up some C code to get the scancodes for this one without the annoying
+ * stick drift spamming the screen, so with a little more work I could probably turn
+ * it into a generic test program
+ *
+ * P.S Windows is gonna make this slightly more annoying and different from what I've
+ * seen.
+ *
+ * - Maxine
+ */
+
+enum class GamepadScancode_AXIS {
+	ABS_X = 0x00,     // Xbox Left Thumbstick Axis
+	ABS_Y = 0x01,     // <-'
+	ABS_Z = 0x02,     // Xbox Left Trigger Axis
+	ABS_RX = 0x03,    // Xbox Right Thumbstick Axis 
+	ABS_RY = 0x04,    // <-'
+	ABS_RZ = 0x05,    // Xbox Right Trigger Axis (I know strange ain't it?)
+	ABS_HAT0X = 0x06, // Xbox DPad Axis (The Dpad is basically seen as a 3rd thumbstick)
+	ABS_HAT0Y = 0x07, // <-'
+}
+	
+enum class GamepadScancode_BTN {
+	BTN_SOUTH = 0x00   // Xbox A Button
+	BTN_EAST = 0x01    // Xbox B Button
+	BTN_WEST = 0x02    // Xbox X Button
+	BTN_NORTH = 0x03   // Xbox Y Button
+	BTN_TL = 0x04,     // Xbox Left Bumper
+	BTN_TR = 0x05,     // Xbox Right Bumper
+	BTN_START = 0x06,  // Xbox Start Button
+	BTN_SELECT = 0x07, // Xbox Select Button
+	BTN_HOME = 0x08,   // Xbox Home/Logo Button
+	BTN_THUMBL = 0x09, // Xbox Left Thumstick Button
+	BTN_THUMBR = 0x0a, // Xbox Right Thumbstick Button
+}
+	
--- a/include/rewindow/data/WindowsScancodes.h
+++ b/include/rewindow/data/WindowsScancodes.h
@@ -1,95 +1,107 @@
 #pragma once

-
 enum class WindowsScancode {
    Nothing = 0,
-    ESCAPE = 0x01,
-    ONE = 0x02,
-    TWO = 0x03,
-    THREE = 0x04,
-    FOUR = 0x05,
-    FIVE = 0x06,
-    SIX = 0x07,
-    SEVEN = 0x08,
-    EIGHT = 0x09,
-    NINE = 0x0A,
-    ZERO = 0x0B,
-    MINUS = 0x0C,
-    EQUALS = 0x0D,
-    BACKSPACE = 0x0E,
-    TAB = 0x0F,
-    Q = 0x10,
-    W = 0x11,
-    E = 0x12,
-    R = 0x13,
-    T = 0x14,
-    Y = 0x15,
-    U = 0x16,
-    I = 0x17,
-    O = 0x18,
-    P = 0x19,
-    LEFT_BRACKET = 0x1A,
-    RIGHT_BRACKET = 0x1B,
-    ENTER = 0x1C,
-    CTRL = 0x1D,
-    A = 0x1E,
-    S = 0x1F,
-    D = 0x20,
-    F = 0x21,
-    G = 0x22,
-    H = 0x23,
-    J = 0x24,
-    K = 0x25,
-    L = 0x26,
-    SEMICOLON = 0x27,
-    SINGLEQUOTE = 0x28,
-    GRAVE = 0x29,
-    LEFT_SHIFT = 0x2A,
-    BACKSLASH = 0x2B,
-    Z = 0x2C,
-    X = 0x2D,
-    C = 0x2E,
-    V = 0x2F,
-    B = 0x30,
-    N = 0x30,
-    M = 0x32,
-    COMMA = 0x33,
-    PERIOD = 0x34,
-    SLASH = 0x35,
-    RIGHT_SHIFT = 0x36,
-    PRINTSCREEN = 0x37,
-    ALT = 0x38,
-    SPACE = 0x39,
-    CAPS_LOCK = 0x3A,
-    F1 = 0x3B,
-    F2 = 0x3C,
-    F3 = 0x3D,
-    F4 = 0x3E,
-    F5 = 0x3F,
-    F6 = 0x40,
-    F7 = 0x41,
-    F8 = 0x42,
-    F9 = 0x43,
-    F10 = 0x44,
-    NUM_LOCK = 0x45,
-    SCROLL_LOCK = 0x46,
-    HOME = 0x47,
-    UP_ARROW = 0x48,
-    LEFT_ARROW,
-    DOWN_ARROW,
-    RIGHT_ARROW,
-    PAGE_UP = 0x49,
-    NUMPAD_MINUS = 0x4A,
-    NUMPAD_4 = 0x4B,
-    NUMPAD_5 = 0x4C,
-    NUMPAD_6 = 0x4D,
-    NUMPAD_PLUS = 0x4E,
-    NUMPAD_ONE = 0x4F,
-    NUMPAD_TWO = 0x50,
-    NUMPAD_THREE = 0x51,
-    NUMPAD_ZERO = 0x52,
-    DELETE = 0x53,
-    F11 = 0x85,
-    F12 = 0x86, // FIX
+    ESCAPE = 0x1B,           // VK_ESCAPE
+    ONE = 0x31,              // '1'
+    TWO = 0x32,              // '2'
+    THREE = 0x33,            // '3'
+    FOUR = 0x34,             // '4'
+    FIVE = 0x35,             // '5'
+    SIX = 0x36,              // '6'
+    SEVEN = 0x37,            // '7'
+    EIGHT = 0x38,            // '8'
+    NINE = 0x39,             // '9'
+    ZERO = 0x30,             // '0'
+    MINUS = 0xBD,            // VK_OEM_MINUS
+    EQUALS = 0xBB,           // VK_OEM_PLUS
+    BACKSPACE = 0x08,        // VK_BACK
+    TAB = 0x09,              // VK_TAB
+    Q = 0x51,                // 'Q'
+    W = 0x57,                // 'W'
+    E = 0x45,                // 'E'
+    R = 0x52,                // 'R'
+    T = 0x54,                // 'T'
+    Y = 0x59,                // 'Y'
+    U = 0x55,                // 'U'
+    I = 0x49,                // 'I'
+    O = 0x4F,                // 'O'
+    P = 0x50,                // 'P'
+    LEFT_BRACKET = 0xDB,     // VK_OEM_4
+    RIGHT_BRACKET = 0xDD,    // VK_OEM_6
+    ENTER = 0x0D,            // VK_RETURN
+    CTRL = 0x11,             // VK_CONTROL
+    A = 0x41,                // 'A'
+    S = 0x53,                // 'S'
+    D = 0x44,                // 'D'
+    F = 0x46,                // 'F'
+    G = 0x47,                // 'G'
+    H = 0x48,                // 'H'
+    J = 0x4A,                // 'J'
+    K = 0x4B,                // 'K'
+    L = 0x4C,                // 'L'
+    SEMICOLON = 0xBA,        // VK_OEM_1
+    SINGLEQUOTE = 0xDE,      // VK_OEM_7
+    GRAVE = 0xC0,            // VK_OEM_3
+    LEFT_SHIFT = 0x10,       // VK_LSHIFT
+    BACKSLASH = 0xDC,        // VK_OEM_5
+    Z = 0x5A,                // 'Z'
+    X = 0x58,                // 'X'
+    C = 0x43,                // 'C'
+    V = 0x56,                // 'V'
+    B = 0x42,                // 'B'
+    N = 0x4E,                // 'N'
+    M = 0x4D,                // 'M'
+    PERIOD = 0xBE,           // VK_OEM_PERIOD
+    SLASH = 0xBF,            // VK_OEM_2
+    RIGHT_SHIFT = 0xA1,      // VK_RSHIFT
+    PRINTSCREEN = 0x2C,      // VK_SNAPSHOT
+    ALT = 0x12,              // VK_MENU
+    SPACE = 0x20,            // VK_SPACE
+    CAPS_LOCK = 0x14,        // VK_CAPITAL
+    F1 = 0x70,               // VK_F1
+    F2 = 0x71,               // VK_F2
+    F3 = 0x72,               // VK_F3
+    F4 = 0x73,               // VK_F4
+    F5 = 0x74,               // VK_F5
+    F6 = 0x75,               // VK_F6
+    F7 = 0x76,               // VK_F7
+    F8 = 0x77,               // VK_F8
+    F9 = 0x78,               // VK_F9
+    F10 = 0x79,              // VK_F10
+    NUM_LOCK = 0x90,         // VK_NUMLOCK
+    SCROLL_LOCK = 0x91,      // VK_SCROLL
+    HOME = 0x24,             // VK_HOME
+    UP_ARROW = 0x26,         // VK_UP
+    PAGE_UP = 0x21,          // VK_PRIOR
+    LEFT_ARROW = 0x25,       // VK_LEFT
+    DOWN_ARROW = 0x28,       // VK_DOWN
+    RIGHT_ARROW = 0x27,      // VK_RIGHT
+    END = 0x23,              // VK_END
+    PAGE_DOWN = 0x22,        // VK_NEXT
+    INSERT = 0x2D,           // VK_INSERT
+    DEL = 0x2E,           // VK_DELETE
+    F11 = 0x7A,              // VK_F11
+    F12 = 0x7B,              // VK_F12

+    NUMPAD_ZERO = 0x60,      // VK_NUMPAD0
+    NUMPAD_ONE = 0x61,       // VK_NUMPAD1
+    NUMPAD_TWO = 0x62,       // VK_NUMPAD2
+    NUMPAD_THREE = 0x63,     // VK_NUMPAD3
+    NUMPAD_FOUR = 0x64,      // VK_NUMPAD4
+    NUMPAD_FIVE = 0x65,      // VK_NUMPAD5
+    NUMPAD_SIX = 0x66,       // VK_NUMPAD6
+    NUMPAD_SEVEN = 0x67,     // VK_NUMPAD7
+    NUMPAD_EIGHT = 0x68,     // VK_NUMPAD8
+    NUMPAD_NINE = 0x69,      // VK_NUMPAD9
+    NUMPAD_PLUS = 0x6B,      // VK_ADD
+    NUMPAD_MINUS = 0x6D,     // VK_SUBTRACT
+    NUMPAD_ASTERISK = 0x6A,
+    NUMPAD_SLASH = 0x6F,
+    NUMPAD_PERIOD = 0x6E,   // VK_DECIMAL
+    NUMPAD_ENTER = 0x0D,      // VK_RETURN
+    SUPER = 0x5B,
+    COMMA = 0xBC,
+    MENU = 93,
+    BREAK = 0x13
 };
--- a/include/rewindow/data/X11Scancodes.h
+++ b/include/rewindow/data/X11Scancodes.h
@@ -24,9 +24,10 @@ enum class X11Scancode {
    PAGEUP = 112,
    PAGEDOWN = 117,
    HOME = 110,
+    MENU = 135,
    END = 115,
    INSERT = 118,
-    DELETE = 119,
+    DEL = 119,
    UP = 111,
    DOWN = 116,
    LEFT = 113,
--- a/include/rewindow/data/scancode.h
+++ b/include/rewindow/data/scancode.h
@@ -0,0 +1,273 @@
+/// ReWindowLibrary
+/// A C++20 Library for creating and managing windows in a platform-independent manner
+/// Developed and Maintained by the boys @ Redacted Software.
+/// (c) 2024 Redacted Software
+/// This work is dedicated to the public domain.
+
+/// @file scancode.h
+/// @desc Abstraction layer for input device scancodes
+/// @edit 2024-12-03
+
+#pragma once
+
+namespace ReWindow {
+    enum class ReScanCodeIndex : unsigned int {
+        Unimplemented = 0,
+
+        MLeft = 1,
+        MRight = 2,
+        MMiddle = 3,
+        MWheel_Up = 4,
+        MWheel_Down = 5,
+        MSide_A = 8,
+        MSide_B = 9,
+
+        KP_0 = 90,
+        KP_1 = 87,
+        KP_2 = 88,
+        KP_3 = 89,
+        KP_4 = 83,
+        KP_5 = 84,
+        KP_6 = 85,
+        KP_7 = 79,
+        KP_8 = 80,
+        KP_9 = 81,
+        KP_PERIOD = 91,
+        KP_RETURN = 104,
+        KP_PLUS = 86,
+        KP_MINUS = 82,
+        KP_ASTERISK = 63,
+        KP_SLASH = 106,
+        KP_NUMLOCK = 77,
+        PAGEUP = 112,
+        PAGEDOWN = 117,
+        HOME = 110,
+        MENU = 135,
+        END = 115,
+        INSERT = 118,
+        DEL = 119,
+        UP = 111,
+        DOWN = 116,
+        LEFT = 113,
+        RIGHT = 114,
+        BACKSPACE = 22,
+        EQUALS = 21,
+        MINUS = 20,
+        ZERO = 19,
+        NINE = 18,
+        EIGHT = 17,
+        SEVEN = 16,
+        SIX = 15,
+        FIVE = 14,
+        FOUR = 13,
+        THREE = 12,
+        TWO = 11,
+        ONE = 10,
+        GRAVE = 49,
+        BACKSLASH = 51,
+        CLOSING_SQUARE_BRACKET = 35,
+        OPENING_SQUARE_BRACKET = 34,
+        P = 33,
+        O = 32,
+        I = 31,
+        U = 30,
+        Y = 29,
+        T = 28,
+        R = 27,
+        E = 26,
+        W = 25,
+        Q = 24,
+        TAB = 23,
+        RETURN = 36,
+        SINGLEQUOTE = 48,
+        SEMICOLON = 47,
+        L = 46,
+        K = 45,
+        J = 44,
+        H = 43,
+        G = 42,
+        F = 41,
+        D = 40,
+        S = 39,
+        A = 38,
+        CAPSLOCK = 66,
+        RIGHT_SHIFT = 62,
+        SLASH = 61,
+        PERIOD = 60,
+        COMMA = 59,
+        M = 58,
+        N = 57,
+        B = 56,
+        V = 55,
+        C = 54,
+        X = 53,
+        Z = 52,
+        LEFT_SHIFT = 50,
+        RIGHT_CONTROL = 105,
+        RIGHT_ALT = 108,
+        SPACE = 65,
+        LEFT_ALT = 64,
+        SUPER = 133,
+        LEFT_CTRL = 37,
+        ESCAPE = 9,
+        F1 = 67,
+        F2 = 68,
+        F3 = 69,
+        F4 = 70,
+        F5 = 71,
+        F6 = 72,
+        F7 = 73,
+        F8 = 74,
+        F9 = 75,
+        F10 = 76,
+        F11 = 95,
+        F12 = 96,
+        PRINT = 107,
+        SCROLL_LOCK = 78,
+        BREAK = 127,
+    };
+
+    class ReScanCode
+    {
+    public:
+        std::string Mnemonic;
+        unsigned int Sindex;
+
+        ReScanCode() = default;
+        explicit ReScanCode(const std::string& string, ReScanCodeIndex sindex);
+        explicit ReScanCode(const std::string& string, unsigned int sindex);
+        bool operator == (const ReScanCode& rs) const;
+        bool operator<(const ReScanCode& rhs) const;
+        ReScanCode(const ReScanCode&) = default;
+    };
+
+    namespace ReScanCodes {
+        static const ReScanCode Unimplemented  ("?", 0);
+
+        static const ReScanCode MouseButtonLeft           ("ML", ReScanCodeIndex::MLeft);
+        static const ReScanCode MouseButtonRight          ("MR", ReScanCodeIndex::MRight);
+        static const ReScanCode MouseButtonMiddle         ("MM", ReScanCodeIndex::MMiddle);
+        static const ReScanCode MouseButtonSideA         ("M4", ReScanCodeIndex::MSide_A);
+        static const ReScanCode MouseButtonSideB         ("M5", ReScanCodeIndex::MSide_B);
+        /// NOTE: IsMouseButtonDown will not return correctly for the mouse-wheel-buttons, because the action is effectively instantaneous.
+        static const ReScanCode MWheelUp       ("MWU", ReScanCodeIndex::MWheel_Up);
+        /// NOTE: IsMouseButtonDown will not return correctly for the mouse-wheel-buttons, because the action is effectively instantaneous.
+        static const ReScanCode MWheelDown     ("MWD", ReScanCodeIndex::MWheel_Down);
+
+        // TODO: Encode both Uppercase and Lowercase version for each keymap
+        static const ReScanCode Escape ("ESC", ReScanCodeIndex::ESCAPE);
+        static const ReScanCode F1  ("F1", ReScanCodeIndex::F1);
+        static const ReScanCode F2  ("F2", ReScanCodeIndex::F2);
+        static const ReScanCode F3  ("F3", ReScanCodeIndex::F3);
+        static const ReScanCode F4  ("F4", ReScanCodeIndex::F4);
+        static const ReScanCode F5  {"F5", ReScanCodeIndex::F5};
+        static const ReScanCode F6  {"F6", ReScanCodeIndex::F6};
+        static const ReScanCode F7  {"F7", ReScanCodeIndex::F7};
+        static const ReScanCode F8  {"F8", ReScanCodeIndex::F8};
+        static const ReScanCode F9  {"F9", ReScanCodeIndex::F9};
+        static const ReScanCode F10 {"F10", ReScanCodeIndex::F10};
+        static const ReScanCode F11 {"F11", ReScanCodeIndex::F11};
+        static const ReScanCode F12 {"F12", ReScanCodeIndex::F12};
+        static const ReScanCode Print {"PRINT", ReScanCodeIndex::PRINT};
+        static const ReScanCode ScrollLock {"SCROLL_LOCK", ReScanCodeIndex::SCROLL_LOCK};
+        static const ReScanCode Break {"BREAK", ReScanCodeIndex::BREAK};
+
+        //TODO On Windows, Return & KP_RETURN are the same thing.
+        static const ReScanCode NumPadReturn {"KP_↵", ReScanCodeIndex::KP_RETURN};
+        static const ReScanCode NumPadPlus {"KP_+", ReScanCodeIndex::KP_PLUS};
+        static const ReScanCode NumPadMinus {"KP_-", ReScanCodeIndex::KP_MINUS};
+        static const ReScanCode NumPadAsterisk {"KP_*", ReScanCodeIndex::KP_ASTERISK};
+        static const ReScanCode NumPadForwardSlash {"KP_/", ReScanCodeIndex::KP_SLASH};
+        static const ReScanCode NumPadPeriod {"KP_.", ReScanCodeIndex::KP_PERIOD};
+        static const ReScanCode NumPadNumLock {"KP_NUMLOCK", ReScanCodeIndex::KP_NUMLOCK};
+
+        static const ReScanCode NumPad1 {"KP_1", ReScanCodeIndex::KP_1};
+        static const ReScanCode NumPad2 {"KP_2", ReScanCodeIndex::KP_2};
+        static const ReScanCode NumPad3 {"KP_3", ReScanCodeIndex::KP_3};
+        static const ReScanCode NumPad4 {"KP_4", ReScanCodeIndex::KP_4};
+        static const ReScanCode NumPad5 {"KP_5", ReScanCodeIndex::KP_5};
+        static const ReScanCode NumPad6 {"KP_6", ReScanCodeIndex::KP_6};
+        static const ReScanCode NumPad7 {"KP_7", ReScanCodeIndex::KP_7};
+        static const ReScanCode NumPad8 {"kP_8", ReScanCodeIndex::KP_8};
+        static const ReScanCode NumPad9 {"KP_9", ReScanCodeIndex::KP_9};
+        static const ReScanCode NumPad0 {"KP_0", ReScanCodeIndex::KP_0};
+
+        static const ReScanCode Grave {"`", ReScanCodeIndex::GRAVE};
+        static const ReScanCode One {"1", ReScanCodeIndex::ONE};
+        static const ReScanCode Two {"2", ReScanCodeIndex::TWO};
+        static const ReScanCode Three {"3", ReScanCodeIndex::THREE};
+        static const ReScanCode Four {"4", ReScanCodeIndex::FOUR};
+        static const ReScanCode Five {"5", ReScanCodeIndex::FIVE};
+        static const ReScanCode Six {"6", ReScanCodeIndex::SIX};
+        static const ReScanCode Seven {"7", ReScanCodeIndex::SEVEN};
+        static const ReScanCode Eight {"8", ReScanCodeIndex::EIGHT};
+        static const ReScanCode Nine {"9", ReScanCodeIndex::NINE};
+        static const ReScanCode Zero {"0", ReScanCodeIndex::ZERO};
+        static const ReScanCode Minus {"-", ReScanCodeIndex::MINUS};
+        static const ReScanCode Equals {"+", ReScanCodeIndex::EQUALS};
+        static const ReScanCode Backspace {"⌫", ReScanCodeIndex::BACKSPACE};
+
+        static const ReScanCode Tab {"⇥", ReScanCodeIndex::TAB};
+        static const ReScanCode Q {"Q", ReScanCodeIndex::Q};
+        static const ReScanCode W {"W", ReScanCodeIndex::W};
+        static const ReScanCode E {"E", ReScanCodeIndex::E};
+        static const ReScanCode R {"R", ReScanCodeIndex::R};
+        static const ReScanCode T {"T", ReScanCodeIndex::T};
+        static const ReScanCode Y {"Y", ReScanCodeIndex::Y};
+        static const ReScanCode U {"U", ReScanCodeIndex::U};
+        static const ReScanCode I {"I", ReScanCodeIndex::I};
+        static const ReScanCode O {"O", ReScanCodeIndex::O};
+        static const ReScanCode P {"P", ReScanCodeIndex::P};
+        static const ReScanCode LeftBracket {"[", ReScanCodeIndex::OPENING_SQUARE_BRACKET};
+        static const ReScanCode RightBracket {"]", ReScanCodeIndex::CLOSING_SQUARE_BRACKET};
+        static const ReScanCode BackSlash {"\\", ReScanCodeIndex::BACKSLASH};
+
+        static const ReScanCode CapsLock {"CAPS", ReScanCodeIndex::CAPSLOCK};
+        static const ReScanCode A {"A", ReScanCodeIndex::A};
+        static const ReScanCode S {"S", ReScanCodeIndex::S};
+        static const ReScanCode D {"D", ReScanCodeIndex::D};
+        static const ReScanCode F {"F", ReScanCodeIndex::F};
+        static const ReScanCode G {"G", ReScanCodeIndex::G};
+        static const ReScanCode H {"H", ReScanCodeIndex::H};
+        static const ReScanCode J {"J", ReScanCodeIndex::J};
+        static const ReScanCode K {"K", ReScanCodeIndex::K};
+        static const ReScanCode L {"L", ReScanCodeIndex::L};
+        static const ReScanCode Semicolon {";", ReScanCodeIndex::SEMICOLON};
+        static const ReScanCode SingeQuote {"\'", ReScanCodeIndex::SINGLEQUOTE};
+        static const ReScanCode Return {"↵", ReScanCodeIndex::RETURN};
+
+        static const ReScanCode LeftShift {"⇧", ReScanCodeIndex::LEFT_SHIFT};
+        static const ReScanCode Z {"Z", ReScanCodeIndex::Z};
+        static const ReScanCode X {"X", ReScanCodeIndex::X};
+        static const ReScanCode C {"C", ReScanCodeIndex::C};
+        static const ReScanCode V {"V", ReScanCodeIndex::V};
+        static const ReScanCode B {"B", ReScanCodeIndex::B};
+        static const ReScanCode N {"N", ReScanCodeIndex::N};
+        static const ReScanCode M {"M", ReScanCodeIndex::M};
+        static const ReScanCode Comma {",", ReScanCodeIndex::COMMA};
+        static const ReScanCode Period {".", ReScanCodeIndex::PERIOD};
+        static const ReScanCode ForwardSlash {"/", ReScanCodeIndex::SLASH};
+
+        static const ReScanCode LeftControl {"LCTRL", ReScanCodeIndex::LEFT_CTRL};
+        static const ReScanCode Super {"❖", ReScanCodeIndex::SUPER};
+        static const ReScanCode LeftAlt {"🄰", ReScanCodeIndex::LEFT_ALT};
+        static const ReScanCode Space {" ", ReScanCodeIndex::SPACE};
+        static const ReScanCode RightAlt {"R🄰", ReScanCodeIndex::RIGHT_ALT};
+        static const ReScanCode Menu {"▤", ReScanCodeIndex::MENU};
+        static const ReScanCode RightControl {"RCTRL", ReScanCodeIndex::RIGHT_CONTROL};
+        static const ReScanCode RightShift {"R⇧", ReScanCodeIndex::RIGHT_SHIFT};
+
+        static const ReScanCode Insert {"INSERT", ReScanCodeIndex::INSERT};
+        static const ReScanCode Home {"HOME", ReScanCodeIndex::HOME};
+        static const ReScanCode PageUp {"PAGEUP", ReScanCodeIndex::PAGEUP};
+        static const ReScanCode Delete {"DELETE", ReScanCodeIndex::DEL};
+        static const ReScanCode End {"End", ReScanCodeIndex::END};
+        static const ReScanCode PageDown {"PAGEDOWN", ReScanCodeIndex::PAGEDOWN};
+
+        static const ReScanCode UpArrow {("↑"), ReScanCodeIndex::UP};
+        static const ReScanCode DownArrow {("↓"), ReScanCodeIndex::DOWN};
+        static const ReScanCode LeftArrow {("←"), ReScanCodeIndex::LEFT};
+        static const ReScanCode RightArrow {("→"), ReScanCodeIndex::RIGHT};
+    }
+}
+
--- a/include/rewindow/logger/logger.h
+++ b/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;
+}
--- a/include/rewindow/types/WindowEvents.hpp
+++ b/include/rewindow/types/WindowEvents.hpp
@@ -0,0 +1,85 @@
+#pragma once
+
+#include <chrono>
+#include <rewindow/types/key.h>
+#include <rewindow/types/mousebutton.h>
+
+namespace ReWindow {
+
+    using namespace std::chrono_literals;
+    using precision_clock = std::chrono::high_resolution_clock;
+    using precision_timestamp = precision_clock::time_point;
+
+    class TimestampedEvent {
+    private:
+
+    public:
+        precision_timestamp Timestamp;
+        TimestampedEvent() : Timestamp(precision_clock::now())
+        { }
+    };
+
+    class RWindowEvent : public TimestampedEvent {
+    public:
+        RWindowEvent() : TimestampedEvent() { }
+    };
+
+    class KeyboardEvent : public RWindowEvent {
+    public:
+        Key key;
+        KeyState state;
+        KeyboardEvent(Key key, KeyState state) : RWindowEvent(), key(key), state(state) {}
+    };
+    class MouseEvent : public RWindowEvent {};
+
+    class GamepadEvent : public RWindowEvent {};
+
+    class MouseMoveEvent : public MouseEvent {
+    public:
+        Vector2 Position;
+        Vector2 Delta;
+        MouseMoveEvent(const Vector2 &pos) : MouseEvent(), Position(pos)
+        {}
+        MouseMoveEvent(int x, int y) : MouseEvent(), Position(Vector2(x, y))
+        {}
+    };
+
+    class KeyDownEvent : public KeyboardEvent {
+    public:
+        KeyDownEvent(Key key) : KeyboardEvent(key, KeyState::Pressed) {}
+    };
+
+    class KeyUpEvent : public KeyboardEvent {
+    public:
+        KeyUpEvent(Key key) : KeyboardEvent(key, KeyState::Released) {}
+    };
+
+    class MouseWheelEvent : public MouseEvent
+    {
+    public:
+        int WheelMovement;
+        MouseWheelEvent() = default;
+        MouseWheelEvent(int wheel) : MouseEvent(), WheelMovement(wheel) {}
+    };
+
+    class MouseButtonDownEvent : public MouseEvent {
+    public:
+        MouseButton Button;
+
+        MouseButtonDownEvent() = default;
+        MouseButtonDownEvent(MouseButton button) : MouseEvent(), Button(button) {}
+    };
+
+    class MouseButtonUpEvent : public MouseEvent {
+    public:
+        MouseButton Button;
+        MouseButtonUpEvent() = default;
+        MouseButtonUpEvent(MouseButton button) : MouseEvent(), Button(button) {}
+    };
+
+    class WindowResizeRequestEvent : public RWindowEvent
+    {
+    public:
+        Vector2 Size;
+    };
+}
--- a/include/rewindow/types/cursors.h
+++ b/include/rewindow/types/cursors.h
@@ -1,60 +1,80 @@
 #pragma once
+
+#if __linux__
 #include <X11/cursorfont.h>
+#endif
+
 namespace ReWindow
 {
-    enum class X11CursorStyle
-    {
-        Default = XC_left_ptr,
-        X = XC_X_cursor,
-        Arrow = XC_arrow,
-        IBeam = XC_xterm,
-        BottomLeftCorner = XC_bottom_left_corner,
-        BottomRightCorner = XC_bottom_right_corner,
-        BottomSide = XC_bottom_side,
-        Dot = XC_dot,
-        DoubleArrow = XC_double_arrow,
-        Exchange = XC_exchange,
-        Hand = XC_hand2,
-        LeftSide = XC_left_side,
-        Plus = XC_plus,
-        RightSide = XC_right_side,
-        Pencil = XC_pencil
-    };
+#if __linux__
+	enum class X11CursorStyle
+	{
+		Default = XC_left_ptr,
+		X = XC_X_cursor,
+		Arrow = XC_arrow,
+		IBeam = XC_xterm,
+		BottomLeftCorner = XC_bottom_left_corner,
+		BottomRightCorner = XC_bottom_right_corner,
+		BottomSide = XC_bottom_side,
+		Dot = XC_dot,
+		DoubleArrow = XC_double_arrow,
+		Exchange = XC_exchange,
+		Hand = XC_hand2,
+		LeftSide = XC_left_side,
+		Plus = XC_plus,
+		RightSide = XC_right_side,
+		Pencil = XC_pencil
+	};

-    // https://learn.microsoft.com/en-us/windows/win32/menurc/about-cursors
-    enum class WindowsCursorStyle
-    {
-        Arrow,
-        IBeam,
-        Wait,
-        Cross,
-        Hand,
-        AppStarting,
-    };
-    class CursorStyle
-    {
-    public:
-        X11CursorStyle X11Cursor;
-        CursorStyle(X11CursorStyle style) : X11Cursor(style) {}
-    };
+	class CursorStyle {
+		public:
+			X11CursorStyle X11Cursor;
+			CursorStyle(X11CursorStyle style) : X11Cursor(style) {}
+	};

-    namespace Cursors
-    {
-        static const CursorStyle Default {X11CursorStyle::Default};
-        static const CursorStyle X {X11CursorStyle::X};
-        static const CursorStyle Arrow {X11CursorStyle::Arrow};
-        static const CursorStyle IBeam {X11CursorStyle::IBeam};
-        static const CursorStyle BottomLeftCorner {X11CursorStyle::BottomLeftCorner};
-        static const CursorStyle BottomRightCorner {X11CursorStyle::BottomRightCorner};
-        static const CursorStyle BottomSide {X11CursorStyle::BottomSide};
-        static const CursorStyle Dot {X11CursorStyle::Dot};
-        static const CursorStyle DoubleArrow {X11CursorStyle::DoubleArrow};
-        static const CursorStyle Exchange {X11CursorStyle::Exchange};
-        static const CursorStyle Hand {X11CursorStyle::Hand};
-        static const CursorStyle LeftSide {X11CursorStyle::LeftSide};
-        static const CursorStyle Plus {X11CursorStyle::Plus};
-        static const CursorStyle RightSide {X11CursorStyle::RightSide};
-        static const CursorStyle Pencil {X11CursorStyle::Pencil};
-    }
+	namespace Cursors {
+		static const CursorStyle Default {X11CursorStyle::Default};
+		static const CursorStyle X {X11CursorStyle::X};
+		static const CursorStyle Arrow {X11CursorStyle::Arrow};
+		static const CursorStyle IBeam {X11CursorStyle::IBeam};
+		static const CursorStyle BottomLeftCorner {X11CursorStyle::BottomLeftCorner};
+		static const CursorStyle BottomRightCorner {X11CursorStyle::BottomRightCorner};
+		static const CursorStyle BottomSide {X11CursorStyle::BottomSide};
+		static const CursorStyle Dot {X11CursorStyle::Dot};
+		static const CursorStyle DoubleArrow {X11CursorStyle::DoubleArrow};
+		static const CursorStyle Exchange {X11CursorStyle::Exchange};
+		static const CursorStyle Hand {X11CursorStyle::Hand};
+		static const CursorStyle LeftSide {X11CursorStyle::LeftSide};
+		static const CursorStyle Plus {X11CursorStyle::Plus};
+		static const CursorStyle RightSide {X11CursorStyle::RightSide};
+		static const CursorStyle Pencil {X11CursorStyle::Pencil};
+	}

+#else
+	// https://learn.microsoft.com/en-us/windows/win32/menurc/about-cursors
+	enum WindowsCursorStyle {
+		Arrow,
+		IBeam,
+		Wait,
+		Cross,
+		Hand,
+		AppStarting,
+	};
+
+	class CursorStyle {
+		public:
+			WindowsCursorStyle WindowsCursor;
+			CursorStyle (WindowsCursorStyle style): WindowsCursor(style) {}
+	};
+
+	namespace Cursors {
+		static const CursorStyle Default {WindowsCursorStyle::Arrow};
+		static const CursorStyle Arrow {WindowsCursorStyle::Arrow};
+		static const CursorStyle IBeam {WindowsCursorStyle::IBeam};
+		static const CursorStyle Cross {WindowsCursorStyle::Cross};
+		static const CursorStyle Wait {WindowsCursorStyle::Wait};
+		static const CursorStyle Hand {WindowsCursorStyle::Hand};
+		static const CursorStyle AppStarting {WindowsCursorStyle::AppStarting};
+	}
+#endif
 }
--- a/include/rewindow/types/display.h
+++ b/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();
+};
--- a/include/rewindow/types/gamepad.h
+++ b/include/rewindow/types/gamepad.h
@@ -0,0 +1,27 @@
+/// ReWindowLibrary
+/// A C++20 Library for creating and managing windows in a platform-independent manner
+/// Developed and Maintained by the boys @ Redacted Software.
+/// (c) 2024 Redacted Software
+/// This work is dedicated to the public domain.
+
+/// @file gamepad.h
+/// @desc A class that models the functionality of a gamepad / controller device.
+/// @edit 2024-07-29
+
+#pragma once
+
+namespace ReWindow
+{
+
+    class InputDevice {}; // TODO: Remember to break InputDevice into it's own file and not define it twice!!!
+
+    class Gamepad : public InputDevice
+    {
+    public:
+
+    };
+
+
+    class XboxGamepad : public Gamepad {};
+    class PS4Gamepad : public Gamepad {};
+}
--- a/include/rewindow/types/gamepadbutton.h
+++ b/include/rewindow/types/gamepadbutton.h
@@ -0,0 +1,75 @@
+/// ReWindowLibrary
+/// A C++20 Library for creating and managing windows in a platform-independent manner
+/// Developed and Maintained by the boys @ Redacted Software.
+/// (c) 2024 Redacted Software
+/// This work is dedicated to the public domain.
+
+/// @file gamepadbutton.h
+/// @desc GamepadButton class and enumerations to define standard buttons found on a Gamepad
+/// @edit 2024-07-29
+
+#include <string>
+#include <J3ML/LinearAlgebra.hpp>
+
+class GamepadButton {
+protected:
+    std::string mnemonic_btn_code;
+public:
+    explicit GamepadButton(const std::string& mnemonic) : mnemonic_btn_code(mnemonic) {  }
+    [[nodiscard]] std::string GetMnemonicButtonCode() const { return mnemonic_btn_code; }
+
+    /// Compares two GamepadButtons by their mnemonic button codes, not their activation state.
+    bool operator ==(const GamepadButton& rhs) const;
+};
+
+class GamepadTrigger {
+public:
+
+    /// Returns a float value between 0-1 representing how much the trigger has been pushed in by.
+    /// (0 being unpressed, 1 being fully pressed)
+    float GetActuation() const;
+
+    /// TODO: Might be more appropriate in the Gamepad class representation.
+    void SetActuationThreshold(float minimum = 0.01f) const;
+};
+
+class GamepadThumbstick
+{
+public:
+    /// Returns a Vector2 value representing the x,y coordinates of the joystick, with 0,0 being the center (at rest).
+    /// This vector ranges from length = 0 to length = 1 (i.e. the unit circle).
+    [[nodiscard]] Vector2 GetPosition() const;
+
+
+    /// Sets the deadzone range of the thumbstick.
+    /// Deadzone controls how far the stick must be moved before any movement is actually reported.
+    /// This is because the thumbstick at-rest will often still report movement.
+    /// If gamecode is architected to use the thumbstick position as a direction, without factoring in magnitude, this would cause problems.
+    void SetDeadzone(float minimum = 0.01f) const;
+};
+
+
+
+using J3ML::LinearAlgebra::Vector2;
+
+namespace GamepadButtons {
+    static const GamepadButton X {"X"};
+    static const GamepadButton Y {"Y"};
+    static const GamepadButton A {"A"};
+    static const GamepadButton B {"B"};
+
+    static const auto Triangle = Y;
+    static const auto Square   = X;
+    static const auto Circle   = A;
+    static const auto Cross    = B;
+
+
+    static const GamepadButton LeftBumper {"LB"};
+    static const GamepadButton RightBumper {"RB"};
+}
+
+namespace GamepadTriggers
+{
+    static const GamepadTrigger Left;
+    static const GamepadTrigger Right;
+}
--- a/include/rewindow/types/inputdevice.hpp
+++ b/include/rewindow/types/inputdevice.hpp
@@ -0,0 +1,39 @@
+#pragma once
+
+namespace ReWindow
+{
+
+    enum class DeviceType {
+        MOUSE, KEYBOARD, GAMEPAD, TOUCHSCREEN, REMOTE, VRHEADSET
+    };
+
+    enum class DeviceState {
+        OK, LOW_BATTERY, UNAVAILABLE
+    };
+
+    class InputDeviceImpl { };
+    class InputDeviceImplLinux { };
+
+    class InputDevice {
+    public:
+        virtual void Update(double elapsed){}
+
+        /// Returns the device's index among devices of the same type.
+        uint GetIndex() const;
+
+        virtual DeviceType GetType() const = 0;
+        DeviceState GetDeviceState() const;
+        bool IsAnyButtonDown();
+    };
+
+    struct InputEvent
+    {
+        std::chrono::system_clock::time_point Timestamp;
+    };
+
+    struct BinaryActuatorState
+    {
+        double TimeHeld;
+        bool Pressed;
+    };
+}
--- a/include/rewindow/types/inputservice.hpp
+++ b/include/rewindow/types/inputservice.hpp
@@ -0,0 +1,32 @@
+#pragma once
+
+#include <rewindow/types/mouse.h>
+
+namespace ReWindow
+{
+
+    namespace detail
+    {
+        static Mouse* internal_mouse;
+
+        void UpdateMouse(Mouse* mouse) {
+            detail::internal_mouse = mouse;
+        }
+
+    }
+
+    namespace InputService
+    {
+        namespace Mouse
+        {
+            Vector2 GetMousePosition()
+            {
+                return detail::internal_mouse->GetPosition();
+            }
+
+            bool IsButtonDown(const MouseButton &btn) {
+                return detail::internal_mouse->IsButtonDown(btn);
+            }
+        }
+
+    }
--- a/include/rewindow/types/key.h
+++ b/include/rewindow/types/key.h
@@ -2,199 +2,154 @@
 // ~DAWSH
 #pragma once

-
 #include <vector>
-#include <J3ML/LinearAlgebra/Vector2.h>
-
 #include <stdexcept>
 #include <iostream>
+#include <string>
+#include <rewindow/data/X11Scancodes.h>
+#include <rewindow/data/WindowsScancodes.h>
+#include <J3ML/LinearAlgebra.hpp>

-#if __linux__
-#include <X11/X.h>
-#endif
-
-#include "rewindow/data/X11Scancodes.h"
-#include "rewindow/data/WindowsScancodes.h"
-
-using J3ML::LinearAlgebra::Vector2;

 class Key
 {
 private:
-    static std::vector<Key> keyboard;
+    //CLion on Linux falsely marks this as being wrong.
+    static inline std::vector<Key> keyboard{};
+
 public:
    static std::vector<Key> GetKeyboard();
-    Key();
-    Key(char charcode, X11Scancode scancode, WindowsScancode wSc);
-    char CharCode;
+    Key() = default;
+    Key(const char* charcode, X11Scancode scancode, WindowsScancode wSc);
+    std::string Mnemonic;
    X11Scancode x11ScanCode;
    WindowsScancode winScanCode;
    bool operator==(const Key& rhs) const;
    bool operator<(const Key& rhs) const;
    Key(const Key&) = default;
-
 };

 namespace Keys {
    // TODO: Encode both Uppercase and Lowercase version for each keymap
-    static const Key Escape {'\b', X11Scancode::ESCAPE, WindowsScancode::ESCAPE};
-    static const Key F1  {'\u000f', X11Scancode::F1, WindowsScancode::F1};
-    static const Key F2  {'\u000f', X11Scancode::F2, WindowsScancode::F2};
-    static const Key F3  {'\u000f', X11Scancode::F3, WindowsScancode::F3};
-    static const Key F4  {'\u000f', X11Scancode::F4, WindowsScancode::F4};
-    static const Key F5  {'\u000f', X11Scancode::F5, WindowsScancode::F5};
-    static const Key F6  {'\u000f', X11Scancode::F6, WindowsScancode::F6};
-    static const Key F7  {'\u000f', X11Scancode::F7, WindowsScancode::F7};
-    static const Key F8  {'\u000f', X11Scancode::F8, WindowsScancode::F8};
-    static const Key F9  {'\u000f', X11Scancode::F9, WindowsScancode::F9};
-    static const Key F10 {'\u000f', X11Scancode::F10, WindowsScancode::F10};
-    static const Key F11 {'\u000f', X11Scancode::F11, WindowsScancode::F11};
-    static const Key F12 {'\u000f', X11Scancode::F12, WindowsScancode::F12};
+    static const Key Escape {"ESC", X11Scancode::ESCAPE, WindowsScancode::ESCAPE};
+    static const Key F1  {"F1", X11Scancode::F1, WindowsScancode::F1};
+    static const Key F2  {"F2", X11Scancode::F2, WindowsScancode::F2};
+    static const Key F3  {"F3", X11Scancode::F3, WindowsScancode::F3};
+    static const Key F4  {"F4", X11Scancode::F4, WindowsScancode::F4};
+    static const Key F5  {"F5", X11Scancode::F5, WindowsScancode::F5};
+    static const Key F6  {"F6", X11Scancode::F6, WindowsScancode::F6};
+    static const Key F7  {"F7", X11Scancode::F7, WindowsScancode::F7};
+    static const Key F8  {"F8", X11Scancode::F8, WindowsScancode::F8};
+    static const Key F9  {"F9", X11Scancode::F9, WindowsScancode::F9};
+    static const Key F10 {"F10", X11Scancode::F10, WindowsScancode::F10};
+    static const Key F11 {"F11", X11Scancode::F11, WindowsScancode::F11};
+    static const Key F12 {"F12", X11Scancode::F12, WindowsScancode::F12};
+    static const Key Print {"PRINT", X11Scancode::PRINT, WindowsScancode::PRINTSCREEN};
+    static const Key ScrollLock {"SCROLL_LOCK", X11Scancode::SCROLL_LOCK, WindowsScancode::SCROLL_LOCK};
+    static const Key Break {"BREAK", X11Scancode::BREAK, WindowsScancode::BREAK};

-    static const Key NumPad1 {'\b', X11Scancode::KP_1, WindowsScancode::NUMPAD_ONE};
-    static const Key NumPad2 {'\b', X11Scancode::KP_2, WindowsScancode::NUMPAD_ONE};
-    static const Key NumPad3 {'\b', X11Scancode::KP_3, WindowsScancode::NUMPAD_ONE};
-    static const Key NumPad4 {'\b', X11Scancode::KP_4, WindowsScancode::NUMPAD_ONE};
-    static const Key NumPad5 {'\b', X11Scancode::KP_5, WindowsScancode::NUMPAD_ONE};
-    static const Key NumPad6 {'\b', X11Scancode::KP_6, WindowsScancode::NUMPAD_ONE};
-    static const Key NumPad7 {'\b', X11Scancode::KP_7, WindowsScancode::NUMPAD_ONE};
-    static const Key NumPad8 {'\b', X11Scancode::KP_8, WindowsScancode::NUMPAD_ONE};
-    static const Key NumPad9 {'\b', X11Scancode::KP_9, WindowsScancode::NUMPAD_ONE};
-    static const Key NumPad0 {'\b', X11Scancode::KP_0, WindowsScancode::NUMPAD_ONE};
+    //TODO On Windows, Return & KP_RETURN are the same thing.
+    static const Key NumPadReturn {"KP_↵", X11Scancode::KP_RETURN, WindowsScancode::NUMPAD_ENTER};
+    static const Key NumPadPlus {"KP_+", X11Scancode::KP_PLUS, WindowsScancode::NUMPAD_PLUS};
+    static const Key NumPadMinus {"KP_-", X11Scancode::KP_MINUS, WindowsScancode::NUMPAD_MINUS};
+    static const Key NumPadAsterisk {"KP_*", X11Scancode::KP_ASTERISK, WindowsScancode::NUMPAD_ASTERISK};
+    static const Key NumPadForwardSlash {"KP_/", X11Scancode::KP_SLASH, WindowsScancode::NUMPAD_SLASH};
+    static const Key NumPadPeriod {"KP_.", X11Scancode::KP_PERIOD, WindowsScancode::NUMPAD_PERIOD};
+    static const Key NumPadNumLock {"KP_NUMLOCK", X11Scancode::KP_NUMLOCK, WindowsScancode::NUM_LOCK};

-    static const Key One {'1', X11Scancode::ONE, WindowsScancode::ONE};
-    static const Key Two {'2', X11Scancode::TWO, WindowsScancode::TWO};
-    static const Key Three {'3', X11Scancode::THREE, WindowsScancode::THREE};
-    static const Key Four {'4', X11Scancode::FOUR, WindowsScancode::FOUR};
-    static const Key Five {'5', X11Scancode::FIVE, WindowsScancode::FIVE};
-    static const Key Six {'6', X11Scancode::SIX, WindowsScancode::SIX};
-    static const Key Seven {'7', X11Scancode::SEVEN, WindowsScancode::SEVEN};
-    static const Key Eight {'8', X11Scancode::EIGHT, WindowsScancode::EIGHT};
-    static const Key Nine {'9', X11Scancode::NINE, WindowsScancode::NINE};
-    static const Key Zero {'0', X11Scancode::ZERO, WindowsScancode::ZERO};
+    static const Key NumPad1 {"KP_1", X11Scancode::KP_1, WindowsScancode::NUMPAD_ONE};
+    static const Key NumPad2 {"KP_2", X11Scancode::KP_2, WindowsScancode::NUMPAD_TWO};
+    static const Key NumPad3 {"KP_3", X11Scancode::KP_3, WindowsScancode::NUMPAD_THREE};
+    static const Key NumPad4 {"KP_4", X11Scancode::KP_4, WindowsScancode::NUMPAD_FOUR};
+    static const Key NumPad5 {"KP_5", X11Scancode::KP_5, WindowsScancode::NUMPAD_FIVE};
+    static const Key NumPad6 {"KP_6", X11Scancode::KP_6, WindowsScancode::NUMPAD_SIX};
+    static const Key NumPad7 {"KP_7", X11Scancode::KP_7, WindowsScancode::NUMPAD_SEVEN};
+    static const Key NumPad8 {"kP_8", X11Scancode::KP_8, WindowsScancode::NUMPAD_EIGHT};
+    static const Key NumPad9 {"KP_9", X11Scancode::KP_9, WindowsScancode::NUMPAD_NINE};
+    static const Key NumPad0 {"KP_0", X11Scancode::KP_0, WindowsScancode::NUMPAD_ZERO};

-    static const Key Q {'Q', X11Scancode::Q, WindowsScancode::Q};
-    static const Key W {'W', X11Scancode::W, WindowsScancode::W};
-    static const Key E {'E', X11Scancode::E, WindowsScancode::E};
-    static const Key R {'R', X11Scancode::R, WindowsScancode::R};
-    static const Key T {'T', X11Scancode::T, WindowsScancode::T};
-    static const Key Y {'Y', X11Scancode::Y, WindowsScancode::Y};
-    static const Key U {'U', X11Scancode::U, WindowsScancode::U};
-    static const Key I {'I', X11Scancode::I, WindowsScancode::I};
-    static const Key O {'O', X11Scancode::O, WindowsScancode::O};
-    static const Key P {'P', X11Scancode::P, WindowsScancode::P};
-    static const Key A {'A', X11Scancode::A, WindowsScancode::A};
-    static const Key S {'S', X11Scancode::S, WindowsScancode::S};
-    static const Key D {'D', X11Scancode::D, WindowsScancode::D};
-    static const Key F {'F', X11Scancode::F, WindowsScancode::F};
-    static const Key G {'G', X11Scancode::G, WindowsScancode::G};
-    static const Key H {'H', X11Scancode::H, WindowsScancode::H};
-    static const Key J {'J', X11Scancode::J, WindowsScancode::J};
-    static const Key K {'K', X11Scancode::K, WindowsScancode::K};
-    static const Key L {'L', X11Scancode::L, WindowsScancode::L};
-    static const Key Semicolon {';', X11Scancode::SEMICOLON, WindowsScancode::SEMICOLON};
-    static const Key SingeQuote {'\'', X11Scancode::SINGLEQUOTE, WindowsScancode::SEMICOLON};
-    static const Key Enter {'\n', X11Scancode::RETURN, WindowsScancode::ENTER};
-    //static const Key KeyPadEnter {'\n', X11Scancode::KP_RETURN};
-    static const Key Minus {'-', X11Scancode::MINUS, WindowsScancode::MINUS};
-    //static const Key KeyPadMinus {'-', X11Scancode::KP_MINUS};
-    static const Key Equals {'=', X11Scancode::EQUALS, WindowsScancode::EQUALS};
-    static const Key Z {'Z', X11Scancode::Z, WindowsScancode::Z};
-    static const Key X {'X', X11Scancode::X, WindowsScancode::X};
-    static const Key C {'C', X11Scancode::C, WindowsScancode::C};
-    static const Key V {'V', X11Scancode::V, WindowsScancode::V};
-    static const Key B {'B', X11Scancode::B, WindowsScancode::B};
-    static const Key N {'N', X11Scancode::N, WindowsScancode::N};
-    static const Key M {'M', X11Scancode::M, WindowsScancode::M};
-    static const Key Period {'.', X11Scancode::PERIOD, WindowsScancode::PERIOD};
-    static const Key ForwardSlash {'/', X11Scancode::SLASH, WindowsScancode::SLASH};
-    static const Key BackSlash {'\\', X11Scancode::BACKSLASH, WindowsScancode::BACKSLASH};
+    static const Key Grave {"`", X11Scancode::GRAVE, WindowsScancode::GRAVE};
+    static const Key One {"1", X11Scancode::ONE, WindowsScancode::ONE};
+    static const Key Two {"2", X11Scancode::TWO, WindowsScancode::TWO};
+    static const Key Three {"3", X11Scancode::THREE, WindowsScancode::THREE};
+    static const Key Four {"4", X11Scancode::FOUR, WindowsScancode::FOUR};
+    static const Key Five {"5", X11Scancode::FIVE, WindowsScancode::FIVE};
+    static const Key Six {"6", X11Scancode::SIX, WindowsScancode::SIX};
+    static const Key Seven {"7", X11Scancode::SEVEN, WindowsScancode::SEVEN};
+    static const Key Eight {"8", X11Scancode::EIGHT, WindowsScancode::EIGHT};
+    static const Key Nine {"9", X11Scancode::NINE, WindowsScancode::NINE};
+    static const Key Zero {"0", X11Scancode::ZERO, WindowsScancode::ZERO};
+    static const Key Minus {"-", X11Scancode::MINUS, WindowsScancode::MINUS};
+    static const Key Equals {"+", X11Scancode::EQUALS, WindowsScancode::EQUALS};
+    static const Key Backspace {"⌫", X11Scancode::BACKSPACE, WindowsScancode::BACKSPACE};

-    static const Key Space {' ', X11Scancode::SPACE, WindowsScancode::SPACE};
+    static const Key Tab {"⇥", X11Scancode::TAB, WindowsScancode::TAB};
+    static const Key Q {"Q", X11Scancode::Q, WindowsScancode::Q};
+    static const Key W {"W", X11Scancode::W, WindowsScancode::W};
+    static const Key E {"E", X11Scancode::E, WindowsScancode::E};
+    static const Key R {"R", X11Scancode::R, WindowsScancode::R};
+    static const Key T {"T", X11Scancode::T, WindowsScancode::T};
+    static const Key Y {"Y", X11Scancode::Y, WindowsScancode::Y};
+    static const Key U {"U", X11Scancode::U, WindowsScancode::U};
+    static const Key I {"I", X11Scancode::I, WindowsScancode::I};
+    static const Key O {"O", X11Scancode::O, WindowsScancode::O};
+    static const Key P {"P", X11Scancode::P, WindowsScancode::P};
+    static const Key LeftBracket {"[", X11Scancode::OPENING_SQUARE_BRACKET, WindowsScancode::LEFT_BRACKET};
+    static const Key RightBracket {"]", X11Scancode::CLOSING_SQUARE_BRACKET, WindowsScancode::RIGHT_BRACKET};
+    static const Key BackSlash {"\\", X11Scancode::BACKSLASH, WindowsScancode::BACKSLASH};

-    static const Key LControl {'\\', X11Scancode::LEFT_CTRL, WindowsScancode::CTRL};
-    static const Key RControl {'\\', X11Scancode::RIGHT_CONTROL, WindowsScancode::CTRL};
+    static const Key CapsLock = {"CAPS", X11Scancode::CAPSLOCK, WindowsScancode::CAPS_LOCK};
+    static const Key A {"A", X11Scancode::A, WindowsScancode::A};
+    static const Key S {"S", X11Scancode::S, WindowsScancode::S};
+    static const Key D {"D", X11Scancode::D, WindowsScancode::D};
+    static const Key F {"F", X11Scancode::F, WindowsScancode::F};
+    static const Key G {"G", X11Scancode::G, WindowsScancode::G};
+    static const Key H {"H", X11Scancode::H, WindowsScancode::H};
+    static const Key J {"J", X11Scancode::J, WindowsScancode::J};
+    static const Key K {"K", X11Scancode::K, WindowsScancode::K};
+    static const Key L {"L", X11Scancode::L, WindowsScancode::L};
+    static const Key Semicolon {";", X11Scancode::SEMICOLON, WindowsScancode::SEMICOLON};
+    static const Key SingeQuote {"\'", X11Scancode::SINGLEQUOTE, WindowsScancode::SINGLEQUOTE};
+    static const Key Return {"↵", X11Scancode::RETURN, WindowsScancode::ENTER};

-    static const Key LAlt {'\\', X11Scancode::LEFT_ALT, WindowsScancode::ALT};
-    static const Key RAlt {'\\', X11Scancode::RIGHT_ALT, WindowsScancode::ALT};
+    static const Key LeftShift {"⇧", X11Scancode::LEFT_SHIFT, WindowsScancode::LEFT_SHIFT};
+    static const Key Z {"Z", X11Scancode::Z, WindowsScancode::Z};
+    static const Key X {"X", X11Scancode::X, WindowsScancode::X};
+    static const Key C {"C", X11Scancode::C, WindowsScancode::C};
+    static const Key V {"V", X11Scancode::V, WindowsScancode::V};
+    static const Key B {"B", X11Scancode::B, WindowsScancode::B};
+    static const Key N {"N", X11Scancode::N, WindowsScancode::N};
+    static const Key M {"M", X11Scancode::M, WindowsScancode::M};
+    static const Key Comma = {",", X11Scancode::COMMA, WindowsScancode::COMMA};
+    static const Key Period {".", X11Scancode::PERIOD, WindowsScancode::PERIOD};
+    static const Key ForwardSlash {"/", X11Scancode::SLASH, WindowsScancode::SLASH};

-    static const Key LShift {'\\', X11Scancode::LEFT, WindowsScancode::LEFT_ARROW};
-    static const Key RShift {'\\', X11Scancode::RIGHT, WindowsScancode::RIGHT_ARROW};
+    static const Key LeftControl {"LCTRL", X11Scancode::LEFT_CTRL, WindowsScancode::CTRL};
+    static const Key Super {"❖", X11Scancode::SUPER, WindowsScancode::SUPER};
+    static const Key LeftAlt {"🄰", X11Scancode::LEFT_ALT, WindowsScancode::ALT};
+    static const Key Space {" ", X11Scancode::SPACE, WindowsScancode::SPACE};
+    static const Key RightAlt {"R🄰", X11Scancode::RIGHT_ALT, WindowsScancode::ALT};
+    static const Key Menu = {"▤", X11Scancode::MENU, WindowsScancode::MENU};
+    static const Key RightControl {"RCTRL", X11Scancode::RIGHT_CONTROL, WindowsScancode::CTRL};
+    static const Key RightShift {"R⇧", X11Scancode::RIGHT_SHIFT, WindowsScancode::RIGHT_SHIFT};

-    // TODO: Get the right character codes for these
-    static const Key UpArrow {'\u000a', X11Scancode::UP, WindowsScancode::UP_ARROW};
-    static const Key DownArrow {'\u000a', X11Scancode::DOWN, WindowsScancode::DOWN_ARROW};
-    static const Key LeftArrow {'\u000a', X11Scancode::LEFT, WindowsScancode::LEFT_ARROW};
-    static const Key RightArrow {'\u000a', X11Scancode::RIGHT, WindowsScancode::RIGHT_ARROW};
+    static const Key Insert {"INSERT", X11Scancode::INSERT, WindowsScancode::INSERT};
+    static const Key Home {"HOME", X11Scancode::HOME, WindowsScancode::HOME};
+    static const Key PageUp {"PAGEUP", X11Scancode::PAGEUP, WindowsScancode::PAGE_UP};
+    static const Key Delete {"DELETE", X11Scancode::DEL, WindowsScancode::DEL};
+    static const Key End {"End", X11Scancode::END, WindowsScancode::END};
+    static const Key PageDown {"PAGEDOWN", X11Scancode::PAGEDOWN, WindowsScancode::PAGE_DOWN};

-    static const Key Super {'\000a', X11Scancode::SUPER, WindowsScancode::Nothing};
-    static const Key Backspace {'\b', X11Scancode::BACKSPACE, WindowsScancode::BACKSPACE};
+    static const Key UpArrow {reinterpret_cast<const char*>(u8"↑"), X11Scancode::UP, WindowsScancode::UP_ARROW};
+    static const Key DownArrow {reinterpret_cast<const char*>(u8"↓"), X11Scancode::DOWN, WindowsScancode::DOWN_ARROW};
+    static const Key LeftArrow {reinterpret_cast<const char*>(u8"←"), X11Scancode::LEFT, WindowsScancode::LEFT_ARROW};
+    static const Key RightArrow {reinterpret_cast<const char*>(u8"→"), X11Scancode::RIGHT, WindowsScancode::RIGHT_ARROW};

-    static const Key LeftBracket {'[', X11Scancode::OPENING_SQUARE_BRACKET, WindowsScancode::LEFT_BRACKET};
-    static const Key RightBracket {']', X11Scancode::CLOSING_SQUARE_BRACKET, WindowsScancode::RIGHT_BRACKET};
-}
-
-class GamepadButton {};
-class MouseButton {};
-
-using J3ML::LinearAlgebra::Vector2;
-
-class InputService {
-public:
-    static Vector2 GetLeftJoystick();
-    static Vector2 GetRightJoystick();
-};
-
-namespace GamepadButtons {
-    static const GamepadButton X;
-    static const GamepadButton Y;
-    static const GamepadButton A;
-    static const GamepadButton B;
 }



-namespace MouseButtons
-{
-    static const MouseButton Left;
-    static const MouseButton Right;
-    static const MouseButton Middle;
-    static const MouseButton Side1;
-    static const MouseButton Side2;
-}

-static MouseButton GetMouseButtonFromXButton(unsigned int button)
-{
-    switch(button)
-    {
-        case Button1: return MouseButtons::Left;
-        case Button2: return MouseButtons::Right;
-        case Button3: return MouseButtons::Middle;
-        case Button4: return MouseButtons::Side1;
-        case Button5: return MouseButtons::Side2;
-        default:
-        {
-            throw std::runtime_error("Undefined XButtonCode: " + button);
-            break;
-        }
-    }
-}

-static Key GetKeyFromX11Scancode(X11Scancode code)
-{
-    for (auto& key : Key::GetKeyboard()) {
-        if (key.x11ScanCode == code)
-            return key;
-    }
-    std::cout << "Unavaliable Scancode: " + std::to_string((int)code) << std::endl;
-    return Keys::Space;
-}
-static Key GetKeyFromWindowsScancode(WindowsScancode code)
-{
-    for (auto& key : Key::GetKeyboard()) {
-        if (key.winScanCode == code)
-            return key;
-    }
-    std::cout << "Unavaliable Scancode: " + std::to_string((int)code) << std::endl;
-    return Keys::Space;
-}
+Key GetKeyFromX11Scancode(X11Scancode code);
+Key GetKeyFromWindowsScancode(WindowsScancode code);
--- a/include/rewindow/types/keyboard.h
+++ b/include/rewindow/types/keyboard.h
@@ -0,0 +1,49 @@
+/// ReWindowLibrary
+/// A C++20 Library for creating and managing windows in a platform-independent manner
+/// Developed and Maintained by the boys @ Redacted Software.
+/// (c) 2024 Redacted Software
+/// This work is dedicated to the public domain.
+
+/// @file keyboard.h
+/// @desc A class that models the functionality of a keyboard device.
+/// @edit 2024-07-29
+
+#pragma once
+
+#include <rewindow/types/inputdevice.hpp>
+#include "rewindow/data/scancode.h"
+#include <Event.h>
+#include <map>
+
+namespace ReWindow
+{
+    using Key = ReScanCode;
+    using KeyState = BinaryActuatorState;
+    struct KeyboardState
+    {
+        std::map<Key, KeyState> Keys;
+    };
+
+    class KeyPressedEvent : public InputEvent {};
+    class KeyReleasedEvent : public InputEvent {};
+
+    class Keyboard : public InputDevice
+    {
+    public:
+        Keyboard() {}
+        ~Keyboard() {}
+        bool IsKeyDown() const;
+        KeyState GetKeyState() const;
+
+        void Update(double elapsed) override;
+        DeviceType GetType() const override { return DeviceType::KEYBOARD;}
+    public:
+        static Event<const KeyPressedEvent&> KeyPressed;
+        static Event<const KeyReleasedEvent&> KeyReleased;
+
+    public:
+        static Keyboard* GetCurrentDevice();
+        static bool GetKeyState(const Key& k);
+        static KeyboardState GetState();
+    };
+}
--- a/include/rewindow/types/mouse.h
+++ b/include/rewindow/types/mouse.h
@@ -0,0 +1,338 @@
+/// ReWindowLibrary
+/// A C++20 Library for creating and managing windows in a platform-independent manner
+/// Developed and Maintained by the boys @ Redacted Software.
+/// (c) 2024 Redacted Software
+/// This work is dedicated to the public domain.
+
+/// @file keyboard.h
+/// @desc A class that models the functionality of a mouse / pointer device.
+/// @edit 2024-07-29
+
+#pragma once
+
+//#include <rewindow/types/inputdevice.hpp>
+#include <rewindow/types/mousebutton.h>
+#include <rewindow/types/key.h>
+#include <Event.h>
+#include <map>
+#include "rewindow/data/scancode.h"
+#include <rewindow/types/inputdevice.hpp>
+//#include <rewindow/types/keyboard.h>
+//#include <rewindow/types/gamepad.h>
+
+namespace ReWindow
+{
+
+    //using Key = ReScanCode;
+
+    using Button = ReScanCode;
+
+    /*
+    enum class DeviceType {
+        MOUSE, KEYBOARD, GAMEPAD, TOUCHSCREEN, REMOTE, VRHEADSET
+    };
+
+    enum class DeviceState {
+        OK, LOW_BATTERY, UNAVAILABLE
+    };
+     */
+
+
+    /*
+    class InputDeviceImpl { };
+    class InputDeviceImplLinux { };
+     */
+    class LinuxMouseImpl { };
+    class LinuxKeyboardImpl {};
+
+    // TODO: Remember to break InputDevice into it's own file and not define it twice!!!
+    /*
+    class InputDevice {
+    public:
+        virtual void Update(double elapsed){}
+
+        /// Returns the device's index among devices of the same type.
+        uint GetIndex() const;
+
+        virtual DeviceType GetType() const = 0;
+        DeviceState GetDeviceState() const;
+        bool IsAnyButtonDown();
+    };
+     */
+
+    /*
+    struct BinaryActuatorState
+    {
+        double TimeHeld;
+        bool Pressed;
+    };
+     */
+
+    using ButtonState = BinaryActuatorState;
+    //using KeyState = BinaryActuatorState;
+
+    /*
+    struct KeyboardState
+    {
+        std::map<Key, KeyState> Keys;
+
+    };
+     */
+
+    /*class MouseState {
+    public:
+        struct
+        {
+            bool LMB = false;
+            bool RMB = false;
+            bool MMB = false;
+            bool SideButton1 = false;
+            bool SideButton2 = false;
+            bool MWheelUp = false;
+            bool MWheelDown = false;
+        } Buttons;
+
+
+        Vector2 Position;
+        int Wheel = 0;
+
+        [[nodiscard]] bool IsDown(const MouseButton& btn) const
+        {
+            if (btn == MouseButtons::Left) return Buttons.LMB;
+            if (btn == MouseButtons::Right) return Buttons.RMB;
+            if (btn == MouseButtons::Middle) return Buttons.MMB;
+            if (btn == MouseButtons::Mouse4) return Buttons.SideButton1;
+            if (btn == MouseButtons::Mouse5) return Buttons.SideButton2;
+            //if (btn == MouseButtons::MWheelUp) return Buttons.MWheelUp;
+            //if (btn == MouseButtons::MWheelDown) return Buttons.MWheelDown;
+
+            return false; // Unknown button?
+        }
+
+        void Set(const MouseButton& btn, bool state)
+        {
+            if (btn == MouseButtons::Left) Buttons.LMB = state;
+            if (btn == MouseButtons::Right) Buttons.RMB = state;
+            if (btn == MouseButtons::Middle) Buttons.MMB = state;
+            if (btn == MouseButtons::Mouse4) Buttons.SideButton1 = state;
+            if (btn == MouseButtons::Mouse5) Buttons.SideButton2 = state;
+            //if (btn == MouseButtons::MWheelUp) Buttons.MWheelUp = state;
+            //if (btn == MouseButtons::MWheelDown) Buttons.MWheelDown = state;
+        }
+
+        bool& operator[](const MouseButton& btn)
+        {
+            if (btn == MouseButtons::Left) return Buttons.LMB;
+            if (btn == MouseButtons::Right) return Buttons.RMB;
+            if (btn == MouseButtons::Middle) return Buttons.MMB;
+            if (btn == MouseButtons::Mouse4) return Buttons.SideButton1;
+            if (btn == MouseButtons::Mouse5) return Buttons.SideButton2;
+            //if (btn == MouseButtons::MWheelUp) return Buttons.MWheelUp;
+            //if (btn == MouseButtons::MWheelDown) return Buttons.MWheelDown;
+
+            throw std::runtime_error("Attempted to handle unmapped mouse button");
+        }
+    };*/
+
+    struct MouseState
+    {
+        ButtonState Left;
+        ButtonState Right;
+        ButtonState Middle;
+        ButtonState Mouse4;
+        ButtonState Mouse5;
+        ButtonState WheelUp;
+        ButtonState WheelDown;
+
+        Vector2 Position;
+        Vector2 Delta;
+        Vector2 Velocity;
+        int Wheel;
+
+
+    };
+
+
+    struct ThumbstickState
+    {
+
+        Vector2 Unit;
+    };
+
+    class Thumbstick
+    {
+
+    };
+
+    struct TriggerState
+    {
+
+    };
+
+    class Trigger
+    {
+
+    };
+
+    struct GamepadState
+    {
+        ButtonState X;
+        ButtonState Y;
+        ButtonState A;
+        ButtonState B;
+
+        // TODO: Also have analog DPad;
+        ButtonState DPadLeft;
+        ButtonState DPadRight;
+        ButtonState DPadUp;
+        ButtonState DPadDown;
+
+        ButtonState Pause;
+        ButtonState Select;
+        ButtonState Home;
+
+        ButtonState LeftThumbButton;
+        ButtonState RightThumbButton;
+
+        TriggerState LeftTrigger;
+        TriggerState RightTrigger;
+
+        ThumbstickState LeftThumbstick;
+        ThumbstickState RightThumbstick;
+
+    };
+
+    class TouchscreenState
+    {
+
+    };
+
+    /*
+     *  Gamepad
+     */
+
+    constexpr int MaxDeviceStateHistory = 100;
+
+    class Gamepad : public InputDevice
+    {
+    public:
+        uint GetButtonCount() const;
+        uint GetRumbleMotorCount() const;
+    protected:
+        Thumbstick LeftThumb;
+        Thumbstick RightThumb;
+
+        Trigger RightTrigger;
+        Trigger LeftTrigger;
+
+        GamepadState current_state;
+        GamepadState previous_state;
+        GamepadState history[MaxDeviceStateHistory];
+    };
+
+
+    class XboxGamepad : public Gamepad {};
+    class PS4Gamepad : public Gamepad {};
+
+    /*
+     *  Pointer
+     */
+
+    class PointerDevice : public InputDevice {
+    public:
+        void Update(double elapsed) override {
+            InputDevice::Update(elapsed);
+        }
+    };
+
+    /*
+    struct InputEvent
+    {
+        std::chrono::system_clock::time_point Timestamp;
+    };
+     */
+
+    struct MouseButtonEvent : public InputEvent
+    {
+
+    };
+
+    class MouseMoveEvent
+    {
+
+    };
+
+    class MouseWheelEvent
+    {
+
+    };
+
+    struct TouchEvent
+    {
+
+        int TouchID;
+        Vector2 Position;
+        Vector2 Velocity;
+        float Pressure;
+    };
+
+    class Mouse : public PointerDevice
+    {
+    public:
+    public:
+        Event<> Moved;
+        Event<> ButtonPressed;
+        Event<> ButtonReleased;
+        Event<> WheelMoved;
+    public:
+        Mouse();
+        ~Mouse();
+        Vector2 GetPosition() const;
+        bool IsButtonDown(const MouseButton& btn) const;
+        ButtonState GetButtonState(const MouseButton& btn) const;
+        void Update(double elapsed) override;
+        DeviceType GetType() const override;
+        void DoButtonPress(const MouseButton& btn);
+        void DoButtonRelease(const MouseButton& btn);
+        void DoMove(const Vector2& pos);
+        void DoScrollWheel(int scroll);
+    protected:
+        void SetButtonPressed(const MouseButton& btn, bool pressed);
+        void SetButtonState(const MouseButton& btn, ButtonState state);
+    protected:
+        MouseState current_state;
+        MouseState previous_state;
+        MouseState history[MaxDeviceStateHistory];
+    public:
+    protected:
+    private:
+    };
+
+    class Touchscreen : public PointerDevice
+    {
+    public:
+        static Event<const TouchEvent&> TouchMoved;
+        static Event<const TouchEvent&> TouchPressed;
+        static Event<const TouchEvent&> TouchReleased;
+
+        static Touchscreen GetCurrentDevice();
+
+        int GetPosition(int touchIndex);
+        int GetTouchCount();
+        int GetMaxTouchCount();
+        std::vector<int> GetTouches();
+
+        /// Returns the pressure of the touch-press. Most touch screens aren't pressure sensitive, in which case the pressure will be 1.
+        float GetPressure(int touchIndex);
+
+    };
+
+    class VRHeadset : public InputDevice { };
+
+    class GenericTVRemote : public InputDevice { };
+
+
+
+
+
+}
--- a/include/rewindow/types/mousebutton.h
+++ b/include/rewindow/types/mousebutton.h
@@ -0,0 +1,46 @@
+/// ReWindowLibrary
+/// A C++20 Library for creating and managing windows in a platform-independent manner
+/// Developed and Maintained by the boys @ Redacted Software.
+/// (c) 2024 Redacted Software
+/// This work is dedicated to the public domain.
+
+/// @file mousebutton.hpp
+/// @desc MouseButton class and defined MouseButtons.
+/// @edit 2024-07-29
+
+#pragma once
+
+#include <string>
+
+class MouseButton {
+public:
+    std::string Mnemonic;
+    unsigned int ButtonIndex;
+
+    MouseButton() = default;
+    explicit MouseButton(const std::string& charcode, unsigned int index);
+
+    bool operator == (const MouseButton& mb) const;
+    bool operator<(const MouseButton& rhs) const;
+    MouseButton(const MouseButton&) = default;
+};
+
+
+namespace MouseButtons
+{
+    static const MouseButton Left           ("L", 1);
+    static const MouseButton Right          ("R", 2);
+    static const MouseButton Middle         ("M", 3);
+    static const MouseButton Mouse4         ("4", 8);
+    static const MouseButton Mouse5         ("5", 9);
+    static const MouseButton Unimplemented  ("?", 0);
+
+    /// NOTE: IsMouseButtonDown will not return correctly for the mouse-wheel-buttons, because the action is effectively instantaneous.
+    static const MouseButton MWheelUp       ("U", 4);
+    /// NOTE: IsMouseButtonDown will not return correctly for the mouse-wheel-buttons, because the action is effectively instantaneous.
+    static const MouseButton MWheelDown     ("D", 5);
+}
+
+MouseButton GetMouseButtonFromXButton(unsigned int button);
+
+
--- a/include/rewindow/types/window.h
+++ b/include/rewindow/types/window.h
@@ -1,239 +1,363 @@
 #pragma once
 #include <cstdint>
 #include <vector>
-#include <memory>
 #include <Event.h>
-#include <functional>
 #include <map>
-#include <rewindow/types/key.h>
-
-
-#if __linux__
-#include <X11/Xlib.h>
-#include <X11/Xutil.h>
-#include <GL/gl.h>
-#include <GL/glx.h>
-#include "cursors.h"
-
-#endif
-
-
-using namespace std::chrono_literals;
-using precision_clock = std::chrono::high_resolution_clock;
-using precision_timestamp = precision_clock::time_point;
+#include <thread>
+//#include <rewindow/types/key.h>
+#include <rewindow/types/cursors.h>
+#include <rewindow/types/mousebutton.h>
+#include <rewindow/types/gamepadbutton.h>
+#include <rewindow/types/mouse.h>
+#include <rewindow/types/WindowEvents.hpp>
+#include <rewindow/types/keyboard.h>
+#include <rewindow/types/gamepad.h>
+#include <J3ML/LinearAlgebra.hpp>
+#include <format>

 enum class RWindowFlags: uint8_t {
-    IN_FOCUS = 0,
-    FULLSCREEN = 1,
-    RESIZABLE = 2,
-    VSYNC = 4
+	IN_FOCUS,
+	FULLSCREEN,
+	RESIZABLE,
+	VSYNC,
+	QUIT,
+	MAX_FLAG
 };

+std::string RWindowFlagToStr(RWindowFlags flag);
+
 enum class RenderingAPI: uint8_t {
-    OPENGL = 0,
-    //Vulkan is unimplemented.
-    VULKAN = 1,
+	OPENGL = 0,
+	//Vulkan is unimplemented.
+	VULKAN = 1,
 };

-
-enum class KeyState { Pressed, Released };
-
 namespace ReWindow
 {
-    using J3ML::LinearAlgebra::Vector2;
-
-    class TimestampedEvent {
-    private:
-
-    public:
-        precision_timestamp Timestamp;
-        TimestampedEvent() : Timestamp(precision_clock::now())
-        { }
-    };
-
-    class RWindowEvent : public TimestampedEvent {
-    public:
-        RWindowEvent() : TimestampedEvent() { }
-    };
-    const RWindowEvent EmptyRWindowEvent;
-
-    namespace WindowEvents
-    {
-        class KeyboardState {
-        public:
-            std::map<Key, bool> PressedKeys;
-        };
-
-        class GamepadState {
-        public:
-            std::map<GamepadButton, bool> PressedButtons;
-        };
-
-        class InputState {
-        public:
-            KeyboardState Keyboard;
-            GamepadState Gamepad;
-        };
-
-        class KeyboardEvent : public RWindowEvent {
-        public:
-            Key key;
-            KeyState state;
-            KeyboardEvent(Key key, KeyState state) : RWindowEvent(), key(key), state(state) {}
-        };
-        class MouseEvent : public RWindowEvent {};
-        class GamepadEvent : public RWindowEvent {};
-
-        class MouseMoveEvent : public MouseEvent {
-        public:
-            Vector2 Position;
-            Vector2 Delta;
-            MouseMoveEvent(const Vector2 &pos) : MouseEvent(), Position(pos)
-            {}
-            MouseMoveEvent(int x, int y) : MouseEvent(), Position(Vector2(x, y))
-            {}
-        };
-
-        class KeyDownEvent : public KeyboardEvent {
-        public:
-            KeyDownEvent(Key key) : KeyboardEvent(key, KeyState::Pressed) {}
-        };
-
-        class KeyUpEvent : public KeyboardEvent {
-        public:
-            KeyUpEvent(Key key) : KeyboardEvent(key, KeyState::Released) {}
-        };
-
-
-        class MouseButtonDownEvent : public MouseEvent {
-        public:
-            MouseButton Button;
-        };
-
-        class MouseButtonUpEvent : public MouseEvent {
-        public:
-            MouseButton Button;
-        };
-
-        class WindowResizeRequestEvent : public RWindowEvent
-        {
-        public:
-            Vector2 Size;
-        };
-    }
-
-    using namespace WindowEvents;
-
-    class RWindow {
-    public:
-
-#pragma region Callbacks
-        /// Bindable Non-intrusive event handlers
-        /// Use these when you can't override the base window class
-        Event<RWindowEvent> OnFocusLostEvent;
-        Event<RWindowEvent> OnFocusGainEvent;
-        Event<float> OnRefreshEvent;
-        Event<WindowResizeRequestEvent> OnResizeRequestEvent;
-        Event<KeyDownEvent> OnKeyDownEvent;
-        Event<KeyUpEvent> OnKeyUpEvent;
-        Event<MouseMoveEvent> OnMouseMoveEvent;
-        Event<MouseButtonDownEvent> OnMouseButtonDownEvent;
-        Event<MouseButtonUpEvent> OnMouseButtonUpEvent;
-#pragma endregion
-
-#pragma region Overrides
-        virtual void OnFocusLost(const RWindowEvent& e) {}
-        virtual void OnFocusGain(const RWindowEvent& e) {}
-        virtual void OnRefresh(float elapsed) {}
-        virtual void OnResizeSuccess() {}
-        virtual bool OnResizeRequest(const WindowResizeRequestEvent& e) { return true;}
-        virtual void OnKeyDown(const KeyDownEvent&) {}
-        virtual void OnKeyUp(const KeyUpEvent&) {}
-        virtual void OnMouseMove(const MouseMoveEvent&) {}
-        virtual void OnMouseButtonDown(const MouseButtonDownEvent&) {}
-        virtual void OnMouseButtonUp(const MouseButtonUpEvent&) {}
-#pragma endregion
+	using J3ML::LinearAlgebra::Vector2;

+    /// RWindow is a class implementation of a platform-independent window abstraction.
+    /// This library also provides abstractions for user-input devices, and their interaction with the window.
+	class RWindow {
+	public:
+#pragma region Constructors
+        /// The default constructor sets a default size and window title.
        RWindow();
+        /// Constructs a window by explicitly setting title, width and height.
        RWindow(const std::string& title, int width, int height);
+        /// Constructs a window as above with the additional argument of explicitly setting which render API is to be used.
        RWindow(const std::string& title, int width, int height, RenderingAPI renderer);
+#pragma endregion

-        void setRenderer(RenderingAPI api);
-        void Open();
-        void Close();
-        void CloseAndReopenInPlace();
+        /// Bindables are provided for hooking into window instances conveniently, without the need to derive and override for simple use cases.
+#pragma region Bindable Events

-        // TODO: Must be implemented from scratch as a Motif Window in x11
-        void MessageBox();
+		Event<> OnOpenEvent;
+        Event<> OnClosingEvent;
+		Event<RWindowEvent> OnFocusLostEvent;
+		Event<RWindowEvent> OnFocusGainEvent;
+		Event<float> OnRefreshEvent;
+		Event<WindowResizeRequestEvent> OnResizeRequestEvent;
+        Event<KeyDownEvent> OnKeyDownEvent;
+		Event<KeyUpEvent> OnKeyUpEvent;
+		Event<MouseMoveEvent> OnMouseMoveEvent;
+		Event<MouseButtonDownEvent> OnMouseButtonDownEvent;
+		Event<MouseButtonUpEvent> OnMouseButtonUpEvent;
+		Event<MouseWheelEvent> OnMouseWheelEvent;

-        bool isFocused() const;
-        bool isFullscreen() const;
-        bool isResizable() const;
-        bool isVsyncEnabled() const;
+        Event<InputDevice*, InputEvent> OnInputDeviceEvent;
+#pragma endregion

-        bool isAlive() const;
+        /// These methods can also be overridden in derived classes.
+#pragma region Overrides

-        void setMouseVisible(bool visible);
-        void setMouseLocked();
-        void setMouseCenter();
-        void restoreMouseFromLastCenter(); // Feels nicer for users
+        /// Called upon the window requesting to open.
+		virtual void OnOpen() {}
+        /// Called right before the window closes.
+        virtual void OnClosing() {}
+        /// Called when the window loses focus.
+		virtual void OnFocusLost(const RWindowEvent& e) {}
+        /// Called when the window gains focus.
+		virtual void OnFocusGain(const RWindowEvent& e) {}
+        /// Called when the window is 'refreshed', in other words, a render pass is completed.
+		virtual void OnRefresh(float elapsed) {}
+        /// Called when a resize request has succeeded.
+		virtual void OnResizeSuccess() {}
+        /// Called when a resize request is sent to the operating system.
+		virtual bool OnResizeRequest(const WindowResizeRequestEvent& e) { return true;}
+		virtual void OnKeyDown(const KeyDownEvent&) {}
+		virtual void OnKeyUp(const KeyUpEvent&) {}
+		virtual void OnMouseMove(const MouseMoveEvent&) {}
+		virtual void OnMouseButtonDown(const MouseButtonDownEvent&) {}
+		virtual void OnMouseButtonUp(const MouseButtonUpEvent&) {}
+		virtual void OnMouseWheel(const MouseWheelEvent&) {}
+#pragma endregion

-        bool isKeyDown(Key key) const;
-        bool isMouseButtonDown(MouseButton button) const;
+        Mouse* GetMouse();
+        Keyboard* GetKeyboard();

-        void setFullscreen(bool fs);
-        void setResizable(bool resizable);
-        void setVsyncEnabled(bool);
-        void setTitle(const std::string& title);
-        std::string getTitle() const;
-        void fullscreen();
-        void restoreFromFullscreen();
-        bool getFlag(RWindowFlags flag) const;
-        void setFlag(RWindowFlags flag, bool state);
-        //void init(RenderingAPI api, const char* title, int width, int height, bool vsync);
-        void destroyWindow();
-        void pollEvents();
-        void refresh();
-        void setSize(int width, int height);
-        void setSize(const Vector2& size);
-        /// Returns the position of the window's top-left corner relative to the display
-        Vector2 getPos() const;
-        Vector2 getSize() const;
-        void setPos(int x, int y);
-        void setPos(const Vector2& pos);
-        Vector2 getCursorPos() const;
-        void raise() const;
-        void lower() const;
-        void setCursorStyle(CursorStyle style) const;
-        void setCursorCustomIcon() const;
+#pragma region Input Helpers
+		/// Returns a Vector2 representing mouse coordinates relative to the top-left corner of the window.
+		/// This result is cached from the operating-system, and as such may be out-of-date.
+		/// @see GetAccurateMouseCoordinates().
+		Vector2 GetMouseCoordinates() const;

-        static void glSwapBuffers();
-        //Initialize to false because it's not guaranteed that they will be cleared first
-    private:
-        Vector2 lastKnownWindowSize {0, 0};
-        bool flags[4];
-        std::vector<RWindowEvent> eventLog;
-        KeyboardState currentKeyboard; // Current Frame's Keyboard State
-        KeyboardState previousKeyboard; // Previous Frame's Keyboard State
-        bool fullscreenmode = false;
-        std::string title;
-        int width;
-        int height;
-        RenderingAPI renderer;
+        int GetMouseWheelPersistent() const { return currentMouse.Wheel;}
+
+#pragma endregion
+
+#pragma region Cursor Modifiers
+        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();
+
+#pragma endregion
+
+		/// Sets which rendering API is to be used with this window.
+		void SetRenderer(RenderingAPI api);
+
+		/// This function instructs the operating system to create the actual window, and give it to us to control.
+		/// Calling this function, therefore, creates the real 'window' object on the operating system.
+		void Open();
+
+		/// Cleans up and closes the window without destroying the handle.
+		void Close();
+
+		void CloseAndReopenInPlace();
+
+		void MessageBox(); // TODO: Must be implemented from scratch as a Motif Window in x11
+
+        /// Sends a request to the operating system to have this window somehow demand attention from the user.
+        /// This is implemented per-operating system, and as such no guarantees about behavior can be made.
+        void Flash();
+
+		/// Returns whether the window currently has mouse and/or keyboard focus.
+		[[nodiscard]] bool IsFocused() const;
+
+        /// Returns whether the window is currently in Fullscreen.
+        // TODO: Support Fullscreen, FullscreenWindowed, and Windowed?
+		[[nodiscard]] bool IsFullscreen() const;
+
+        /// Returns whether the window can be resized.
+		[[nodiscard]] bool IsResizable() const;
+
+        /// Returns whether V-Sync is enabled.
+		[[nodiscard]] bool IsVsyncEnabled() const;
+
+        /// Returns whether the window is considered to be alive. Once dead, any logic loop should be terminated, and the cleanup procedure should run.
+		[[nodiscard]] bool IsAlive() const;
+
+        /// Returns whether the given key is currently being pressed.
+		[[nodiscard]] bool IsKeyDown(Key key) const;
+
+        /// Returns whether the given mouse button is currently being pressed.
+		[[nodiscard]] bool IsMouseButtonDown(const MouseButton &button) const;
+
+        /// Sets whether or not to make the window fullscreen.
+        /// @note This is implemented per-OS, and as such, it simply requests the OS to do what we want. No guarantee about follow-through can be given.
+		void SetFullscreen(bool fs);
+
+        /// Sets whether or not to make the window resizable.
+        /// @note This is implemented per-OS, and as such, it simply requests the OS to do what we want. No guarantee about follow-through can be given.
+		void SetResizable(bool resizable);
+
+        /// Sets whether or not to enable vertical synchronization.
+        /// @note This is implemented per-OS, and as such, it simply requests the OS to do what we want. No guarantee about follow-through can be given.
+		void SetVsyncEnabled(bool vsync);
+
+        /// Sets the title of this window.
+		void SetTitle(const std::string& title);
+		[[nodiscard]] std::string GetTitle() const;
+
+        /// Returns the horizontal length of this window, in pixels.
+		[[nodiscard]] int GetWidth() const;
+        /// Returns the vertical length of this window, in pixels.
+		[[nodiscard]] int GetHeight() const;
+
+        /// A special-case function to change our internal size variable, without triggering event updates.
+		void SetSizeWithoutEvent(const Vector2& size); //AAAAAHHHHHHHHH WINDOZE MAKING THINGS DIFFICULT :/ - Redacted.
+
+		void SetLastKnownWindowSize(const Vector2& size);
+
+		// TODO: Josh hates parameter-flags, it's not 1995 :/
+		bool GetFlag(RWindowFlags flag) const;
+		// TODO: Josh hates parameter-flags, it's not 1995 :/
+		void SetFlag(RWindowFlags flag, bool state);
+
+        /// Returns the name of the developer of the user's graphics driver, if it can be determined.
+        std::string getGraphicsDriverVendor();
+
+		/// Tells the underlying window manager to destroy this window and drop the handle.
+		/// The window, in theory, can not be re-opened after this.
+		void DestroyWindow();
+
+		/// Reads events from the operating system, and processes them accordingly.
+		/// TODO: Move out of public API, consumers should call Refresh or ideally an update() call.
+		void PollEvents();
+
+        /// Updates internal window state, similar to ManagedRefresh, but without accounting for any timekeeping. This is left up to the user.
+		void Refresh();
+
+        /// Updates the window and handles timing internally.
+        void ManagedRefresh();
+
+        /// Requests the operating system to change the window size.
+        /// @param width
+        /// @param height
+		void SetSize(int width, int height);
+        /// Requests the operating system to change the window size.
+        /// @param size
+		void SetSize(const Vector2& size);
+
+		/// Returns the position of the window's top-left corner relative to the display
+		Vector2 GetPos() const;
+
+		/// Returns the known size of the window, in {x,y} pixel measurement.
+		Vector2 GetSize() const;
+
+        /// Returns the position of the "renderable area" of the window relative to it's top left corner.
+        /// (used to account for the width of the border & title bar).
+        Vector2 GetPositionOfRenderableArea() const;
+
+        /// Requests the operating system to move the window to the specified coordinates on the display.
+        /// @param x The horizontal screen position to place the window at.
+        /// @param y The vertical screen position to place the window at.
+		void SetPos(int x, int y);
+        /// Requests the operating system to move the window to the specified coordinates on the display.
+        /// @param pos A Vector2 representing the x,y coordinates of the desired window destination. Fractional values are ignored.
+		void SetPos(const Vector2& pos);
+
+
+		/// Pull the window to the top, such that it is displayed on top of everything else.
+		/// NOTE: The implementation is defined per-OS, and thus there is no guarantee of it always working.
+		void Raise() const;
+		/// Push the window Lower, such that it is effectively hidden behind other windows.
+		/// NOTE: The implementation is defined per-OS, and thus there is no guarantee of it always working.
+		void Lower() const;
+
+
+		/// Calls OpenGL's SwapBuffers routine.
+		/// NOTE: This is only used when the underlying rendering API is set to OpenGL.
+		static void GLSwapBuffers();
+
+        /// Returns the current time, represented as a high-resolution std::chrono alias.
+        static std::chrono::steady_clock::time_point GetTimestamp();
+
+        /// Computes elapsed time from a start-point and end-point.
+        float ComputeElapsedFrameTimeSeconds(std::chrono::steady_clock::time_point start, std::chrono::steady_clock::time_point end);
+
+        /// Updates internals to account for the latest calculated frame time.
+        void UpdateFrameTiming(float frame_time);
+
+        /// Returns the amount of time, in seconds, between the current and last frame.
+        /// Technically, no, it returns the elapsed time of the frame, start to finish.
+        [[nodiscard]] float GetDeltaTime() const;
+
+        /// Returns the approximate frames-per-second using delta time.
+        [[nodiscard]] float GetRefreshRate() const;
+
+        /// Returns the number of frames ran since the windows' creation.
+        [[nodiscard]] float GetRefreshCounter() const;
+    protected:
+        /// Requests the operating system to make the window fullscreen. Saves the previous window size as well.
+        void Fullscreen();
+
+        /// Requests the operating system to take the window out of fullscreen mode. Previously saved window size is restored, if possible.
+        void RestoreFromFullscreen();
+
+        bool DetectsMouse();
+        bool DetectsKeyboard();
+        bool DetectsGamepad();
+
+    protected:
+#pragma region Data
+
+        std::string title = "Redacted Window";
+        int width = 1280;
+        int height = 720;
+
+        bool fullscreen_mode = false;
+        bool focused = true;
+        bool vsync = false;
+        bool cursor_visible = true;
        bool open = false;
-        bool resizable;
+        bool resizable = true;
+
+        Vector2 lastKnownWindowSize {0, 0};
+        bool flags[5];
+        std::vector<RWindowEvent> eventLog;
+
+        /// Input Devices;
+        Mouse* mouse;
+        Keyboard* keyboard;
+        Gamepad* gamepad;
+
+        std::vector<InputDevice*> input_devices;


-    };
+        RenderingAPI renderer = RenderingAPI::OPENGL;
+
+        //Vector2 mouse_coords = {0, 0};
+        //Vector2 last_mouse_coords = {0, 0};


-    class WindowsImplementationRWindow : public RWindow
-    {
+        float delta_time = 0.f;
+        float refresh_rate = 0.f;
+        unsigned int refresh_count = 0;

-    };
+        // TODO: Implement ringbuffer / circular vector class of some sort.
+        float refresh_rate_prev_1 = 0.f;
+        float refresh_rate_prev_2 = 0.f;
+        float refresh_rate_prev_3 = 0.f;
+        float refresh_rate_prev_4 = 0.f;
+        float refresh_rate_prev_5 = 0.f;

-    class X11ImplementationRWindow : public RWindow
-    {
+        float avg_refresh_rate = 0.0f;
+#pragma endregion
+#pragma region Internals
+		/// Returns the most accurate and recent available mouse coordinates.
+		/// @note Call this version at most **once** per-frame. It polls the X-Window server and therefore is quite slow.
+		/// @see getCursorPos();
+		Vector2 GetAccurateMouseCoordinates() const;

+	public:
+/// These unfortunately *have* to be public because of the poor design of the windows event loop.
+#pragma region Event Callers
+        /// Executes event handlers for keyboard rele;ase events.
+        void processKeyRelease (Key key);
+        /// Executes event handlers for keyboard press events.
+        void processKeyPress (Key key);
+        /// Executes event handlers for window close events.
+        /// @note This will be invoked **before** the window-close procedure begins.
+		void processOnClose();
+        /// Executes event handlers for window open events.
+        /// @note This will be invoked **after** the window-open procedure completes.
+		void processOnOpen();
+		/// Executes event handlers for mouse press events.
+        void processMousePress(const MouseButton& btn);
+        /// Executes event handlers for mouse release events.
+        void processMouseRelease(const MouseButton& btn);
+        /// Executes event handlers for window focus events.
+        void processFocusIn();
+        /// Executes event handlers for window unfocus events.
+        void processFocusOut();
+
+        void processMouseMove(Vector2 last_pos, Vector2 new_pos);
+
+        void processMouseWheel(int scrolls);
+#pragma endregion
+private:
+#pragma endregion
    };
 }
--- a/main.cpp
+++ b/main.cpp
@@ -1,144 +1,178 @@
 #include <iostream>
 #include <rewindow/types/window.h>
+#include <rewindow/types/display.h>
+#include <rewindow/logger/logger.h>

-#if __linux__
+//aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa Windows :/
+#if _WIN32
+	#include <windows.h>
+#endif
+
+#include <GL/gl.h>

 Vector2 mouse_pos;

 // TODO: Move to J3ML::LinearAlgebra::Vector2
-std::ostream& operator<<(std::ostream& os, const Vector2& v)
-{
-    return os << "{" << v.x << ", " << v.y << "}";
+std::ostream& operator<<(std::ostream& os, const Vector2& v) {
+	return os << "{" << v.x << ", " << v.y << "}";
 }

-class MyWindow : public ReWindow::RWindow
-{
-public:
-    MyWindow(const std::string& title, int w, int h) : ReWindow::RWindow(title, w, h)
-    {}
+class MyWindow : public ReWindow::RWindow {
+	public:
+		MyWindow(const std::string& title, int w, int h) : ReWindow::RWindow(title, w, h) {}
+
+	void OnMouseMove(const ReWindow::MouseMoveEvent& e) override {}
+
+	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 = GetMouseCoordinates();
+		//std::cout << pos.x << ", " << pos.y << std::endl;
+
+        //if (IsMouseButtonDown(MouseButtons::MWheelUp))
+            //std::cout << "WheelUp Mouse Button" << std::endl;
+
+        //if (IsMouseButtonDown(MouseButtons::MWheelDown))
+            //std::cout << "WheelDown Mouse Button" << std::endl;
+
+        if (IsMouseButtonDown(MouseButtons::Left))
+            std::cout << "Left Mouse Button" << std::endl;
+
+        if (IsMouseButtonDown(MouseButtons::Right))
+            std::cout << "Right Mouse Button" << std::endl;
+
+        if (IsMouseButtonDown(MouseButtons::Middle))
+            std::cout << "Middle Mouse Button" << std::endl;


-    void OnMouseMove(const ReWindow::MouseMoveEvent& e) override
+        if (IsMouseButtonDown(MouseButtons::Mouse4))
+            std::cout << "Mouse4 Mouse Button" << std::endl;
+
+        if (IsMouseButtonDown(MouseButtons::Mouse5))
+            std::cout << "Mouse5 Mouse Button" << std::endl;
+
+        RWindow::OnRefresh(elapsed);
+	}
+
+	bool OnResizeRequest(const ReWindow::WindowResizeRequestEvent& e) override {
+		std::cout << "resized to " << e.Size.x << ", " << e.Size.y << std::endl;
+		return true;
+	}
+
+    void OnMouseButtonDown(const ReWindow::MouseButtonDownEvent &e) override
    {
-
+            std::cout << "Overload Down: " << e.Button.Mnemonic << std::endl;
+            RWindow::OnMouseButtonDown(e);
    }
-    void OnKeyDown(const ReWindow::KeyDownEvent& e) override
-    {

-    }
-    void OnRefresh(float elapsed) override
+    void OnMouseButtonUp(const ReWindow::MouseButtonUpEvent &e) override
    {
-        glSwapBuffers();
-        auto pos = getCursorPos();
-        //std::cout << pos.x << ", " << pos.y << std::endl;
-
-        if (isKeyDown(Keys::L))
-            this->setCursorStyle(ReWindow::Cursors::Pencil);
-        else
-            this->setCursorStyle(ReWindow::Cursors::Default);
-    }
-    bool OnResizeRequest(const ReWindow::WindowResizeRequestEvent& e) override
-    {
-        std::cout << "resized to " << e.Size.x << ", " << e.Size.y << std::endl;
-        return true;
+            std::cout << "Overload Up: " << e.Button.Mnemonic << std::endl;
+            RWindow::OnMouseButtonUp(e);
    }
 };

 int main() {
-    auto* window = new MyWindow("Test Window", 600, 480);
+	auto* window = new MyWindow("Test Window", 600, 480);
+	jlog::Debug(std::format("New window '{}' created. width={} height={}", window->GetTitle(), window->GetWidth(),
+                            window->GetHeight()));

-    window->setRenderer(RenderingAPI::OPENGL);
-    window->Open();
-    // TODO: Cannot set flags until after window is open
-    // Make this work somehow
-    window->setFullscreen(false);
-    window->setVsyncEnabled(true);
-    window->setResizable(true);
+    window->SetRenderer(RenderingAPI::OPENGL);
+	jlog::Debug(std::format("Rendering API OPENGL set for window '{}'", window->GetTitle()));

-    window->OnKeyDownEvent += [&] (ReWindow::KeyDownEvent e)
-    {
-        if (e.key == Keys::LeftArrow)
-        {
-            std::cout << "Left Arrow Hit" << std::endl;
+	window->Open();
+	jlog::Debug(std::format("Opened window '{}'", window->GetTitle()));
+
+	// TODO: Cannot set flags until after window is open
+	// Make this work somehow
+	jlog::Debug("TODO: Cannot set flags until after window is open");
+    window->SetFullscreen(false);
+    window->SetVsyncEnabled(true);
+    window->SetResizable(true);
+    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),
+                                        window->GetFlag(RWindowFlags::RESIZABLE),
+                                        window->GetFlag(RWindowFlags::VSYNC),
+                                        window->GetFlag(RWindowFlags::QUIT)));
+
+
+	window->OnKeyDownEvent += [&] (ReWindow::KeyDownEvent e) {
+        jlog::Debug(e.key.Mnemonic);
+	};
+
+
+	window->OnMouseButtonDownEvent += [&] (ReWindow::MouseButtonDownEvent e) {
+		jlog::Debug(e.Button.Mnemonic + std::to_string(e.Button.ButtonIndex));
+	};
+
+    window->OnMouseWheelEvent += [&, window] (ReWindow::MouseWheelEvent e)
+    {
+        std::cout << window->GetMouseWheelPersistent() << std::endl;
    };

-    while (window->isAlive()) {
-        window->pollEvents();
-        window->refresh();
-    }
+	while (window->IsAlive()) {
+        window->PollEvents();
+        window->ManagedRefresh();
+	}
+    // Alternatively:
+    /*
+     * while (window->IsAlive()) {
+     *      auto start = window->GetTimestamp();
+     *      ourUpdateLogic(window->GetDeltaTime());
+     *      window->update();
+     *      ourDrawLogic();
+     *      window->Refresh();
+     *      auto end = window->GetTimestamp();
+     *      auto dt = window->ComputeElapsedFrameTimeSeconds(start, end);
+     *      window->UpdateFrameTiming(dt);
+     * }
+     *
+     */
 }

-#endif
-
-#ifdef WIN32
-
+/*
+//Windows :(
+#ifdef _WIN32
 #ifndef UNICODE
 #define UNICODE
 #endif

-#include <windows.h>
-LRESULT CALLBACK WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
-
-int WINAPI wWinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, PWSTR pCmdLine, int nCmdShow)
-{
-    auto* window = new RWindow();
-    window->init(RenderingAPI::OPENGL, "mame", 100, 100);
-    window->setFlag
-
-    // Register the window class.
-    const wchar_t CLASS_NAME[] = L"Sample Window Class";
-
-    WNDCLASS wc = { };
-    wc.lpfnWndProc = WindowProc;
-    wc.hInstance = hInstance;
-    wc.lpszClassName = CLASS_NAME;
-
-    RegisterClass(&wc);
-
-    // Create the window.
-    HWND hwnd = CreateWindowEx(
-            0,
-            CLASS_NAME,
-            CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
-            NULL, // Parent Window
-            NULL, // Menu
-            hInstance, // Instancehandle
-            NULL
-            );
-    if (hwnd == NULL)
-        return 0;
-
-    ShowWindow(hwnd, nCmdShow);
-
-    // Run the message loop
-    MSG msg = {};
-    while (GetMessage(&msg, NULL, 0, 0) > 0)
-    {
-        TranslateMessage(&msg);
-        DispatchMessage(&msg);
-    }
-    return 0;
+extern "C" {
+	int wmain(int argc, wchar_t* argv[]) {
+		return main();
+	}
 }
-
-LRESULT CALLBACK WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
-{
-    switch(uMsg) {
-        case WM_DESTROY:
-            PostQuitMessage(0);
-            return 0;
-        case WM_PAINT:
-        {
-            PAINTSTRUCT ps;
-            HDC hdc = BeginPaint(hwnd, &ps);
-
-            // All painting occurs here, between BeginPaint and EndPaint
-            FillRect(hdc, &ps.rcPaint, (HBRUSH) (COLOR_WINDOW+1));
-            EndPaint(hwnd, &ps);
-        }
-        return 0;
-    }
-    return DefWindowProc(hwnd, uMsg, wParam, lParam);
-}
-
-#endif
+#endif
+*/
--- a/reci/scripts/builddeps.reci
+++ b/reci/scripts/builddeps.reci
@@ -0,0 +1 @@
+Main:new("Install build dependencies", "apt-get install -yq libx11-6 libx11-dev libgl-dev")
--- a/src/linux/window.cpp
+++ b/src/linux/window.cpp
@@ -1,399 +0,0 @@
-#include <iostream>
-#include <rewindow/types/window.h>
-#include <rewindow/data/WindowsScancodes.h>
-#include <X11/Xlib.h>
-#include <X11/Xutil.h>
-#include <X11/Xatom.h>
-#include <X11/cursorfont.h>
-
-#include <cstdlib>
-#include <cstring>
-#include <thread>
-#include "rewindow/types/cursors.h"
-
-// TODO: Move all "global" members to be instantiated class members of Window
-// Doing this would break the intended "Platform-Specific" Encapsulation
-// So should we do derived platform-specific subclasses?
-// The intended goal of the ReWindow class is a one-stop object that handles window management on **ALL** platforms
-
-Window window;
-XEvent xev;
-Display* display = XOpenDisplay(nullptr);
-int defaultScreen = DefaultScreen(display);
-XVisualInfo* visual;
-XSetWindowAttributes xSetWindowAttributes;
-XWindowAttributes windowAttributes;
-Atom wmDeleteWindow;
-XSizeHints hints;
-GLXContext glContext;
-
-namespace ReWindow {
-
-    RWindow::RWindow(const std::string& title, int width, int height) : flags(false,false,false,false) {
-        this->title = title;
-        this->width = width;
-        this->height = height;
-    }
-
-    RWindow::RWindow(const std::string& title, int width, int height, RenderingAPI renderer) :
-            title(title), width(width), height(height), renderer(renderer)
-    { }
-
-    void RWindow::raise() const { XRaiseWindow(display, window); }
-    void RWindow::lower() const { XLowerWindow(display, window); }
-
-
-
-
-    void RWindow::destroyWindow() {
-        XDestroySubwindows(display, window);
-        XAutoRepeatOn(display);
-        XDestroyWindow(display, window);
-        delete this;
-    }
-
-    void RWindow::refresh() {
-        // TODO: Implement refresh time keeping
-        OnRefresh(0.f);
-
-        // TODO: Check if mouse coords have changed, only then fire OnMouseMove event
-        Vector2 mouse_coords = getCursorPos();
-
-        auto eventData = MouseMoveEvent(mouse_coords);
-        OnMouseMove(eventData);
-
-        std::this_thread::sleep_for(1ms);
-    }
-
-    bool RWindow::getFlag(RWindowFlags flag) const
-    {
-        if (flags[(int)flag])
-            return true;
-        return false;
-    }
-
-    void RWindow::setFlag(RWindowFlags flag, bool state) {
-        XGetWindowAttributes(display,window,&windowAttributes);
-        flags[(int) flag] = state;
-        //Once you've done this you cannot make it resizable again.
-        if (flag == RWindowFlags::RESIZABLE && !state) {
-            hints.flags = PMinSize | PMaxSize;
-            hints.min_width = hints.max_width = windowAttributes.width;
-            hints.min_height = hints.max_height = windowAttributes.height;
-            XSetWMNormalHints(display, window, &hints);
-        }
-    }
-
-    void RWindow::pollEvents() {
-        while(XPending(display)) {
-            XNextEvent(display, &xev);
-
-            if (xev.type == ClientMessage) {
-                if (xev.xclient.message_type == XInternAtom(display, "WM_PROTOCOLS", False) &&
-                    static_cast<Atom>(xev.xclient.data.l[0]) == wmDeleteWindow) {
-                    destroyWindow();
-                    exit(0);
-                }
-            }
-
-            if (xev.type == FocusIn) {
-                XAutoRepeatOff(display);
-                //focusGained.Invoke();
-                RWindowEvent event {};
-                OnFocusGain(event);
-                setFlag(RWindowFlags::IN_FOCUS, true);
-            }
-
-            if (xev.type == FocusOut) {
-                XAutoRepeatOn(display);
-                //focusLost.Invoke();
-                RWindowEvent event {};
-                OnFocusLost(event);
-                setFlag(RWindowFlags::IN_FOCUS, false);
-            }
-
-            if (xev.type == KeyRelease) {
-                auto scancode = (X11Scancode) xev.xkey.keycode;
-                auto key = GetKeyFromX11Scancode(scancode);
-                currentKeyboard.PressedKeys[key] = false;
-                KeyUpEvent eventData = KeyUpEvent(key);
-                OnKeyUp(eventData);
-            }
-
-            if (xev.type == KeyPress) {
-                auto scancode = (X11Scancode) xev.xkey.keycode;
-                auto key = GetKeyFromX11Scancode(scancode);
-                currentKeyboard.PressedKeys[key] = true;
-                KeyDownEvent eventData = KeyDownEvent(key);
-                OnKeyDown(eventData);
-                eventLog.push_back(eventData);
-            }
-
-            if (xev.type == ButtonRelease) {
-                MouseButton button = GetMouseButtonFromXButton(xev.xbutton.button);
-                auto eventData = MouseButtonUpEvent();
-                eventData.Button = button;
-
-                OnMouseButtonUp(eventData);
-            }
-
-            if (xev.type == ButtonPress)
-            {
-                MouseButton button = GetMouseButtonFromXButton(xev.xbutton.button);
-                auto eventData = MouseButtonDownEvent();
-                eventData.Button = button;
-
-                OnMouseButtonDown(eventData);
-            }
-
-            if (xev.type == 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)
-            {
-                //auto eventData = MouseMoveEvent(xev.xmotion.x, xev.xmotion.y);
-
-                //OnMouseMove(eventData);
-            }
-
-            if (xev.type == ResizeRequest)
-            {
-                auto eventData = WindowResizeRequestEvent();
-                lastKnownWindowSize = eventData.Size;
-                eventData.Size = {(float)xev.xresizerequest.width, (float)xev.xresizerequest.height};
-                lastKnownWindowSize = eventData.Size;
-                OnResizeRequest(eventData);
-            }
-        }
-
-        previousKeyboard = currentKeyboard;
-    }
-
-    // Might make the window go off the screen on some window managers.
-    void RWindow::setSize(int newWidth, int newHeight)
-    {
-        this->width = newWidth;
-        this->height = newHeight;
-        if (!getFlag(RWindowFlags::RESIZABLE))
-            return;
-        XResizeWindow(display, window, width, height);
-    }
-
-    void RWindow::setSize(const Vector2& size)
-    {
-        this->width = size.x;
-        this->height = size.y;
-        this->setSize(size.x, size.y);
-    }
-
-    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};
-    }
-
-    // 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);
-    }
-
-    bool RWindow::isAlive() const {
-        return true;
-    }
-
-    void RWindow::setResizable(bool resizable) {
-        this->resizable = resizable;
-        this->setFlag(RWindowFlags::RESIZABLE, resizable);
-    }
-
-
-
-    void RWindow::setFullscreen(bool fs) {
-        if (fs)
-            fullscreen();
-        else
-            restoreFromFullscreen();
-    }
-
-    void RWindow::fullscreen() {
-        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);
-    }
-
-    void RWindow::restoreFromFullscreen() {
-        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);
-    }
-
-    void RWindow::setVsyncEnabled(bool b) {
-        PFNGLXSWAPINTERVALEXTPROC glXSwapIntervalEXT = nullptr;
-        glXSwapIntervalEXT = (PFNGLXSWAPINTERVALEXTPROC)glXGetProcAddressARB((const GLubyte*)"glXSwapIntervalEXT");
-        glXSwapIntervalEXT(display, None, b);
-    }
-
-    bool RWindow::isFullscreen() const {
-        return fullscreenmode;
-    }
-
-    using J3ML::u32;
-    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);
-        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);
-        if (renderer == RenderingAPI::OPENGL)
-        {
-            glXMakeCurrent(display, window, glContext);
-        }
-
-        //setVsyncEnabled(vsync);
-
-
-        open = true;
-    }
-
-    void RWindow::setTitle(const std::string &title) {
-        this->title = title;
-        XStoreName(display, window, title.c_str());
-    }
-
-    std::string RWindow::getTitle() const {
-        return this->title;
-    }
-
-    bool RWindow::isKeyDown(Key key) const {
-        if (!currentKeyboard.PressedKeys.contains(key))
-            return false;
-        return currentKeyboard.PressedKeys.at(key);
-    }
-
-    // TODO: Implement MouseButton map
-    bool RWindow::isMouseButtonDown(MouseButton button) const
-    {
-        return false;
-    }
-
-    RWindow::RWindow() {
-        title = "ReWindow Application";
-        width = 640;
-        height = 480;
-    }
-
-    void RWindow::setRenderer(RenderingAPI api) {
-        renderer = api;
-    }
-
-    // TODO: Implement ControllerButton map
-
-
-}
--- a/src/logger/logger.cpp
+++ b/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};
+}
--- a/src/platform/linux/display.cpp
+++ b/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;
+}
--- a/src/platform/linux/window.cpp
+++ b/src/platform/linux/window.cpp
@@ -0,0 +1,411 @@
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+#include <X11/Xatom.h>
+#include <GL/glx.h>
+#include <cstdlib>
+#include <cstring>
+#include <rewindow/types/window.h>
+#include <rewindow/types/cursors.h>
+#include <J3ML/J3ML.hpp>
+#include <rewindow/logger/logger.h>
+
+
+
+// TODO: Move all "global" members to be instantiated class members of Window
+// Doing this would break the intended "Platform-Specific" Encapsulation
+// So should we do derived platform-specific subclasses?
+// The intended goal of the ReWindow class is a one-stop object that handles window management on **ALL** platforms
+
+Window window;
+XEvent xev;
+Display* display = XOpenDisplay(nullptr);
+int defaultScreen = DefaultScreen(display);
+XVisualInfo* visual;
+XSetWindowAttributes xSetWindowAttributes;
+XWindowAttributes windowAttributes;
+Atom wmDeleteWindow;
+// Make it start as floating because fuck tiling WMs
+Atom windowTypeAtom;
+Atom windowTypeUtilityAtom;
+XSizeHints hints;
+GLXContext glContext;
+Cursor invisible_cursor = 0;
+
+Vector2 render_area_position = {0, 0};
+Vector2 position = {0, 0};
+bool should_poll_x_for_mouse_pos = true;
+
+
+using namespace ReWindow;
+
+void RWindow::Raise() const {
+    Logger::Debug(std::format("Raising window '{}'", this->title));
+
+    // Get the position of the renderable area relative to the rest of the window.
+    XGetWindowAttributes(display, window, &windowAttributes);
+    render_area_position =  { (float) windowAttributes.x, (float) windowAttributes.y };
+
+    XRaiseWindow(display, window);
+}
+
+void RWindow::Lower() const
+{
+    Logger::Debug(std::format("Lowering window '{}'", this->title));
+    XLowerWindow(display, window);
+}
+
+void RWindow::DestroyWindow() {
+    Logger::Debug(std::format("Destroying window '{}'", this->title));
+    XDestroySubwindows(display, window);
+    Logger::Debug(std::format("Destroyed window '{}'", this->title));
+    XDestroyWindow(display, window);
+    delete this;
+}
+
+//void RWindow::
+
+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::SetResizable(bool sizable) {
+    XGetWindowAttributes(display,window,&windowAttributes);
+
+
+    this->resizable = sizable;
+    if (!sizable)
+    {
+        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);
+    }
+    //this->SetFlag(RWindowFlags::RESIZABLE, resizable);
+
+}
+
+void RWindow::SetFlag(RWindowFlags flag, bool state) {
+    XGetWindowAttributes(display,window,&windowAttributes);
+    flags[(int) flag] = state;
+    //Once you've done this you cannot make it resizable again.
+    if (flag == RWindowFlags::RESIZABLE && !state) {
+        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);
+    }
+    Logger::Debug(std::format("Set flag '{}' to state '{}' for window '{}'", RWindowFlagToStr(flag), state, this->title));
+}
+
+void RWindow::PollEvents() {
+    while(XPending(display)) {
+        XNextEvent(display, &xev);
+
+        if (xev.type == ClientMessage)
+            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) {
+
+            processOnClose();
+            DestroyWindow();
+            system("xset r on");
+            exit(0);
+        }
+
+        if (xev.type == FocusIn) {
+            Logger::Debug(std::format("Recieved event '{}'", "FocusIn"));
+            XAutoRepeatOff(display);
+            SetFlag(RWindowFlags::IN_FOCUS, true);
+
+            if (!cursor_visible)
+                XDefineCursor(display, window, invisible_cursor);
+
+            // Get the position of the renderable area relative to the rest of the window.
+            XGetWindowAttributes(display, window, &windowAttributes);
+            render_area_position =  { (float) windowAttributes.x, (float) windowAttributes.y };
+            processFocusIn();
+        }
+
+        if (xev.type == FocusOut) {
+            Logger::Debug(std::format("Recieved event '{}'", "FocusOut"));
+            XAutoRepeatOn(display);
+
+            SetFlag(RWindowFlags::IN_FOCUS, false);
+            if (!cursor_visible)
+                XUndefineCursor(display, window);
+
+            processFocusOut();
+        }
+
+        if (xev.type == KeyRelease) {
+            Logger::Debug(std::format("Recieved event '{}'", "KeyRelease"));
+            auto scancode = (X11Scancode) xev.xkey.keycode;
+            auto key = GetKeyFromX11Scancode(scancode);
+            processKeyRelease(key);
+        }
+
+        if (xev.type == KeyPress) {
+            Logger::Debug(std::format("Recieved event '{}'", "KeyPress"));
+            auto scancode = (X11Scancode) xev.xkey.keycode;
+            auto key = GetKeyFromX11Scancode(scancode);
+            processKeyPress(key);
+        }
+
+        if (xev.type == ButtonRelease) {
+
+            // Mouse Wheel fires both the ButtonPress and ButtonRelease instantaneously.
+            // Therefore, we handle it as a specific MouseWheel event rather than a MouseButton event,
+            // and only call on ButtonPress, otherwise it will appear to duplicate the mouse wheel scroll.
+            if (xev.xbutton.button != 4 && xev.xbutton.button != 5) {
+                MouseButton button = GetMouseButtonFromXButton(xev.xbutton.button);
+                Logger::Debug(std::format("Recieved event '{}'", "ButtonRelease"));
+                processMouseRelease(button);
+            }
+        }
+
+        if (xev.type == ButtonPress) {
+
+            // Mouse Wheel fires both the ButtonPress and ButtonRelease instantaneously.
+            // Therefore, we handle it as a specific MouseWheel event rather than a MouseButton event,
+            // and only call on ButtonPress, otherwise it will appear to duplicate the mouse wheel scroll.
+            if (xev.xbutton.button == 4) {
+                processMouseWheel(-1);
+            } else if (xev.xbutton.button == 5) {
+                processMouseWheel(1);
+            } else
+            {
+                MouseButton button = GetMouseButtonFromXButton(xev.xbutton.button);
+
+                Logger::Debug(std::format("Window event: MouseButtonPress {}", button.Mnemonic));
+
+                processMousePress(button);
+            }
+        }
+
+        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 == ConfigureNotify) {
+            if (this->width != xev.xconfigurerequest.width || this->height != xev.xconfigurerequest.height) {
+                Logger::Debug(std::format("Recieved event '{}'", "ResizeRequest"));
+
+                this->width = xev.xconfigurerequest.width;
+                this->height = xev.xconfigurerequest.height;
+
+                auto eventData = WindowResizeRequestEvent();
+                eventData.Size = { (float) xev.xconfigurerequest.width, (float) xev.xconfigurerequest.height };
+                lastKnownWindowSize = eventData.Size;
+
+                OnResizeRequest(eventData);
+                OnResizeRequestEvent(eventData);
+            }
+
+            //Window Moved.
+            if (position.x != xev.xconfigurerequest.x || position.y != xev.xconfigurerequest.y)
+                position = { (float) xev.xconfigurerequest.x, (float) xev.xconfigurerequest.y };
+        }
+
+    }
+    previousKeyboard = currentKeyboard;
+    previousMouse.Buttons = currentMouse.Buttons;
+}
+
+
+// Might make the window go off the screen on some window managers.
+void RWindow::SetSize(int newWidth, int newHeight) {
+    if (!resizable) return;
+
+    this->width = newWidth;
+    this->height = newHeight;
+    XResizeWindow(display, window, newWidth, newHeight);
+    XFlush(display);
+    Logger::Debug(std::format("Set size for window '{}'. width={} height={}", this->title, newWidth, newHeight));
+}
+
+Vector2 RWindow::GetAccurateMouseCoordinates() const {
+
+    Window root_return, child_return;
+    int root_x_ret, root_y_ret;
+    int win_x_ret, win_y_ret;
+    uint32_t mask_return;
+
+    // This seems to be relative to the top left corner of the renderable area.
+    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: normalize coordinates from displaySpace to windowSpace
+        // TODO: fire mouse movement event
+        Vector2 m_coords = { (float) win_x_ret, (float) win_y_ret };
+        return m_coords;
+    }
+    return Vector2::Zero;
+}
+
+
+Vector2 RWindow::GetSize() const {
+    return {(float) this->width, (float) this->height};
+}
+
+//Vector2 RWindow::getLastKnownResize() const
+//{
+//    return lastKnownWindowSize;
+//}
+
+// TODO: implement integer vector2/3 types
+Vector2 RWindow::GetPos() const {
+    return position;
+}
+
+void RWindow::SetPos(int x, int y) {
+    XMoveWindow(display, window, x, y);
+    position = { (float) x, (float) y };
+}
+
+void RWindow::SetPos(const Vector2& pos) {
+    SetPos(pos.x, pos.y);
+}
+
+
+void RWindow::GLSwapBuffers() {
+    glXSwapBuffers(display,window);
+}
+
+
+
+void RWindow::Fullscreen() {
+    Logger::Debug(std::format("Fullscreening window '{}'", this->title));
+    fullscreen_mode = 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] = fullscreen_mode;
+    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));
+    fullscreen_mode = 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] = fullscreen_mode;
+    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);
+}
+
+
+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 );
+    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);
+
+    // Get the position of the renderable area relative to the rest of the window.
+    XGetWindowAttributes(display, window, &windowAttributes);
+    render_area_position =  { (float) windowAttributes.x, (float) windowAttributes.y };
+    open = true;
+
+
+    processOnOpen();
+}
+
+void RWindow::SetTitle(const std::string &title) {
+    this->title = title;
+    XStoreName(display, window, title.c_str());
+}
+
+
+
+Vector2 RWindow::GetPositionOfRenderableArea() const {
+    return render_area_position;
+}
+
+std::string RWindow::getGraphicsDriverVendor() {
+    return std::string(reinterpret_cast<const char*>(glGetString(GL_VENDOR)));
+}
+
+
+// TODO: Implement ControllerButton map
+
--- a/src/platform/shared/display.cpp
+++ b/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;
+}
--- a/src/platform/shared/window.cpp
+++ b/src/platform/shared/window.cpp
@@ -0,0 +1,293 @@
+ #include <rewindow/types/window.h>
+#include "rewindow/logger/logger.h"
+#include <rewindow/types/mouse.h>
+
+std::string RWindowFlagToStr(RWindowFlags flag) {
+    switch (flag) {
+        case RWindowFlags::IN_FOCUS: return "IN_FOCUS";
+        case RWindowFlags::FULLSCREEN: return "FULLSCREEN";
+        case RWindowFlags::RESIZABLE: return "RESIZEABLE";
+        case RWindowFlags::VSYNC: return "VSYNC";
+        case RWindowFlags::QUIT: return "QUIT";
+        case RWindowFlags::MAX_FLAG: return "MAX_FLAG";
+        default:
+            return "unimplemented flag";
+    }
+};
+
+using namespace ReWindow;
+
+
+
+RWindow::RWindow() {
+    title = "ReWindow Application";
+    width = 640;
+    height = 480;
+
+    if (DetectsKeyboard())
+    {
+        keyboard = new Keyboard();
+        input_devices.push_back(keyboard);
+    }
+
+    if (DetectsMouse())
+    {
+        mouse = new Mouse();
+        input_devices.push_back(mouse);
+    }
+
+    if (DetectsGamepad())
+    {
+        gamepad = new Gamepad();
+        input_devices.push_back(gamepad);
+    }
+
+
+
+
+
+    //RWindow::singleton = this;
+}
+
+RWindow::RWindow(const std::string& title, int width, int height) : flags{false,false,false,false} {
+    this->title = title;
+    this->width = width;
+    this->height = height;
+    //RWindow::singleton = this;
+}
+
+RWindow::RWindow(const std::string& title, int width, int height, RenderingAPI renderer) :
+        title(title), width(width), height(height), renderer(renderer) {}
+
+Vector2 RWindow::GetMouseCoordinates() const {
+    return mouse->GetPosition();
+}
+
+bool RWindow::GetFlag(RWindowFlags flag) const {
+    return flags[(int) flag];
+}
+
+bool RWindow::IsAlive() const {
+    return true;
+}
+
+
+void RWindow::SetFullscreen(bool fs) {
+    if (fs)
+        Fullscreen();
+    else
+        RestoreFromFullscreen();
+}
+
+void RWindow::processFocusIn()
+{
+    RWindowEvent event {};
+    OnFocusGain(event);
+    OnFocusGainEvent(event);
+}
+
+void RWindow::processFocusOut()
+{
+    RWindowEvent event {};
+    OnFocusLost(event);
+    OnFocusLostEvent(event);
+}
+
+void RWindow::processMousePress(const MouseButton& btn)
+{
+    mouse->DoButtonPress(btn); // .Set(btn, true);
+    auto eventData = MouseButtonDownEvent(btn);
+    OnMouseButtonDown(eventData);
+    OnMouseButtonDownEvent(eventData);
+
+}
+
+void RWindow::processMouseMove(Vector2 last_pos, Vector2 new_pos)
+{
+    currentMouse.Position = new_pos;
+    auto eventData = MouseMoveEvent(new_pos);
+    OnMouseMove(eventData);
+    OnMouseMoveEvent(eventData);
+}
+
+void RWindow::processMouseRelease(const MouseButton& btn)
+{
+    currentMouse.Set(btn, false);
+    auto eventData = MouseButtonUpEvent(btn);
+    OnMouseButtonUp(eventData);
+    OnMouseButtonUpEvent(eventData);
+
+}
+
+void RWindow::processKeyRelease(Key key) {
+    currentKeyboard.PressedKeys[key] = false;
+    auto event = KeyUpEvent(key);
+    OnKeyUp(event);
+    OnKeyUpEvent(key);
+}
+
+
+std::string RWindow::GetTitle() const {
+    return this->title;
+}
+
+/*
+Vector2 RWindow::GetSize() const
+{
+    return {this->width, this->height};
+}
+*/
+
+int RWindow::GetWidth() const
+{
+    return this->width;
+}
+
+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;
+}
+
+void RWindow::SetSize(const Vector2& size) {
+    this->width = size.x;
+    this->height = size.y;
+    this->SetSize(size.x, size.y);
+}
+
+bool RWindow::IsKeyDown(Key key) const {
+    for (const auto& pair : currentKeyboard.PressedKeys)
+        if (pair.first == key && pair.second)
+            return true;
+    return false;
+}
+
+bool RWindow::IsMouseButtonDown(const MouseButton &button) const {
+    // TODO: Implement MouseButton map
+    return currentMouse.IsDown(button);
+}
+
+void RWindow::processKeyPress(Key key) {
+    currentKeyboard.PressedKeys[key] = true;
+
+    Input::
+
+    auto eventData = KeyDownEvent(key);
+    OnKeyDown(eventData);
+    OnKeyDownEvent(key);
+}
+
+void RWindow::processOnClose()
+{
+    OnClosing();
+    OnClosingEvent();
+}
+
+void RWindow::processOnOpen()
+{
+    OnOpen();
+    OnOpenEvent();
+}
+
+void RWindow::ManagedRefresh()
+{
+     auto begin = GetTimestamp();
+     Refresh();
+     auto end = GetTimestamp();
+
+     float dt = ComputeElapsedFrameTimeSeconds(begin, end);
+
+     UpdateFrameTiming(dt);
+}
+
+void RWindow::Refresh() {
+    PollEvents();
+    OnRefresh(delta_time);
+
+    // Only call once and cache the result.
+    currentMouse.Position = GetAccurateMouseCoordinates();
+
+    /// TODO: Implement optional minimum epsilon to trigger a Mouse Update.
+    if (currentMouse.Position != previousMouse.Position) {
+        processMouseMove(previousMouse.Position, currentMouse.Position);
+        previousMouse.Position = currentMouse.Position;
+    }
+
+    detail::UpdateMouse(currentMouse);
+
+}
+
+float RWindow::ComputeElapsedFrameTimeSeconds(std::chrono::steady_clock::time_point start, std::chrono::steady_clock::time_point end) {
+    auto frame_time = end - start;
+    unsigned long int frame_time_us = std::chrono::duration_cast<std::chrono::microseconds>(frame_time).count();
+    float frame_time_s = frame_time_us / (1000.f * 1000.f);
+    return frame_time_s;
+}
+
+ std::chrono::steady_clock::time_point RWindow::GetTimestamp() {
+    return std::chrono::steady_clock::now();
+}
+
+void RWindow::UpdateFrameTiming(float frame_time) {
+    delta_time = frame_time;
+    refresh_rate = 1.f / delta_time;
+    refresh_rate_prev_5 = refresh_rate_prev_4;
+    refresh_rate_prev_4 = refresh_rate_prev_3;
+    refresh_rate_prev_3 = refresh_rate_prev_2;
+    refresh_rate_prev_2 = refresh_rate_prev_1;
+    refresh_rate_prev_1 = refresh_rate;
+    avg_refresh_rate = (refresh_rate_prev_1 + refresh_rate_prev_2 + refresh_rate_prev_3 + refresh_rate_prev_4 + refresh_rate_prev_5) / 5.f;
+    refresh_count++;
+}
+
+
+void RWindow::processMouseWheel(int scrolls)
+{
+    currentMouse.Wheel += scrolls;
+    auto ev = MouseWheelEvent(scrolls);
+    OnMouseWheel(ev);
+    OnMouseWheelEvent(ev);
+
+    previousMouse.Wheel = currentMouse.Wheel;
+}
+
+
+void RWindow::Close() {
+    /// TODO: Implement closing the window without destroying the handle.
+    processOnClose();
+}
+
+bool RWindow::IsResizable() const {
+    return resizable;
+}
+
+bool RWindow::IsFullscreen() const {
+    return fullscreen_mode;
+}
+
+bool RWindow::IsFocused() const {
+    return focused;
+}
+
+ bool RWindow::IsVsyncEnabled() const {
+     return vsync;
+ }
+
+ float RWindow::GetDeltaTime() const { return delta_time; }
+
+ float RWindow::GetRefreshRate() const { return refresh_rate; }
+
+ float RWindow::GetRefreshCounter() const { return refresh_count; }
+
--- a/src/platform/windows/window.cpp
+++ b/src/platform/windows/window.cpp
@@ -0,0 +1,302 @@
+#include <Windows.h>
+#include <gl/GL.h>
+#include <rewindow/types/window.h>
+
+using namespace ReWindow;
+
+bool fullscreenmode = false;
+bool open = false;
+HINSTANCE hInstance = GetModuleHandle(nullptr);
+HWND hwnd;
+HDC hdc;
+HGLRC glContext;
+
+void raise() { SetWindowPos(hwnd, HWND_TOP, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE); }
+void lower() { SetWindowPos(hwnd, HWND_BOTTOM, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE); }
+
+void RWindow::SetFlag(RWindowFlags flag, bool state) {
+    flags[(int) flag] = state;
+    if (flag == RWindowFlags::RESIZABLE && !state) {
+        RECT rect;
+        GetWindowRect(hwnd, &rect);
+        LONG style = GetWindowLong(hwnd, GWL_STYLE);
+        style &= ~(WS_THICKFRAME | WS_MAXIMIZEBOX);
+        SetWindowLong(hwnd, GWL_STYLE, style);
+        SetWindowPos(hwnd, nullptr, rect.left, rect.top, rect.right - rect.left, rect.bottom - rect.top, SWP_FRAMECHANGED | SWP_NOZORDER | SWP_NOOWNERZORDER);
+    }
+}wasd
+void RWindow::SetResizable(bool resizable) {
+    SetFlag(RWindowFlags::RESIZABLE, resizable);;
+}
+
+
+void RWindow::PollEvents() {
+    MSG msg;
+    while (PeekMessage(&msg, nullptr, 0, 0, PM_REMOVE)) {
+        TranslateMessage(&msg);
+        DispatchMessage(&msg);
+    }
+}
+
+void RWindow::SetSize(int newWidth, int newHeight) {
+    if (!resizable) return;
+    this->width = width;
+    this->height = height;
+    SetWindowPos(hwnd, nullptr, 0, 0, width, height, SWP_NOMOVE | SWP_NOZORDER);
+}
+
+Vector2 RWindow::GetAccurateMouseCoordinates() const {
+    POINT point;
+    GetCursorPos(&point);
+    ScreenToClient(hwnd, &point);
+    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);
+    return { (float)(rect.right - rect.left), (float)(rect.bottom - rect.top) };
+}
+
+void RWindow::SetPos(int x, int y) {
+    SetWindowPos(hwnd, nullptr, x, y, 0, 0, SWP_NOSIZE | SWP_NOZORDER);
+}
+
+void RWindow::SetPos(const Vector2& pos) {
+    SetPos(pos.x, pos.y);
+}
+
+void RWindow::Fullscreen() {
+    // Implement fullscreen
+    SetWindowLong(hwnd, GWL_STYLE, GetWindowLong(hwnd, GWL_STYLE) & ~WS_OVERLAPPEDWINDOW);
+    SetWindowPos(hwnd, HWND_TOP, 0, 0, GetSystemMetrics(SM_CXSCREEN), GetSystemMetrics(SM_CYSCREEN), SWP_FRAMECHANGED | SWP_NOOWNERZORDER);
+}
+
+void RWindow::RestoreFromFullscreen() {
+    // Implement restore from fullscreen
+    SetWindowLong(hwnd, GWL_STYLE, GetWindowLong(hwnd, GWL_STYLE) | WS_OVERLAPPEDWINDOW);
+    SetWindowPos(hwnd, nullptr, 0, 0, width, height, SWP_FRAMECHANGED | SWP_NOZORDER | SWP_NOOWNERZORDER);
+}
+
+void RWindow::SetVsyncEnabled(bool b) {
+    typedef BOOL(WINAPI* PFNWGLSWAPINTERVALEXTPROC)(int interval);
+    auto wglSwapIntervalEXT = (PFNWGLSWAPINTERVALEXTPROC) wglGetProcAddress("wglSwapIntervalEXT");
+
+    if (wglSwapIntervalEXT)
+        wglSwapIntervalEXT(b ? 1 : 0);
+}
+
+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);
+
+                    eWindow->processOnClose();
+            }
+
+            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()});
+
+                    // TODO: Implement eWindow->processOnResize()
+
+                    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: {
+
+                    eWindow->processFocusIn();
+
+                    eWindow->SetFlag(RWindowFlags::IN_FOCUS, true);
+                    break;
+            }
+
+            case WM_KILLFOCUS: {
+
+                    eWindow->processFocusOut();
+
+                    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->processKeyPress(key);
+                    }
+                    break;
+            }
+
+            case WM_KEYUP: {
+                    auto key = GetKeyFromWindowsScancode((WindowsScancode) wParam);
+                    eWindow->processKeyRelease(key);
+                    break;
+            }
+
+            //Mouse Buttons.
+            case WM_MOUSEWHEEL: {
+                    int wheel_delta = GET_WHEEL_DELTA_WPARAM(wParam);
+
+                    // TODO: Determine sign of wheel_delta for each direction, (and on linux too), and document this.
+                    eWindow->processMouseWheel(wheel_delta);
+
+                    break;
+            }
+
+            case WM_LBUTTONDOWN: {
+                    eWindow->processMousePress(MouseButtons::Left);
+                    break;
+            }
+
+            case WM_LBUTTONUP: {
+                    eWindow->processMouseRelease(MouseButtons::Left);
+                    break;
+            }
+
+            case WM_RBUTTONDOWN: {
+                    eWindow->processMousePress(MouseButtons::Right);
+                    break;
+            }
+
+            case WM_RBUTTONUP: {
+                    eWindow->processMouseRelease(MouseButtons::Right);
+                    break;
+            }
+
+            case WM_MBUTTONDOWN: {
+                    eWindow->processMousePress(MouseButtons::Middle);
+                    break;
+            }
+
+            case WM_MBUTTONUP: {
+                    eWindow->processMouseRelease(MouseButtons::Middle);
+                    break;
+            }
+
+            case WM_XBUTTONDOWN: {
+                    WORD button = GET_XBUTTON_WPARAM(wParam);
+
+                    if (button == XBUTTON1)
+                        eWindow->processMousePress(MouseButtons::Mouse4);
+
+                    if (button == XBUTTON2)
+                        eWindow->processMousePress(MouseButtons::Mouse5);
+
+                    break;
+            }
+
+            case WM_XBUTTONUP: {
+                    WORD button = GET_XBUTTON_WPARAM(wParam);
+                    if (button == XBUTTON1)
+                        eWindow->processMouseRelease(MouseButtons::Mouse4);
+
+                    if (button == XBUTTON2)
+                        eWindow->processMouseRelease(MouseButtons::Mouse5);
+                    break;
+        }
+
+        //This is the same as "Motion Notify" in the X Window System.
+        case WM_MOUSEMOVE:
+            break;
+    }
+
+    if (pKeyboard != nullptr && cKeyboard != nullptr)
+        pKeyboard = cKeyboard;
+    
+    return DefWindowProc(hwnd, uMsg, wParam, lParam);
+}
+
+void RWindow::SetCursorStyle(CursorStyle style) const {}
+
+void RWindow::Open() {
+    eWindow = this;
+    pKeyboard = &previousKeyboard;
+    cKeyboard = &currentKeyboard;
+    WNDCLASS wc = { };
+    wc.lpfnWndProc = WindowProc;
+    wc.hInstance = hInstance;
+    wc.lpszClassName = "RWindowClass";
+    RegisterClass(&wc);
+    hwnd = CreateWindowEx(
+        0,
+        "RWindowClass",
+        title.c_str(),
+        WS_OVERLAPPEDWINDOW,
+        CW_USEDEFAULT, CW_USEDEFAULT, width, height,
+        nullptr,
+        nullptr,
+        hInstance,
+        nullptr
+    );
+
+    if (renderer == RenderingAPI::OPENGL) {
+        PIXELFORMATDESCRIPTOR pfd = {
+            sizeof(PIXELFORMATDESCRIPTOR),
+            1,
+            PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER,
+            PFD_TYPE_RGBA,
+            24,
+            0, 0, 0, 0, 0, 0,
+            0,
+            0,
+            0,
+            0, 0, 0, 0,
+            24,
+            8,
+            0,
+            PFD_MAIN_PLANE,
+            0,
+            0, 0, 0
+        };
+
+        hdc = GetDC(hwnd);
+        int pixelFormat = ChoosePixelFormat(hdc, &pfd);
+        SetPixelFormat(hdc, pixelFormat, &pfd);
+
+        glContext = wglCreateContext(hdc);
+        wglMakeCurrent(hdc, glContext);
+    }
+    ShowWindow(hwnd, SW_SHOW);
+    open = true;
+}
+
+void RWindow::GLSwapBuffers() {
+    SwapBuffers(hdc);
+}
+
+std::string RWindow::getGraphicsDriverVendor() {
+    return std::string(reinterpret_cast<const char*>(glGetString(GL_VENDOR)));
+}
--- a/src/rewindow/types/key.cpp
+++ b/src/rewindow/types/key.cpp
@@ -1,24 +0,0 @@
-#include <rewindow/types/key.h>
-
-std::vector<Key> Key::keyboard = {};
-
-std::vector<Key> Key::GetKeyboard() { return keyboard; }
-
-Key::Key() {
-
-    keyboard.push_back(*this);
-}
-
-Key::Key(char charcode, X11Scancode scancode, WindowsScancode sc)
-        : CharCode(charcode), x11ScanCode(scancode), winScanCode(sc)
-{
-    keyboard.push_back(*this);
-}
-
-bool Key::operator==(const Key &rhs) const {
-    return (this->CharCode == rhs.CharCode);
-}
-
-bool Key::operator<(const Key &rhs) const {
-    return (this->CharCode < rhs.CharCode);
-}
--- a/src/types/WindowEvents.cpp
+++ b/src/types/WindowEvents.cpp
@@ -0,0 +1,7 @@
+#include <rewindow/types/WindowEvents.hpp>
+
+
+namespace ReWindow
+{
+
+}
--- a/src/types/gamepadbutton.cpp
+++ b/src/types/gamepadbutton.cpp
@@ -0,0 +1,9 @@
+#include <rewindow/types/gamepadbutton.h>
+
+bool GamepadButton::operator==(const GamepadButton &rhs) const {
+    return this->GetMnemonicButtonCode() == rhs.GetMnemonicButtonCode();
+}
+
+void GamepadThumbstick::SetDeadzone(float minimum) const {
+
+}
--- a/src/types/inputdevice.cpp
+++ b/src/types/inputdevice.cpp
@@ -0,0 +1 @@
+#include <rewindow/types/inputdevice.hpp>
--- a/src/types/inputservice.cpp
+++ b/src/types/inputservice.cpp
@@ -0,0 +1,29 @@
+#include <rewindow/types/inputservice.hpp>
+
+namespace ReWindow {
+    namespace detail
+    {
+        static Mouse* internal_mouse;
+
+        void UpdateMouse(Mouse* mouse) {
+            detail::internal_mouse = mouse;
+        }
+
+    }
+
+    namespace InputService
+    {
+        namespace Mouse
+        {
+            Vector2 GetMousePosition()
+            {
+                return detail::internal_mouse->GetPosition();
+            }
+
+            bool IsButtonDown(const MouseButton &btn) {
+                return detail::internal_mouse->IsButtonDown(btn);
+            }
+        }
+
+    }
+}
--- a/src/types/key.cpp
+++ b/src/types/key.cpp
@@ -0,0 +1,42 @@
+#include <rewindow/types/key.h>
+//#include <rewindow/logger.h>
+//std::vector<Key> Key::keyboard = {};
+
+std::vector<Key> Key::GetKeyboard() { return keyboard; }
+
+
+
+Key::Key(const char* charcode, X11Scancode scancode, WindowsScancode sc)
+        : Mnemonic(charcode), x11ScanCode(scancode), winScanCode(sc)
+{
+    //TODO doing this is what crashes the program.
+    keyboard.push_back(*this);
+}
+
+bool Key::operator==(const Key &rhs) const {
+    //This is not a good workaround.
+    return (this->x11ScanCode == rhs.x11ScanCode);
+}
+
+bool Key::operator<(const Key &rhs) const {
+    return (this->Mnemonic < rhs.Mnemonic);
+}
+
+
+
+Key GetKeyFromX11Scancode(X11Scancode code) {
+    for (const auto& key : Key::GetKeyboard())
+        if (key.x11ScanCode == code)
+            return key;
+    std::cout << "Unavaliable Scancode: " + std::to_string((int)code) << std::endl;
+    return Keys::Space;
+}
+
+Key GetKeyFromWindowsScancode(WindowsScancode code) {
+    for (const auto& key : Key::GetKeyboard())
+        if (key.winScanCode == code)
+            return key;
+
+    std::cout << "Unavaliable Scancode: " + std::to_string((int) code) << std::endl;
+    return Keys::Space;
+}
--- a/src/types/keyboard.cpp
+++ b/src/types/keyboard.cpp
@@ -0,0 +1 @@
+#include <rewindow/types/keyboard.h>
--- a/src/types/mouse.cpp
+++ b/src/types/mouse.cpp
@@ -0,0 +1,82 @@
+#include <rewindow/types/mouse.h>
+
+namespace ReWindow
+{
+    namespace detail
+    {
+        static Mouse* internal_mouse;
+
+        void UpdateMouse(Mouse* mouse) {
+            detail::internal_mouse = mouse;
+        }
+
+    }
+
+    namespace InputService
+    {
+        namespace Mouse
+        {
+            Vector2 GetMousePosition()
+            {
+                return detail::internal_mouse->GetPosition();
+            }
+
+            bool IsButtonDown(const MouseButton &btn) {
+                return detail::internal_mouse->IsButtonDown(btn);
+            }
+        }
+
+    }
+
+
+    void Mouse::DoButtonPress(const MouseButton &btn) {
+        SetButtonPressed(btn, true);
+    }
+
+    void Mouse::DoButtonRelease(const MouseButton &btn) {
+        SetButtonPressed(btn, false);
+    }
+
+    DeviceType Mouse::GetType() const { return DeviceType::MOUSE;}
+
+    void Mouse::Update(double elapsed) {
+        current_state.Left.TimeHeld += elapsed;
+        current_state.Right.TimeHeld += elapsed;
+        current_state.Middle.TimeHeld += elapsed;
+        current_state.Mouse4.TimeHeld += elapsed;
+        current_state.Mouse5.TimeHeld += elapsed;
+
+        previous_state = current_state;
+    }
+
+    ButtonState Mouse::GetButtonState(const MouseButton &btn) const {
+        if (btn == MouseButtons::Left)   return current_state.Left;
+        if (btn == MouseButtons::Right)  return current_state.Right;
+        if (btn == MouseButtons::Middle) return current_state.Middle;
+        if (btn == MouseButtons::Mouse4) return current_state.Mouse4;
+        if (btn == MouseButtons::Mouse5) return current_state.Mouse5;
+    }
+
+    bool Mouse::IsButtonDown(const MouseButton &btn) const {
+        return GetButtonState(btn).Pressed;
+    }
+
+    Mouse::~Mouse() {}
+
+    Mouse::Mouse() {}
+
+    void Mouse::SetButtonPressed(const MouseButton &btn, bool pressed) {
+        auto state = GetButtonState(btn);
+        state.Pressed = pressed;
+        state.TimeHeld = 0;
+        SetButtonState(btn, state);
+    }
+
+    void Mouse::SetButtonState(const MouseButton &btn, ButtonState state) {
+        if (btn == MouseButtons::Left)   current_state.Left = state;
+        if (btn == MouseButtons::Right)  current_state.Right = state;
+        if (btn == MouseButtons::Middle) current_state.Middle = state;
+        if (btn == MouseButtons::Mouse4) current_state.Mouse4 = state;
+        if (btn == MouseButtons::Mouse5) current_state.Mouse5 = state;
+    }
+}
--- a/src/types/mousebutton.cpp
+++ b/src/types/mousebutton.cpp
@@ -0,0 +1,36 @@
+#include <rewindow/types/mousebutton.h>
+#include <string>
+#include <X11/X.h>
+#include "rewindow/logger/logger.h"
+
+
+MouseButton::MouseButton(const std::string& charcode, unsigned int index) {
+    this->Mnemonic = charcode;
+    this->ButtonIndex = index;
+}
+
+bool MouseButton::operator==(const MouseButton &mb) const {
+    return (mb.ButtonIndex == this->ButtonIndex);
+}
+
+bool MouseButton::operator<(const MouseButton &rhs) const {
+    return (this->ButtonIndex < rhs.ButtonIndex);
+}
+
+
+MouseButton GetMouseButtonFromXButton(unsigned int button) {
+    switch(button) {
+        case 1: return MouseButtons::Left;
+        case 2: return MouseButtons::Middle;
+        case 3: return MouseButtons::Right;
+        //case 4: return MouseButtons::MWheelUp;
+        //case 5: return MouseButtons::MWheelDown;
+            //For *whatever* reason. These aren't in X.h
+        case 8: return MouseButtons::Mouse4;
+        case 9: return MouseButtons::Mouse5;
+        default: {
+            ReWindow::Logger::Fatal("Undefined XButtonCode: " + std::to_string((int) button));
+            return MouseButtons::Unimplemented;
+        }
+    }
+}
--- a/src/windows/window.cpp
+++ b/src/windows/window.cpp
@@ -1,31 +0,0 @@
-#include <rewindow/types/window.h>
-
-
-LRESULT CALLBACK WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
-
-
-LPTSTR szClassName = TEXT("GenericProgramWindowClass");
-
-WNDCLASS wc = { };
-wc.lpfnWndProc = WindowProc;
-
-HWND hwnd;
-
-RWindow::RWindow()
-{
-    hwnd = CreateWindow();
-}
-
-
-void RWindow::raise() const {
-    SendMessage(hwnd, WM_SYSCOMMAND, SC_RESTORE, 0); // Restore
-    SetForegroundWindow(hwnd);
-    SetActiveWindow(hwnd);
-    SetWindowPos(hwnd, HWND_TOP, 0, 0, 0, 0, SWP_SHOWWINDOW | SWP_NOMOVE | SWP_NOSIZE);
-    // Redraw to prevent the window blank
-    RedrawWindow(hwnd, NULL, 0, RDW_FRAME | RDW_INVALIDATE | RDW_ALLCHILDREN);
-}
-
-void RWindow::lower() const {
-
-}
Author	SHA1	Message	Date
josh	4b2aeea2ca	Temp Work Some checks failed Run ReCI Build Test / Explore-Gitea-Actions (push) Failing after 6m28s Details	2024-12-06 11:50:20 -05:00
josh	feacea61b1	Fix Mouse Button errors, implement MouseWheel events Some checks failed Run ReCI Build Test / Explore-Gitea-Actions (push) Failing after 6m30s Details	2024-12-04 10:17:10 -05:00
josh	a3adbb6266	Fix Mouse Button errors, implement MouseWheel events All checks were successful Run ReCI Build Test / Explore-Gitea-Actions (push) Successful in 1m42s Details	2024-12-03 21:24:50 -05:00
maxine	b75f44f1ee	Fix IsMouseButtonDown infinite loop All checks were successful Run ReCI Build Test / Explore-Gitea-Actions (push) Successful in 1m39s Details	2024-12-03 19:39:58 -05:00
josh	e4e860564c	Fix RWindow::SetResizable on linux/X-server All checks were successful Run ReCI Build Test / Explore-Gitea-Actions (push) Successful in 1m38s Details	2024-12-03 19:19:51 -05:00
josh	fb6825224f	Fix RWindow::SetResizable on linux/X-server	2024-12-03 19:16:43 -05:00
Redacted	6b9bf4c2cc	Update window.cpp All checks were successful Run ReCI Build Test / Explore-Gitea-Actions (push) Successful in 2m0s Details fix the types not being convertable on loonix	2024-12-01 17:36:56 -05:00
Redacted	f25370cada	Make it atleast start on Windows again. Some checks failed Run ReCI Build Test / Explore-Gitea-Actions (push) Failing after 1m53s Details TODO fix the mouse buttons and keyboard input. They currently segfault the program.	2024-12-01 22:31:08 -05:00
josh	f826b2a268	Other Minor Edits Some checks failed Run ReCI Build Test / Explore-Gitea-Actions (push) Failing after 6m14s Details	2024-11-04 11:56:13 -05:00
josh	5dfa0fe114	Additional Commentary Some checks failed Run ReCI Build Test / Explore-Gitea-Actions (push) Failing after 1m33s Details	2024-11-01 15:44:06 -04:00
josh	216b7218e6	Try and fix conflicts All checks were successful Run ReCI Build Test / Explore-Gitea-Actions (push) Successful in 2m11s Details	2024-11-01 14:12:39 -04:00
josh	dc466e695f	Merge remote-tracking branch 'origin/main' # Conflicts: # include/rewindow/types/window.h # src/platform/shared/window.cpp	2024-11-01 14:08:46 -04:00
josh	a4322c4b21	Refactoring RWindow class to support usage in ReCaveGame	2024-11-01 14:01:58 -04:00
Redacted	db63cc2272	Update window.cpp All checks were successful Run ReCI Build Test / Explore-Gitea-Actions (push) Successful in 3m25s Details	2024-10-14 21:37:44 -04:00
Redacted	1d9424a243	Merge branch 'main' of https://git.redacted.cc/Redacted/ReWindow Some checks failed Run ReCI Build Test / Explore-Gitea-Actions (push) Has been cancelled Details	2024-10-14 21:24:22 -04:00
Redacted	2e0d84d559	getGraphicsDriverVendor	2024-10-14 21:24:20 -04:00
Josh	cc2cc6f7c1	Fix build error, migrate to new event delegation system. All checks were successful Run ReCI Build Test / Explore-Gitea-Actions (push) Successful in 4m43s Details	2024-10-11 11:39:39 -04:00
Redacted	fb6ed84b76	Update to newest J3ML All checks were successful Run ReCI Build Test / Explore-Gitea-Actions (push) Successful in 5m40s Details	2024-10-10 12:21:53 -04:00
Redacted	3085ad21a9	Update .gitea/workflows/buildtest.yml All checks were successful Run ReCI Build Test / Explore-Gitea-Actions (push) Successful in 1m28s Details	2024-10-04 23:32:02 -04:00
josh	35b09cb026	Implement rolling average (last 5 frames) of FPS Some checks failed Run ReCI Build Test / Explore-Gitea-Actions (push) Failing after 1m48s Details	2024-10-04 14:19:10 -04:00
josh	6bd9ec0eb8	Adjust member-variable signatures on window class Some checks failed Run ReCI Build Test / Explore-Gitea-Actions (push) Failing after 1m55s Details	2024-10-04 12:30:40 -04:00
josh	ae073b3a96	Another one Some checks failed Run ReCI Build Test / Explore-Gitea-Actions (push) Failing after 1m22s Details	2024-09-30 23:49:11 -04:00
josh	48091496d5	Overlooked a stupid in refresh_rate calculation. Some checks failed Run ReCI Build Test / Explore-Gitea-Actions (push) Failing after 1m27s Details	2024-09-30 23:41:39 -04:00
josh	c202ca5c84	Migrate timekeeping-related member variables to protected scope. Some checks failed Run ReCI Build Test / Explore-Gitea-Actions (push) Failing after 1m43s Details	2024-09-30 23:35:06 -04:00
josh	c5f94b7c49	More small refactors. Some checks failed Run ReCI Build Test / Explore-Gitea-Actions (push) Failing after 2m32s Details	2024-09-26 12:38:58 -04:00
josh	b351577a20	Refactors Some checks failed Run ReCI Build Test / Explore-Gitea-Actions (push) Failing after 1m53s Details	2024-09-26 00:39:05 -05:00
josh	fb3a77e2e3	Implement timekeeping for OnRefresh, fix duplicate event firing. Some checks failed Run ReCI Build Test / Explore-Gitea-Actions (push) Failing after 2m11s Details	2024-09-24 21:40:00 -04:00
Redacted	b96dd03af1	Update window.cpp Some checks failed Run ReCI Build Test / Explore-Gitea-Actions (push) Failing after 1m34s Details Only ask X11 where the cursor is once per frame.	2024-09-21 12:38:19 -04:00
Redacted	3e99394b6f	Performance speedup. Some checks failed Run ReCI Build Test / Explore-Gitea-Actions (push) Failing after 2m17s Details	2024-09-20 13:35:07 -04:00
Redacted	5b10e55f83	Update window.cpp Some checks failed Run ReCI Build Test / Explore-Gitea-Actions (push) Failing after 5m46s Details speedup for resize event.	2024-09-20 08:44:38 -04:00
Redacted	c0dc56bc8c	Update main.cpp Some checks failed Run ReCI Build Test / Explore-Gitea-Actions (push) Failing after 1m30s Details fix for msvc	2024-09-14 22:11:50 -04:00
maxine	a62c576d14	event and jlog update Some checks failed Run ReCI Build Test / Explore-Gitea-Actions (push) Failing after 1m35s Details	2024-09-12 20:54:42 -04:00
maxine	92b567e48f	fix https://git.redacted.cc/Redacted/ReWindow.git using rebitch Some checks failed Run ReCI Build Test / Explore-Gitea-Actions (push) Failing after 1m26s Details	2024-08-26 19:48:17 -04:00
maxine	3617d610ea	Merge pull request 'brokenbullshit' (#12 ) from brokenbullshit into main Some checks failed Run ReCI Build Test / Explore-Gitea-Actions (push) Failing after 1m56s Details Reviewed-on: #12	2024-08-23 11:01:00 -04:00
maxine	9500681420	fixed to use new JLog and Event APIs. New ReWindow specific logger too. Should be able to toggle it on and off in programs that use ReWindow as a dependency and still have other loggers working. Some checks failed Run ReCI Build Test / Explore-Gitea-Actions (push) Failing after 6m48s Details	2024-08-23 11:02:03 -04:00
Redacted	bf41652336	Update CMakeLists.txt Some checks failed Run ReCI Build Test / Explore-Gitea-Actions (push) Failing after 5m39s Details Still broken but closer I guess.	2024-08-22 12:45:54 -04:00
maxine	68ae72e6be	broken SHIT Some checks failed Run ReCI Build Test / Explore-Gitea-Actions (push) Failing after 6m13s Details	2024-08-22 12:00:26 -04:00
Redacted	a4b68a5abc	Update display.cpp Some checks failed Run ReCI Build Test / Explore-Gitea-Actions (push) Failing after 6m21s Details both displays	2024-08-13 13:21:22 -04:00
josh	1345669c32	Add Aspect ratio output Some checks failed Run ReCI Build Test / Explore-Gitea-Actions (push) Failing after 6m31s Details	2024-08-13 12:52:57 -04:00
josh	9d51ac0026	Test Info Output Format Some checks failed Run ReCI Build Test / Explore-Gitea-Actions (push) Has been cancelled Details	2024-08-13 12:48:27 -04:00
Redacted	edb2e29246	poll for graphics modes. Some checks failed Run ReCI Build Test / Explore-Gitea-Actions (push) Failing after 4m48s Details	2024-08-13 12:41:29 -04:00
Redacted	bed600d4d4	Make resizing on windows actually send the event. All checks were successful Run ReCI Build Test / Explore-Gitea-Actions (push) Successful in 1m36s Details	2024-08-10 23:43:15 -04:00
Redacted	acf66ae909	When the cursor is hidden, Still show it on the title bar (WINDOWS) All checks were successful Run ReCI Build Test / Explore-Gitea-Actions (push) Successful in 1m25s Details	2024-08-09 19:01:38 -04:00
Redacted	c319acfffb	Set cursor visible (Linux) All checks were successful Run ReCI Build Test / Explore-Gitea-Actions (push) Successful in 24m43s Details	2024-08-08 20:43:27 -04:00
Redacted	9b810101a4	Set cursor visible (windows) All checks were successful Run ReCI Build Test / Explore-Gitea-Actions (push) Successful in 1m32s Details	2024-08-08 20:26:25 -04:00
Redacted	4c616d68af	make it actually work kkthx All checks were successful Run ReCI Build Test / Explore-Gitea-Actions (push) Successful in 6m4s Details	2024-08-08 14:49:08 -04:00
Redacted	4571016c4c	Update window.h All checks were successful Run ReCI Build Test / Explore-Gitea-Actions (push) Successful in 6m9s Details	2024-08-08 14:33:14 -04:00
Redacted	a8c85a29dd	idk Some checks failed Run ReCI Build Test / Explore-Gitea-Actions (push) Failing after 5m27s Details	2024-08-08 14:24:15 -04:00
Redacted	483b5dadad	WINDOZEEEEEEEEEEEEEEEEEEEEEEEEEEEE All checks were successful Run ReCI Build Test / Explore-Gitea-Actions (push) Successful in 7m11s Details	2024-08-07 23:49:11 -04:00
josh	9565bfeef9	Merge remote-tracking branch 'origin/main' All checks were successful Run ReCI Build Test / Explore-Gitea-Actions (push) Successful in 1m27s Details	2024-08-05 18:28:35 -04:00
josh	e1fc2f289f	Migrated to J3ML 2.4	2024-08-05 18:28:30 -04:00
Redacted	7bc90af3d5	Update All checks were successful Run ReCI Build Test / Explore-Gitea-Actions (push) Successful in 4m10s Details	2024-08-05 13:35:39 -04:00
Redacted	d9ee8ebedc	Update window.cpp All checks were successful Run ReCI Build Test / Explore-Gitea-Actions (push) Successful in 4m1s Details	2024-08-05 11:58:29 -04:00
josh	94e61aa2ea	Changed MouseButton::operator==() to compare buttons via their ButtonIndices instead of CharCodes All checks were successful Run ReCI Build Test / Explore-Gitea-Actions (push) Successful in 1m16s Details	2024-07-30 16:41:37 -04:00
josh	c95ad0ee0d	Accidentally lost invokation of OnMouseMoveEvent, so we're re-adding it. All checks were successful Run ReCI Build Test / Explore-Gitea-Actions (push) Successful in 4m29s Details	2024-07-30 15:02:45 -04:00
maxine	3b3d1ba197	should be all deps for ubuntu All checks were successful Run ReCI Build Test / Explore-Gitea-Actions (push) Successful in 1m32s Details	2024-07-29 20:19:04 -04:00
maxine	1542224ffc	Merge remote-tracking branch 'refs/remotes/origin/main' Some checks failed Run ReCI Build Test / Explore-Gitea-Actions (push) Failing after 48s Details reci shit	2024-07-29 20:15:03 -04:00
maxine	8d92abdecf	use ubuntu names	2024-07-29 20:14:51 -04:00
maxine	9247472a13	use ubuntu names Some checks failed Run ReCI Build Test / Explore-Gitea-Actions (push) Has been cancelled Details	2024-07-29 20:08:42 -04:00
josh	7e5d85c88a	Merge pull request 'Input Class Refactoring' (#11 ) from litandbased_refactors into main Some checks failed Run ReCI Build Test / Explore-Gitea-Actions (push) Failing after 50s Details Reviewed-on: #11	2024-07-29 20:08:00 -04:00
maxine	7dad83bbc1	reci test Some checks failed Run ReCI Build Test / Explore-Gitea-Actions (push) Failing after 45s Details	2024-07-29 20:07:32 -04:00
maxine	c18fd72b74	reci test Some checks failed Run ReCI Build Test / Explore-Gitea-Actions (push) Failing after 43s Details	2024-07-29 20:06:36 -04:00
maxine	663109da75	reci	2024-07-29 20:02:52 -04:00
josh	c7a2b42f1d	Implement operator == on MouseButton class	2024-07-29 19:53:50 -04:00
josh	1f81c0b843	More small refactoring	2024-07-29 18:54:56 -04:00
josh	c25983a87d	Random refactoring of the input systems.	2024-07-29 18:22:23 -04:00
josh	1b02dcc364	Small oopsie.	2024-07-17 00:44:10 -04:00
josh	254f991c49	Made sure all event raisers were implemented, implemented getLastKnownResize()	2024-07-17 00:41:56 -04:00
josh	b4c4827c9c	Adding dev notes and documenting the public API.	2024-07-15 13:01:27 -04:00
Redacted	ebf939d747	Add missing keys	2024-07-03 12:15:17 -04:00
Redacted	04c82df9c5	Fix window resize on windows	2024-07-02 12:41:32 -04:00
Redacted	2f0cedcd04	Windows smh	2024-07-01 14:58:55 -04:00
Redacted	a215d9f398	Merge branch 'latest' of https://git.redacted.cc/Redacted/ReWindow into latest	2024-06-28 19:39:41 -04:00
Redacted	a3697cd022	Refactor	2024-06-28 19:39:20 -04:00
Redacted	68a1f52515	Refactor	2024-06-28 19:32:45 -04:00
Redacted	8f8eabfe47	Update CMakeLists.txt	2024-06-26 23:27:20 -04:00
Redacted	a4ec53fdd9	Update CMakeLists.txt	2024-06-26 23:25:18 -04:00
Redacted	c0ecb08a3b	Update window.cpp Fix use after free	2024-06-21 16:24:38 -04:00
maxine	7d2921f598	Started adding DEBUG logging to library code. Wrote RWindowFlagToStr function for better logging capabilities.	2024-06-19 16:15:29 -04:00
maxine	850fe4aabb	Redid some log formatting.	2024-06-19 15:02:51 -04:00
maxine	80904cf4b1	Added DEBUG logging to main.cpp. Implemented getWidth and getSize for RWindow.	2024-06-19 14:59:17 -04:00
maxine	b6bb00e0de	Updated to use jlog prerelease-8. Adjusted as necessary.	2024-06-19 13:58:47 -04:00
Redacted	cb03a67f17	fix OnKeyDown	2024-06-18 21:19:38 -04:00
Redacted	f8f9e78dab	Update CMakeLists.txt	2024-06-18 14:30:34 -04:00
Redacted	214c3e72fd	Update window.cpp key repeat fix	2024-06-18 14:03:25 -04:00
Redacted	f6b9bae45f	Winblows keydown & keyup	2024-06-18 10:38:17 -07:00
Redacted	074f0235c0	Merge branch 'windows-test'	2024-06-18 02:25:38 -04:00
Redacted	adec224701	Push	2024-06-18 01:15:23 -04:00
Redacted	5b8788f94f	Restructure	2024-06-17 22:50:38 -04:00
Redacted	56fdc3d90b	gut	2024-06-17 22:15:20 -04:00
Redacted	3adef96da7	initial	2024-06-16 23:35:10 -07:00
Redacted	2956c0b350	Initial commit	2024-06-16 20:39:13 -07:00
Redacted	50a7e2cfe1	Fix "ISO C++ 11 does not allow converting from string literal to char*"	2024-06-16 21:52:15 -04:00
Redacted	10a63d738c	Update main.cpp	2024-06-16 20:47:54 -04:00
maxbyte9p	b914e9b563	updated CMakeLists.txt to use jlog prerelease-3. Made input event logging use SDEBUG from jlog prerelease-3	2024-06-15 21:17:04 -04:00
maxbyte9p	4fb237f11a	Incorporated jlog for input event logging. Side mouse button reading possibly having issues.	2024-06-14 16:23:21 -04:00
maxbyte9p	dfbf018807	made CharCode char* for printing the funny unicode arrows for arrow keys	2024-06-14 15:19:26 -04:00
Redacted	ee5b2f18cd	lol	2024-06-11 20:12:32 -04:00
Redacted	4336b2bfc9	Revert "Maybe?" This reverts commit `4d587f9448`.	2024-06-11 20:12:03 -04:00
Redacted	4d587f9448	Maybe?	2024-06-11 20:02:22 -04:00
maxbyte9p	b73cc46ecb	Gamepad scancodes harvested from some Xbox controller clone.	2024-06-07 16:15:27 -04:00
Redacted	f5be8b2707	Update CMakeLists.txt	2024-06-01 19:33:59 -04:00
Redacted	39990e587b	Update CMakeLists.txt	2024-05-23 19:33:53 -04:00
Redacted	51d370e045	Update CMakeLists.txt	2024-05-22 20:34:33 -04:00
Redacted	4ee4cafad7	Update CMakeLists.txt	2024-05-22 20:15:36 -04:00
maxbyte9p	e1c0cdd1a2	Fixed left and right shift scan codes	2024-05-22 13:51:57 -04:00
maxbyte9p	7b149594fe	Make window start as a floating window because fuck i3	2024-05-22 13:39:22 -04:00
Redacted	350b12aa6d	Update CMakeLists.txt	2024-05-22 12:19:16 -04:00
josh	a8da7b6bdf	Update	2024-05-22 07:23:57 -07:00
Redacted	50ccfe3860	Update J3ML	2024-05-21 13:16:06 -04:00
orange bowler hat	3572ef01cd	More Windows Update Several minor changes to code and build setup Demo runs now	2024-05-13 23:14:04 +01:00
orange bowler hat	664d213c04	Several smaller updates Windows version of ReWindow now compiling Added to gitignore	2024-05-13 13:40:11 +01:00
Redacted	d3a971d598	Fix	2024-05-08 22:15:28 -04:00
orange bowler hat	52e1b6eb00	More Windows compatibility Almost everything addressed Couldn't figure out where the process handle is stored, if it is Some cpp problems about CursorStyle classes. I tried several ways to solve this but nothing seemed to work so I'm really not sure what its actually complaining about now	2024-05-09 00:00:32 +01:00
orange bowler hat	f47e6bc786	Lets try that last one again Comments as previous commit	2024-05-03 23:57:40 +01:00
orange bowler hat	1d9169679f	Updates to windows version Many changes to flesh out windows version of ReWindow. Incomplete, not compiled or tested. Almost certainly won't work as is but a lot closer to a functioning Windows version	2024-05-03 23:49:35 +01:00
Redacted	a7b7de93dd	fix cmake & vsync	2024-04-30 14:45:43 -07:00
orange bowler hat	124cbedf4d	Updates to windows version (Thanks Steven) Many changes to flesh out windows version of ReWindow. Incomplete, not compiled or tested. Almost certainly won't work as is but a lot closer to a functioning Windows version	2024-04-29 19:13:25 -04:00
orange bowler hat	4db3b5f908	Updates to windows version Many changes to flesh out windows version of ReWindow. Incomplete, not compiled or tested. Almost certainly won't work as is but a lot closer to a functioning Windows version	2024-04-29 23:03:35 +01:00
josh	9a4a4dddcc	Merge remote-tracking branch 'origin/main'	2024-04-09 16:38:49 -04:00
josh	04fa303a81	Migrate to J3ML Release 1	2024-04-09 16:38:39 -04:00
Redacted	4facfb11fa	Update window.cpp vsync fix	2024-03-26 11:47:59 -04:00
josh	ef257765fe	Migrate to J3ML v20	2024-03-21 13:05:09 -04:00
Redacted	5696dd4ed8	Un-break	2024-02-24 08:42:42 -05:00
Redacted	9f0a511022	Update CMakeLists.txt	2024-02-24 07:48:37 -05:00
josh	ffe49e4c67	Implement static GetMouseCoordinates() ?	2024-02-22 00:31:04 -05:00
				`@@ -0,0 +1 @@`
				`Main:new("Install build dependencies", "apt-get install -yq libx11-6 libx11-dev libgl-dev")`