Fix public linkage of JGL turning into build dependency for entire lib

Fully Deprecate GLM
Technically working, however values are incorrect (So is result of RWindow::getPos())
2024-02-13 17:25:36 -05:00 · 2024-02-13 16:28:29 -05:00 · 2024-02-07 16:11:42 -05:00 · 2024-02-07 15:05:24 -05:00 · 2024-02-07 11:40:54 -06:00 · 2024-02-07 08:29:53 -06:00
12 changed files with 1153 additions and 371 deletions
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -18,9 +18,20 @@ 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-14.zip
+)
+
+CPMAddPackage(
+        NAME JGL
+        URL https://git.redacted.cc/josh/JGL/archive/pre-1.zip
+)
+
 find_package(OpenGL REQUIRED)
-include_directories({$OPENGL_INCLUDE_DIRS})
+include_directories({$OPENGL_INCLUDE_DIRS} ${J3ML_SOURCE_DIR}/include)
 file(GLOB_RECURSE HEADERS "include/*.h" "include/*.hpp")

 if(UNIX AND NOT APPLE)
@@ -32,14 +43,22 @@ if(WIN32)
 endif()

 include_directories("include")
-add_library(ReWindowLibrary SHARED ${SOURCES})
+add_library(ReWindowLibrary SHARED ${SOURCES}
+        include/rewindow/data/X11Scancodes.h
+        include/rewindow/types/key.h
+        include/rewindow/data/WindowsScancodes.h
+        src/rewindow/types/key.cpp
+        src/rewindow/types/window.cpp
+)
 # 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 ${OPENGL_LIBRARIES})
    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)
--- 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/WindowsScancodes.h
+++ b/include/rewindow/data/WindowsScancodes.h
@@ -0,0 +1,95 @@
+#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
+
+};
--- a/include/rewindow/data/X11Scancodes.h
+++ b/include/rewindow/data/X11Scancodes.h
@@ -0,0 +1,109 @@
+// @file X11Scancodes.h
+// @
+
+#pragma once
+
+enum class X11Scancode {
+    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,
+    END = 115,
+    INSERT = 118,
+    DELETE = 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 = 77,
+    F12 = 78,
+    PRINT = 107,
+    SCROLL_LOCK = 78,
+    BREAK = 127,
+};
--- a/include/rewindow/types/event.h
+++ b/include/rewindow/types/event.h
@@ -1,146 +1,81 @@
 #pragma once
-#if __linux__
-#include <X11/Xlib.h>
+
 #include <chrono>
-#endif
+#include <functional>

-//This is also the x11 scancodes.
-enum class SCANCODE {
-    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,
-    END = 115,
-    INSERT = 118,
-    DELETE = 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,
-    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,
-    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
-};
+template <typename ... Args>
+class Event;

