Temp Work

fix the types not being convertable on loonix

.gitea/workflows/buildtest.yml

@@ -17,7 +17,7 @@ jobs:
       - 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: apt-get update && apt-get install -y lua5.3 git libxrandr-dev && git clone $RECI_GIT $RECI
       - run: lua $RECI/reci.lua -f $RECI/scripts/buildtools.reci -f reci/scripts/builddeps.reci -f $RECI/scripts/buildtest.reci
       - run: echo this exists so I can run the reci test
       - run: echo "This job's status is ${{ job.status }}."

CMakeLists.txt

@@ -18,7 +18,7 @@ include(cmake/CPM.cmake)
 
 CPMAddPackage(
     NAME J3ML
-    URL https://git.redacted.cc/josh/j3ml/archive/Release-3.1.zip
+    URL https://git.redacted.cc/josh/j3ml/archive/Release-3.2.zip
 )
 
 CPMAddPackage(

include/rewindow/data/scancode.h

@@ -0,0 +1,273 @@
+/// ReWindowLibrary
+/// A C++20 Library for creating and managing windows in a platform-independent manner
+/// Developed and Maintained by the boys @ Redacted Software.
+/// (c) 2024 Redacted Software
+/// This work is dedicated to the public domain.
+
+/// @file scancode.h
+/// @desc Abstraction layer for input device scancodes
+/// @edit 2024-12-03
+
+#pragma once
+
+namespace ReWindow {
+    enum class ReScanCodeIndex : unsigned int {
+        Unimplemented = 0,
+
+        MLeft = 1,
+        MRight = 2,
+        MMiddle = 3,
+        MWheel_Up = 4,
+        MWheel_Down = 5,
+        MSide_A = 8,
+        MSide_B = 9,
+
+        KP_0 = 90,
+        KP_1 = 87,
+        KP_2 = 88,
+        KP_3 = 89,
+        KP_4 = 83,
+        KP_5 = 84,
+        KP_6 = 85,
+        KP_7 = 79,
+        KP_8 = 80,
+        KP_9 = 81,
+        KP_PERIOD = 91,
+        KP_RETURN = 104,
+        KP_PLUS = 86,
+        KP_MINUS = 82,
+        KP_ASTERISK = 63,
+        KP_SLASH = 106,
+        KP_NUMLOCK = 77,
+        PAGEUP = 112,
+        PAGEDOWN = 117,
+        HOME = 110,
+        MENU = 135,
+        END = 115,
+        INSERT = 118,
+        DEL = 119,
+        UP = 111,
+        DOWN = 116,
+        LEFT = 113,
+        RIGHT = 114,
+        BACKSPACE = 22,
+        EQUALS = 21,
+        MINUS = 20,
+        ZERO = 19,
+        NINE = 18,
+        EIGHT = 17,
+        SEVEN = 16,
+        SIX = 15,
+        FIVE = 14,
+        FOUR = 13,
+        THREE = 12,
+        TWO = 11,
+        ONE = 10,
+        GRAVE = 49,
+        BACKSLASH = 51,
+        CLOSING_SQUARE_BRACKET = 35,
+        OPENING_SQUARE_BRACKET = 34,
+        P = 33,
+        O = 32,
+        I = 31,
+        U = 30,
+        Y = 29,
+        T = 28,
+        R = 27,
+        E = 26,
+        W = 25,
+        Q = 24,
+        TAB = 23,
+        RETURN = 36,
+        SINGLEQUOTE = 48,
+        SEMICOLON = 47,
+        L = 46,
+        K = 45,
+        J = 44,
+        H = 43,
+        G = 42,
+        F = 41,
+        D = 40,
+        S = 39,
+        A = 38,
+        CAPSLOCK = 66,
+        RIGHT_SHIFT = 62,
+        SLASH = 61,
+        PERIOD = 60,
+        COMMA = 59,
+        M = 58,
+        N = 57,
+        B = 56,
+        V = 55,
+        C = 54,
+        X = 53,
+        Z = 52,
+        LEFT_SHIFT = 50,
+        RIGHT_CONTROL = 105,
+        RIGHT_ALT = 108,
+        SPACE = 65,
+        LEFT_ALT = 64,
+        SUPER = 133,
+        LEFT_CTRL = 37,
+        ESCAPE = 9,
+        F1 = 67,
+        F2 = 68,
+        F3 = 69,
+        F4 = 70,
+        F5 = 71,
+        F6 = 72,
+        F7 = 73,
+        F8 = 74,
+        F9 = 75,
+        F10 = 76,
+        F11 = 95,
+        F12 = 96,
+        PRINT = 107,
+        SCROLL_LOCK = 78,
+        BREAK = 127,
+    };
+
+    class ReScanCode
+    {
+    public:
+        std::string Mnemonic;
+        unsigned int Sindex;
+
+        ReScanCode() = default;
+        explicit ReScanCode(const std::string& string, ReScanCodeIndex sindex);
+        explicit ReScanCode(const std::string& string, unsigned int sindex);
+        bool operator == (const ReScanCode& rs) const;
+        bool operator<(const ReScanCode& rhs) const;
+        ReScanCode(const ReScanCode&) = default;
+    };
+
+    namespace ReScanCodes {
+        static const ReScanCode Unimplemented  ("?", 0);
+
+        static const ReScanCode MouseButtonLeft           ("ML", ReScanCodeIndex::MLeft);
+        static const ReScanCode MouseButtonRight          ("MR", ReScanCodeIndex::MRight);
+        static const ReScanCode MouseButtonMiddle         ("MM", ReScanCodeIndex::MMiddle);
+        static const ReScanCode MouseButtonSideA         ("M4", ReScanCodeIndex::MSide_A);
+        static const ReScanCode MouseButtonSideB         ("M5", ReScanCodeIndex::MSide_B);
+        /// NOTE: IsMouseButtonDown will not return correctly for the mouse-wheel-buttons, because the action is effectively instantaneous.
+        static const ReScanCode MWheelUp       ("MWU", ReScanCodeIndex::MWheel_Up);
+        /// NOTE: IsMouseButtonDown will not return correctly for the mouse-wheel-buttons, because the action is effectively instantaneous.
+        static const ReScanCode MWheelDown     ("MWD", ReScanCodeIndex::MWheel_Down);
+
+        // TODO: Encode both Uppercase and Lowercase version for each keymap
+        static const ReScanCode Escape ("ESC", ReScanCodeIndex::ESCAPE);
+        static const ReScanCode F1  ("F1", ReScanCodeIndex::F1);
+        static const ReScanCode F2  ("F2", ReScanCodeIndex::F2);
+        static const ReScanCode F3  ("F3", ReScanCodeIndex::F3);
+        static const ReScanCode F4  ("F4", ReScanCodeIndex::F4);
+        static const ReScanCode F5  {"F5", ReScanCodeIndex::F5};
+        static const ReScanCode F6  {"F6", ReScanCodeIndex::F6};
+        static const ReScanCode F7  {"F7", ReScanCodeIndex::F7};
+        static const ReScanCode F8  {"F8", ReScanCodeIndex::F8};
+        static const ReScanCode F9  {"F9", ReScanCodeIndex::F9};
+        static const ReScanCode F10 {"F10", ReScanCodeIndex::F10};
+        static const ReScanCode F11 {"F11", ReScanCodeIndex::F11};
+        static const ReScanCode F12 {"F12", ReScanCodeIndex::F12};
+        static const ReScanCode Print {"PRINT", ReScanCodeIndex::PRINT};
+        static const ReScanCode ScrollLock {"SCROLL_LOCK", ReScanCodeIndex::SCROLL_LOCK};
+        static const ReScanCode Break {"BREAK", ReScanCodeIndex::BREAK};
+
+        //TODO On Windows, Return & KP_RETURN are the same thing.
+        static const ReScanCode NumPadReturn {"KP_↵", ReScanCodeIndex::KP_RETURN};
+        static const ReScanCode NumPadPlus {"KP_+", ReScanCodeIndex::KP_PLUS};
+        static const ReScanCode NumPadMinus {"KP_-", ReScanCodeIndex::KP_MINUS};
+        static const ReScanCode NumPadAsterisk {"KP_*", ReScanCodeIndex::KP_ASTERISK};
+        static const ReScanCode NumPadForwardSlash {"KP_/", ReScanCodeIndex::KP_SLASH};
+        static const ReScanCode NumPadPeriod {"KP_.", ReScanCodeIndex::KP_PERIOD};
+        static const ReScanCode NumPadNumLock {"KP_NUMLOCK", ReScanCodeIndex::KP_NUMLOCK};
+
+        static const ReScanCode NumPad1 {"KP_1", ReScanCodeIndex::KP_1};
+        static const ReScanCode NumPad2 {"KP_2", ReScanCodeIndex::KP_2};
+        static const ReScanCode NumPad3 {"KP_3", ReScanCodeIndex::KP_3};
+        static const ReScanCode NumPad4 {"KP_4", ReScanCodeIndex::KP_4};
+        static const ReScanCode NumPad5 {"KP_5", ReScanCodeIndex::KP_5};
+        static const ReScanCode NumPad6 {"KP_6", ReScanCodeIndex::KP_6};
+        static const ReScanCode NumPad7 {"KP_7", ReScanCodeIndex::KP_7};
+        static const ReScanCode NumPad8 {"kP_8", ReScanCodeIndex::KP_8};
+        static const ReScanCode NumPad9 {"KP_9", ReScanCodeIndex::KP_9};
+        static const ReScanCode NumPad0 {"KP_0", ReScanCodeIndex::KP_0};
+
+        static const ReScanCode Grave {"`", ReScanCodeIndex::GRAVE};
+        static const ReScanCode One {"1", ReScanCodeIndex::ONE};
+        static const ReScanCode Two {"2", ReScanCodeIndex::TWO};
+        static const ReScanCode Three {"3", ReScanCodeIndex::THREE};
+        static const ReScanCode Four {"4", ReScanCodeIndex::FOUR};
+        static const ReScanCode Five {"5", ReScanCodeIndex::FIVE};
+        static const ReScanCode Six {"6", ReScanCodeIndex::SIX};
+        static const ReScanCode Seven {"7", ReScanCodeIndex::SEVEN};
+        static const ReScanCode Eight {"8", ReScanCodeIndex::EIGHT};
+        static const ReScanCode Nine {"9", ReScanCodeIndex::NINE};
+        static const ReScanCode Zero {"0", ReScanCodeIndex::ZERO};
+        static const ReScanCode Minus {"-", ReScanCodeIndex::MINUS};
+        static const ReScanCode Equals {"+", ReScanCodeIndex::EQUALS};
+        static const ReScanCode Backspace {"⌫", ReScanCodeIndex::BACKSPACE};
+
+        static const ReScanCode Tab {"⇥", ReScanCodeIndex::TAB};
+        static const ReScanCode Q {"Q", ReScanCodeIndex::Q};
+        static const ReScanCode W {"W", ReScanCodeIndex::W};
+        static const ReScanCode E {"E", ReScanCodeIndex::E};
+        static const ReScanCode R {"R", ReScanCodeIndex::R};
+        static const ReScanCode T {"T", ReScanCodeIndex::T};
+        static const ReScanCode Y {"Y", ReScanCodeIndex::Y};
+        static const ReScanCode U {"U", ReScanCodeIndex::U};
+        static const ReScanCode I {"I", ReScanCodeIndex::I};
+        static const ReScanCode O {"O", ReScanCodeIndex::O};
+        static const ReScanCode P {"P", ReScanCodeIndex::P};
+        static const ReScanCode LeftBracket {"[", ReScanCodeIndex::OPENING_SQUARE_BRACKET};
+        static const ReScanCode RightBracket {"]", ReScanCodeIndex::CLOSING_SQUARE_BRACKET};
+        static const ReScanCode BackSlash {"\\", ReScanCodeIndex::BACKSLASH};
+
+        static const ReScanCode CapsLock {"CAPS", ReScanCodeIndex::CAPSLOCK};
+        static const ReScanCode A {"A", ReScanCodeIndex::A};
+        static const ReScanCode S {"S", ReScanCodeIndex::S};
+        static const ReScanCode D {"D", ReScanCodeIndex::D};
+        static const ReScanCode F {"F", ReScanCodeIndex::F};
+        static const ReScanCode G {"G", ReScanCodeIndex::G};
+        static const ReScanCode H {"H", ReScanCodeIndex::H};
+        static const ReScanCode J {"J", ReScanCodeIndex::J};
+        static const ReScanCode K {"K", ReScanCodeIndex::K};
+        static const ReScanCode L {"L", ReScanCodeIndex::L};
+        static const ReScanCode Semicolon {";", ReScanCodeIndex::SEMICOLON};
+        static const ReScanCode SingeQuote {"\'", ReScanCodeIndex::SINGLEQUOTE};
+        static const ReScanCode Return {"↵", ReScanCodeIndex::RETURN};
+
+        static const ReScanCode LeftShift {"⇧", ReScanCodeIndex::LEFT_SHIFT};
+        static const ReScanCode Z {"Z", ReScanCodeIndex::Z};
+        static const ReScanCode X {"X", ReScanCodeIndex::X};
+        static const ReScanCode C {"C", ReScanCodeIndex::C};
+        static const ReScanCode V {"V", ReScanCodeIndex::V};
+        static const ReScanCode B {"B", ReScanCodeIndex::B};
+        static const ReScanCode N {"N", ReScanCodeIndex::N};
+        static const ReScanCode M {"M", ReScanCodeIndex::M};
+        static const ReScanCode Comma {",", ReScanCodeIndex::COMMA};
+        static const ReScanCode Period {".", ReScanCodeIndex::PERIOD};
+        static const ReScanCode ForwardSlash {"/", ReScanCodeIndex::SLASH};
+
+        static const ReScanCode LeftControl {"LCTRL", ReScanCodeIndex::LEFT_CTRL};
+        static const ReScanCode Super {"❖", ReScanCodeIndex::SUPER};
+        static const ReScanCode LeftAlt {"🄰", ReScanCodeIndex::LEFT_ALT};
+        static const ReScanCode Space {" ", ReScanCodeIndex::SPACE};
+        static const ReScanCode RightAlt {"R🄰", ReScanCodeIndex::RIGHT_ALT};
+        static const ReScanCode Menu {"▤", ReScanCodeIndex::MENU};
+        static const ReScanCode RightControl {"RCTRL", ReScanCodeIndex::RIGHT_CONTROL};
+        static const ReScanCode RightShift {"R⇧", ReScanCodeIndex::RIGHT_SHIFT};
+
+        static const ReScanCode Insert {"INSERT", ReScanCodeIndex::INSERT};
+        static const ReScanCode Home {"HOME", ReScanCodeIndex::HOME};
+        static const ReScanCode PageUp {"PAGEUP", ReScanCodeIndex::PAGEUP};
+        static const ReScanCode Delete {"DELETE", ReScanCodeIndex::DEL};
+        static const ReScanCode End {"End", ReScanCodeIndex::END};
+        static const ReScanCode PageDown {"PAGEDOWN", ReScanCodeIndex::PAGEDOWN};
+
+        static const ReScanCode UpArrow {("↑"), ReScanCodeIndex::UP};
+        static const ReScanCode DownArrow {("↓"), ReScanCodeIndex::DOWN};
+        static const ReScanCode LeftArrow {("←"), ReScanCodeIndex::LEFT};
+        static const ReScanCode RightArrow {("→"), ReScanCodeIndex::RIGHT};
+    }
+}
+

include/rewindow/types/WindowEvents.hpp

@@ -0,0 +1,85 @@
+#pragma once
+
+#include <chrono>
+#include <rewindow/types/key.h>
+#include <rewindow/types/mousebutton.h>
+
+namespace ReWindow {
+
+    using namespace std::chrono_literals;
+    using precision_clock = std::chrono::high_resolution_clock;
+    using precision_timestamp = precision_clock::time_point;
+
+    class TimestampedEvent {
+    private:
+
+    public:
+        precision_timestamp Timestamp;
+        TimestampedEvent() : Timestamp(precision_clock::now())
+        { }
+    };
+
+    class RWindowEvent : public TimestampedEvent {
+    public:
+        RWindowEvent() : TimestampedEvent() { }
+    };
+
+    class KeyboardEvent : public RWindowEvent {
+    public:
+        Key key;
+        KeyState state;
+        KeyboardEvent(Key key, KeyState state) : RWindowEvent(), key(key), state(state) {}
+    };
+    class MouseEvent : public RWindowEvent {};
+
+    class GamepadEvent : public RWindowEvent {};
+
+    class MouseMoveEvent : public MouseEvent {
+    public:
+        Vector2 Position;
+        Vector2 Delta;
+        MouseMoveEvent(const Vector2 &pos) : MouseEvent(), Position(pos)
+        {}
+        MouseMoveEvent(int x, int y) : MouseEvent(), Position(Vector2(x, y))
+        {}
+    };
+
+    class KeyDownEvent : public KeyboardEvent {
+    public:
+        KeyDownEvent(Key key) : KeyboardEvent(key, KeyState::Pressed) {}
+    };
+
+    class KeyUpEvent : public KeyboardEvent {
+    public:
+        KeyUpEvent(Key key) : KeyboardEvent(key, KeyState::Released) {}
+    };
+
+    class MouseWheelEvent : public MouseEvent
+    {
+    public:
+        int WheelMovement;
+        MouseWheelEvent() = default;
+        MouseWheelEvent(int wheel) : MouseEvent(), WheelMovement(wheel) {}
+    };
+
+    class MouseButtonDownEvent : public MouseEvent {
+    public:
+        MouseButton Button;
+
+        MouseButtonDownEvent() = default;
+        MouseButtonDownEvent(MouseButton button) : MouseEvent(), Button(button) {}
+    };
+
+    class MouseButtonUpEvent : public MouseEvent {
+    public:
+        MouseButton Button;
+        MouseButtonUpEvent() = default;
+        MouseButtonUpEvent(MouseButton button) : MouseEvent(), Button(button) {}
+    };
+
+    class WindowResizeRequestEvent : public RWindowEvent
+    {
+    public:
+        Vector2 Size;
+    };
+}

include/rewindow/types/gamepad.h

@@ -17,6 +17,7 @@ namespace ReWindow
 
     class Gamepad : public InputDevice
     {
+    public:
 
     };
 

include/rewindow/types/inputdevice.hpp

@@ -0,0 +1,39 @@
+#pragma once
+
+namespace ReWindow
+{
+
+    enum class DeviceType {
+        MOUSE, KEYBOARD, GAMEPAD, TOUCHSCREEN, REMOTE, VRHEADSET
+    };
+
+    enum class DeviceState {
+        OK, LOW_BATTERY, UNAVAILABLE
+    };
+
+    class InputDeviceImpl { };
+    class InputDeviceImplLinux { };
+
+    class InputDevice {
+    public:
+        virtual void Update(double elapsed){}
+
+        /// Returns the device's index among devices of the same type.
+        uint GetIndex() const;
+
+        virtual DeviceType GetType() const = 0;
+        DeviceState GetDeviceState() const;
+        bool IsAnyButtonDown();
+    };
+
+    struct InputEvent
+    {
+        std::chrono::system_clock::time_point Timestamp;
+    };
+
+    struct BinaryActuatorState
+    {
+        double TimeHeld;
+        bool Pressed;
+    };
+}

include/rewindow/types/inputservice.hpp

@@ -0,0 +1,32 @@
+#pragma once
+
+#include <rewindow/types/mouse.h>
+
+namespace ReWindow
+{
+
+    namespace detail
+    {
+        static Mouse* internal_mouse;
+
+        void UpdateMouse(Mouse* mouse) {
+            detail::internal_mouse = mouse;
+        }
+
+    }
+
+    namespace InputService
+    {
+        namespace Mouse
+        {
+            Vector2 GetMousePosition()
+            {
+                return detail::internal_mouse->GetPosition();
+            }
+
+            bool IsButtonDown(const MouseButton &btn) {
+                return detail::internal_mouse->IsButtonDown(btn);
+            }
+        }
+
+    }

include/rewindow/types/key.h

@@ -19,9 +19,9 @@ private:
 
 public:
     static std::vector<Key> GetKeyboard();
-    Key();
+    Key() = default;
     Key(const char* charcode, X11Scancode scancode, WindowsScancode wSc);
-    const char* CharCode;
+    std::string Mnemonic;
     X11Scancode x11ScanCode;
     WindowsScancode winScanCode;
     bool operator==(const Key& rhs) const;

include/rewindow/types/keyboard.h

@@ -10,13 +10,40 @@
 
 #pragma once
 
+#include <rewindow/types/inputdevice.hpp>
+#include "rewindow/data/scancode.h"
+#include <Event.h>
+#include <map>
 
 namespace ReWindow
 {
-    class InputDevice {};
+    using Key = ReScanCode;
+    using KeyState = BinaryActuatorState;
+    struct KeyboardState
+    {
+        std::map<Key, KeyState> Keys;
+    };
+
+    class KeyPressedEvent : public InputEvent {};
+    class KeyReleasedEvent : public InputEvent {};
 
     class Keyboard : public InputDevice
     {
+    public:
+        Keyboard() {}
+        ~Keyboard() {}
+        bool IsKeyDown() const;
+        KeyState GetKeyState() const;
 
+        void Update(double elapsed) override;
+        DeviceType GetType() const override { return DeviceType::KEYBOARD;}
+    public:
+        static Event<const KeyPressedEvent&> KeyPressed;
+        static Event<const KeyReleasedEvent&> KeyReleased;
+
+    public:
+        static Keyboard* GetCurrentDevice();
+        static bool GetKeyState(const Key& k);
+        static KeyboardState GetState();
     };
 }

include/rewindow/types/mouse.h

@@ -10,17 +10,329 @@
 
 #pragma once
 
+//#include <rewindow/types/inputdevice.hpp>
+#include <rewindow/types/mousebutton.h>
+#include <rewindow/types/key.h>
+#include <Event.h>
+#include <map>
+#include "rewindow/data/scancode.h"
+#include <rewindow/types/inputdevice.hpp>
+//#include <rewindow/types/keyboard.h>
+//#include <rewindow/types/gamepad.h>
 
 namespace ReWindow
 {
 
-    class InputDevice {}; // TODO: Remember to break InputDevice into it's own file and not define it twice!!!
+    //using Key = ReScanCode;
 
-    class Pointer : public InputDevice {};
+    using Button = ReScanCode;
+
+    /*
+    enum class DeviceType {
+        MOUSE, KEYBOARD, GAMEPAD, TOUCHSCREEN, REMOTE, VRHEADSET
+    };
+
+    enum class DeviceState {
+        OK, LOW_BATTERY, UNAVAILABLE
+    };
+     */
 
 
-    class Mouse : public Pointer
+    /*
+    class InputDeviceImpl { };
+    class InputDeviceImplLinux { };
+     */
+    class LinuxMouseImpl { };
+    class LinuxKeyboardImpl {};
+
+    // TODO: Remember to break InputDevice into it's own file and not define it twice!!!
+    /*
+    class InputDevice {
+    public:
+        virtual void Update(double elapsed){}
+
+        /// Returns the device's index among devices of the same type.
+        uint GetIndex() const;
+
+        virtual DeviceType GetType() const = 0;
+        DeviceState GetDeviceState() const;
+        bool IsAnyButtonDown();
+    };
+     */
+
+    /*
+    struct BinaryActuatorState
+    {
+        double TimeHeld;
+        bool Pressed;
+    };
+     */
+
+    using ButtonState = BinaryActuatorState;
+    //using KeyState = BinaryActuatorState;
+
+    /*
+    struct KeyboardState
+    {
+        std::map<Key, KeyState> Keys;
+
+    };
+     */
+
+    /*class MouseState {
+    public:
+        struct
+        {
+            bool LMB = false;
+            bool RMB = false;
+            bool MMB = false;
+            bool SideButton1 = false;
+            bool SideButton2 = false;
+            bool MWheelUp = false;
+            bool MWheelDown = false;
+        } Buttons;
+
+
+        Vector2 Position;
+        int Wheel = 0;
+
+        [[nodiscard]] bool IsDown(const MouseButton& btn) const
+        {
+            if (btn == MouseButtons::Left) return Buttons.LMB;
+            if (btn == MouseButtons::Right) return Buttons.RMB;
+            if (btn == MouseButtons::Middle) return Buttons.MMB;
+            if (btn == MouseButtons::Mouse4) return Buttons.SideButton1;
+            if (btn == MouseButtons::Mouse5) return Buttons.SideButton2;
+            //if (btn == MouseButtons::MWheelUp) return Buttons.MWheelUp;
+            //if (btn == MouseButtons::MWheelDown) return Buttons.MWheelDown;
+
+            return false; // Unknown button?
+        }
+
+        void Set(const MouseButton& btn, bool state)
+        {
+            if (btn == MouseButtons::Left) Buttons.LMB = state;
+            if (btn == MouseButtons::Right) Buttons.RMB = state;
+            if (btn == MouseButtons::Middle) Buttons.MMB = state;
+            if (btn == MouseButtons::Mouse4) Buttons.SideButton1 = state;
+            if (btn == MouseButtons::Mouse5) Buttons.SideButton2 = state;
+            //if (btn == MouseButtons::MWheelUp) Buttons.MWheelUp = state;
+            //if (btn == MouseButtons::MWheelDown) Buttons.MWheelDown = state;
+        }
+
+        bool& operator[](const MouseButton& btn)
+        {
+            if (btn == MouseButtons::Left) return Buttons.LMB;
+            if (btn == MouseButtons::Right) return Buttons.RMB;
+            if (btn == MouseButtons::Middle) return Buttons.MMB;
+            if (btn == MouseButtons::Mouse4) return Buttons.SideButton1;
+            if (btn == MouseButtons::Mouse5) return Buttons.SideButton2;
+            //if (btn == MouseButtons::MWheelUp) return Buttons.MWheelUp;
+            //if (btn == MouseButtons::MWheelDown) return Buttons.MWheelDown;
+
+            throw std::runtime_error("Attempted to handle unmapped mouse button");
+        }
+    };*/
+
+    struct MouseState
+    {
+        ButtonState Left;
+        ButtonState Right;
+        ButtonState Middle;
+        ButtonState Mouse4;
+        ButtonState Mouse5;
+        ButtonState WheelUp;
+        ButtonState WheelDown;
+
+        Vector2 Position;
+        Vector2 Delta;
+        Vector2 Velocity;
+        int Wheel;
+
+
+    };
+
+
+    struct ThumbstickState
+    {
+
+        Vector2 Unit;
+    };
+
+    class Thumbstick
     {
 
     };
+
+    struct TriggerState
+    {
+
+    };
+
+    class Trigger
+    {
+
+    };
+
+    struct GamepadState
+    {
+        ButtonState X;
+        ButtonState Y;
+        ButtonState A;
+        ButtonState B;
+
+        // TODO: Also have analog DPad;
+        ButtonState DPadLeft;
+        ButtonState DPadRight;
+        ButtonState DPadUp;
+        ButtonState DPadDown;
+
+        ButtonState Pause;
+        ButtonState Select;
+        ButtonState Home;
+
+        ButtonState LeftThumbButton;
+        ButtonState RightThumbButton;
+
+        TriggerState LeftTrigger;
+        TriggerState RightTrigger;
+
+        ThumbstickState LeftThumbstick;
+        ThumbstickState RightThumbstick;
+
+    };
+
+    class TouchscreenState
+    {
+
+    };
+
+    /*
+     *  Gamepad
+     */
+
+    constexpr int MaxDeviceStateHistory = 100;
+
+    class Gamepad : public InputDevice
+    {
+    public:
+        uint GetButtonCount() const;
+        uint GetRumbleMotorCount() const;
+    protected:
+        Thumbstick LeftThumb;
+        Thumbstick RightThumb;
+
+        Trigger RightTrigger;
+        Trigger LeftTrigger;
+
+        GamepadState current_state;
+        GamepadState previous_state;
+        GamepadState history[MaxDeviceStateHistory];
+    };
+
+
+    class XboxGamepad : public Gamepad {};
+    class PS4Gamepad : public Gamepad {};
+
+    /*
+     *  Pointer
+     */
+
+    class PointerDevice : public InputDevice {
+    public:
+        void Update(double elapsed) override {
+            InputDevice::Update(elapsed);
+        }
+    };
+
+    /*
+    struct InputEvent
+    {
+        std::chrono::system_clock::time_point Timestamp;
+    };
+     */
+
+    struct MouseButtonEvent : public InputEvent
+    {
+
+    };
+
+    class MouseMoveEvent
+    {
+
+    };
+
+    class MouseWheelEvent
+    {
+
+    };
+
+    struct TouchEvent
+    {
+
+        int TouchID;
+        Vector2 Position;
+        Vector2 Velocity;
+        float Pressure;
+    };
+
+    class Mouse : public PointerDevice
+    {
+    public:
+    public:
+        Event<> Moved;
+        Event<> ButtonPressed;
+        Event<> ButtonReleased;
+        Event<> WheelMoved;
+    public:
+        Mouse();
+        ~Mouse();
+        Vector2 GetPosition() const;
+        bool IsButtonDown(const MouseButton& btn) const;
+        ButtonState GetButtonState(const MouseButton& btn) const;
+        void Update(double elapsed) override;
+        DeviceType GetType() const override;
+        void DoButtonPress(const MouseButton& btn);
+        void DoButtonRelease(const MouseButton& btn);
+        void DoMove(const Vector2& pos);
+        void DoScrollWheel(int scroll);
+    protected:
+        void SetButtonPressed(const MouseButton& btn, bool pressed);
+        void SetButtonState(const MouseButton& btn, ButtonState state);
+    protected:
+        MouseState current_state;
+        MouseState previous_state;
+        MouseState history[MaxDeviceStateHistory];
+    public:
+    protected:
+    private:
+    };
+
+    class Touchscreen : public PointerDevice
+    {
+    public:
+        static Event<const TouchEvent&> TouchMoved;
+        static Event<const TouchEvent&> TouchPressed;
+        static Event<const TouchEvent&> TouchReleased;
+
+        static Touchscreen GetCurrentDevice();
+
+        int GetPosition(int touchIndex);
+        int GetTouchCount();
+        int GetMaxTouchCount();
+        std::vector<int> GetTouches();
+
+        /// Returns the pressure of the touch-press. Most touch screens aren't pressure sensitive, in which case the pressure will be 1.
+        float GetPressure(int touchIndex);
+
+    };
+
+    class VRHeadset : public InputDevice { };
+
+    class GenericTVRemote : public InputDevice { };
+
+
+
+
+
 }

include/rewindow/types/mousebutton.h

@@ -10,27 +10,35 @@
 
 #pragma once
 
+#include <string>
 
 class MouseButton {
 public:
-    MouseButton();
-    explicit MouseButton(const char* charcode, unsigned int index);
-    const char* CharCode;
+    std::string Mnemonic;
     unsigned int ButtonIndex;
+
+    MouseButton() = default;
+    explicit MouseButton(const std::string& charcode, unsigned int index);
+
     bool operator == (const MouseButton& mb) const;
+    bool operator<(const MouseButton& rhs) const;
+    MouseButton(const MouseButton&) = default;
 };
 
 
 namespace MouseButtons
 {
-    static const MouseButton Left {"l", 1};
-    static const MouseButton Right {"r", 2};
-    static const MouseButton Middle {"m", 3};
-    static const MouseButton 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};
+    static const MouseButton Left           ("L", 1);
+    static const MouseButton Right          ("R", 2);
+    static const MouseButton Middle         ("M", 3);
+    static const MouseButton Mouse4         ("4", 8);
+    static const MouseButton Mouse5         ("5", 9);
+    static const MouseButton Unimplemented  ("?", 0);
+
+    /// NOTE: IsMouseButtonDown will not return correctly for the mouse-wheel-buttons, because the action is effectively instantaneous.
+    static const MouseButton MWheelUp       ("U", 4);
+    /// NOTE: IsMouseButtonDown will not return correctly for the mouse-wheel-buttons, because the action is effectively instantaneous.
+    static const MouseButton MWheelDown     ("D", 5);
 }
 
 MouseButton GetMouseButtonFromXButton(unsigned int button);

include/rewindow/types/window.h

@@ -2,18 +2,18 @@
 #include <cstdint>
 #include <vector>
 #include <Event.h>
-#include <EventConnection.h> // TODO: Fix this shit to where we don't need to include both files they should just be bundled together
 #include <map>
 #include <thread>
-#include <rewindow/types/key.h>
+//#include <rewindow/types/key.h>
 #include <rewindow/types/cursors.h>
 #include <rewindow/types/mousebutton.h>
 #include <rewindow/types/gamepadbutton.h>
+#include <rewindow/types/mouse.h>
+#include <rewindow/types/WindowEvents.hpp>
+#include <rewindow/types/keyboard.h>
+#include <rewindow/types/gamepad.h>
 #include <J3ML/LinearAlgebra.hpp>
-
-using namespace std::chrono_literals;
-using precision_clock = std::chrono::high_resolution_clock;
-using precision_timestamp = precision_clock::time_point;
+#include <format>
 
 enum class RWindowFlags: uint8_t {
 	IN_FOCUS,
@@ -32,113 +32,26 @@ enum class RenderingAPI: uint8_t {
 	VULKAN = 1,
 };
 
-enum class KeyState {Pressed, Released};
-
 namespace ReWindow
 {
 	using J3ML::LinearAlgebra::Vector2;
 
-	class TimestampedEvent {
-	private:
-
-	public:
-		precision_timestamp Timestamp;
-		TimestampedEvent() : Timestamp(precision_clock::now())
-		{ }
-	};
-
-	class RWindowEvent : public TimestampedEvent {
-	public:
-		RWindowEvent() : TimestampedEvent() { }
-	};
-	const RWindowEvent EmptyRWindowEvent;
-
-	namespace WindowEvents {
-		class KeyboardState {
-		public:
-			std::map<Key, bool> PressedKeys;
-		};
-
-		class GamepadState {
-		public:
-			std::map<GamepadButton, bool> PressedButtons;
-		};
-
-		class InputState {
-		public:
-			KeyboardState Keyboard;
-			GamepadState Gamepad;
-		};
-
-		class KeyboardEvent : public RWindowEvent {
-		public:
-			Key key;
-			KeyState state;
-			KeyboardEvent(Key key, KeyState state) : RWindowEvent(), key(key), state(state) {}
-		};
-		class MouseEvent : public RWindowEvent {};
-
-		class GamepadEvent : public RWindowEvent {};
-
-		class MouseMoveEvent : public MouseEvent {
-		public:
-			Vector2 Position;
-			Vector2 Delta;
-			MouseMoveEvent(const Vector2 &pos) : MouseEvent(), Position(pos)
-			{}
-			MouseMoveEvent(int x, int y) : MouseEvent(), Position(Vector2(x, y))
-			{}
-		};
-
-		class KeyDownEvent : public KeyboardEvent {
-		public:
-			KeyDownEvent(Key key) : KeyboardEvent(key, KeyState::Pressed) {}
-		};
-
-		class KeyUpEvent : public KeyboardEvent {
-		public:
-			KeyUpEvent(Key key) : KeyboardEvent(key, KeyState::Released) {}
-		};
-
-
-		class MouseButtonDownEvent : public MouseEvent {
-		public:
-			MouseButton Button;
-
-            MouseButtonDownEvent() = default;
-			MouseButtonDownEvent(MouseButton Button) : MouseEvent() {}
-		};
-
-		class MouseButtonUpEvent : public MouseEvent {
-		public:
-			MouseButton Button;
-            MouseButtonUpEvent() = default;
-			MouseButtonUpEvent(MouseButton Button) : MouseEvent() {}
-		};
-
-		class WindowResizeRequestEvent : public RWindowEvent
-		{
-		public:
-			Vector2 Size;
-		};
-	}
-
-	using namespace WindowEvents;
-
-
-	/// General To Do List
-	/// TODO: Clean up public API to express the cross-platform, multi-graphics-mode ethos of this project.
-	///
-
+    /// RWindow is a class implementation of a platform-independent window abstraction.
+    /// This library also provides abstractions for user-input devices, and their interaction with the window.
 	class RWindow {
 	public:
+#pragma region Constructors
+        /// The default constructor sets a default size and window title.
+        RWindow();
+        /// Constructs a window by explicitly setting title, width and height.
+        RWindow(const std::string& title, int width, int height);
+        /// Constructs a window as above with the additional argument of explicitly setting which render API is to be used.
+        RWindow(const std::string& title, int width, int height, RenderingAPI renderer);
+#pragma endregion
+
+        /// Bindables are provided for hooking into window instances conveniently, without the need to derive and override for simple use cases.
+#pragma region Bindable Events
 
-		/// 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;
@@ -150,41 +63,72 @@ namespace ReWindow
 		Event<MouseMoveEvent> OnMouseMoveEvent;
 		Event<MouseButtonDownEvent> OnMouseButtonDownEvent;
 		Event<MouseButtonUpEvent> OnMouseButtonUpEvent;
+		Event<MouseWheelEvent> OnMouseWheelEvent;
+
+        Event<InputDevice*, InputEvent> OnInputDeviceEvent;
 #pragma endregion
+
+        /// These methods can also be overridden in derived classes.
 #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() {}
+        /// Called when the window loses focus.
 		virtual void OnFocusLost(const RWindowEvent& e) {}
+        /// Called when the window gains focus.
 		virtual void OnFocusGain(const RWindowEvent& e) {}
+        /// Called when the window is 'refreshed', in other words, a render pass is completed.
 		virtual void OnRefresh(float elapsed) {}
+        /// Called when a resize request has succeeded.
 		virtual void OnResizeSuccess() {}
+        /// Called when a resize request is sent to the operating system.
 		virtual bool OnResizeRequest(const WindowResizeRequestEvent& e) { return true;}
 		virtual void OnKeyDown(const KeyDownEvent&) {}
 		virtual void OnKeyUp(const KeyUpEvent&) {}
 		virtual void OnMouseMove(const MouseMoveEvent&) {}
 		virtual void OnMouseButtonDown(const MouseButtonDownEvent&) {}
 		virtual void OnMouseButtonUp(const MouseButtonUpEvent&) {}
+		virtual void OnMouseWheel(const MouseWheelEvent&) {}
 #pragma endregion
 
-		/// 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);
+        Mouse* GetMouse();
+        Keyboard* GetKeyboard();
 
+#pragma region Input Helpers
 		/// Returns a Vector2 representing mouse coordinates relative to the top-left corner of the window.
+		/// This result is cached from the operating-system, and as such may be out-of-date.
+		/// @see GetAccurateMouseCoordinates().
 		Vector2 GetMouseCoordinates() const;
 
-		/// Sets which rendering API is to be used with this window.
-		void setRenderer(RenderingAPI api);
+        int GetMouseWheelPersistent() const { return currentMouse.Wheel;}
 
-		/// Initializes all state with the window manager and rendering API, then opens the window.
+#pragma endregion
+
+#pragma region Cursor Modifiers
+        void SetCursorStyle(CursorStyle style) const;
+
+        void SetCursorCustomIcon() const;
+
+        void SetCursorLocked();
+
+        void SetCursorCenter();
+
+        void RestoreCursorFromLastCenter(); // Feels nicer for users
+
+        /// Hides the cursor when it's inside of our window. Useful for 3D game camera.
+        void SetCursorVisible(bool cursor_enable);
+
+        bool GetCursorVisible();
+
+#pragma endregion
+
+		/// Sets which rendering API is to be used with this window.
+		void SetRenderer(RenderingAPI api);
+
+		/// This function instructs the operating system to create the actual window, and give it to us to control.
+		/// Calling this function, therefore, creates the real 'window' object on the operating system.
 		void Open();
 
 		/// Cleans up and closes the window without destroying the handle.
@@ -194,117 +138,202 @@ namespace ReWindow
 
 		void MessageBox(); // TODO: Must be implemented from scratch as a Motif Window in x11
 
+        /// Sends a request to the operating system to have this window somehow demand attention from the user.
+        /// This is implemented per-operating system, and as such no guarantees about behavior can be made.
+        void Flash();
+
 		/// Returns whether the window currently has mouse and/or keyboard focus.
-		[[nodiscard]] bool isFocused() const;
-		[[nodiscard]] bool isFullscreen() const;
-		[[nodiscard]] bool isResizable() const;
-		[[nodiscard]] bool isVsyncEnabled() const;
+		[[nodiscard]] bool IsFocused() const;
 
-		[[nodiscard]] bool isAlive() const; // TODO: Always returns true.
+        /// Returns whether the window is currently in Fullscreen.
+        // TODO: Support Fullscreen, FullscreenWindowed, and Windowed?
+		[[nodiscard]] bool IsFullscreen() const;
 
-		[[nodiscard]] bool isKeyDown(Key key) const;
-		[[nodiscard]] bool isMouseButtonDown(MouseButton button) const;
+        /// Returns whether the window can be resized.
+		[[nodiscard]] bool IsResizable() const;
 
-		void setFullscreen(bool fs);
-		void setResizable(bool resizable);
-		void setVsyncEnabled(bool);
-		void setTitle(const std::string& title);
-		[[nodiscard]] std::string getTitle() const;
-		[[nodiscard]] int getWidth() const;  // Honestly no idea if we'll keep these or still go with getSize.
-		[[nodiscard]] int getHeight() const; // getSize wasn't working for me for logging. -maxine
-		void setSizeWithoutEvent(const Vector2& size); //AAAAAHHHHHHHHH WINDOZE MAKING THINGS DIFFICULT :/ - Redacted.
-		// TODO: Move out of public API, consumers should use setFullscreen()
-		void fullscreen();
-		// TODO: Move out of public API, consumers should use setFullscreen()
-		void restoreFromFullscreen();
+        /// Returns whether V-Sync is enabled.
+		[[nodiscard]] bool IsVsyncEnabled() const;
+
+        /// Returns whether the window is considered to be alive. Once dead, any logic loop should be terminated, and the cleanup procedure should run.
+		[[nodiscard]] bool IsAlive() const;
+
+        /// Returns whether the given key is currently being pressed.
+		[[nodiscard]] bool IsKeyDown(Key key) const;
+
+        /// Returns whether the given mouse button is currently being pressed.
+		[[nodiscard]] bool IsMouseButtonDown(const MouseButton &button) const;
+
+        /// Sets whether or not to make the window fullscreen.
+        /// @note This is implemented per-OS, and as such, it simply requests the OS to do what we want. No guarantee about follow-through can be given.
+		void SetFullscreen(bool fs);
+
+        /// Sets whether or not to make the window resizable.
+        /// @note This is implemented per-OS, and as such, it simply requests the OS to do what we want. No guarantee about follow-through can be given.
+		void SetResizable(bool resizable);
+
+        /// Sets whether or not to enable vertical synchronization.
+        /// @note This is implemented per-OS, and as such, it simply requests the OS to do what we want. No guarantee about follow-through can be given.
+		void SetVsyncEnabled(bool vsync);
+
+        /// Sets the title of this window.
+		void SetTitle(const std::string& title);
+		[[nodiscard]] std::string GetTitle() const;
+
+        /// Returns the horizontal length of this window, in pixels.
+		[[nodiscard]] int GetWidth() const;
+        /// Returns the vertical length of this window, in pixels.
+		[[nodiscard]] int GetHeight() const;
+
+        /// A special-case function to change our internal size variable, without triggering event updates.
+		void SetSizeWithoutEvent(const Vector2& size); //AAAAAHHHHHHHHH WINDOZE MAKING THINGS DIFFICULT :/ - Redacted.
+
+		void SetLastKnownWindowSize(const Vector2& size);
 
 		// TODO: Josh hates parameter-flags, it's not 1995 :/
-		bool getFlag(RWindowFlags flag) const;
+		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);
+		void SetFlag(RWindowFlags flag, bool state);
+
+        /// Returns the name of the developer of the user's graphics driver, if it can be determined.
+        std::string getGraphicsDriverVendor();
 
 		/// Tells the underlying window manager to destroy this window and drop the handle.
 		/// The window, in theory, can not be re-opened after this.
-		/// TODO: Create a destructor and move to there?
-		/// TODO: What's the semantic difference between this and Close()?
-		void destroyWindow();
+		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();
+		/// Reads events from the operating system, and processes them accordingly.
+		/// TODO: Move out of public API, consumers should call Refresh or ideally an update() call.
+		void PollEvents();
+
+        /// Updates internal window state, similar to ManagedRefresh, but without accounting for any timekeeping. This is left up to the user.
+		void Refresh();
+
+        /// Updates the window and handles timing internally.
+        void ManagedRefresh();
+
+        /// Requests the operating system to change the window size.
+        /// @param width
+        /// @param height
+		void SetSize(int width, int height);
+        /// Requests the operating system to change the window size.
+        /// @param size
+		void SetSize(const Vector2& size);
 
-		/// 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;
+		Vector2 GetPos() const;
+
+		/// Returns the known size of the window, in {x,y} pixel measurement.
+		Vector2 GetSize() const;
 
         /// Returns the position of the "renderable area" of the window relative to it's top left corner.
-        /// (used to account for the width or the border & title bar).
-        Vector2 getPositionOfRenderableArea() const;
+        /// (used to account for the width of the border & title bar).
+        Vector2 GetPositionOfRenderableArea() const;
+
+        /// Requests the operating system to move the window to the specified coordinates on the display.
+        /// @param x The horizontal screen position to place the window at.
+        /// @param y The vertical screen position to place the window at.
+		void SetPos(int x, int y);
+        /// Requests the operating system to move the window to the specified coordinates on the display.
+        /// @param pos A Vector2 representing the x,y coordinates of the desired window destination. Fractional values are ignored.
+		void SetPos(const Vector2& pos);
 
-		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;
+		/// NOTE: The implementation is defined per-OS, and thus there is no guarantee of it always working.
+		void Raise() const;
+		/// Push the window Lower, such that it is effectively hidden behind other windows.
+		/// NOTE: The implementation is defined per-OS, and thus there is no guarantee of it always working.
+		void Lower() const;
 
-        void setCursorLocked();
-        void setCursorCenter();
-        void restoreCursorFromLastCenter(); // Feels nicer for users
-
-		///Hides the cursor when it's inside of our window.
-		///Useful for 3D game camera.
-		void setCursorVisible(bool cursor_enable);
-		bool getCursorVisible();
 
 		/// Calls OpenGL's SwapBuffers routine.
 		/// NOTE: This is only used when the underlying rendering API is set to OpenGL.
-		static void glSwapBuffers();
-        Vector2 getLastKnownResize() const;
-		void setLastKnownWindowSize(const Vector2& size);
+		static void GLSwapBuffers();
+
+        /// Returns the current time, represented as a high-resolution std::chrono alias.
+        static std::chrono::steady_clock::time_point GetTimestamp();
+
+        /// Computes elapsed time from a start-point and end-point.
+        float ComputeElapsedFrameTimeSeconds(std::chrono::steady_clock::time_point start, std::chrono::steady_clock::time_point end);
+
+        /// Updates internals to account for the latest calculated frame time.
+        void UpdateFrameTiming(float frame_time);
+
+        /// Returns the amount of time, in seconds, between the current and last frame.
+        /// Technically, no, it returns the elapsed time of the frame, start to finish.
+        [[nodiscard]] float GetDeltaTime() const;
+
+        /// Returns the approximate frames-per-second using delta time.
+        [[nodiscard]] float GetRefreshRate() const;
+
+        /// Returns the number of frames ran since the windows' creation.
+        [[nodiscard]] float GetRefreshCounter() const;
     protected:
-        float delta_time;
-        float refresh_rate;
-        int refresh_count;
+        /// Requests the operating system to make the window fullscreen. Saves the previous window size as well.
+        void Fullscreen();
+
+        /// Requests the operating system to take the window out of fullscreen mode. Previously saved window size is restored, if possible.
+        void RestoreFromFullscreen();
+
+        bool DetectsMouse();
+        bool DetectsKeyboard();
+        bool DetectsGamepad();
+
+    protected:
+#pragma region Data
+
+        std::string title = "Redacted Window";
+        int width = 1280;
+        int height = 720;
+
+        bool fullscreen_mode = false;
+        bool focused = true;
+        bool vsync = false;
         bool cursor_visible = true;
+        bool open = false;
+        bool resizable = true;
+
         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;
 
-        Vector2 mouse_coords = {0, 0};
-        Vector2 last_mouse_coords = {0, 0};
-	private:
+        /// Input Devices;
+        Mouse* mouse;
+        Keyboard* keyboard;
+        Gamepad* gamepad;
+
+        std::vector<InputDevice*> input_devices;
 
 
+        RenderingAPI renderer = RenderingAPI::OPENGL;
+
+        //Vector2 mouse_coords = {0, 0};
+        //Vector2 last_mouse_coords = {0, 0};
+
+
+        float delta_time = 0.f;
+        float refresh_rate = 0.f;
+        unsigned int refresh_count = 0;
+
+        // TODO: Implement ringbuffer / circular vector class of some sort.
+        float refresh_rate_prev_1 = 0.f;
+        float refresh_rate_prev_2 = 0.f;
+        float refresh_rate_prev_3 = 0.f;
+        float refresh_rate_prev_4 = 0.f;
+        float refresh_rate_prev_5 = 0.f;
+
+        float avg_refresh_rate = 0.0f;
+#pragma endregion
+#pragma region Internals
 		/// Returns the most accurate and recent available mouse coordinates.
 		/// @note Call this version at most **once** per-frame. It polls the X-Window server and therefore is quite slow.
 		/// @see getCursorPos();
 		Vector2 GetAccurateMouseCoordinates() const;
 
+	public:
+/// These unfortunately *have* to be public because of the poor design of the windows event loop.
+#pragma region Event Callers
         /// Executes event handlers for keyboard rele;ase events.
         void processKeyRelease (Key key);
         /// Executes event handlers for keyboard press events.
@@ -316,9 +345,9 @@ namespace ReWindow
         /// @note This will be invoked **after** the window-open procedure completes.
 		void processOnOpen();
 		/// Executes event handlers for mouse press events.
-        void processMousePress(MouseButton btn);
+        void processMousePress(const MouseButton& btn);
         /// Executes event handlers for mouse release events.
-        void processMouseRelease(MouseButton btn);
+        void processMouseRelease(const MouseButton& btn);
         /// Executes event handlers for window focus events.
         void processFocusIn();
         /// Executes event handlers for window unfocus events.
@@ -326,9 +355,9 @@ namespace ReWindow
 
         void processMouseMove(Vector2 last_pos, Vector2 new_pos);
 
-    private:
-
-
-
+        void processMouseWheel(int scrolls);
+#pragma endregion
+private:
+#pragma endregion
     };
 }

main.cpp

@@ -28,10 +28,32 @@ class MyWindow : public ReWindow::RWindow {
 	void OnRefresh(float elapsed) override {
             glClearColor(255, 0, 0, 255);
             glClear(GL_COLOR_BUFFER_BIT);
-		glSwapBuffers();
+        GLSwapBuffers();
 		auto pos = GetMouseCoordinates();
 		//std::cout << pos.x << ", " << pos.y << std::endl;
 
+        //if (IsMouseButtonDown(MouseButtons::MWheelUp))
+            //std::cout << "WheelUp Mouse Button" << std::endl;
+
+        //if (IsMouseButtonDown(MouseButtons::MWheelDown))
+            //std::cout << "WheelDown Mouse Button" << std::endl;
+
+        if (IsMouseButtonDown(MouseButtons::Left))
+            std::cout << "Left Mouse Button" << std::endl;
+
+        if (IsMouseButtonDown(MouseButtons::Right))
+            std::cout << "Right Mouse Button" << std::endl;
+
+        if (IsMouseButtonDown(MouseButtons::Middle))
+            std::cout << "Middle Mouse Button" << std::endl;
+
+
+        if (IsMouseButtonDown(MouseButtons::Mouse4))
+            std::cout << "Mouse4 Mouse Button" << std::endl;
+
+        if (IsMouseButtonDown(MouseButtons::Mouse5))
+            std::cout << "Mouse5 Mouse Button" << std::endl;
+
         RWindow::OnRefresh(elapsed);
 	}
 
@@ -39,25 +61,38 @@ class MyWindow : public ReWindow::RWindow {
 		std::cout << "resized to " << e.Size.x << ", " << e.Size.y << std::endl;
 		return true;
 	}
+
+    void OnMouseButtonDown(const ReWindow::MouseButtonDownEvent &e) override
+    {
+            std::cout << "Overload Down: " << e.Button.Mnemonic << std::endl;
+            RWindow::OnMouseButtonDown(e);
+    }
+
+    void OnMouseButtonUp(const ReWindow::MouseButtonUpEvent &e) override
+    {
+            std::cout << "Overload Up: " << e.Button.Mnemonic << std::endl;
+            RWindow::OnMouseButtonUp(e);
+    }
 };
 
 int main() {
 	auto* window = new MyWindow("Test Window", 600, 480);
-	jlog::Debug(std::format("New window '{}' created. width={} height={}", window->getTitle(), window->getWidth(), window->getHeight()));
+	jlog::Debug(std::format("New window '{}' created. width={} height={}", window->GetTitle(), window->GetWidth(),
+                            window->GetHeight()));
 
-	window->setRenderer(RenderingAPI::OPENGL);
-	jlog::Debug(std::format("Rendering API OPENGL set for window '{}'", window->getTitle()));
+    window->SetRenderer(RenderingAPI::OPENGL);
+	jlog::Debug(std::format("Rendering API OPENGL set for window '{}'", window->GetTitle()));
 
 	window->Open();
-	jlog::Debug(std::format("Opened window '{}'", window->getTitle()));
+	jlog::Debug(std::format("Opened window '{}'", window->GetTitle()));
 
 	// TODO: Cannot set flags until after window is open
 	// Make this work somehow
 	jlog::Debug("TODO: Cannot set flags until after window is open");
-	window->setFullscreen(false);
-	window->setVsyncEnabled(true);
-	window->setResizable(true);
-	window->setCursorVisible(false);
+    window->SetFullscreen(false);
+    window->SetVsyncEnabled(true);
+    window->SetResizable(true);
+    window->SetCursorVisible(false);
 
 	/*
     std::vector<ReWindow::Display> d = ReWindow::Display::getDisplaysFromWindowManager();
@@ -73,8 +108,8 @@ int main() {
         std::cout << std::format("Mode ({},{}) @ {}hz Ratio {}", w, h, r, aspect) << std::endl;
 
         for (ReWindow::FullscreenGraphicsMode& fgm : display.getGraphicsModes()) {
-            w =  fgm.getWidth();
-            h = fgm.getHeight();
+            w =  fgm.GetWidth();
+            h = fgm.GetHeight();
             r = fgm.getRefreshRate();
 
             auto aspect = (float)w/(float)h;
@@ -85,27 +120,46 @@ int main() {
     */
 
 	ReWindow::Logger::Debug(std::format("Window '{}' flags: IN_FOCUS={} FULLSCREEN={} RESIZEABLE={} VSYNC={} QUIT={}",
-		window->getTitle(),
-		window->getFlag(RWindowFlags::IN_FOCUS),
-		window->getFlag(RWindowFlags::FULLSCREEN),
-		window->getFlag(RWindowFlags::RESIZABLE),
-		window->getFlag(RWindowFlags::VSYNC),
-		window->getFlag(RWindowFlags::QUIT)));
+                                        window->GetTitle(),
+                                        window->GetFlag(RWindowFlags::IN_FOCUS),
+                                        window->GetFlag(RWindowFlags::FULLSCREEN),
+                                        window->GetFlag(RWindowFlags::RESIZABLE),
+                                        window->GetFlag(RWindowFlags::VSYNC),
+                                        window->GetFlag(RWindowFlags::QUIT)));
 
 
 	window->OnKeyDownEvent += [&] (ReWindow::KeyDownEvent e) {
-        jlog::Debug(e.key.CharCode);
+        jlog::Debug(e.key.Mnemonic);
 	};
 
 
 	window->OnMouseButtonDownEvent += [&] (ReWindow::MouseButtonDownEvent e) {
-		jlog::Debug(e.Button.CharCode);
+		jlog::Debug(e.Button.Mnemonic + std::to_string(e.Button.ButtonIndex));
 	};
 
