Changed MouseButton::operator==() to compare buttons via their ButtonIndices instead of CharCodes

Accidentally lost invokation of OnMouseMoveEvent, so we're re-adding it.
should be all deps for ubuntu
2024-07-30 16:41:37 -04:00 · 2024-07-30 15:02:45 -04:00 · 2024-07-29 20:19:04 -04:00 · 2024-07-29 20:15:03 -04:00 · 2024-07-29 20:14:51 -04:00 · 2024-07-29 20:08:42 -04:00
28 changed files with 1816 additions and 352 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 && 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
@@ -10,37 +10,69 @@ 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/Release-2.2.zip
+)
+
+CPMAddPackage(
+    NAME Event
+    URL https://git.redacted.cc/josh/Event/archive/Release-6.zip
+)
+
+CPMAddPackage(
+        NAME jlog
+        URL https://git.redacted.cc/josh/jlog/archive/Prerelease-9.zip
+)
+
 find_package(OpenGL REQUIRED)
-include_directories({$OPENGL_INCLUDE_DIRS})
+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")

 if(UNIX AND NOT APPLE)
-    file(GLOB_RECURSE SOURCES "src/linux/*.cpp")
+    file(GLOB_RECURSE SOURCES "src/types/*.cpp" "src/platform/linux/*.cpp" "src/platform/shared/*.cpp")
 endif()

 if(WIN32)
-    file(GLOB_RECURSE SOURCES "src/windows/*.cpp")
+    file(GLOB_RECURSE SOURCES "src/types/*.cpp" "src/platform/windows/*.cpp" "src/platform/shared/*.cpp")
 endif()

 include_directories("include")
-add_library(ReWindowLibrary SHARED ${SOURCES})
+
+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)
+
 # Why god???
 set_target_properties(ReWindowLibrary PROPERTIES LINKER_LANGUAGE CXX)

 if(UNIX AND NOT APPLE)
-    target_link_libraries(ReWindowLibrary PUBLIC X11 ${OPENGL_LIBRARIES})
+    target_link_libraries(ReWindowLibrary PUBLIC X11 J3ML Event jlog ${OPENGL_LIBRARIES})
+    target_link_libraries(ReWindowLibrary PUBLIC)
+
    add_executable(ReWindowLibraryDemo main.cpp)
    target_link_libraries(ReWindowLibraryDemo PUBLIC ReWindowLibrary)
 endif()

 if(WIN32)