-class RWindowEvent {
+template <typename ... Args>
+class EventConnection {
 private:
-    std::chrono::high_resolution_clock::time_point timePoint;
+    using delegate = std::function<void(Args...)>;
 public:
-    std::chrono::high_resolution_clock::time_point timeStamp();
-    virtual ~RWindowEvent() = default;
-    virtual bool empty();
-    RWindowEvent() {
-        timePoint = std::chrono::high_resolution_clock::now();
+    EventConnection(Event<Args...> *creator, delegate cb) : owner(creator), callback(std::move(cb)) {}
+    bool Disconnect(); // Breaks the event connection, but does not destroy the instance
+    void Invoke(Args... e);
+private:
+    Event<Args...> * owner;
+    delegate callback;
+    bool active = true;
+};
+
+template <typename ... Args>
+class Event {
+public:
+    using delegate = std::function<void(Args...)>;
+    using connection = EventConnection<Args ...>;
+    using event_ptr = std::shared_ptr<connection>;
+public:
+    void Await(Args& ... arg);
+    void Invoke(Args... args);
+    void operator()(Args... args);
+    connection Connect(delegate callback);
+    void Disconnect(connection &conn);
+    connection operator+=(delegate callback);
+private:
+    std::vector<event_ptr> listeners;
+    uint64_t listenerCounter = 0;
+};
+
+
+template<typename... Args>
+EventConnection<Args...> Event<Args...>::operator+=(Event::delegate callback) { return Connect(callback); }
+
+template<typename... Args>
+void Event<Args...>::operator()(Args... args) { Invoke(args...);}
+
+template <typename... Args>
+void EventConnection<Args...>::Invoke(Args... e) { callback(e...); }
+
+template <typename ... Args>
+bool EventConnection<Args...>::Disconnect() {
+    if (active) {
+        owner->Disconnect(this);
+        active = false;
+        return true;
    }
-};
-const RWindowEvent EmptyRWindowEvent;
+    return false;
+}

-class KeyDownEvent : public RWindowEvent {
-public:
-    SCANCODE key;
-};
-const KeyDownEvent EmptyKeyDownEvent{};
+template <typename ... Args>
+void Event<Args...>::Invoke(Args... args) {
+    for (event_ptr &connection_ptr: this->listeners) {
+        connection_ptr->Invoke(args...);
+    }
+}
+
+template <typename ... Args>
+EventConnection<Args...>  Event<Args...>::Connect(delegate callback)
+{
+    event_ptr retval(new connection(this, callback));
+    this->listeners.push_back(retval);
+    return *retval;
+}
+
+template <typename ... Args>
+void Event<Args...>::Disconnect(connection &conn) {
+    listeners.erase(std::remove(listeners.begin(), listeners.end(), 99), listeners.end());
+}

-class MouseButtonDownEvent : public RWindowEvent {
-public:
-    MOUSEBUTTONCODE button;
-};
-const MouseButtonDownEvent EmptyMouseButtonDownEvent{};
--- a/include/rewindow/types/key.h
+++ b/include/rewindow/types/key.h
@@ -0,0 +1,169 @@
+//
+// ~DAWSH
+#pragma once
+
+
+#include <vector>
+#include <J3ML/LinearAlgebra/Vector2.h>
+
+#include <stdexcept>
+
+#if __linux__
+#include <X11/X.h>
+#endif
+
+#include "rewindow/data/X11Scancodes.h"
+#include "rewindow/data/WindowsScancodes.h"
+
+using Vector2 = LinearAlgebra::Vector2;
+
+class Key
+{
+private:
+    static std::vector<Key> keyboard;
+public:
+    inline static std::vector<Key> GetKeyboard();
+    Key();
+    Key(char charcode, X11Scancode scancode, WindowsScancode wSc);
+    char CharCode;
+    X11Scancode x11ScanCode;
+    WindowsScancode winScanCode;
+    bool operator==(const Key& rhs) const;
+    bool operator<(const Key& rhs) const;
+    Key(const Key&) = default;
+
+};
+
+namespace Keys {
+    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 NumPad1 {'\b', X11Scancode::ONE, WindowsScancode::NUMPAD_ONE};
+    static const Key NumPad2 {'\b', X11Scancode::ONE, WindowsScancode::NUMPAD_ONE};
+    static const Key NumPad3 {'\b', X11Scancode::ONE, WindowsScancode::NUMPAD_ONE};
+    static const Key NumPad4 {'\b', X11Scancode::ONE, WindowsScancode::NUMPAD_ONE};
+    static const Key NumPad5 {'\b', X11Scancode::ONE, WindowsScancode::NUMPAD_ONE};
+    static const Key NumPad6 {'\b', X11Scancode::ONE, WindowsScancode::NUMPAD_ONE};
+    static const Key NumPad7 {'\b', X11Scancode::ONE, WindowsScancode::NUMPAD_ONE};
+    static const Key NumPad8 {'\b', X11Scancode::ONE, WindowsScancode::NUMPAD_ONE};
+    static const Key NumPad9 {'\b', X11Scancode::ONE, WindowsScancode::NUMPAD_ONE};
+    static const Key NumPad0 {'\b', X11Scancode::ONE, WindowsScancode::NUMPAD_ONE};
+
+    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 LShift;
+    static const Key RShift;
+
+    // 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};
+}
+
+class GamepadButton {};
+class MouseButton {};
+
+
+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;
+    }
+    throw std::runtime_error("Unavaliable Scancode: " + std::to_string((int)code));
+}
+static Key GetKeyFromWindowsScancode(WindowsScancode code)
+{
+    for (auto& key : Key::GetKeyboard()) {
+        if (key.winScanCode == code)
+            return key;
+    }
+    throw std::runtime_error("Unavaliable Scancode: " + std::to_string((int)code));
+}
--- a/include/rewindow/types/window.h
+++ b/include/rewindow/types/window.h
@@ -2,7 +2,11 @@
 #include <cstdint>
 #include <vector>
 #include <memory>