-	while (window->isAlive()) {
-		window->pollEvents();
-		window->refresh();
+    window->OnMouseWheelEvent += [&, window] (ReWindow::MouseWheelEvent e)
+    {
+        std::cout << window->GetMouseWheelPersistent() << std::endl;
+    };
+
+	while (window->IsAlive()) {
+        window->PollEvents();
+        window->ManagedRefresh();
 	}
+    // Alternatively:
+    /*
+     * while (window->IsAlive()) {
+     *      auto start = window->GetTimestamp();
+     *      ourUpdateLogic(window->GetDeltaTime());
+     *      window->update();
+     *      ourDrawLogic();
+     *      window->Refresh();
+     *      auto end = window->GetTimestamp();
+     *      auto dt = window->ComputeElapsedFrameTimeSeconds(start, end);
+     *      window->UpdateFrameTiming(dt);
+     * }
+     *
+     */
 }
 
 /*

src/platform/linux/display.cpp

@@ -53,7 +53,7 @@ std::vector<ReWindow::Display> ReWindow::Display::getDisplaysFromWindowManager()
                 for (int k = 0; k < screen_resources->nmode; k++) {
                     if (screen_resources->modes[k].id == mode) {
                         XRRModeInfo mode_info = screen_resources->modes[k];
-                        // Calculate refresh rate from the mode's dot clock
+                        // Calculate Refresh rate from the mode's dot clock
                         double refresh_rate = 0.0;
                         if (mode_info.hTotal > 0 && mode_info.vTotal > 0)
                             refresh_rate = mode_info.dotClock / (double)(mode_info.hTotal * mode_info.vTotal);

src/platform/linux/window.cpp

@@ -38,7 +38,7 @@ bool should_poll_x_for_mouse_pos = true;
 
 using namespace ReWindow;
 
-void RWindow::raise() const {
+void RWindow::Raise() const {
     Logger::Debug(std::format("Raising window '{}'", this->title));
 
     // Get the position of the renderable area relative to the rest of the window.
@@ -48,13 +48,13 @@ void RWindow::raise() const {
     XRaiseWindow(display, window);
 }
 
-void RWindow::lower() const
+void RWindow::Lower() const
 {
     Logger::Debug(std::format("Lowering window '{}'", this->title));
     XLowerWindow(display, window);
 }
 
-void RWindow::destroyWindow() {
+void RWindow::DestroyWindow() {
     Logger::Debug(std::format("Destroying window '{}'", this->title));
     XDestroySubwindows(display, window);
     Logger::Debug(std::format("Destroyed window '{}'", this->title));
@@ -62,41 +62,10 @@ void RWindow::destroyWindow() {
     delete this;
 }
 
-void RWindow::refresh() {
+//void RWindow::
 
-    auto begin_frame = std::chrono::high_resolution_clock::now();
-
-
-    OnRefresh(delta_time);
-
-    // Only call once and cache the result.
-    mouse_coords = GetAccurateMouseCoordinates();
-
-    /// TODO: Implement optional minimum epsilon to trigger a Mouse Update.
-    if (mouse_coords != last_mouse_coords) {
-        processMouseMove(last_mouse_coords, mouse_coords);
-        last_mouse_coords = mouse_coords;
-    }
-
-    auto end_frame = std::chrono::high_resolution_clock::now();
-
-    auto frame_time = end_frame - begin_frame;
-    int frame_time_ms = std::chrono::duration_cast<std::chrono::milliseconds>(frame_time).count();
-    float frame_time_s = frame_time_ms / 1000.f;
-    delta_time = frame_time_ms;
-
-    refresh_rate = 1.f / refresh_rate;
-
-
-    refresh_count++;
-
-
-    //std::this_thread::sleep_for(1ms);
-}
-
-void RWindow::setCursorVisible(bool cursor_enable) {
+void RWindow::SetCursorVisible(bool cursor_enable) {
     cursor_visible = cursor_enable;
-
     if (invisible_cursor == 0) {
         Pixmap blank_pixmap = XCreatePixmap(display, window, 1, 1, 1);
         XColor dummy; dummy.pixel = 0; dummy.red = 0; dummy.flags = 0;
@@ -111,7 +80,24 @@ void RWindow::setCursorVisible(bool cursor_enable) {
         XUndefineCursor(display, window);
 }
 
-void RWindow::setFlag(RWindowFlags flag, bool state) {
+void RWindow::SetResizable(bool sizable) {
+    XGetWindowAttributes(display,window,&windowAttributes);
+
+
+    this->resizable = sizable;
+    if (!sizable)
+    {
+        Logger::Debug("Once you've done this you cannot make it resizable again.");
+        hints.flags = PMinSize | PMaxSize;
+        hints.min_width = hints.max_width = windowAttributes.width;
+        hints.min_height = hints.max_height = windowAttributes.height;
+        XSetWMNormalHints(display, window, &hints);
+    }
+    //this->SetFlag(RWindowFlags::RESIZABLE, resizable);
+
+}
+
+void RWindow::SetFlag(RWindowFlags flag, bool state) {
     XGetWindowAttributes(display,window,&windowAttributes);
     flags[(int) flag] = state;
     //Once you've done this you cannot make it resizable again.
@@ -125,7 +111,7 @@ void RWindow::setFlag(RWindowFlags flag, bool state) {
     Logger::Debug(std::format("Set flag '{}' to state '{}' for window '{}'", RWindowFlagToStr(flag), state, this->title));
 }
 
-void RWindow::pollEvents() {
+void RWindow::PollEvents() {
     while(XPending(display)) {
         XNextEvent(display, &xev);
 
@@ -135,7 +121,7 @@ void RWindow::pollEvents() {
         if (xev.xclient.message_type == XInternAtom(display, "WM_PROTOCOLS", False) && static_cast<Atom>(xev.xclient.data.l[0]) == wmDeleteWindow) {
 
             processOnClose();
-            destroyWindow();
+            DestroyWindow();
             system("xset r on");
             exit(0);
         }
@@ -143,7 +129,7 @@ void RWindow::pollEvents() {
         if (xev.type == FocusIn) {
             Logger::Debug(std::format("Recieved event '{}'", "FocusIn"));
             XAutoRepeatOff(display);
-            setFlag(RWindowFlags::IN_FOCUS, true);
+            SetFlag(RWindowFlags::IN_FOCUS, true);
 
             if (!cursor_visible)
                 XDefineCursor(display, window, invisible_cursor);
@@ -158,7 +144,7 @@ void RWindow::pollEvents() {
             Logger::Debug(std::format("Recieved event '{}'", "FocusOut"));
             XAutoRepeatOn(display);
 
-            setFlag(RWindowFlags::IN_FOCUS, false);
+            SetFlag(RWindowFlags::IN_FOCUS, false);
             if (!cursor_visible)
                 XUndefineCursor(display, window);
 
@@ -180,18 +166,34 @@ void RWindow::pollEvents() {
         }
 
         if (xev.type == ButtonRelease) {
-            Logger::Debug(std::format("Recieved event '{}'", "ButtonRelease"));
-            MouseButton button = GetMouseButtonFromXButton(xev.xbutton.button);
 
-            processMouseRelease(button);
+            // Mouse Wheel fires both the ButtonPress and ButtonRelease instantaneously.
+            // Therefore, we handle it as a specific MouseWheel event rather than a MouseButton event,
+            // and only call on ButtonPress, otherwise it will appear to duplicate the mouse wheel scroll.
+            if (xev.xbutton.button != 4 && xev.xbutton.button != 5) {
+                MouseButton button = GetMouseButtonFromXButton(xev.xbutton.button);
+                Logger::Debug(std::format("Recieved event '{}'", "ButtonRelease"));
+                processMouseRelease(button);
+            }
         }
 
         if (xev.type == ButtonPress) {
-            MouseButton button = GetMouseButtonFromXButton(xev.xbutton.button);
 
-            Logger::Debug(std::format("Window event: MouseButtonPress {}", button.CharCode));
+            // Mouse Wheel fires both the ButtonPress and ButtonRelease instantaneously.
+            // Therefore, we handle it as a specific MouseWheel event rather than a MouseButton event,
+            // and only call on ButtonPress, otherwise it will appear to duplicate the mouse wheel scroll.
+            if (xev.xbutton.button == 4) {
+                processMouseWheel(-1);
+            } else if (xev.xbutton.button == 5) {
+                processMouseWheel(1);
+            } else
+            {
+                MouseButton button = GetMouseButtonFromXButton(xev.xbutton.button);
 
-            processMousePress(button);
+                Logger::Debug(std::format("Window event: MouseButtonPress {}", button.Mnemonic));
+
+                processMousePress(button);
+            }
         }
 
         if (xev.type == Expose)
@@ -227,12 +229,13 @@ void RWindow::pollEvents() {
 
     }
     previousKeyboard = currentKeyboard;
+    previousMouse.Buttons = currentMouse.Buttons;
 }
 
 
 // Might make the window go off the screen on some window managers.
-void RWindow::setSize(int newWidth, int newHeight) {
-    if (!getFlag(RWindowFlags::RESIZABLE)) return;
+void RWindow::SetSize(int newWidth, int newHeight) {
+    if (!resizable) return;
 
     this->width = newWidth;
     this->height = newHeight;
@@ -260,42 +263,40 @@ Vector2 RWindow::GetAccurateMouseCoordinates() const {
     return Vector2::Zero;
 }
 
-// TODO: implement integer vector2/3 types
-Vector2 RWindow::getSize() const {
+
+Vector2 RWindow::GetSize() const {
     return {(float) this->width, (float) this->height};
 }
 
-Vector2 RWindow::getLastKnownResize() const
-{
-    return lastKnownWindowSize;
-}
+//Vector2 RWindow::getLastKnownResize() const
+//{
+//    return lastKnownWindowSize;
+//}
 
 // TODO: implement integer vector2/3 types
-Vector2 RWindow::getPos() const {
+Vector2 RWindow::GetPos() const {
     return position;
 }
 
-void RWindow::setPos(int x, int y) {
+void RWindow::SetPos(int x, int y) {
     XMoveWindow(display, window, x, y);
     position = { (float) x, (float) y };
 }
 
-void RWindow::setPos(const Vector2& pos) {
-    setPos(pos.x, pos.y);
+void RWindow::SetPos(const Vector2& pos) {
+    SetPos(pos.x, pos.y);
 }
 
 
-void RWindow::glSwapBuffers() {
+void RWindow::GLSwapBuffers() {
     glXSwapBuffers(display,window);
 }
 
-bool RWindow::isResizable() const {
-    return getFlag(RWindowFlags::RESIZABLE);
-}
 
-void RWindow::fullscreen() {
+
+void RWindow::Fullscreen() {
     Logger::Debug(std::format("Fullscreening window '{}'", this->title));
-    fullscreenmode = true;
+    fullscreen_mode = true;
 
     XEvent xev;
     Atom wm_state   = XInternAtom(display, "_NET_WM_STATE", true);
@@ -308,15 +309,15 @@ void RWindow::fullscreen() {
     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[1] = fullscreen_mode;
     xev.xclient.data.l[2] = 0;
     XSendEvent(display, DefaultRootWindow(display), False, SubstructureNotifyMask | SubstructureRedirectMask, &xev);
     Logger::Debug(std::format("Fullscreened window '{}'", this->title));
 }
 
-void RWindow::restoreFromFullscreen() {
-    Logger::Debug(std::format("Restoring window '{}' from fullscreen", this->title));
-    fullscreenmode = false;
+void RWindow::RestoreFromFullscreen() {
+    Logger::Debug(std::format("Restoring window '{}' from Fullscreen", this->title));
+    fullscreen_mode = false;
     XEvent xev;
     Atom wm_state = XInternAtom(display, "_NET_WM_STATE", False);
     Atom fullscreen = XInternAtom(display, "_NET_WM_STATE_FULLSCREEN", False);
@@ -326,23 +327,20 @@ void RWindow::restoreFromFullscreen() {
     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[1] = fullscreen_mode;
     xev.xclient.data.l[2] = 0;
     XSendEvent(display, DefaultRootWindow(display), False, SubstructureNotifyMask | SubstructureRedirectMask, &xev);
-    Logger::Debug(std::format("Restored window '{}' from fullscreen", this->title));
+    Logger::Debug(std::format("Restored window '{}' from Fullscreen", this->title));
 }
 
-void RWindow::setVsyncEnabled(bool b) {
+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 {
+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);
@@ -353,7 +351,7 @@ void RWindow::Open() {
     xSetWindowAttributes.background_pixel = BlackPixel(display, defaultScreen);
     xSetWindowAttributes.override_redirect = True;
     xSetWindowAttributes.event_mask = ExposureMask;
-    //setVsyncEnabled(vsync);
+    //SetVsyncEnabled(vsync);
     if (renderer == RenderingAPI::OPENGL) {
         GLint glAttributes[] = {GLX_RGBA, GLX_DEPTH_SIZE, 24, GLX_DOUBLEBUFFER, None};
         visual = glXChooseVisual(display, defaultScreen, glAttributes);
@@ -375,7 +373,7 @@ void RWindow::Open() {
                  ExposureMask | KeyPressMask | KeyReleaseMask | ButtonPressMask | ButtonReleaseMask |
                  PointerMotionMask |
                  PointerMotionHintMask | FocusChangeMask | StructureNotifyMask | SubstructureRedirectMask |
-                 SubstructureNotifyMask | CWColormap);
+                 SubstructureNotifyMask | CWColormap );
     XMapWindow(display, window);
     XStoreName(display, window, title.c_str());
     wmDeleteWindow = XInternAtom(display, "WM_DELETE_WINDOW", False);
@@ -393,21 +391,20 @@ void RWindow::Open() {
     processOnOpen();
 }
 
-void RWindow::setTitle(const std::string &title) {
+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;
-}
 
-Vector2 RWindow::getPositionOfRenderableArea() const {
+
+Vector2 RWindow::GetPositionOfRenderableArea() const {
     return render_area_position;
 }
 
-
+std::string RWindow::getGraphicsDriverVendor() {
+    return std::string(reinterpret_cast<const char*>(glGetString(GL_VENDOR)));
+}
 
 
 // TODO: Implement ControllerButton map

src/platform/shared/window.cpp

@@ -1,5 +1,7 @@
  #include <rewindow/types/window.h>
 #include "rewindow/logger/logger.h"
+#include <rewindow/types/mouse.h>
+
 std::string RWindowFlagToStr(RWindowFlags flag) {
     switch (flag) {
         case RWindowFlags::IN_FOCUS: return "IN_FOCUS";
@@ -15,10 +17,35 @@ std::string RWindowFlagToStr(RWindowFlags flag) {
 
 using namespace ReWindow;
 
+
+
 RWindow::RWindow() {
     title = "ReWindow Application";
     width = 640;
     height = 480;
+
+    if (DetectsKeyboard())
+    {
+        keyboard = new Keyboard();
+        input_devices.push_back(keyboard);
+    }
+
+    if (DetectsMouse())
+    {
+        mouse = new Mouse();
+        input_devices.push_back(mouse);
+    }
+
+    if (DetectsGamepad())
+    {
+        gamepad = new Gamepad();
+        input_devices.push_back(gamepad);
+    }
+
+
+
+
+
     //RWindow::singleton = this;
 }
 
@@ -33,27 +60,23 @@ RWindow::RWindow(const std::string& title, int width, int height, RenderingAPI r
         title(title), width(width), height(height), renderer(renderer) {}
 
 Vector2 RWindow::GetMouseCoordinates() const {
-    return mouse_coords;
+    return mouse->GetPosition();
 }
 
-bool RWindow::getFlag(RWindowFlags flag) const {
+bool RWindow::GetFlag(RWindowFlags flag) const {
     return flags[(int) flag];
 }
 
-bool RWindow::isAlive() const {
+bool RWindow::IsAlive() const {
     return true;
 }
 
-void RWindow::setResizable(bool resizable) {
-    this->resizable = resizable;
-    this->setFlag(RWindowFlags::RESIZABLE, resizable);
-}
 
-void RWindow::setFullscreen(bool fs) {
+void RWindow::SetFullscreen(bool fs) {
     if (fs)
-        fullscreen();
+        Fullscreen();
     else
-        restoreFromFullscreen();
+        RestoreFromFullscreen();
 }
 
 void RWindow::processFocusIn()
@@ -70,25 +93,30 @@ void RWindow::processFocusOut()
     OnFocusLostEvent(event);
 }
 
-void RWindow::processMousePress(MouseButton btn)
+void RWindow::processMousePress(const MouseButton& btn)
 {
+    mouse->DoButtonPress(btn); // .Set(btn, true);
     auto eventData = MouseButtonDownEvent(btn);
-    OnMouseButtonDownEvent(eventData);
     OnMouseButtonDown(eventData);
+    OnMouseButtonDownEvent(eventData);
+
 }
 
 void RWindow::processMouseMove(Vector2 last_pos, Vector2 new_pos)
 {
+    currentMouse.Position = new_pos;
     auto eventData = MouseMoveEvent(new_pos);
     OnMouseMove(eventData);
     OnMouseMoveEvent(eventData);
 }
 
-void RWindow::processMouseRelease(MouseButton btn)
+void RWindow::processMouseRelease(const MouseButton& btn)
 {
+    currentMouse.Set(btn, false);
     auto eventData = MouseButtonUpEvent(btn);
-    OnMouseButtonUpEvent(eventData);
     OnMouseButtonUp(eventData);
+    OnMouseButtonUpEvent(eventData);
+
 }
 
 void RWindow::processKeyRelease(Key key) {
@@ -99,55 +127,63 @@ void RWindow::processKeyRelease(Key key) {
 }
 
 
-std::string RWindow::getTitle() const {
+std::string RWindow::GetTitle() const {
     return this->title;
 }
 
 /*
-Vector2 RWindow::getSize() const
+Vector2 RWindow::GetSize() const
 {
     return {this->width, this->height};
 }
 */
 
