Merge remote-tracking branch 'origin/main'

include/rewindow/types/gamepad.h

@@ -10,17 +10,18 @@
 
 #pragma once
 
-namespace ReWindow
-{
+namespace ReWindow {
+    class Gamepad;
+    class Xbox360Gamepad;
+    class XboxOneGamepad;
+    class PS4Gamepad;
+    class Ultimate8BitDoPro2Gamepad;
+}
 
-    class InputDevice {}; // TODO: Remember to break InputDevice into it's own file and not define it twice!!!
+class ReWindow::Gamepad {
+public:
+    virtual ~Gamepad() = default;
+};
 
-    class Gamepad : public InputDevice
-    {
-
-    };
-
-
-    class XboxGamepad : public Gamepad {};
-    class PS4Gamepad : public Gamepad {};
-}
+class ReWindow::XboxOneGamepad : public Gamepad {};
+class ReWindow::PS4Gamepad : public Gamepad {};

include/rewindow/types/gamepadbutton.h

@@ -9,67 +9,101 @@
 /// @edit 2024-07-29
 
 #include <string>
+#include <utility>
 #include <J3ML/LinearAlgebra.hpp>
+namespace ReWindow {
+    class GamepadButton;
+    class GamepadTrigger;
+    class GamepadThumbstick;
+}
 
-class GamepadButton {
+class ReWindow::GamepadButton {
 protected:
     std::string mnemonic_btn_code;
 public:
-    explicit GamepadButton(const std::string& mnemonic) : mnemonic_btn_code(mnemonic) {  }
-    [[nodiscard]] std::string GetMnemonicButtonCode() const { return mnemonic_btn_code; }
+    explicit GamepadButton(std::string mnemonic) : mnemonic_btn_code(std::move(mnemonic)){}
+    [[nodiscard]] std::string GetMnemonicButtonCode() const;
 
     /// Compares two GamepadButtons by their mnemonic button codes, not their activation state.
     bool operator ==(const GamepadButton& rhs) const;
 };
 
-class GamepadTrigger {
+class ReWindow::GamepadTrigger {
+protected:
+    std::string mnemonic_trigger_code;
+    /// A float value between 0 and 1 representing how much the trigger has been pushed in by.
+    float position = 0.0f;
+
+    /// The minimum possible movement of the trigger from the at-rest position.
+    /// Movements less than this won't count.
+    float dead_zone = 0.0f;
 public:
-
-    /// Returns a float value between 0-1 representing how much the trigger has been pushed in by.
-    /// (0 being unpressed, 1 being fully pressed)
-    float GetActuation() const;
-
-    /// TODO: Might be more appropriate in the Gamepad class representation.
-    void SetActuationThreshold(float minimum = 0.01f) const;
+    void SetDeadzone(float minimum = 0.01f);
+    [[nodiscard]] float GetActuation() const;
+public:
+    explicit GamepadTrigger(std::string mnemonic) : mnemonic_trigger_code(std::move(mnemonic)){}
 };
 
-class GamepadThumbstick
-{
+class ReWindow::GamepadThumbstick {
+protected:
+    std::string mnemonic_stick_code;
+    // X -1 is all the way left, X +1 is all the way right.
+    // Y -1 is all the way down, Y +1 is all the way up.
+    Vector2 position = {0.0f, 0.0f};
+
+    // The minimum possible movement from the center in any direction.
+    float dead_zone = 0.0f;
 public:
-    /// Returns a Vector2 value representing the x,y coordinates of the joystick, with 0,0 being the center (at rest).
-    /// This vector ranges from length = 0 to length = 1 (i.e. the unit circle).
     [[nodiscard]] Vector2 GetPosition() const;
-
-
-    /// Sets the deadzone range of the thumbstick.
-    /// Deadzone controls how far the stick must be moved before any movement is actually reported.
-    /// This is because the thumbstick at-rest will often still report movement.
-    /// If gamecode is architected to use the thumbstick position as a direction, without factoring in magnitude, this would cause problems.
-    void SetDeadzone(float minimum = 0.01f) const;
+    void SetDeadzone(float minimum = 0.01f);
+public:
+    explicit GamepadThumbstick(std::string mnemonic) : mnemonic_stick_code(std::move(mnemonic)){}
 };
 
 
 
 using J3ML::LinearAlgebra::Vector2;
 
-namespace GamepadButtons {
-    static const GamepadButton X {"X"};
-    static const GamepadButton Y {"Y"};
-    static const GamepadButton A {"A"};
-    static const GamepadButton B {"B"};
+namespace ReWindow::GamepadButtons {
+    static const GamepadButton Triangle("△");
+    static const GamepadButton Square("□");
+    static const GamepadButton Circle("○");
+    static const GamepadButton Cross("X");
 
-    static const auto Triangle = Y;
-    static const auto Square   = X;
-    static const auto Circle   = A;
-    static const auto Cross    = B;
+    // If you like xbox :shrug:
+    static const GamepadButton Y = Triangle;
+    static const GamepadButton X = Square;
+    static const GamepadButton A = Cross;
+    static const GamepadButton B = Circle;
 
+    static const GamepadButton LButton("LB");
+    static const GamepadButton RButton("RB");
 
-    static const GamepadButton LeftBumper {"LB"};
-    static const GamepadButton RightBumper {"RB"};
+    /* For controllers where L2 & R2 is a button or counts as one when pressed all the way down.
+     * Gamecube & PS2 controllers do this. - Redacted. */
+    static const GamepadButton LButton2("LB2");
+    static const GamepadButton RButton2("RB2");
+
+    // The buttons when you press in the sticks.
+    static const GamepadButton LButton3("LB3");
+    static const GamepadButton RButton3("RB3");
+
+    // Will eventually need to handle making it not possible to, for ex. Press left and right at the same time.
+    static const GamepadButton DPadUp("DPU");
+    static const GamepadButton DPadDown("DPD");
+    static const GamepadButton DPadLeft("DPL");
+    static const GamepadButton DPadRight("DPR");
+
+    static const GamepadButton Select("SEL");
+    static const GamepadButton Start("START");
 }
 
-namespace GamepadTriggers
-{
-    static const GamepadTrigger Left;
-    static const GamepadTrigger Right;
+namespace ReWindow::GamepadTriggers {
+    static const ReWindow::GamepadTrigger Left {"LT"};
+    static const ReWindow::GamepadTrigger Right {"RT"};
+}
+
+namespace ReWindow::GamepadThumbsticks {
+    static const GamepadThumbstick Left {"LS"};
+    static const GamepadThumbstick Right {"RS"};
 }

src/types/gamepadbutton.cpp

@@ -1,9 +1,25 @@
 #include <rewindow/types/gamepadbutton.h>
 
-bool GamepadButton::operator==(const GamepadButton &rhs) const {
+bool ReWindow::GamepadButton::operator ==(const GamepadButton &rhs) const {
     return this->GetMnemonicButtonCode() == rhs.GetMnemonicButtonCode();
 }
 
-void GamepadThumbstick::SetDeadzone(float minimum) const {
-
+std::string ReWindow::GamepadButton::GetMnemonicButtonCode() const {
+    return mnemonic_btn_code;
+}
+
+void ReWindow::GamepadThumbstick::SetDeadzone(float minimum) {
+    dead_zone = minimum;
+}
+
+Vector2 ReWindow::GamepadThumbstick::GetPosition() const {
+    return position;
+}
+
+void ReWindow::GamepadTrigger::SetDeadzone(float minimum) {
+    dead_zone = minimum;
+}
+
+float ReWindow::GamepadTrigger::GetActuation() const {
+    return position;
 }