-#include "event.h"
+#include <rewindow/types/event.h>
+#include <functional>
+#include <map>
+#include <rewindow/types/key.h>
+

 #if __linux__
 #include <X11/Xlib.h>
@@ -11,11 +15,16 @@
 #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
+    VSYNC = 4
 };

 enum class RenderingAPI: uint8_t {
@@ -24,27 +33,201 @@ enum class RenderingAPI: uint8_t {
    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 CursorStyle
+{
+    Default,
+    X,
+    Arrow,
+    IBeam,
+    BottomLeftCorner,
+    BottomRightCorner,
+    BottomSide,
+    Dot,
+    DoubleArrow,
+    Exchange,
+    Hand,
+    LeftSide,
+    Plus,
+    RightSide,
+};

-};
+enum class KeyState { Pressed, Released };
+
+namespace ReWindow
+{
+    using 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;
+        };
+    }
+
+    using namespace WindowEvents;
+
+    class RWindow {
+
+    private:
+        bool flags[4];
+        std::vector<RWindowEvent> eventLog;
+        KeyboardState currentKeyboard; // Current Frame's Keyboard State
+        KeyboardState previousKeyboard; // Previous Frame's Keyboard State
+        bool fullscreenmode = false;
+    public:
+        Event<> focusGained;
+        Event<> focusLost;
+        // TODO: Integrate J3ML
+        Event<MouseMoveEvent&> mouseMoved;
+        Event<MouseButton> mouseBtnPressed;
+        Event<MouseButton> mouseBtnReleased;
+        Event<KeyDownEvent> onKeyboardPress;
+        Event<KeyUpEvent> onKeyboardRelease;
+
+        virtual void OnFocusLost(const RWindowEvent& e) {}
+        virtual void OnFocusGain(const RWindowEvent& e) {}
+        virtual void OnRefresh(float elapsed) {}
+        virtual void OnResizeSuccess() {}
+        virtual bool OnResizeRequest() {}
+        virtual void OnKeyDownEvent(const KeyDownEvent&) {}
+        virtual void OnKeyUpEvent(const KeyUpEvent&) {}
+        virtual void OnMouseMove(const MouseMoveEvent&) {}
+        virtual void OnMouseButtonDown(const MouseButtonDownEvent&) {}
+        virtual void OnMouseButtonUp(const MouseButtonUpEvent&) {}
+
+
+        RWindow();
+
+        // TODO: Must be implemented from scratch as a Motif Window in x11
+        void MessageBox();
+
+        bool isFocused() const;
+        bool isFullscreen() const
+        {
+            return fullscreenmode;
+        }
+        bool isResizable() const;
+        bool isVsyncEnabled() const;
+
+        bool isAlive() const;
+
+        void setMouseVisible(bool visible);
+        void setMouseLocked();
+        void setMouseCenter();
+        void restoreMouseFromLastCenter(); // Feels nicer for users
+
+
+        void setFullscreen(bool fs);
+        void setResizable(bool resizable);
+        void setVsyncEnabled(bool);
+        void setTitle(const std::string& title);
+
+        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);
+
+        Vector2 getPos() const;
+        Vector2 getSize() const;
+        void setPos(int x, int y);
+        void setPos(const Vector2& pos);
+
+        void raise() const;
+        void lower() const;
+
+        void setCursor(CursorStyle style) const;
+
+        // TODO: Implement
+        // void setCursor(Icon* icon) const;
+
+        static void glSwapBuffers();
+        //Initialize to false because it's not guaranteed that they will be cleared first
+
+    };
+
+
+    class WindowsImplementationRWindow : public RWindow
+    {
+
+    };
+
+    class X11ImplementationRWindow : public RWindow
+    {
+
+    };
+}
--- a/main.cpp
+++ b/main.cpp
@@ -1,27 +1,124 @@
 #include <iostream>