-int RWindow::getWidth() const
+int RWindow::GetWidth() const
 {
     return this->width;
 }
 
-int RWindow::getHeight() const
+int RWindow::GetHeight() const
 {
     return this->height;
 }
 
-void RWindow::setSizeWithoutEvent(const Vector2& size) {
+void RWindow::SetSizeWithoutEvent(const Vector2& size) {
     width = size.x;
     height = size.y;
 }
 
-void RWindow::setLastKnownWindowSize(const Vector2& size) {
+void RWindow::SetLastKnownWindowSize(const Vector2& size) {
     lastKnownWindowSize = size;
 }
 
-void RWindow::setRenderer(RenderingAPI api) {
+void RWindow::SetRenderer(RenderingAPI api) {
     renderer = api;
 }
 
-void RWindow::setSize(const Vector2& size) {
+void RWindow::SetSize(const Vector2& size) {
     this->width = size.x;
     this->height = size.y;
-    this->setSize(size.x, size.y);
+    this->SetSize(size.x, size.y);
 }
 
-bool RWindow::isKeyDown(Key key) const {
+bool RWindow::IsKeyDown(Key key) const {
     for (const auto& pair : currentKeyboard.PressedKeys)
         if (pair.first == key && pair.second)
             return true;
     return false;
 }
 
+bool RWindow::IsMouseButtonDown(const MouseButton &button) const {
+    // TODO: Implement MouseButton map
+    return currentMouse.IsDown(button);
+}
+
 void RWindow::processKeyPress(Key key) {
     currentKeyboard.PressedKeys[key] = true;
+
+    Input::
+
     auto eventData = KeyDownEvent(key);
     OnKeyDown(eventData);
     OnKeyDownEvent(key);
@@ -165,8 +201,93 @@ void RWindow::processOnOpen()
     OnOpenEvent();
 }
 
+void RWindow::ManagedRefresh()
+{
+     auto begin = GetTimestamp();
+     Refresh();
+     auto end = GetTimestamp();
+
+     float dt = ComputeElapsedFrameTimeSeconds(begin, end);
+
+     UpdateFrameTiming(dt);
+}
+
+void RWindow::Refresh() {
+    PollEvents();
+    OnRefresh(delta_time);
+
+    // Only call once and cache the result.
+    currentMouse.Position = GetAccurateMouseCoordinates();
+
+    /// TODO: Implement optional minimum epsilon to trigger a Mouse Update.
+    if (currentMouse.Position != previousMouse.Position) {
+        processMouseMove(previousMouse.Position, currentMouse.Position);
+        previousMouse.Position = currentMouse.Position;
+    }
+
+    detail::UpdateMouse(currentMouse);
+
+}
+
+float RWindow::ComputeElapsedFrameTimeSeconds(std::chrono::steady_clock::time_point start, std::chrono::steady_clock::time_point end) {
+    auto frame_time = end - start;
+    unsigned long int frame_time_us = std::chrono::duration_cast<std::chrono::microseconds>(frame_time).count();
+    float frame_time_s = frame_time_us / (1000.f * 1000.f);
+    return frame_time_s;
+}
+
+ std::chrono::steady_clock::time_point RWindow::GetTimestamp() {
+    return std::chrono::steady_clock::now();
+}
+
+void RWindow::UpdateFrameTiming(float frame_time) {
+    delta_time = frame_time;
+    refresh_rate = 1.f / delta_time;
+    refresh_rate_prev_5 = refresh_rate_prev_4;
+    refresh_rate_prev_4 = refresh_rate_prev_3;
+    refresh_rate_prev_3 = refresh_rate_prev_2;
+    refresh_rate_prev_2 = refresh_rate_prev_1;
+    refresh_rate_prev_1 = refresh_rate;
+    avg_refresh_rate = (refresh_rate_prev_1 + refresh_rate_prev_2 + refresh_rate_prev_3 + refresh_rate_prev_4 + refresh_rate_prev_5) / 5.f;
+    refresh_count++;
+}
+
+
+void RWindow::processMouseWheel(int scrolls)
+{
+    currentMouse.Wheel += scrolls;
+    auto ev = MouseWheelEvent(scrolls);
+    OnMouseWheel(ev);
+    OnMouseWheelEvent(ev);
+
+    previousMouse.Wheel = currentMouse.Wheel;
+}
+
 
 void RWindow::Close() {
     /// TODO: Implement closing the window without destroying the handle.
     processOnClose();
-}
+}
+
+bool RWindow::IsResizable() const {
+    return resizable;
+}
+
+bool RWindow::IsFullscreen() const {
+    return fullscreen_mode;
+}
+
+bool RWindow::IsFocused() const {
+    return focused;
+}
+
+ bool RWindow::IsVsyncEnabled() const {
+     return vsync;
+ }
+
+ float RWindow::GetDeltaTime() const { return delta_time; }
+
+ float RWindow::GetRefreshRate() const { return refresh_rate; }
+
+ float RWindow::GetRefreshCounter() const { return refresh_count; }
+

src/platform/windows/window.cpp

@@ -14,7 +14,7 @@ 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) {
+void RWindow::SetFlag(RWindowFlags flag, bool state) {
     flags[(int) flag] = state;
     if (flag == RWindowFlags::RESIZABLE && !state) {
         RECT rect;
@@ -24,9 +24,13 @@ void RWindow::setFlag(RWindowFlags flag, bool state) {
         SetWindowLong(hwnd, GWL_STYLE, style);
         SetWindowPos(hwnd, nullptr, rect.left, rect.top, rect.right - rect.left, rect.bottom - rect.top, SWP_FRAMECHANGED | SWP_NOZORDER | SWP_NOOWNERZORDER);
     }
+}wasd
+void RWindow::SetResizable(bool resizable) {
+    SetFlag(RWindowFlags::RESIZABLE, resizable);;
 }
 
-void RWindow::pollEvents() {
+
+void RWindow::PollEvents() {
     MSG msg;
     while (PeekMessage(&msg, nullptr, 0, 0, PM_REMOVE)) {
         TranslateMessage(&msg);
@@ -34,56 +38,56 @@ void RWindow::pollEvents() {
     }
 }
 
-void RWindow::setSize(int newWidth, int newHeight) {
-    if (!getFlag(RWindowFlags::RESIZABLE)) return;
-    this->width = newWidth;
-    this->height = newHeight;
+void RWindow::SetSize(int newWidth, int newHeight) {
+    if (!resizable) return;
+    this->width = width;
+    this->height = height;
     SetWindowPos(hwnd, nullptr, 0, 0, width, height, SWP_NOMOVE | SWP_NOZORDER);
 }
 
-Vector2 RWindow::getCursorPos() const {
+Vector2 RWindow::GetAccurateMouseCoordinates() const {
     POINT point;
     GetCursorPos(&point);
     ScreenToClient(hwnd, &point);
     return { (float)point.x, (float)point.y };
 }
 
-void RWindow::setCursorVisible(bool cursor_enable) {
+void RWindow::SetCursorVisible(bool cursor_enable) {
     cursor_visible = cursor_enable;
 }
 
-bool RWindow::getCursorVisible() {
+bool RWindow::GetCursorVisible() {
     return cursor_visible;
 }
 
 
-Vector2 RWindow::getSize() const {
+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) {
+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::SetPos(const Vector2& pos) {
+    SetPos(pos.x, pos.y);
 }
 
-void RWindow::fullscreen() {
+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() {
+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) {
+void RWindow::SetVsyncEnabled(bool b) {
     typedef BOOL(WINAPI* PFNWGLSWAPINTERVALEXTPROC)(int interval);
     auto wglSwapIntervalEXT = (PFNWGLSWAPINTERVALEXTPROC) wglGetProcAddress("wglSwapIntervalEXT");
 
@@ -91,10 +95,6 @@ void RWindow::setVsyncEnabled(bool b) {
         wglSwapIntervalEXT(b ? 1 : 0);
 }
 
-bool RWindow::isFullscreen() const {
-    return fullscreenmode;
-}
-
 RWindow* eWindow = nullptr;
 KeyboardState* pKeyboard = nullptr;
 KeyboardState* cKeyboard = nullptr;
@@ -104,6 +104,8 @@ LRESULT CALLBACK WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
     switch (uMsg) {
             case WM_CLOSE: {
                     DestroyWindow(hwnd);
+
+                    eWindow->processOnClose();
             }
 
             case WM_DESTROY: {
@@ -111,37 +113,40 @@ LRESULT CALLBACK WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
             }
 
             case WM_SIZE: {
-                    eWindow->setSizeWithoutEvent({(float) LOWORD(lParam), (float) HIWORD(lParam)});
+                    eWindow->SetSizeWithoutEvent({(float) LOWORD(lParam), (float) HIWORD(lParam)});
                     auto eventData = WindowResizeRequestEvent();
-                    eventData.Size = {(float) eWindow->getWidth(), (float) eWindow->getHeight()};
-                    eWindow->setLastKnownWindowSize({(float) eWindow->getWidth(), (float) eWindow->getHeight()});
+                    eventData.Size = {(float) eWindow->GetWidth(), (float) eWindow->GetHeight()};
+                    eWindow->SetLastKnownWindowSize({(float) eWindow->GetWidth(), (float) eWindow->GetHeight()});
+
+                    // TODO: Implement eWindow->processOnResize()
+
                     eWindow->OnResizeRequest(eventData);
                     eWindow->OnResizeRequestEvent(eventData);
+
+
                     //Just to be absolutely sure the OpenGL viewport resizes along with the window.
-                    glViewport(0, 0, eWindow->getWidth(), eWindow->getHeight());
+                    glViewport(0, 0, eWindow->GetWidth(), eWindow->GetHeight());
                     break;
                 }
 
             case WM_SETFOCUS: {
-                    RWindowEvent event {};
-                    eWindow->OnFocusGain(event);
-                    eWindow->OnFocusGainEvent(event);
 
-                    eWindow->setFlag(RWindowFlags::IN_FOCUS, true);
+                    eWindow->processFocusIn();
+
+                    eWindow->SetFlag(RWindowFlags::IN_FOCUS, true);
                     break;
             }
 
             case WM_KILLFOCUS: {
-                    RWindowEvent event {};
-                    eWindow->OnFocusLost(event);
-                    eWindow->OnFocusLostEvent(event);
 
-                    eWindow->setFlag(RWindowFlags::IN_FOCUS, false);
+                    eWindow->processFocusOut();
+
+                    eWindow->SetFlag(RWindowFlags::IN_FOCUS, false);
                     break;
             }
 
             case WM_SETCURSOR: {
-                    if (LOWORD(lParam) == HTCLIENT && eWindow->getCursorVisible() == false)
+                    if (LOWORD(lParam) == HTCLIENT && eWindow->GetCursorVisible() == false)
                         SetCursor(nullptr);
                 break;
             }
@@ -150,122 +155,76 @@ LRESULT CALLBACK WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
                     auto key = GetKeyFromWindowsScancode((WindowsScancode) wParam);
                     //Key repeat fix.
                     if (!pKeyboard->PressedKeys[key]) {
-                        eWindow->OnKeyDownEvent(key);
-                        eWindow->OnKeyDown(key);
-                        eWindow->pressKey(key);
+                        eWindow->processKeyPress(key);
                     }
                     break;
             }
 
             case WM_KEYUP: {
                     auto key = GetKeyFromWindowsScancode((WindowsScancode) wParam);
-                    eWindow->OnKeyUpEvent(key);
-                    eWindow->OnKeyUp(key);
-                    eWindow->liftKey(key);
+                    eWindow->processKeyRelease(key);
                     break;
             }
 
             //Mouse Buttons.
             case WM_MOUSEWHEEL: {
-                    auto eventData = MouseButtonDownEvent();
                     int wheel_delta = GET_WHEEL_DELTA_WPARAM(wParam);
 
-                    //If the wheel delta is positive it's MWheelUp, Negative is MWheelDown.
-                    if (wheel_delta > 0)
-                        eventData.Button = MouseButtons::MWheelUp,
-                        eWindow->OnMouseButtonDownEvent(eventData),
-                        eWindow->OnMouseButtonDown(eventData);
+                    // TODO: Determine sign of wheel_delta for each direction, (and on linux too), and document this.
+                    eWindow->processMouseWheel(wheel_delta);
 
-                    else
-                        eventData.Button = MouseButtons::MWheelDown,
-                        eWindow->OnMouseButtonDownEvent(eventData),
-                        eWindow->OnMouseButtonDown(eventData);
                     break;
             }
 
             case WM_LBUTTONDOWN: {
-                    auto eventData = MouseButtonDownEvent();
-                    eventData.Button = MouseButtons::Left;
-
-                    eWindow->OnMouseButtonDownEvent(eventData);
-                    eWindow->OnMouseButtonDown(eventData);
+                    eWindow->processMousePress(MouseButtons::Left);
                     break;
             }
 
             case WM_LBUTTONUP: {
-                    auto eventData = MouseButtonUpEvent();
-                    eventData.Button = MouseButtons::Left;
-
-                    eWindow->OnMouseButtonUpEvent(eventData);
-                    eWindow->OnMouseButtonUp(eventData);
+                    eWindow->processMouseRelease(MouseButtons::Left);
                     break;
             }
 
             case WM_RBUTTONDOWN: {
-                    auto eventData = MouseButtonDownEvent();
-                    eventData.Button = MouseButtons::Right;
-
-                    eWindow->OnMouseButtonDownEvent(eventData);
-                    eWindow->OnMouseButtonDown(eventData);
+                    eWindow->processMousePress(MouseButtons::Right);
                     break;
             }
 
             case WM_RBUTTONUP: {
-                    auto eventData = MouseButtonUpEvent();
-                    eventData.Button = MouseButtons::Right;
-
-                    eWindow->OnMouseButtonUpEvent(eventData);
-                    eWindow->OnMouseButtonUp(eventData);
+                    eWindow->processMouseRelease(MouseButtons::Right);
                     break;
             }
 
             case WM_MBUTTONDOWN: {
-                    auto eventData = MouseButtonDownEvent();
-                    eventData.Button = MouseButtons::Middle;
-
-                    eWindow->OnMouseButtonDownEvent(eventData);
-                    eWindow->OnMouseButtonDown(eventData);
+                    eWindow->processMousePress(MouseButtons::Middle);
                     break;
             }
 
             case WM_MBUTTONUP: {
-                    auto eventData = MouseButtonUpEvent();
-                    eventData.Button = MouseButtons::Middle;
-
-                    eWindow->OnMouseButtonUpEvent(eventData);
-                    eWindow->OnMouseButtonUp(eventData);
+                    eWindow->processMouseRelease(MouseButtons::Middle);
                     break;
             }
 
             case WM_XBUTTONDOWN: {
                     WORD button = GET_XBUTTON_WPARAM(wParam);
-                    auto eventData = MouseButtonDownEvent();
 
                     if (button == XBUTTON1)
-                        eventData.Button = MouseButtons::Mouse4,
-                        eWindow->OnMouseButtonDownEvent(eventData),
-                        eWindow->OnMouseButtonDown(eventData);
+                        eWindow->processMousePress(MouseButtons::Mouse4);
 
                     if (button == XBUTTON2)
-                        eventData.Button = MouseButtons::Mouse5,
-                        eWindow->OnMouseButtonDownEvent(eventData),
-                        eWindow->OnMouseButtonDown(eventData);
+                        eWindow->processMousePress(MouseButtons::Mouse5);
+
                     break;
             }
 
             case WM_XBUTTONUP: {
                     WORD button = GET_XBUTTON_WPARAM(wParam);
-                    auto eventData = MouseButtonUpEvent();
-
                     if (button == XBUTTON1)
-                        eventData.Button = MouseButtons::Mouse4,
-                        eWindow->OnMouseButtonUpEvent(eventData),
-                        eWindow->OnMouseButtonUp(eventData);
+                        eWindow->processMouseRelease(MouseButtons::Mouse4);
 
                     if (button == XBUTTON2)
-                        eventData.Button = MouseButtons::Mouse5,
-                        eWindow->OnMouseButtonUpEvent(eventData),
-                        eWindow->OnMouseButtonUp(eventData);
+                        eWindow->processMouseRelease(MouseButtons::Mouse5);
                     break;
         }
 
@@ -280,7 +239,7 @@ LRESULT CALLBACK WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
     return DefWindowProc(hwnd, uMsg, wParam, lParam);
 }
 
-void RWindow::setCursorStyle(CursorStyle style) const {}
+void RWindow::SetCursorStyle(CursorStyle style) const {}
 
 void RWindow::Open() {
     eWindow = this;
@@ -334,17 +293,10 @@ void RWindow::Open() {
     open = true;
 }
 
-void RWindow::glSwapBuffers() {
+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::string RWindow::getGraphicsDriverVendor() {
+    return std::string(reinterpret_cast<const char*>(glGetString(GL_VENDOR)));
+}

src/types/WindowEvents.cpp

@@ -0,0 +1,7 @@
+#include <rewindow/types/WindowEvents.hpp>
+
+
+namespace ReWindow
+{
+
+}

src/types/inputdevice.cpp

@@ -0,0 +1 @@
+#include <rewindow/types/inputdevice.hpp>

src/types/inputservice.cpp

@@ -0,0 +1,29 @@
+#include <rewindow/types/inputservice.hpp>
+
+namespace ReWindow {
+    namespace detail
+    {
+        static Mouse* internal_mouse;
+
+        void UpdateMouse(Mouse* mouse) {
+            detail::internal_mouse = mouse;
+        }
+
+    }
+
+    namespace InputService
+    {
+        namespace Mouse
+        {
+            Vector2 GetMousePosition()
+            {
+                return detail::internal_mouse->GetPosition();
+            }
+
+            bool IsButtonDown(const MouseButton &btn) {
+                return detail::internal_mouse->IsButtonDown(btn);
+            }
+        }
+
+    }
+}

src/types/key.cpp

@@ -4,26 +4,22 @@
 
 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)
+        : Mnemonic(charcode), x11ScanCode(scancode), winScanCode(sc)
 {
     //TODO doing this is what crashes the program.
     keyboard.push_back(*this);
 }
 
-
-
 bool Key::operator==(const Key &rhs) const {
     //This is not a good workaround.
     return (this->x11ScanCode == rhs.x11ScanCode);
 }
 
 bool Key::operator<(const Key &rhs) const {
-    return (this->CharCode < rhs.CharCode);
+    return (this->Mnemonic < rhs.Mnemonic);
 }
 
 

src/types/keyboard.cpp

@@ -0,0 +1 @@
+#include <rewindow/types/keyboard.h>

src/types/mouse.cpp

@@ -0,0 +1,82 @@
+#include <rewindow/types/mouse.h>
+
+namespace ReWindow
+{
+    namespace detail
+    {
+        static Mouse* internal_mouse;
+
+        void UpdateMouse(Mouse* mouse) {
+            detail::internal_mouse = mouse;
+        }
+
+    }
+
+    namespace InputService
+    {
+        namespace Mouse
+        {
+            Vector2 GetMousePosition()
+            {
+                return detail::internal_mouse->GetPosition();
+            }
+
+            bool IsButtonDown(const MouseButton &btn) {
+                return detail::internal_mouse->IsButtonDown(btn);
+            }
+        }
+
+    }
+
+
+    void Mouse::DoButtonPress(const MouseButton &btn) {
+        SetButtonPressed(btn, true);
+    }
+
+    void Mouse::DoButtonRelease(const MouseButton &btn) {
+        SetButtonPressed(btn, false);
+    }
+
+    DeviceType Mouse::GetType() const { return DeviceType::MOUSE;}
+
+    void Mouse::Update(double elapsed) {
+        current_state.Left.TimeHeld += elapsed;
+        current_state.Right.TimeHeld += elapsed;
+        current_state.Middle.TimeHeld += elapsed;
+        current_state.Mouse4.TimeHeld += elapsed;
+        current_state.Mouse5.TimeHeld += elapsed;
+
+        previous_state = current_state;
+    }
+
+    ButtonState Mouse::GetButtonState(const MouseButton &btn) const {
+        if (btn == MouseButtons::Left)   return current_state.Left;
+        if (btn == MouseButtons::Right)  return current_state.Right;
+        if (btn == MouseButtons::Middle) return current_state.Middle;
+        if (btn == MouseButtons::Mouse4) return current_state.Mouse4;
+        if (btn == MouseButtons::Mouse5) return current_state.Mouse5;
+    }
+
+    bool Mouse::IsButtonDown(const MouseButton &btn) const {
+        return GetButtonState(btn).Pressed;
+    }
+
+    Mouse::~Mouse() {}
+
+    Mouse::Mouse() {}
+
+    void Mouse::SetButtonPressed(const MouseButton &btn, bool pressed) {
+        auto state = GetButtonState(btn);
+        state.Pressed = pressed;
+        state.TimeHeld = 0;
+        SetButtonState(btn, state);
+    }
+
+    void Mouse::SetButtonState(const MouseButton &btn, ButtonState state) {
+        if (btn == MouseButtons::Left)   current_state.Left = state;
+        if (btn == MouseButtons::Right)  current_state.Right = state;
+        if (btn == MouseButtons::Middle) current_state.Middle = state;
+        if (btn == MouseButtons::Mouse4) current_state.Mouse4 = state;
+        if (btn == MouseButtons::Mouse5) current_state.Mouse5 = state;
+    }
+}

src/types/mousebutton.cpp

@@ -1,12 +1,11 @@
 #include <rewindow/types/mousebutton.h>
 #include <string>
+#include <X11/X.h>
 #include "rewindow/logger/logger.h"
 
-MouseButton::MouseButton() {
-}
 
-MouseButton::MouseButton(const char* charcode, unsigned int index) {
-    this->CharCode = charcode;
+MouseButton::MouseButton(const std::string& charcode, unsigned int index) {
+    this->Mnemonic = charcode;
     this->ButtonIndex = index;
 }
 
@@ -14,14 +13,18 @@ bool MouseButton::operator==(const MouseButton &mb) const {
     return (mb.ButtonIndex == this->ButtonIndex);
 }
 
+bool MouseButton::operator<(const MouseButton &rhs) const {
+    return (this->ButtonIndex < rhs.ButtonIndex);
+}
+
 
 MouseButton GetMouseButtonFromXButton(unsigned int button) {
     switch(button) {
         case 1: return MouseButtons::Left;
         case 2: return MouseButtons::Middle;
         case 3: return MouseButtons::Right;
-        case 4: return MouseButtons::MWheelUp;
-        case 5: return MouseButtons::MWheelDown;
+        //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;