+    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
@@ -12,6 +12,7 @@ Install dependencies

 ```bash
  dnf install cmake make gcc-g++ libX11 libX11-devel
+  apt-get install cmake make gcc g++ libx11-6 libx11-dev libgl-dev
 ```

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

 ```bash
  ./ReWindowDemo
-```
+```
--- a/cmake/CPM.cmake
+++ b/cmake/CPM.cmake
@@ -0,0 +1,24 @@
+# SPDX-License-Identifier: MIT
+#
+# SPDX-FileCopyrightText: Copyright (c) 2019-2023 Lars Melchior and contributors
+
+set(CPM_DOWNLOAD_VERSION 0.38.7)
+set(CPM_HASH_SUM "83e5eb71b2bbb8b1f2ad38f1950287a057624e385c238f6087f94cdfc44af9c5")
+
+if(CPM_SOURCE_CACHE)
+    set(CPM_DOWNLOAD_LOCATION "${CPM_SOURCE_CACHE}/cpm/CPM_${CPM_DOWNLOAD_VERSION}.cmake")
+elseif(DEFINED ENV{CPM_SOURCE_CACHE})
+    set(CPM_DOWNLOAD_LOCATION "$ENV{CPM_SOURCE_CACHE}/cpm/CPM_${CPM_DOWNLOAD_VERSION}.cmake")
+else()
+    set(CPM_DOWNLOAD_LOCATION "${CMAKE_BINARY_DIR}/cmake/CPM_${CPM_DOWNLOAD_VERSION}.cmake")
+endif()
+
+# Expand relative path. This is important if the provided path contains a tilde (~)
+get_filename_component(CPM_DOWNLOAD_LOCATION ${CPM_DOWNLOAD_LOCATION} ABSOLUTE)
+
+file(DOWNLOAD
+        https://github.com/cpm-cmake/CPM.cmake/releases/download/v${CPM_DOWNLOAD_VERSION}/CPM.cmake
+        ${CPM_DOWNLOAD_LOCATION} EXPECTED_HASH SHA256=${CPM_HASH_SUM}
+)
+
+include(${CPM_DOWNLOAD_LOCATION})
--- 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
@@ -0,0 +1,107 @@
+#pragma once
+
+enum class WindowsScancode {
+    Nothing = 0,
+    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
@@ -1,11 +1,9 @@
-#pragma once
-#if __linux__
-#include <X11/Xlib.h>
-#include <chrono>
-#endif
+// @file X11Scancodes.h
+// @

-//This is also the x11 scancodes.
-enum class SCANCODE {
+#pragma once
+
+enum class X11Scancode {
    KP_0 = 90,
    KP_1 = 87,
    KP_2 = 88,
@@ -26,9 +24,10 @@ enum class SCANCODE {
    PAGEUP = 112,
    PAGEDOWN = 117,
    HOME = 110,
+    MENU = 135,
    END = 115,
    INSERT = 118,
-    DELETE = 119,
+    DEL = 119,
    UP = 111,
    DOWN = 116,
    LEFT = 113,
@@ -93,54 +92,20 @@ enum class SCANCODE {
    SUPER = 133,
    LEFT_CTRL = 37,
    ESCAPE = 9,
-    FUNCTION_ONE = 67,
-    FUNCTION_TWO = 68,
-    FUNCTION_THREE = 69,
-    FUNCTION_FOUR = 70,
-    FUNCTION_FIVE = 71,
-    FUNCTION_SIX = 72,
-    FUNCTION_SEVEN = 73,
-    FUNCTION_EIGHT = 74,
-    FUNCTION_NINE = 75,
-    FUNCTION_TEN = 76,
-    FUNCTION_ELEVEN = 77,
-    FUNCTION_TWELVE = 78,
+    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,
-};

-enum class MOUSEBUTTONCODE {
-    LEFT_CLICK = 1,
-    MIDDLE_CLICK = 2,
-    RIGHT_CLICK = 3,
-    SCROLL_UP = 4,
-    SCROLL_DOWN = 5,
-    SIDE_FORWARD = 9,
-    SIDE_BACK = 8
 };
-
-class RWindowEvent {
-private:
-    std::chrono::high_resolution_clock::time_point timePoint;
-public:
-    std::chrono::high_resolution_clock::time_point timeStamp();
-    virtual ~RWindowEvent() = default;
-    virtual bool empty();
-    RWindowEvent() {
-        timePoint = std::chrono::high_resolution_clock::now();
-    }
-};
-const RWindowEvent EmptyRWindowEvent;
-
-class KeyDownEvent : public RWindowEvent {
-public:
-    SCANCODE key;
-};
-const KeyDownEvent EmptyKeyDownEvent{};
-
-class MouseButtonDownEvent : public RWindowEvent {
-public:
-    MOUSEBUTTONCODE button;
-};
-const MouseButtonDownEvent EmptyMouseButtonDownEvent{};
--- a/include/rewindow/types/cursors.h
+++ b/include/rewindow/types/cursors.h
@@ -0,0 +1,80 @@
+#pragma once
+
+#if __linux__
+#include <X11/cursorfont.h>
+#endif
+
+namespace ReWindow
+{
+#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
+	};
+
+	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};
+	}
+
+#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/gamepad.h
+++ b/include/rewindow/types/gamepad.h
@@ -0,0 +1,26 @@
+/// 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
+    {
+
+    };
+
+
+    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.h>
+
+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/key.h
+++ b/include/rewindow/types/key.h
@@ -0,0 +1,156 @@
+//
+// ~DAWSH
+#pragma once
+
+#include <vector>
+#include <stdexcept>
+#include <iostream>
+#include <string>
+#include <rewindow/data/X11Scancodes.h>
+#include <rewindow/data/WindowsScancodes.h>
+#include <J3ML/LinearAlgebra/Vector2.h>
+
+using J3ML::LinearAlgebra::Vector2;
+
+class Key
+{
+private:
+    //CLion on Linux falsely marks this as being wrong.
+    static inline std::vector<Key> keyboard{};
+
+public:
+    static std::vector<Key> GetKeyboard();
+    Key();
+    Key(const char* charcode, X11Scancode scancode, WindowsScancode wSc);
+    const char* CharCode;
+    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 {"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};
+
+    //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 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 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 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 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 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 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};
+
+    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 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};
+
+}
+
+
+
+
+
+Key GetKeyFromX11Scancode(X11Scancode code);
+Key GetKeyFromWindowsScancode(WindowsScancode code);
--- a/include/rewindow/types/keyboard.h
+++ b/include/rewindow/types/keyboard.h
@@ -0,0 +1,22 @@
+/// 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
+
+
+namespace ReWindow
+{
+    class InputDevice {};
+
+    class Keyboard : public InputDevice
+    {
+
+    };
+}
--- a/include/rewindow/types/mouse.h
+++ b/include/rewindow/types/mouse.h
@@ -0,0 +1,26 @@
+/// 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
+
+
+namespace ReWindow
+{
+
+    class InputDevice {}; // TODO: Remember to break InputDevice into it's own file and not define it twice!!!
+
+    class Pointer : public InputDevice {};
+
+
+    class Mouse : public Pointer
+    {
+
+    };
+}
--- a/include/rewindow/types/mousebutton.h
+++ b/include/rewindow/types/mousebutton.h
@@ -0,0 +1,38 @@
+/// 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
+
+
+class MouseButton {
+public:
+    MouseButton();
+    explicit MouseButton(const char* charcode, unsigned int index);
+    const char* CharCode;
+    unsigned int ButtonIndex;
+    bool operator == (const MouseButton& mb) const;
+};
+
+
+namespace MouseButtons
+{
+    static const MouseButton Left {"l", 1};
+    static const MouseButton Right {"r", 2};
+    static const MouseButton Middle {"m", 3};
+    static const MouseButton MWheelUp {"1", 4};
+    static const MouseButton MWheelDown {"2", 5};
+    static const MouseButton Mouse4 {"4", 8};
+    static const MouseButton Mouse5 {"5", 9};
+    static const MouseButton Unimplemented {"u", 0};
+}
+
+MouseButton GetMouseButtonFromXButton(unsigned int button);
+
+
--- a/include/rewindow/types/window.h
+++ b/include/rewindow/types/window.h
@@ -1,50 +1,289 @@
 #pragma once
 #include <cstdint>
 #include <vector>
-#include <memory>
-#include "event.h"
+#include <Event.h>
+#include <map>
+#include <thread>
+#include <rewindow/types/key.h>
+#include <rewindow/types/cursors.h>
+#include <rewindow/types/mousebutton.h>
+#include <rewindow/types/gamepadbutton.h>

-#if __linux__
-#include <X11/Xlib.h>
-#include <X11/Xutil.h>
-#include <GL/gl.h>
-#include <GL/glx.h>
-#endif
+using namespace std::chrono_literals;
+using precision_clock = std::chrono::high_resolution_clock;
+using precision_timestamp = precision_clock::time_point;

 enum class RWindowFlags: uint8_t {
-    IN_FOCUS = 0,
-    FULLSCREEN = 1,
-    RESIZABLE = 2,
-    VSYNC = 3
+	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,
 };

-class RWindow {
-private:
-    bool flags[4];
-    std::vector<RWindowEvent*> events;
-public:
-    bool getFlag(RWindowFlags flag);
-    void setFlag(RWindowFlags flag, bool state);
-    void init(RenderingAPI api, const char* title, int width, int height, bool vsync);
-    static void setVsyncEnabled(bool b);
-    void destroyWindow();
-    void pollEvents();
-    void setSize(int width, int height);
-    std::unique_ptr<int[]> getPos();
-    std::unique_ptr<int[]> getSize();
-    void setPos(int x, int y);
-    bool keyDown(SCANCODE scancode);
-    bool mouseButtonDown(MOUSEBUTTONCODE buttoncode);
-    KeyDownEvent getEvent(SCANCODE scancode);
-    MouseButtonDownEvent getEvent(MOUSEBUTTONCODE buttoncode);
-    static void glSwapBuffers();
-    //Initialize to false because it's not guaranteed that they will be cleared first
-    RWindow() : flags(false,false,false,false) {}
+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;
+			MouseButtonDownEvent(MouseButton Button) : MouseEvent() {}
+		};
+
+		class MouseButtonUpEvent : public MouseEvent {
+		public:
+			MouseButton Button;
+		};
+
+		class WindowResizeRequestEvent : public RWindowEvent
+		{
+		public:
+			Vector2 Size;
+		};
+	}
+
+	using namespace WindowEvents;
+
+
+	/// General To Do List
+	/// TODO: Implement accurate timekeeping on refresh. Have mechanism to expose to user (hook into their game engine's timestepping)
+	/// TODO: Clean up public API to express the cross-platform, multi-graphics-mode ethos of this project.
+	///
+
+	class RWindow {
+	public:
+
+		/// We keep and support both mechanisms for extending behavior to suit:
+		/// 1. Derived windows with added functionality.
+		/// 2. Binding functions to a pre-existing window.
+#pragma region Callbacks
+		/// Bindable Non-intrusive event handlers
+		/// Use these when you can't override the base window class
+		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;
+#pragma endregion
+#pragma region Overrides
+		/// Intrusive virtual methods intended to be overridden in a derived class.
+		/// Do not stuff any logic into these. Someone WILL override it and forget to call the base.
+
+        /// Called upon the window requesting to open.
+		virtual void OnOpen() {}
+        /// Called right before the window closes.
+        virtual void OnClosing() {}
+		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
+
+		/// 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);
+
+		/// Returns a Vector2 representing mouse coordinates relative to the top-left corner of the window.
+		Vector2 GetMouseCoordinates() const;
+
+		// TODO: Is this part of the API interface? Can it be moved to protected?
+		void liftKey (Key key);
+
+		// TODO: Is this part of the API interface? Can it be moved to protected?
+		void pressKey (Key key);
+
+		/// Sets which rendering API is to be used with this window.
+		void setRenderer(RenderingAPI api);
+
+		/// Initializes all state with the window manager and rendering API, then opens the window.
+		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
+
+		/// Returns whether the window currently has mouse and/or keyboard focus.
+		bool isFocused() const;
+		bool isFullscreen() const;
+		bool isResizable() const;
+		bool isVsyncEnabled() const;
+
+		bool isAlive() const; // TODO: Always returns true.
+
+		/// Sets whether the mouse is visible when inside the window.
+		void setMouseVisible(bool visible);
+		void setMouseLocked();
+		void setMouseCenter();
+		void restoreMouseFromLastCenter(); // Feels nicer for users
+
+		bool isKeyDown(Key key) const;
+		bool isMouseButtonDown(MouseButton button) const;
+
+		void setFullscreen(bool fs);
+		void setResizable(bool resizable);
+		void setVsyncEnabled(bool);
+		void setTitle(const std::string& title);
+		std::string getTitle() const;
+		int getWidth() const;  // Honestly no idea if we'll keep these or still go with getSize.
+		int getHeight() const; // getSize wasn't working for me for logging. -maxine
+
+		// TODO: Move out of public API, consumers should use setFullscreen()
+		void fullscreen();
+		// TODO: Move out of public API, consumers should use setFullscreen()
+		void restoreFromFullscreen();
+
+		// 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);
+		//void init(RenderingAPI api, const char* title, int width, int height, bool vsync);
+
+		/// Tells the underlying window manager to destroy this window and drop the handle.
+		/// The window, in theory, can not be re-opened after this.
+		/// TODO: Create a destructor and move to there?
+		/// TODO: What's the semantic difference between this and Close()?
+		void destroyWindow();
+
+		/// Reads events from the underlying window manager.
+		/// TODO: Move out of public API, consumers should call refresh or ideally an update() call.
+		void pollEvents();
+
+		/// Updates the window and handles timing internally.
+		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;
+		// I want to know why this is made platform specific. Is that even necessary? -maxine
+		// Because each OS / WM implements it with a different API. - josh
+		// If we stored ourselves a copy (accurately) of the window's size, we could implement it into the shared layer
+		// But this is at BEST, unreliable.
+		Vector2 getSize() const;
+
+		void setPos(int x, int y);
+		void setPos(const Vector2& pos);
+		Vector2 getCursorPos() const;
+
+		/// Pull the window to the top, such that it is displayed on top of everything else.
+		/// NOTE: The implementation is window-manager defined, 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 window-manager defined, and thus there is no guarantee of it always working.
+		void lower() const;
+		void setCursorStyle(CursorStyle style) const;
+		void setCursorCustomIcon() const;
+
+		/// Calls OpenGL's SwapBuffers routine.
+		/// NOTE: This is only used when the underlying rendering API is set to OpenGL.
+		static void glSwapBuffers();
+        Vector2 getLastKnownResize() const;
+	private:
+		Vector2 lastKnownWindowSize {0, 0};
+		bool flags[5];
+		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;
+		bool open = false;
+		bool resizable;
+
+
+    };
+}
--- a/main.cpp
+++ b/main.cpp
@@ -1,27 +1,82 @@
 #include <iostream>
-#include "include/rewindow/types/window.h"
+#include <rewindow/types/window.h>
+#include <jlog/jlog.hpp>
+
+
+Vector2 mouse_pos;
+
+// TODO: Move to J3ML::LinearAlgebra::Vector2
+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) {}
+
+	void OnMouseMove(const ReWindow::MouseMoveEvent& e) override {}
+
+	void OnKeyDown(const ReWindow::KeyDownEvent& e) override {}
+
+	void OnRefresh(float elapsed) override {
+		glSwapBuffers();
+		auto pos = getCursorPos();
+		//std::cout << pos.x << ", " << pos.y << std::endl;
+	}
+
+	bool OnResizeRequest(const ReWindow::WindowResizeRequestEvent& e) override {
+		std::cout << "resized to " << e.Size.x << ", " << e.Size.y << std::endl;
+		return true;
+	}
+};
+
 int main() {
-    auto* window = new(RWindow);
-    window->init(RenderingAPI::OPENGL, "name",1152,864, false);
-    window->setFlag(RWindowFlags::RESIZABLE, false);
-    int i;
-    while (true) {
-        if (i <= 10)
-        window->pollEvents();
-        window->glSwapBuffers();
-        i++;
-        std::cout << i << std::endl;
-        if (window->keyDown(SCANCODE::A)) {
-            std::cout << "A" << std::endl;
-            std::cout << (int64_t) window->getEvent(SCANCODE::A).empty() << std::endl;
-        }
-        if (window->mouseButtonDown(MOUSEBUTTONCODE::LEFT_CLICK))
-            std::cout << window->mouseButtonDown(MOUSEBUTTONCODE::LEFT_CLICK) << std::endl;
-        //std::cout << window->events.size() << std::endl;
-        //window->resize(800,600);
-        //std::cout << window->getPos()[1] << std::endl;
-        //auto* d = new(KeyDownEvent);
-        //d->key = SCANCODE::A;
-        //window->events.push_back(d);
-    }
-}
+	auto* window = new MyWindow("Test Window", 600, 480);
+	DEBUG(std::format("New window '{}' created. width={} height={}", window->getTitle(), window->getWidth(), window->getHeight()));
+
+	window->setRenderer(RenderingAPI::OPENGL);
+	DEBUG(std::format("Rendering API OPENGL set for window '{}'", window->getTitle()));
+
+	window->Open();
+	DEBUG(std::format("Opened window '{}'", window->getTitle()));
+
+	// TODO: Cannot set flags until after window is open
+	// Make this work somehow
+	DEBUG("TODO: Cannot set flags until after window is open")
+	window->setFullscreen(false);
+	window->setVsyncEnabled(false);
+	window->setResizable(true);
+	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) {
+        DEBUG(e.key.CharCode);
+	};
+
+	window->OnMouseButtonDownEvent += [&] (ReWindow::MouseButtonDownEvent e) {
+		DEBUG(e.Button.CharCode);
+	};
+
+	while (window->isAlive()) {
+		window->pollEvents();
+		window->refresh();
+	}
+}
+
+//Windows :(
+#ifdef _WIN32
+#ifndef UNICODE
+#define UNICODE
+#endif
+
+extern "C" {
+	int wmain(int argc, wchar_t* argv[]) {
+		return main();
+	}
+}
+#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/event.cpp
+++ b/src/linux/event.cpp
@@ -1,10 +0,0 @@
-#include "../include/rewindow/types/event.h"
-bool RWindowEvent::empty() {
-    if (timePoint == EmptyRWindowEvent.timePoint || this->timePoint == EmptyKeyDownEvent.timePoint || this->timePoint == EmptyMouseButtonDownEvent.timePoint)
-        return true;
-    return false;
-}
-
-std::chrono::high_resolution_clock::time_point RWindowEvent::timeStamp() {
-    return timePoint;
-}
--- a/src/linux/window.cpp
+++ b/src/linux/window.cpp
@@ -1,213 +0,0 @@
-#include <iostream>
-#include "rewindow/types/window.h"
-
-bool vsync = false;
-Window window;
-XEvent xev;
-Display* display = XOpenDisplay(nullptr);
-int defaultScreen = DefaultScreen(display);
-//Visual* visual = DefaultVisual(display,defaultScreen);
-XVisualInfo* visual;
-//int depth = DefaultDepth(display, defaultScreen);
-XSetWindowAttributes xSetWindowAttributes;
-XWindowAttributes windowAttributes;
-Atom wmDeleteWindow;
-XSizeHints hints;
-GLXContext glContext;
-PFNGLXSWAPINTERVALEXTPROC glXSwapIntervalEXT = nullptr;
-
-void RWindow::init(RenderingAPI api, const char* title, int width, int height, bool sync) {
-    if (api == RenderingAPI::OPENGL) {
-    xSetWindowAttributes.border_pixel = BlackPixel(display, defaultScreen);
-    xSetWindowAttributes.background_pixel = BlackPixel(display, defaultScreen);
-    xSetWindowAttributes.override_redirect = True;
-    xSetWindowAttributes.event_mask = ExposureMask;
-        GLint glAttributes[] = {GLX_RGBA, GLX_DEPTH_SIZE, 24, GLX_DOUBLEBUFFER, None};
-        visual = glXChooseVisual(display, defaultScreen, glAttributes);
-        glContext = glXCreateContext(display, visual, nullptr, GL_TRUE);
-        vsync = sync;
-        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 |
-                     Button1MotionMask | Button2MotionMask | Button3MotionMask | Button4MotionMask | Button5MotionMask |
-                     PointerMotionHintMask | FocusChangeMask | StructureNotifyMask | SubstructureRedirectMask |
-                     SubstructureNotifyMask | CWColormap);
-        XMapWindow(display, window);
-        XStoreName(display, window, title);
-        wmDeleteWindow = XInternAtom(display, "WM_DELETE_WINDOW", False);
-        XSetWMProtocols(display, window, &wmDeleteWindow, 1);
-        glXMakeCurrent(display, window, glContext);
-    } else {exit(0);}
-}
-
-void RWindow::destroyWindow() {
-    XDestroySubwindows(display, window);
-    XAutoRepeatOn(XOpenDisplay(nullptr));
-    XDestroyWindow(display, window);
-    delete this;
-}
-
-bool RWindow::getFlag(RWindowFlags flag) {
-    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);
-            setFlag(RWindowFlags::IN_FOCUS, true);
-        }
-
-        if (xev.type == FocusOut) {
-            XAutoRepeatOn(display);
-            setFlag(RWindowFlags::IN_FOCUS, false);
-        }
-
-        if (xev.type == KeyRelease) {
-            for (unsigned int i = 0; i < events.size(); i++) {
-                if (auto *e = dynamic_cast<KeyDownEvent *>(events[i])) {
-                    if ((int) e->key == (int) xev.xkey.keycode) {
-                        delete events[i];
-                        events.erase(events.begin() + i);
-                    }
-                }
-            }
-        }
-
-        if (xev.type == KeyPress) {
-            //On Windows you'll have to do this the long way.
-            //The keycodes won't be the same :shrug:
-            auto *kD = new(KeyDownEvent);
-            kD->key = (SCANCODE) xev.xkey.keycode;
-            events.push_back(kD);
-        }
-
-        if (xev.type == ButtonRelease) {
-            for (unsigned int i = 0; i < events.size(); i++) {
-                if (auto *e = dynamic_cast<MouseButtonDownEvent *>(events[i])) {
-                    if ((int) e->button == (int) xev.xbutton.button) {
-                        delete events[i];
-                        events.erase(events.begin() + i);
-                    }
-                }
-            }
-        }
-
-        if (xev.type == ButtonPress) {
-            std::cout << (int) xev.xbutton.button << std::endl;
-            auto *mBD = new(MouseButtonDownEvent);
-            mBD->button = (MOUSEBUTTONCODE) xev.xbutton.button;
-            events.push_back(mBD);
-        }
-
-        if (xev.type == Expose) {
-        }
-    }
-}
-
-//Might make the window go off the screen on some window managers.
-void RWindow::setSize(int width, int height) {
-    if (!getFlag(RWindowFlags::RESIZABLE))
-        return;
-    XResizeWindow(display, window, width, height);
-}
-
-std::unique_ptr<int[]> RWindow::getSize() {
-    XGetWindowAttributes(display,window,&windowAttributes);
-    std::unique_ptr<int[]> size = std::make_unique<int[]>(2);
-    size[0] = windowAttributes.width;
-    size[1] = windowAttributes.height;
-    return size;
-}
-
-//I'm unsure why this doesn't work as you'd expect.
-std::unique_ptr<int[]> RWindow::getPos() {
-    XGetWindowAttributes(display,window,&windowAttributes);
-    std::unique_ptr<int[]> pos = std::make_unique<int[]>(2);
-    pos[0] = windowAttributes.x;
-    pos[1] = windowAttributes.y;
-    return pos;
-}
-
-void RWindow::setPos(int x, int y) {
-    XMoveWindow(display, window, x, y);
-}
-
-bool RWindow::keyDown(SCANCODE scancode) {
-    for (auto & ev : events) {
-        if (auto *e = dynamic_cast<KeyDownEvent *>(ev)) {
-            if (e->key == scancode) { return true;}
-        }
-    }
-    return false;
-}
-
-KeyDownEvent RWindow::getEvent(SCANCODE scancode) {
-    for (auto & ev : events) {
-        if (auto *e = dynamic_cast<KeyDownEvent *>(ev)) {
-            if (e->key == scancode) { return *e;}
-        }
-    }
-    return EmptyKeyDownEvent;
-}
-
-bool RWindow::mouseButtonDown(MOUSEBUTTONCODE buttoncode) {
-    for (auto & ev : events) {
-        if (auto *e = dynamic_cast<MouseButtonDownEvent *>(ev)) {
-            if (e->button == buttoncode) { return true;}
-        }
-    }
-    return false;
-}
-
-MouseButtonDownEvent RWindow::getEvent(MOUSEBUTTONCODE buttoncode) {
-    for (auto & ev : events) {
-        if (auto *e = dynamic_cast<MouseButtonDownEvent *>(ev)) {
-            if (e->button == buttoncode) { return *e;}
-        }
-    }
-    return EmptyMouseButtonDownEvent;
-}
-
-void RWindow::glSwapBuffers() {
-    glXSwapBuffers(display,window);
-    //This seems to be the best option for now
-    //Because sending it *only once* doesn't work.
-    setVsyncEnabled(vsync);
-}
-
-void RWindow::setVsyncEnabled(bool b) {
-    vsync = b;
-    glXSwapIntervalEXT = (PFNGLXSWAPINTERVALEXTPROC)glXGetProcAddressARB((const GLubyte*)"glXSwapIntervalEXT");
-    glXSwapIntervalEXT(display, window, vsync);
-
-}
-
--- a/src/platform/linux/window.cpp
+++ b/src/platform/linux/window.cpp
@@ -0,0 +1,357 @@
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+#include <X11/Xatom.h>
+#include <GL/glx.h>
+#include <cstdlib>
+#include <cstring>
+#include <thread>
+#include <rewindow/types/window.h>
+#include <rewindow/types/cursors.h>
+#include <J3ML/J3ML.h>
+#include <jlog/jlog.hpp>
+
+
+
+// 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;
+
+using namespace ReWindow;
+
+void RWindow::raise() const {
+    DEBUG(std::format("Raising window '{}'", this->title));
+    XRaiseWindow(display, window);
+}
+
+void RWindow::lower() const
+{
+    DEBUG(std::format("Lowering window '{}'", this->title));
+    XLowerWindow(display, window);
+}
+
+void RWindow::destroyWindow() {
+    DEBUG(std::format("Destroying window '{}'", this->title));
+    XDestroySubwindows(display, window);
+    DEBUG(std::format("Destroyed window '{}'", title));
+    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);
+    OnMouseMoveEvent(eventData);
+    std::this_thread::sleep_for(1ms);
+}
+
+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) {
+        DEBUG("Once you've done this you cannot make it resizable again.");
+        hints.flags = PMinSize | PMaxSize;
+        hints.min_width = hints.max_width = windowAttributes.width;
+        hints.min_height = hints.max_height = windowAttributes.height;
+        XSetWMNormalHints(display, window, &hints);
+    }
+    DEBUG(std::format("Set flag '{}' to state '{}' for window '{}'", RWindowFlagToStr(flag), state, this->title));
+}
+
+void RWindow::pollEvents() {
+    while(XPending(display)) {
+        XNextEvent(display, &xev);
+
+        if (xev.type == ClientMessage)
+            DEBUG(std::format("Recieved event '{}'", "ClientMessage"));
+            if (xev.xclient.message_type == XInternAtom(display, "WM_PROTOCOLS", False) && static_cast<Atom>(xev.xclient.data.l[0]) == wmDeleteWindow) {
+                destroyWindow();
+                system("xset r on");
+                exit(0);
+            }
+
+        if (xev.type == FocusIn) {
+            DEBUG(std::format("Recieved event '{}'", "FocusIn"));
+            XAutoRepeatOff(display);
+            //focusGained.Invoke();
+            RWindowEvent event {};
+            OnFocusGain(event);
+            OnFocusGainEvent(event);
+            setFlag(RWindowFlags::IN_FOCUS, true);
+        }
+
+        if (xev.type == FocusOut) {
+            DEBUG(std::format("Recieved event '{}'", "FocusOut"));
+                XAutoRepeatOn(display);
+                //focusLost.Invoke();
+                RWindowEvent event {};
+                OnFocusLost(event);
+                OnFocusLostEvent(event);
+                setFlag(RWindowFlags::IN_FOCUS, false);
+            }
+
+            if (xev.type == KeyRelease) {
+                DEBUG(std::format("Recieved event '{}'", "KeyRelease"));
+                auto scancode = (X11Scancode) xev.xkey.keycode;
+                auto key = GetKeyFromX11Scancode(scancode);
+                OnKeyUpEvent(key);
+                OnKeyUp(key);
+                liftKey(key);
+            }
+
+            if (xev.type == KeyPress) {
+                DEBUG(std::format("Recieved event '{}'", "KeyPress"));
+                auto scancode = (X11Scancode) xev.xkey.keycode;
+                auto key = GetKeyFromX11Scancode(scancode);
+                OnKeyDownEvent(key);
+                OnKeyDown(key);
+                pressKey(key);
+                //eventLog.push_back(eventData);
+            }
+
+            if (xev.type == ButtonRelease) {
+                DEBUG(std::format("Recieved event '{}'", "ButtonRelease"));
+                MouseButton button = GetMouseButtonFromXButton(xev.xbutton.button);
+                auto eventData = MouseButtonUpEvent();
+                eventData.Button = button;
+
+                OnMouseButtonUpEvent(eventData);
+                OnMouseButtonUp(eventData);
+            }
+
+            if (xev.type == ButtonPress) {
+                DEBUG(std::format("Recieved event '{}'", "ButtonPress"));
+                MouseButton button = GetMouseButtonFromXButton(xev.xbutton.button);
+                auto eventData = MouseButtonDownEvent(button);
+                eventData.Button = button;
+
+                OnMouseButtonDownEvent(eventData);
+                OnMouseButtonDown(eventData);
+            }
+
+            if (xev.type == Expose)
+            {
+                DEBUG(std::format("Recieved event '{}'", "Expose"));
+            }
+
+            // NOTE: This event is functionally useless, as it only informs of the very beginning and end of a mouse movement.
+            if (xev.type == MotionNotify)
+            {
+                DEBUG("NOTE: This event is functionally useless, as it only informs of the very beginning and end of a mouse movement.");
+                DEBUG(std::format("Recieved event '{}'", "MotionNotify"));
+            }
+
+            if (xev.type == ResizeRequest) {
+                DEBUG(std::format("Recieved event '{}'", "ResizeRequest"));
+                auto eventData = WindowResizeRequestEvent();
+                eventData.Size = {(float)xev.xresizerequest.width, (float)xev.xresizerequest.height};
+                lastKnownWindowSize = eventData.Size;
+                OnResizeRequest(eventData);
+                OnResizeRequestEvent(eventData);
+            }
+        }
+
+        previousKeyboard = currentKeyboard;
+    }
+
+    // Might make the window go off the screen on some window managers.
+ void RWindow::setSize(int newWidth, int newHeight) {
+        if (!getFlag(RWindowFlags::RESIZABLE)) return;
+
+        this->width = newWidth;
+        this->height = newHeight;
+        XResizeWindow(display, window, width, height);
+        DEBUG("Might make the window go off the screen on some window managers.");
+        DEBUG(std::format("Set size for window '{}'. width={} height={}", this->title, newWidth, newHeight));
+    }
+
+    Vector2 RWindow::getCursorPos() const {
+        Window root = XDefaultRootWindow(display);
+        Window root_return;
+        Window child_return;
+        int root_x_ret;
+        int root_y_ret;
+        int win_x_ret;
+        int win_y_ret;
+        uint32_t mask_return;
+        unsigned m;
+        bool mouseAvailable = XQueryPointer(display, window, &root_return, &child_return, &root_x_ret, &root_y_ret, &win_x_ret, &win_y_ret, &mask_return);
+
+        if (mouseAvailable) {
+            // TODO: process retrieved mouse coordinates
+            // TODO: normalize coordinates from displaySpace to windowSpace
+            // TODO: fire mouse movement event
+            //std::cout << win_x_ret << ", " << win_y_ret << std::endl;
+            // TODO: Compensate for height of window TitleBar + window border width
+            float window_border_width = 2;
+            float window_titlebar_height = 18;
+            Vector2 mouse_coords_raw = {(float)win_x_ret+window_border_width, (float)win_y_ret+window_titlebar_height};
+            auto window_pos = getPos();
+            return mouse_coords_raw - window_pos;
+        }
+        return Vector2::Zero;
+    }
+
+    // TODO: implement integer vector2/3 types
+    Vector2 RWindow::getSize() const {
+        XGetWindowAttributes(display,window,&windowAttributes);
+        return {(float)windowAttributes.width, (float)windowAttributes.height};
+    }
+
+    Vector2 RWindow::getLastKnownResize() const
+    {
+        return lastKnownWindowSize;
+    }
+
+    // TODO: implement integer vector2/3 types
+    Vector2 RWindow::getPos() const {
+        XGetWindowAttributes(display,window,&windowAttributes);
+        return {(float)windowAttributes.x, (float)windowAttributes.y};
+    }
+
+    void RWindow::setPos(int x, int y) {
+        XMoveWindow(display, window, x, y);
+    }
+
+    void RWindow::setPos(const Vector2& pos) {
+        this->setPos(pos.x, pos.y);
+    }
+
+
+    void RWindow::glSwapBuffers() {
+        glXSwapBuffers(display,window);
+    }
+
+    bool RWindow::isResizable() const {
+        return this->getFlag(RWindowFlags::RESIZABLE);
+    }
+
+    void RWindow::fullscreen() {
+        DEBUG(std::format("Fullscreening window '{}'", this->title));
+        fullscreenmode = true;
+
+        XEvent xev;
+        Atom wm_state   = XInternAtom(display, "_NET_WM_STATE", true);
+        Atom wm_fullscreen = XInternAtom(display, "_NET_WM_STATE_FULLSCREEN", true);
+
+        XChangeProperty(display, window, wm_state, XA_ATOM, 32, PropModeReplace, (unsigned char *)&wm_fullscreen, 1);
+        memset(&xev, 0, sizeof(xev));
+        xev.type = ClientMessage;
+        xev.xclient.window = window;
+        xev.xclient.message_type = wm_state;
+        xev.xclient.format = 32;
+        xev.xclient.data.l[0] = 1; // _NET_WM_STATE_ADD
+        xev.xclient.data.l[1] = fullscreenmode;
+        xev.xclient.data.l[2] = 0;
+        XSendEvent(display, DefaultRootWindow(display), False, SubstructureNotifyMask | SubstructureRedirectMask, &xev);
+        DEBUG(std::format("Fullscreened window '{}'", this->title));
+    }
+
+    void RWindow::restoreFromFullscreen() {
+        DEBUG(std::format("Restoring window '{}' from fullscreen", this->title));
+        fullscreenmode = false;
+        XEvent xev;
+        Atom wm_state = XInternAtom(display, "_NET_WM_STATE", False);
+        Atom fullscreen = XInternAtom(display, "_NET_WM_STATE_FULLSCREEN", False);
+        memset(&xev, 0, sizeof(xev));
+        xev.type = ClientMessage;
+        xev.xclient.window = window;
+        xev.xclient.message_type = wm_state;
+        xev.xclient.format = 32;
+        xev.xclient.data.l[0] = 0; // _NET_WM_STATE_REMOVE
+        xev.xclient.data.l[1] = fullscreenmode;
+        xev.xclient.data.l[2] = 0;
+        XSendEvent(display, DefaultRootWindow(display), False, SubstructureNotifyMask | SubstructureRedirectMask, &xev);
+        DEBUG(std::format("Restored window '{}' from fullscreen", this->title));
+    }
+
+    void RWindow::setVsyncEnabled(bool b) {
+        PFNGLXSWAPINTERVALEXTPROC glXSwapIntervalEXT;
+        glXSwapIntervalEXT = (PFNGLXSWAPINTERVALEXTPROC)glXGetProcAddressARB((const GLubyte*)"glXSwapIntervalEXT");
+        glXSwapIntervalEXT(display, window, b);
+    }
+
+    bool RWindow::isFullscreen() const {
+        return fullscreenmode;
+    }
+
+    void RWindow::setCursorStyle(CursorStyle style) const {
+        u32 x11_cursor_resolved_enum = static_cast<u32>(style.X11Cursor);
+        Cursor c = XCreateFontCursor(display, x11_cursor_resolved_enum);
+        XDefineCursor(display, window, c);
+    }
+
+    void RWindow::Open() {
+        xSetWindowAttributes.border_pixel = BlackPixel(display, defaultScreen);
+        xSetWindowAttributes.background_pixel = BlackPixel(display, defaultScreen);
+        xSetWindowAttributes.override_redirect = True;
+        xSetWindowAttributes.event_mask = ExposureMask;
+        //setVsyncEnabled(vsync);
+        if (renderer == RenderingAPI::OPENGL) {
+            GLint glAttributes[] = {GLX_RGBA, GLX_DEPTH_SIZE, 24, GLX_DOUBLEBUFFER, None};
+            visual = glXChooseVisual(display, defaultScreen, glAttributes);
+            glContext = glXCreateContext(display, visual, nullptr, GL_TRUE);
+        }
+
+        xSetWindowAttributes.colormap = XCreateColormap(display, RootWindow(display, defaultScreen), visual->visual, AllocNone);
+
+        window = XCreateWindow(display, RootWindow(display, defaultScreen), 0, 0, width, height, 0, visual->depth,
+                               InputOutput, visual->visual, CWBackPixel | CWColormap | CWBorderPixel | NoEventMask,
+                               &xSetWindowAttributes);
+	// Set window to floating because fucking tiling WMs
+	windowTypeAtom = XInternAtom(display, "_NET_WM_WINDOW_TYPE", False);
+	windowTypeUtilityAtom = XInternAtom(display, "_NET_WM_WINDOW_TYPE_UTILITY", False);
+        XChangeProperty(display, window, windowTypeAtom, XA_ATOM, 32, PropModeReplace,
+                    (unsigned char *)&windowTypeUtilityAtom, 1);
+	//
+        XSelectInput(display, window,
+                     ExposureMask | KeyPressMask | KeyReleaseMask | ButtonPressMask | ButtonReleaseMask |
+                     PointerMotionMask |
+                     PointerMotionHintMask | FocusChangeMask | StructureNotifyMask | SubstructureRedirectMask |
+                     SubstructureNotifyMask | CWColormap | ResizeRequest | ResizeRedirectMask);
+        XMapWindow(display, window);
+        XStoreName(display, window, title.c_str());
+        wmDeleteWindow = XInternAtom(display, "WM_DELETE_WINDOW", False);
+        XSetWMProtocols(display, window, &wmDeleteWindow, 1);
+
+        if (renderer == RenderingAPI::OPENGL)
+            glXMakeCurrent(display, window, glContext);
+        open = true;
+    }
+
+    void RWindow::setTitle(const std::string &title) {
+        this->title = title;
+        XStoreName(display, window, title.c_str());
+    }
+
+    // TODO: Implement MouseButton map
+    bool RWindow::isMouseButtonDown(MouseButton button) const {
+        return false;
+    }
+
+
+
+
+// TODO: Implement ControllerButton map
+
--- a/src/platform/shared/window.cpp
+++ b/src/platform/shared/window.cpp
@@ -0,0 +1,114 @@
+#include <rewindow/types/window.h>
+#include <jlog/jlog.hpp>
+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:
+            FATAL("")
+            return "unimplemented flag";
+    }
+};
+
+using namespace ReWindow;
+
+RWindow::RWindow() {
+    title = "ReWindow Application";
+    width = 640;
+    height = 480;
+    //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 getCursorPos();
+}
+
+bool RWindow::getFlag(RWindowFlags flag) const {return flags[(int)flag];}
+
+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::liftKey(Key key) {
+    currentKeyboard.PressedKeys[key] = false;
+    auto event = ReWindow::WindowEvents::KeyUpEvent(key);
+    OnKeyUp(event);
+}
+
+
+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::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;
+}
+
+void RWindow::pressKey(Key key) {
+    currentKeyboard.PressedKeys[key] = true;
+    auto eventData = KeyDownEvent(key);
+    OnKeyDown(eventData);
+}
+
+
+void RWindow::Close()
+{
+    
+}
--- a/src/platform/windows/window.cpp
+++ b/src/platform/windows/window.cpp
@@ -0,0 +1,200 @@
+#include <Windows.h>
+#include <gl/GL.h>
+#include <rewindow/types/window.h>
+
+using namespace ReWindow;
+
+bool fullscreenmode = false;
+bool open = false;
+HINSTANCE hInstance = GetModuleHandle(NULL);
+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);
+    }
+}
+
+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 (!getFlag(RWindowFlags::RESIZABLE)) return;
+    this->width = newWidth;
+    this->height = newHeight;
+    SetWindowPos(hwnd, nullptr, 0, 0, width, height, SWP_NOMOVE | SWP_NOZORDER);
+}
+
+Vector2 RWindow::getCursorPos() const {
+    POINT point;
+    GetCursorPos(&point);
+    ScreenToClient(hwnd, &point);
+    return { (float)point.x, (float)point.y };
+}
+
+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);
+    PFNWGLSWAPINTERVALEXTPROC wglSwapIntervalEXT = nullptr;
+    wglSwapIntervalEXT = (PFNWGLSWAPINTERVALEXTPROC) wglGetProcAddress("wglSwapIntervalEXT");
+
+    if (wglSwapIntervalEXT)
+        wglSwapIntervalEXT(b ? 1 : 0);
+}
+
+bool RWindow::isFullscreen() const {
+    return fullscreenmode;
+}
+
+RWindow* eWindow = nullptr;
+KeyboardState* pKeyboard = nullptr;
+KeyboardState* cKeyboard = nullptr;
+//Event loop.
+LRESULT CALLBACK WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) {
+    switch (uMsg) {
+        case WM_CLOSE:
+            DestroyWindow(hwnd);
+        case WM_DESTROY:
+            exit(0);
+        case WM_SIZE:
+                break;
+        case WM_KEYDOWN: {
+            auto key = GetKeyFromWindowsScancode((WindowsScancode) wParam);
+            //Key repeat fix.
+            if (!pKeyboard->PressedKeys[key]) {
+                eWindow->OnKeyDownEvent(key);
+                eWindow->OnKeyDown(key);
+                eWindow->pressKey(key);
+            }
+            break;
+        }
+        case WM_KEYUP: {
+            auto key = GetKeyFromWindowsScancode((WindowsScancode) wParam);
+            eWindow->OnKeyUpEvent(key);
+            eWindow->OnKeyUp(key);
+            eWindow->liftKey(key);
+            break;
+        }
+        case WM_LBUTTONDOWN:
+                break;
+        case WM_LBUTTONUP:
+                break;
+        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);
+}
+
+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);
+}
--- 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/key.cpp
+++ b/src/types/key.cpp
@@ -0,0 +1,46 @@
+#include <rewindow/types/key.h>
+#include <jlog/jlog.hpp>
+//std::vector<Key> Key::keyboard = {};
+
+std::vector<Key> Key::GetKeyboard() { return keyboard; }
+
+Key::Key() {
+    keyboard.push_back(*this);
+}
+
+Key::Key(const char* charcode, X11Scancode scancode, WindowsScancode sc)
+        : CharCode(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->CharCode < rhs.CharCode);
+}
+
+
+
+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;
+}
+
+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/mousebutton.cpp
+++ b/src/types/mousebutton.cpp
@@ -0,0 +1,33 @@
+#include <rewindow/types/mousebutton.h>
+#include <string>
+#include <jlog/jlog.hpp>
+
+MouseButton::MouseButton() {
+}
+
+MouseButton::MouseButton(const char* charcode, unsigned int index) {
+    this->CharCode = charcode;
+    this->ButtonIndex = index;
+}
+
+bool MouseButton::operator==(const MouseButton &mb) const {
+    return (mb.ButtonIndex == this->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: {
+            FATAL("Undefined XButtonCode: " + std::to_string((int) button));
+            return MouseButtons::Unimplemented;
+        }
+    }
+}
--- a/src/windows/event.cpp
+++ b/src/windows/event.cpp
--- a/src/windows/window.cpp
+++ b/src/windows/window.cpp
@@ -1 +0,0 @@
-#include "../../include/rewindow/types/window.h"
Author	SHA1	Message	Date
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
josh	28f904783f	Fix SIGILL	2024-02-21 23:46:42 -05:00
josh	6969568549	Attempt to fix broken integration	2024-02-21 23:38:12 -05:00
josh	bcc74ea3d4	Integrate Event module	2024-02-21 23:12:36 -05:00
josh	ef57fb0732	Implement RWindow::isKeyDown	2024-02-21 20:21:37 -05:00
josh	2930391ee4	Implement CursorStyles, minor refactors	2024-02-21 20:10:06 -05:00
josh	b1dfab70a1	Lil Cleanup	2024-02-21 05:37:12 -05:00
josh	bdc1427626	Clear TODOs	2024-02-21 05:35:20 -05:00
josh	158fafaa79	Implement Window::getCursorPos, also fixed Window::getPos	2024-02-21 05:35:08 -05:00
josh	426b02b3ea	Migrate to latest J3ML	2024-02-20 03:52:24 -05:00
josh	227ecdb64c	Implementing Window::GetSize()	2024-02-14 20:38:26 -05:00
josh	089b110b87	Implementing more of the Windows/X11 KeyMap	2024-02-13 20:24:06 -05:00
josh	7e8a1b4030	Remove JGL dependency	2024-02-13 19:59:02 -05:00
josh	f0bf6c5871	Fix public linkage of JGL turning into build dependency for entire lib	2024-02-13 17:25:36 -05:00
josh	46e947eb77	Fully Deprecate GLM	2024-02-13 16:28:29 -05:00
josh	fe6638c4be	Technically working, however values are incorrect (So is result of RWindow::getPos())	2024-02-07 16:11:42 -05:00
josh	70e41a56cb	XError Kekekek	2024-02-07 15:05:24 -05:00
scientiist	3306c6acba	Implement MouseDelta check (WIP)	2024-02-07 11:40:54 -06:00
scientiist	01eed78c48	Implement Mouse Input (TODO: Event only fires when mouse begins and stops moving)	2024-02-07 08:29:53 -06:00
scientiist	ef7e8b1211	Fix fucked up header	2024-02-07 05:29:33 -06:00
josh	432d1818f3	Refactoring	2024-02-06 23:37:46 -05:00
josh	983428f69d	Merge All Branches	2024-01-25 20:10:46 -05:00
josh	1336297ac0	Merge pull request 'vsync-test' (#4 ) from vsync-test into main Reviewed-on: #4	2024-01-25 20:02:42 -05:00
josh	103c5b2001	Merge remote-tracking branch 'origin/vsync-test' into vsync-test # Conflicts: # CMakeLists.txt # include/rewindow/data/X11Scancodes.h # include/rewindow/types/event.h # include/rewindow/types/key.h # include/rewindow/types/window.h # main.cpp # src/linux/window.cpp	2024-01-25 20:02:02 -05:00
Redacted	89a6fa57b6	Update window.cpp	2024-01-25 20:01:30 -05:00
Redacted	04ced07c18	Update window.cpp Fixed a problem that'd cause setting vsync to behave strangely and overlays to crash.	2024-01-25 20:00:05 -05:00
Redacted	353def8ba9	update	2024-01-25 19:55:57 -05:00
Redacted	c3605a052f	Update CMakeLists.txt	2024-01-25 19:54:52 -05:00
Redacted	d122da68fd	vsync test	2024-01-25 19:54:50 -05:00
josh	b49f44855f	Merge pull request 'virtual-window' (#3 ) from virtual-window into main Reviewed-on: #3	2024-01-25 19:43:58 -05:00
Redacted	7343a95a45	Update window.cpp	2024-01-24 22:16:29 -05:00
Redacted	62568e3252	Update window.cpp	2024-01-24 22:09:58 -05:00
josh	ae5aebae5e	Tryna Implement Fullscreen	2024-01-24 20:19:39 -05:00
josh	2714c41167	Refactoring	2024-01-24 19:28:53 -05:00
Redacted	668d7869fe	Update window.cpp Fixed a problem that'd cause setting vsync to behave strangely and overlays to crash.	2024-01-24 06:22:34 -05:00
josh	6f8fbf18bd	Implementing WindowsScancodes	2024-01-05 13:02:30 -05:00
josh	10a8105f71	Implementing WindowsScancodes	2024-01-05 12:47:25 -05:00
josh	eed5f10413	Implementing X11Scancodes	2024-01-04 17:26:41 -05:00
josh	6afccc34a5	Implementing Stuff	2024-01-04 07:29:59 -05:00
				`@@ -0,0 +1 @@`
				`Main:new("Install build dependencies", "apt-get install -yq libx11-6 libx11-dev libgl-dev")`
				`@@ -1 +0,0 @@`
				`#include "../../include/rewindow/types/window.h"`