-#include "include/rewindow/types/window.h"
-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);
+#include <rewindow/types/window.h>
+#include <JGL/JGL.h>
+
+#if __linux__
+
+void KeyDown(const ReWindow::WindowEvents::KeyDownEvent& e)
+{
+    std::cout << e.key.CharCode << " pressed" << std::endl;
+}
+
+Vector2 mouse_pos;
+
+std::ostream& operator<<(std::ostream& os, const Vector2& v)
+{
+    return os << "{" << v.x << ", " << v.y << "}";
+}
+
+
+class MyWindow : public ReWindow::RWindow
+{
+public:
+    void OnMouseMove(const ReWindow::MouseMoveEvent& e) override
+    {
+        std::cout << "Mouse Moved: " << e.Position << " @ " << std::endl;
    }
-}
+    void OnRefresh(float elapsed) override
+    {
+        JGL::J2D::FillRect2D(JGL::Colors::White, {400.f, 400.f}, {200.f, 200.f});
+        glSwapBuffers();
+    }
+};
+
+int main() {
+    auto* window = new MyWindow();
+    window->init(RenderingAPI::OPENGL, "name",100,100, true);
+    window->setFlag(RWindowFlags::RESIZABLE, false);
+
+    window->onKeyboardPress += KeyDown;
+    window->onKeyboardRelease += [&](ReWindow::WindowEvents::KeyUpEvent e)
+    {
+        if (e.key == Keys::F)
+            window->setFullscreen(!window->isFullscreen());
+    };
+
+    while (window->isAlive()) {
+        window->pollEvents();
+        window->refresh();
+    }
+}
+
+#endif
+
+#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;
+}
+
+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
--- a/src/linux/event.cpp
+++ b/src/linux/event.cpp
@@ -1,10 +1 @@
 #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,7 +1,19 @@
 #include <iostream>
-#include "rewindow/types/window.h"
+#include <rewindow/types/window.h>
+#include <rewindow/data/WindowsScancodes.h>
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+#include <X11/Xatom.h>
+
+#include <cstdlib>
+#include <cstring>
+#include <thread>
+
+// 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

-bool vsync = false;
 Window window;
 XEvent xev;
 Display* display = XOpenDisplay(nullptr);
@@ -12,197 +24,291 @@ XWindowAttributes windowAttributes;
 Atom wmDeleteWindow;
 XSizeHints hints;
 GLXContext glContext;
-PFNGLXSWAPINTERVALEXTPROC _glXSwapIntervalEXT = nullptr; //It causes issues if it's named just "glXSwapIntervalEXT".

-void RWindow::init(RenderingAPI api, const char* title, int width, int height, bool sync) {
-    if (api == RenderingAPI::OPENGL) {
+namespace ReWindow {
+
+    RWindow::RWindow() : flags(false,false,false,false) {
+
+    }
+
+    void RWindow::raise() const { XRaiseWindow(display, window); }
+    void RWindow::lower() const { XLowerWindow(display, window); }
+
+    void RWindow::init(RenderingAPI api, const char* title, int width, int height, bool vsync) {
+        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_CONTEXT_MAJOR_VERSION_ARB, 1, GLX_CONTEXT_MINOR_VERSION_ARB, 4, GLX_CONTEXT_PROFILE_MASK_ARB, GLX_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB, 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);
+            setVsyncEnabled(vsync);
+            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);
-        setVsyncEnabled(vsync);
-    } else {exit(0);}
-}
+            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);
+            XMapWindow(display, window);
+            XStoreName(display, window, title);
+            wmDeleteWindow = XInternAtom(display, "WM_DELETE_WINDOW", False);
+            XSetWMProtocols(display, window, &wmDeleteWindow, 1);
+            glXMakeCurrent(display, window, glContext);
+            setVsyncEnabled(vsync);
+        } else {exit(0);}
+    }

-void RWindow::destroyWindow() {
-    XDestroySubwindows(display, window);
-    XAutoRepeatOn(XOpenDisplay(nullptr));
-    XDestroyWindow(display, window);
-    delete this;
-}
+    void RWindow::destroyWindow() {
+        XDestroySubwindows(display, window);
+        XAutoRepeatOn(display);
+        XDestroyWindow(display, window);
+        delete this;
+    }

