-

codenamecpp · codenamecpp · commit a07f0e449a8b · 2019-10-27T23:02:29.000+02:00
diff --git a/src/CarnageGame.cpp b/src/CarnageGame.cpp
@@ -161,6 +161,11 @@ void CarnageGame::InputEvent(KeyCharEvent& inputEvent)
 {
 }
 
+void CarnageGame::InputEvent(GamepadInputEvent& inputEvent)
+{
+
+}
+
 void CarnageGame::SetCameraController(CameraController* controller)
 {
     if (mCameraController == controller)
diff --git a/src/CarnageGame.h b/src/CarnageGame.h
@@ -34,6 +34,7 @@ class CarnageGame final: public cxx::noncopyable
     void InputEvent(MouseMovedInputEvent& inputEvent);
     void InputEvent(MouseScrollInputEvent& inputEvent);
     void InputEvent(KeyCharEvent& inputEvent);
+    void InputEvent(GamepadInputEvent& inputEvent);
 
     // public for debug purposes
     void SetCameraController(CameraController* controller);
diff --git a/src/GraphicsDevice.cpp b/src/GraphicsDevice.cpp
@@ -84,6 +84,29 @@ static eMButton GlfwMouseButtonToNative(int mbutton)
     return eMButton_null;
 }
 
+static eGamepadButton GlfwGamepadButtonToNative(int gpbutton)
+{
+    switch(gpbutton)
+    {
+        case GLFW_GAMEPAD_BUTTON_A: return eGamepadButton_A;
+        case GLFW_GAMEPAD_BUTTON_B: return eGamepadButton_B;
+        case GLFW_GAMEPAD_BUTTON_X: return eGamepadButton_X;
+        case GLFW_GAMEPAD_BUTTON_Y: return eGamepadButton_Y;
+        case GLFW_GAMEPAD_BUTTON_LEFT_BUMPER: return eGamepadButton_LeftBumper;
+        case GLFW_GAMEPAD_BUTTON_RIGHT_BUMPER: return eGamepadButton_RightBumper;
+        case GLFW_GAMEPAD_BUTTON_BACK: return eGamepadButton_Back;
+        case GLFW_GAMEPAD_BUTTON_START: return eGamepadButton_Start;
+        case GLFW_GAMEPAD_BUTTON_GUIDE: return eGamepadButton_Guide;
+        case GLFW_GAMEPAD_BUTTON_LEFT_THUMB: return eGamepadButton_LeftThumb;
+        case GLFW_GAMEPAD_BUTTON_RIGHT_THUMB: return eGamepadButton_RightThumb;
+        case GLFW_GAMEPAD_BUTTON_DPAD_UP: return eGamepadButton_DPAD_Up;
+        case GLFW_GAMEPAD_BUTTON_DPAD_RIGHT: return eGamepadButton_DPAD_Right;
+        case GLFW_GAMEPAD_BUTTON_DPAD_DOWN: return eGamepadButton_DPAD_Down;
+        case GLFW_GAMEPAD_BUTTON_DPAD_LEFT: return eGamepadButton_DPAD_Left;
+    };
+    return eGamepadButton_null;
+}
+
 //////////////////////////////////////////////////////////////////////////
 
 GraphicsDevice::GraphicsDevice()
@@ -210,6 +233,13 @@ bool GraphicsDevice::Initialize(int screensizex, int screensizey, bool fullscree
             };
             gSystem.HandleEvent(ev);
         });
+    ::glfwSetJoystickCallback([](int gamepad, int gamepadStatus)
+        {
+            if (gamepad < MAX_GAMEPADS)
+            {
+                gInputs.SetGamepadPresent(gamepad, (gamepadStatus == GLFW_CONNECTED));
+            }
+        });
 
     // setup opengl extensions
     if (!InitializeOGLExtensions())
@@ -266,6 +296,14 @@ bool GraphicsDevice::Initialize(int screensizex, int screensizey, bool fullscree
 
     EnableFullscreen(fullscreen);
     EnableVSync(vsync);
+
+    // init gamepads
+    for (int icurr = 0; icurr < MAX_GAMEPADS; ++icurr)
+    {
+        bool isGamepad = ::glfwJoystickIsGamepad(icurr) == GLFW_TRUE;
+        gInputs.SetGamepadPresent(icurr, isGamepad);
+    }
+
     return true;
 }
 
@@ -740,6 +778,51 @@ void GraphicsDevice::Present()
         gSystem.QuitRequest();
         return;
     }
+    ProcessGamepadsInputs();
+}
+
+void GraphicsDevice::ProcessGamepadsInputs()
+{
+    GLFWgamepadstate gamepadstate;
+
+    for (int icurr = 0; icurr < MAX_GAMEPADS; ++icurr)
+    {
+        GamepadState& currGamepad = gInputs.mGamepadsState[icurr];
+        if (!currGamepad.mPresent)
+            continue;
+
+        if (::glfwGetGamepadState(icurr, &gamepadstate) != GLFW_TRUE)
+            continue;
+
+        for (int ibutton = 0; ibutton < GLFW_JOYSTICK_LAST + 1; ++ibutton)
+        {
+            eGamepadButton buttonNative = GlfwGamepadButtonToNative(ibutton);
+            if (buttonNative == eGamepadButton_null)
+                continue;
+
+            bool newPressed = gamepadstate.buttons[ibutton] == GLFW_PRESS;
+            if (currGamepad.mButtons[buttonNative] == newPressed)
+                continue;
+
+            GamepadInputEvent inputEvent { icurr, buttonNative, newPressed };
+            gSystem.HandleEvent(inputEvent);
+        }
+        
+        // triggers
+        bool leftTriggerPressed = gamepadstate.axes[GLFW_GAMEPAD_AXIS_LEFT_TRIGGER] > 0.5f;
+        if (leftTriggerPressed != currGamepad.mButtons[eGamepadButton_LeftTrigger])
+        {
+            GamepadInputEvent inputEvent { icurr, eGamepadButton_LeftTrigger, leftTriggerPressed };
+            gSystem.HandleEvent(inputEvent);
+        }
+
+        bool rightTriggerPressed = gamepadstate.axes[GLFW_GAMEPAD_AXIS_RIGHT_TRIGGER] > 0.5f;
+        if (rightTriggerPressed != currGamepad.mButtons[eGamepadButton_RightTrigger])
+        {
+            GamepadInputEvent inputEvent { icurr, eGamepadButton_RightTrigger, rightTriggerPressed };
+            gSystem.HandleEvent(inputEvent);
+        }
+    }
 }
 
 void GraphicsDevice::SetViewportRect(const Rect2D& sourceRectangle)
diff --git a/src/GraphicsDevice.h b/src/GraphicsDevice.h
@@ -162,6 +162,8 @@ class GraphicsDevice final: public cxx::noncopyable
 
     void SetupVertexAttributes(const VertexFormat& streamDefinition);
 
+    void ProcessGamepadsInputs();
+
 private:
     GraphicsContext mGraphicsContext;
     GLFWwindow* mGraphicsWindow;
diff --git a/src/Inputs.cpp b/src/Inputs.cpp
@@ -23,6 +23,13 @@ void Inputs::HandleEvent(MouseScrollInputEvent& inputEvent)
 {
 }
 
+void Inputs::HandleEvent(GamepadInputEvent& inputEvent)
+{
+    debug_assert(inputEvent.mGamepad < MAX_GAMEPADS);
+    debug_assert(inputEvent.mButton < eGamepadButton_COUNT);
+    mGamepadsState[inputEvent.mGamepad].mButtons[inputEvent.mButton] = inputEvent.mPressed;
+}
+
 void Inputs::HandleEvent(KeyInputEvent& inputEvent)
 {
     mKeyboardKeys[inputEvent.mKeycode] = inputEvent.mPressed;
@@ -32,8 +39,17 @@ void Inputs::Cleanup()
 {
     ::memset(mMouseButtons, 0, sizeof(mMouseButtons));
     ::memset(mKeyboardKeys, 0, sizeof(mKeyboardKeys));
+    ::memset(mGamepadsState, 0, sizeof(mGamepadsState));
 }
 
 void Inputs::HandleEvent(KeyCharEvent& inputEvent)
 {
-}
+}
+
+void Inputs::SetGamepadPresent(int gamepad, bool isPresent)
+{
+    debug_assert(gamepad < MAX_GAMEPADS);
+
+    mGamepadsState[gamepad].mPresent = isPresent;
+    ::memset(mGamepadsState[gamepad].mButtons, 0, sizeof(mGamepadsState[gamepad].mButtons));
+}
diff --git a/src/Inputs.h b/src/Inputs.h
@@ -1,7 +1,9 @@
 #pragma once
 