-bool RWindow::getFlag(RWindowFlags flag) {
-    if (flags[(int)flag])
+    void RWindow::refresh() {
+        // TODO: Implement refresh time keeping
+        OnRefresh(0.f);
+
+
+        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, root, &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;
+            Vector2 mouse_coords_raw = {(float)win_x_ret, (float)win_y_ret};
+            auto window_pos = getPos();
+            Vector2 mouse_coords = mouse_coords_raw - window_pos;
+
+            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);
+                OnKeyUpEvent(eventData);
+
+            }
+
+            if (xev.type == KeyPress) {
+                auto scancode = (X11Scancode) xev.xkey.keycode;
+                auto key = GetKeyFromX11Scancode(scancode);
+                currentKeyboard.PressedKeys[key] = true;
+                KeyDownEvent eventData = KeyDownEvent(key);
+                OnKeyDownEvent(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) {
+            }
+
+            if (xev.type == MotionNotify)
+            {
+                //auto eventData = MouseMoveEvent(xev.xmotion.x, xev.xmotion.y);
+
+                //OnMouseMove(eventData);
+            }
+        }
+
+        previousKeyboard = currentKeyboard;
+    }
+
+    // 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);
+    }
+
+    void RWindow::setSize(const Vector2& size)
+    {
+        this->setSize(size.x, size.y);
+    }
+
+    // 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
+    {
+        auto root = XDefaultRootWindow(display);
+        XGetWindowAttributes(display,root,&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;
-    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) {
-        }
+    void RWindow::setResizable(bool resizable) {
+        this->setFlag(RWindowFlags::RESIZABLE, resizable);
    }
-}

-//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;}
-        }
+    void RWindow::setFullscreen(bool fs) {
+        if (fs)
+            fullscreen();
+        else
+            restoreFromFullscreen();
    }
-    return false;
-}

-KeyDownEvent RWindow::getEvent(SCANCODE scancode) {
-    for (auto & ev : events) {
-        if (auto *e = dynamic_cast<KeyDownEvent *>(ev)) {
-            if (e->key == scancode) { return *e;}
-        }
+    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);
    }
-    return EmptyKeyDownEvent;
-}

-bool RWindow::mouseButtonDown(MOUSEBUTTONCODE buttoncode) {
-    for (auto & ev : events) {
-        if (auto *e = dynamic_cast<MouseButtonDownEvent *>(ev)) {
-            if (e->button == buttoncode) { return true;}
-        }
+    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);
    }
-    return false;
-}

-MouseButtonDownEvent RWindow::getEvent(MOUSEBUTTONCODE buttoncode) {
-    for (auto & ev : events) {
-        if (auto *e = dynamic_cast<MouseButtonDownEvent *>(ev)) {
-            if (e->button == buttoncode) { return *e;}
-        }
+    void RWindow::setVsyncEnabled(bool b) {
+        PFNGLXSWAPINTERVALEXTPROC glXSwapIntervalEXT = nullptr;
+        glXSwapIntervalEXT = (PFNGLXSWAPINTERVALEXTPROC)glXGetProcAddressARB((const GLubyte*)"glXSwapIntervalEXT");
+        glXSwapIntervalEXT(display, None, b);
    }
-    return EmptyMouseButtonDownEvent;
-}

-void RWindow::glSwapBuffers() {
-    glXSwapBuffers(display,window);
-}

-void RWindow::setVsyncEnabled(bool b) {
-    vsync = b;
-    _glXSwapIntervalEXT = (PFNGLXSWAPINTERVALEXTPROC)glXGetProcAddressARB((const GLubyte*)"glXSwapIntervalEXT");
-    _glXSwapIntervalEXT(display, window, vsync);
-}

+}
--- a/src/rewindow/types/key.cpp
+++ b/src/rewindow/types/key.cpp
@@ -0,0 +1,24 @@
+#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/windows/window.cpp
+++ b/src/windows/window.cpp
@@ -1 +1,31 @@
-#include "../../include/rewindow/types/window.h"
+#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	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
josh	ae5aebae5e	Tryna Implement Fullscreen	2024-01-24 20:19:39 -05:00
josh	2714c41167	Refactoring	2024-01-24 19:28:53 -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