-enum //key mods
+enum 
 {
+    MAX_GAMEPADS    = 4,
+    //key mods
     KEYMOD_SHIFT    = GLFW_MOD_SHIFT,
     KEYMOD_CTRL     = GLFW_MOD_CONTROL,
     KEYMOD_ALT      = GLFW_MOD_ALT,
@@ -85,6 +87,55 @@ enum eKeycode
 
 decl_enum_strings(eKeycode);
 
+// gamepad inputs
+enum eGamepadButton
+{
+    eGamepadButton_null, // invalid button
+    eGamepadButton_A,
+    eGamepadButton_B,
+    eGamepadButton_X,
+    eGamepadButton_Y,
+    eGamepadButton_LeftBumper,
+    eGamepadButton_RightBumper,
+    eGamepadButton_Back,
+    eGamepadButton_Start,
+    eGamepadButton_Guide,
+    eGamepadButton_LeftThumb,
+    eGamepadButton_RightThumb,
+    eGamepadButton_DPAD_Up,
+    eGamepadButton_DPAD_Right,
+    eGamepadButton_DPAD_Down,
+    eGamepadButton_DPAD_Left,
+    eGamepadButton_LeftTrigger,
+    eGamepadButton_RightTrigger,
+    eGamepadButton_COUNT
+};
+
+decl_enum_strings(eGamepadButton);
+
+// input controller
+enum eInputControllerType
+{
+    eInputControllerType_Keyboard,
+    eInputControllerType_Gamepad1,
+    eInputControllerType_Gamepad2,
+    eInputControllerType_Gamepad3,
+    eInputControllerType_Gamepad4,
+    eInputControllerType_COUNT
+};
+
+decl_enum_strings(eInputControllerType);
+
+// gamepad state
+struct GamepadState
+{
+public:
+    GamepadState() = default;
+public:
+    bool mButtons[eGamepadButton_COUNT];
+    bool mPresent;
+};
+
 // input events
 struct BaseInputEvent
 {
@@ -181,6 +232,22 @@ struct MouseScrollInputEvent: public BaseInputEvent
     int mScrollY;
 };
 
+struct GamepadInputEvent: public BaseInputEvent
+{
+public:
+    GamepadInputEvent() = default;
+    GamepadInputEvent(int gamepad, eGamepadButton button, bool pressed)
+        : mButton(button)
+        , mGamepad(gamepad)
+        , mPressed(pressed)
+    {
+    }
+public:
+    int mGamepad;
+    eGamepadButton mButton;
+    bool mPressed;
+};
+
 //////////////////////////////////////////////////////////////////////////
 // Input State Holder
 //////////////////////////////////////////////////////////////////////////
@@ -190,9 +257,12 @@ class Inputs final: public cxx::noncopyable
 public:
     bool mMouseButtons[eMButton_COUNT];
     bool mKeyboardKeys[eKeycode_COUNT];
+
     int mCursorPositionX;
     int mCursorPositionY;
 
+    GamepadState mGamepadsState[MAX_GAMEPADS];
+
 public:
     Inputs();
 
@@ -203,6 +273,7 @@ class Inputs final: public cxx::noncopyable
     void HandleEvent(MouseScrollInputEvent& inputEvent);
     void HandleEvent(KeyInputEvent& inputEvent);
     void HandleEvent(KeyCharEvent& inputEvent);
+    void HandleEvent(GamepadInputEvent& inputEvent);
 
     // Reset all keys and mouse buttons state
     void Cleanup();
@@ -248,6 +319,8 @@ class Inputs final: public cxx::noncopyable
         debug_assert(button < eMButton_COUNT && button > eMButton_null);
         return mMouseButtons[button];
     }
+
+    void SetGamepadPresent(int gamepad, bool isPresent);
 };
 
 extern Inputs gInputs;
diff --git a/src/System.cpp b/src/System.cpp
@@ -222,6 +222,15 @@ void System::HandleEvent(KeyCharEvent& inputEvent)
     gCarnageGame.InputEvent(inputEvent);
 }
 
+void System::HandleEvent(GamepadInputEvent& inputEvent)
+{
+    if (mIgnoreInputs)
+        return;
+
+    gInputs.HandleEvent(inputEvent);
+    gCarnageGame.InputEvent(inputEvent);
+}
+
 long System::GetSysMilliseconds() const
 {
     double totalSeconds = ::glfwGetTime();
diff --git a/src/System.h b/src/System.h
@@ -67,6 +67,7 @@ class System final: public cxx::noncopyable
     void HandleEvent(MouseScrollInputEvent& inputEvent);
     void HandleEvent(KeyInputEvent& inputEvent);
     void HandleEvent(KeyCharEvent& inputEvent);
+    void HandleEvent(GamepadInputEvent& inputEvent);
 
     // Set application exit request flag, execution will be interrupted soon
     void QuitRequest();
diff --git a/src/enums_impl.cpp b/src/enums_impl.cpp
@@ -66,6 +66,36 @@ impl_enum_strings(eMButton)
     {eMButton_MIDDLE, "Middle"},
 };
 
+impl_enum_strings(eGamepadButton)
+{
+    {eGamepadButton_A, "A"},
+    {eGamepadButton_B, "B"},
+    {eGamepadButton_X, "X"},
+    {eGamepadButton_Y, "Y"},
+    {eGamepadButton_LeftBumper, "LeftBumper"},
+    {eGamepadButton_RightBumper, "RightBumper"},
+    {eGamepadButton_Back, "Back"},
+    {eGamepadButton_Start, "Start"},
+    {eGamepadButton_Guide, "Guide"},
+    {eGamepadButton_LeftThumb, "LeftThumb"},
+    {eGamepadButton_RightThumb, "RightThumb"},
+    {eGamepadButton_DPAD_Up, "Up"},
+    {eGamepadButton_DPAD_Right, "Right"},
+    {eGamepadButton_DPAD_Down, "Down"},
+    {eGamepadButton_DPAD_Left, "Left"},
+    {eGamepadButton_LeftTrigger, "LeftTrigger"},
+    {eGamepadButton_RightTrigger, "RightTrigger"},
+};
+
+impl_enum_strings(eInputControllerType)
+{
+    {eInputControllerType_Keyboard, "Keyboard"},
+    {eInputControllerType_Gamepad1, "Gamepad1"},
+    {eInputControllerType_Gamepad2, "Gamepad2"},
+    {eInputControllerType_Gamepad3, "Gamepad3"},
+    {eInputControllerType_Gamepad4, "Gamepad4"},
+};
+
 impl_enum_strings(eLogMessage)
 {
     {eLogMessage_Debug, "debug"},

Original file line number	Diff line number	Diff line change
`@@ -161,6 +161,11 @@ void CarnageGame::InputEvent(KeyCharEvent& inputEvent)`
`161`	`161`	`{`
`162`	`162`	`}`
`163`	`163`
	`164`	`+void CarnageGame::InputEvent(GamepadInputEvent& inputEvent)`
	`165`	`+{`
	`166`	`+`
	`167`	`+}`
	`168`	`+`
`164`	`169`	`void CarnageGame::SetCameraController(CameraController* controller)`
`165`	`170`	`{`
`166`	`171`	`if (mCameraController == controller)`
Original file line number	Diff line number	Diff line change
`@@ -23,6 +23,13 @@ void Inputs::HandleEvent(MouseScrollInputEvent& inputEvent)`
`23`	`23`	`{`
`24`	`24`	`}`
`25`	`25`
	`26`	`+void Inputs::HandleEvent(GamepadInputEvent& inputEvent)`
	`27`	`+{`
	`28`	`+ debug_assert(inputEvent.mGamepad < MAX_GAMEPADS);`
	`29`	`+ debug_assert(inputEvent.mButton < eGamepadButton_COUNT);`
	`30`	`+ mGamepadsState[inputEvent.mGamepad].mButtons[inputEvent.mButton] = inputEvent.mPressed;`
	`31`	`+}`
	`32`	`+`
`26`	`33`	`void Inputs::HandleEvent(KeyInputEvent& inputEvent)`
`27`	`34`	`{`
`28`	`35`	`mKeyboardKeys[inputEvent.mKeycode] = inputEvent.mPressed;`
`@@ -32,8 +39,17 @@ void Inputs::Cleanup()`
`32`	`39`	`{`
`33`	`40`	`::memset(mMouseButtons, 0, sizeof(mMouseButtons));`
`34`	`41`	`::memset(mKeyboardKeys, 0, sizeof(mKeyboardKeys));`
	`42`	`+ ::memset(mGamepadsState, 0, sizeof(mGamepadsState));`
`35`	`43`	`}`
`36`	`44`
`37`	`45`	`void Inputs::HandleEvent(KeyCharEvent& inputEvent)`
`38`	`46`	`{`
`39`		`-}`
	`47`	`+}`
	`48`	`+`
	`49`	`+void Inputs::SetGamepadPresent(int gamepad, bool isPresent)`
	`50`	`+{`
	`51`	`+ debug_assert(gamepad < MAX_GAMEPADS);`
	`52`	`+`
	`53`	`+ mGamepadsState[gamepad].mPresent = isPresent;`
	`54`	`+ ::memset(mGamepadsState[gamepad].mButtons, 0, sizeof(mGamepadsState[gamepad].mButtons));`
	`55`	`+}`