Controller support, Camera Quaternion

ChangeLog.md

@@ -2,6 +2,11 @@
 
 ## OpenRaider (0.1.3) xythobuz <xythobuz@xythobuz.de>
 
+    [ 20141227 ]
+    * Added rudimentary SDL2 Game Controller support.
+    * Camera now using Quaternion for rotation.
+    * Movement now done using speed and frame time delta.
+
     [ 20141223 ]
     * View frustum calculation now working
 

include/Camera.h

@@ -11,6 +11,7 @@
 #include <glm/vec2.hpp>
 #include <glm/vec3.hpp>
 #include <glm/mat4x4.hpp>
+#include <glm/gtc/quaternion.hpp>
 
 #include "RoomData.h"
 
@@ -18,15 +19,17 @@ class Camera {
   public:
 
     static void reset();
+    static bool update();
 
     static void handleAction(ActionEvents action, bool isFinished);
     static void handleMouseMotion(int x, int y);
-    static bool update();
+    static void handleControllerAxis(float value, KeyboardButton axis);
+    static void handleControllerButton(KeyboardButton button, bool released);
 
     static void setPosition(glm::vec3 p) { pos = p; }
     static glm::vec3 getPosition() { return pos; }
 
-    static glm::vec2 getRotation() { return rot; }
+    static glm::vec2 getRotation();
     static glm::mat4 getProjectionMatrix() { return projection; }
     static glm::mat4 getViewMatrix() { return view; }
 
@@ -43,10 +46,12 @@ class Camera {
     static void displayFrustum(glm::mat4 MVP);
 
   private:
+    static void calculateFrustumPlanes();
+
     static glm::vec3 pos;
-    static glm::vec2 rot;
-    static glm::vec3 lastPos;
-    static glm::vec2 lastRot;
+    static glm::quat quaternion;
+    static glm::vec3 posSpeed;
+    static glm::vec2 rotSpeed;
     static glm::vec2 lastSize;
     static glm::mat4 projection;
     static glm::mat4 view;

include/Game.h

@@ -15,7 +15,6 @@
 
 class Game {
   public:
-
     Game();
     ~Game();
 
@@ -30,12 +29,13 @@ class Game {
     void display();
     void handleAction(ActionEvents action, bool isFinished);
     void handleMouseMotion(int xrel, int yrel, int xabs, int yabs);
+    void handleControllerAxis(float value, KeyboardButton axis);
+    void handleControllerButton(KeyboardButton button, bool released);
 
     Entity& getLara();
     void setLara(long lara);
 
   private:
-
     void processPakSounds();
     void processTextures();
     void processSprites();
@@ -48,6 +48,8 @@ class Game {
     bool mLoaded;
 
     long mLara;
+
+    bool activeEvents[ActionEventCount];
 };
 
 Game& getGame();

include/RunTime.h

@@ -41,6 +41,8 @@ class RunTime {
     unsigned long getFPS();
     const std::vector<float>& getHistoryFPS();
 
+    float getLastFrameTime();
+
   private:
     std::string baseDir;
     std::string pakDir;
@@ -51,7 +53,7 @@ class RunTime {
     bool gameIsRunning;
     bool showFPS;
 
-    unsigned long lastTime;
+    unsigned long lastTime, lastFrameTime;
     unsigned long frameCount, frameCount2;
     unsigned long frameTimeSum, frameTimeSum2;
     unsigned long fps;

include/UI.h

@@ -30,6 +30,8 @@ class UI {
     static void handleMouseClick(unsigned int x, unsigned int y, KeyboardButton button, bool released);
     static void handleMouseMotion(int xrel, int yrel, int xabs, int yabs);
     static void handleMouseScroll(int xrel, int yrel);
+    static void handleControllerAxis(float value, KeyboardButton axis);
+    static void handleControllerButton(KeyboardButton button, bool released);
 
     static void renderImGui(ImDrawList** const draw_lists, int count);
 

include/global.h

@@ -43,6 +43,7 @@ typedef enum {
 
 // Keys available for binding
 typedef enum {
+    // Keyboard
     zeroKey = '0', oneKey = '1', twoKey = '2',
     threeKey = '3', fourKey = '4', fiveKey = '5',
     sixKey = '6', sevenKey = '7', eightKey = '8',
@@ -64,6 +65,13 @@ typedef enum {
     semicolonKey, slashKey, spaceKey, tabKey,
     leftmouseKey, middlemouseKey, rightmouseKey,
     fourthmouseKey, fifthmouseKey,
+
+    // Game Controller
+    aButton, bButton, xButton, yButton, backButton, startButton,
+    guideButton, leftStick, rightStick, leftShoulder, rightShoulder,
+    padUp, padDown, padLeft, padRight,
+    leftXAxis, leftYAxis, rightXAxis, rightYAxis, leftTrigger, rightTrigger,
+
     unknownKey // Should always be at the end
 } KeyboardButton;
 

include/system/WindowSDL.h

@@ -45,6 +45,7 @@ class WindowSDL : public Window {
   private:
     SDL_Window* mWindow;      //!< This is the pointer to the SDL surface
     SDL_GLContext mGLContext; //!< The OpenGL Context
+    SDL_GameController* controller;
 };
 
 #endif

src/Camera.cpp

@@ -6,9 +6,13 @@
  * \author xythobuz
  */
 
+#include <limits>
+#include <glm/gtc/epsilon.hpp>
 #include <glm/gtc/matrix_transform.hpp>
+#include <glm/gtx/quaternion.hpp>
 
 #include "global.h"
+#include "RunTime.h"
 #include "system/Window.h"
 #include "Camera.h"
 
@@ -28,153 +32,160 @@
 #define FBR 6
 #define FTR 7
 
-class Plane {
-  public:
-    Plane() : normal(glm::vec3(0.0f, 0.0f, 0.0f)), d(0.0f) { }
-    void set(glm::vec3 v1, glm::vec3 v2, glm::vec3 v3) {
-        normal = glm::normalize(glm::cross(v3 - v2, v1 - v2));
-        d = -glm::dot(normal, v2);
-    }
-    float distance(glm::vec3 p) {
-        return d + glm::dot(normal, p);
-    }
-  private:
-    glm::vec3 normal;
-    float d;
-};
-
-// ----------------------------------------------------------------------------
-
 const static float fov = 45.0f;
 const static float nearDist = 0.1f;
 const static float farDist = 75000.0f;
-const static float freeCameraStep = 256.0f;
+const static float maxSpeed = 2048.0f;
+const static float controllerViewFactor = 384.0f;
+
+const static glm::vec3 rightUnit(1.0f, 0.0f, 0.0f);
+const static glm::vec3 upUnit(0.0f, 1.0f, 0.0f);
+const static glm::vec3 dirUnit(0.0f, 0.0f, -1.0f);
 
 glm::vec3 Camera::pos(0.0f, 0.0f, 0.0f);
-glm::vec2 Camera::rot(0.0f, 0.0f);
-glm::vec3 Camera::lastPos(1.0f, 0.0f, 0.0f);
-glm::vec2 Camera::lastRot(1.0f, 0.0f);
+glm::quat Camera::quaternion(glm::vec3(0.0f, 0.0f, 0.0f));
+glm::vec3 Camera::posSpeed(0.0f, 0.0f, 0.0f);
+glm::vec2 Camera::rotSpeed(0.0f, 0.0f);
 glm::vec2 Camera::lastSize(0.0f, 0.0f);
 glm::mat4 Camera::projection(1.0f);
 glm::mat4 Camera::view(1.0f);
 float Camera::rotationDeltaX = 0.75f;
 float Camera::rotationDeltaY = 0.75f;
 bool Camera::updateViewFrustum = true;
-static Plane planes[6];
-
-static glm::vec3 frustumColors[6] = {
-    glm::vec3(1.0f, 0.0f, 0.0f), // NEAR, red
-    glm::vec3(0.0f, 1.0f, 0.0f), // FAR, green
-    glm::vec3(0.0f, 0.0f, 1.0f), // TOP, blue
-    glm::vec3(1.0f, 1.0f, 0.0f), // BOTTOM, yellow
-    glm::vec3(0.0f, 1.0f, 1.0f), // LEFT, light-blue
-    glm::vec3(1.0f, 0.0f, 1.0f)  // RIGHT, pink
-};
-static glm::vec3 frustumVertices[8];
 
 void Camera::reset() {
     pos = glm::vec3(0.0f, 0.0f, 0.0f);
-    rot = glm::vec2(0.0f, 0.0f);
-    lastPos = glm::vec3(1.0f, 0.0f, 0.0f);
-    lastRot = glm::vec2(1.0f, 0.0f);
+    quaternion = glm::quat(glm::vec3(0.0f, 0.0f, 0.0f));
+    posSpeed = glm::vec3(0.0f, 0.0f, 0.0f);
+    rotSpeed = glm::vec2(0.0f, 0.0f);
     lastSize = glm::vec2(0.0f, 0.0f);
     projection = glm::mat4(1.0f);
     view = glm::mat4(1.0f);
 }
 
 void Camera::handleAction(ActionEvents action, bool isFinished) {
+    float factor = 1.0f;
     if (isFinished)
-        return;
-
-    glm::vec3 dir(
-        glm::cos(rot.y) * glm::sin(rot.x),
-        glm::sin(rot.y),
-        glm::cos(rot.y) * glm::cos(rot.x)
-    );
-    glm::vec3 right(
-        glm::sin(rot.x - glm::pi<float>() / 2.0f),
-        0.0f,
-        glm::cos(rot.x - glm::pi<float>() / 2.0f)
-    );
-    glm::vec3 up = glm::vec3(0.0f, 1.0f, 0.0f);
+        factor = -1.0f;
 
     if (action == forwardAction) {
-        pos += dir * freeCameraStep;
+        posSpeed += dirUnit * maxSpeed * factor;
     } else if (action == backwardAction) {
-        pos -= dir * freeCameraStep;
+        posSpeed -= dirUnit * maxSpeed * factor;
     } else if (action == leftAction) {
-        pos += right * freeCameraStep;
+        posSpeed += rightUnit * maxSpeed * factor;
     } else if (action == rightAction) {
-        pos -= right * freeCameraStep;
+        posSpeed -= rightUnit * maxSpeed * factor;
     } else if (action == jumpAction) {
-        pos += up * freeCameraStep;
+        posSpeed += upUnit * maxSpeed * factor;
     } else if (action == crouchAction) {
-        pos -= up * freeCameraStep;
-    } else if (action == useAction) {
-    } else if (action == holsterAction) {
-    } else if (action == walkAction) {
+        posSpeed -= upUnit * maxSpeed * factor;
     }
 }
 
 void Camera::handleMouseMotion(int x, int y) {
-    while (x > 0) {
-        rot.x += rotationDeltaX;
-        x--;
-    }
-    while (x < 0) {
-        rot.x -= rotationDeltaX;
-        x++;
-    }
-    while (y > 0) {
-        if (rot.y > -(glm::pi<float>() / 2.0f)) {
-            rot.y -= rotationDeltaY;
-        }
-        y--;
-    }
-    while (y < 0) {
-        if (rot.y < (glm::pi<float>() / 2.0f)) {
-            rot.y += rotationDeltaY;
-        }
-        y++;
-    }
+    if (x != 0)
+        quaternion = glm::quat(upUnit * rotationDeltaX * float(x)) * quaternion;
 
-    while (rot.x > (glm::pi<float>() * 2.0f))
-        rot.x -= glm::pi<float>() * 2.0f;
+    if (y != 0)
+        quaternion = glm::quat(quaternion * -rightUnit * rotationDeltaY * float(y)) * quaternion;
+}
+
+void Camera::handleControllerAxis(float value, KeyboardButton axis) {
+    if (glm::epsilonEqual(value, 0.0f, 0.01f))
+        value = 0.0f;
+
+    if (axis == leftXAxis) {
+        posSpeed.x = -maxSpeed * value;
+    } else if (axis == leftYAxis) {
+        posSpeed.z = maxSpeed * value;
+    } else if (axis == rightXAxis) {
+        rotSpeed.x = controllerViewFactor * value;
+    } else if (axis == rightYAxis) {
+        rotSpeed.y = controllerViewFactor * value;
+    }
+}
 
-    while (rot.x < -(glm::pi<float>() * 2.0f))
-        rot.x += glm::pi<float>() * 2.0f;
+void Camera::handleControllerButton(KeyboardButton button, bool released) {
+    if (button == aButton) {
+        handleAction(jumpAction, released);
+    } else if (button == bButton) {
+        handleAction(crouchAction, released);
+    } else if (button == padUp) {
+        handleAction(forwardAction, released);
+    } else if (button == padDown) {
+        handleAction(backwardAction, released);
+    } else if (button == padLeft) {
+        handleAction(leftAction, released);
+    } else if (button == padRight) {
+        handleAction(rightAction, released);
+    }
 }
 
 bool Camera::update() {
     glm::vec2 size(getWindow().getWidth(), getWindow().getHeight());
 
-    if ((lastPos == pos) && (lastRot == rot) && (lastSize == size))
-        return false;
-
     if (lastSize != size) {
-        //! \fixme TODO instead of mirroring the axes in the shader, scale here
+        //! \fixme TODO instead of mirroring the Y axis in the shader, scale with -1 here
         projection = glm::perspective(fov, size.x / size.y, nearDist, farDist);
         lastSize = size;
     }
 
-    glm::vec3 dir(
-        glm::cos(rot.y) * glm::sin(rot.x),
-        glm::sin(rot.y),
-        glm::cos(rot.y) * glm::cos(rot.x)
-    );
+    float dT = getRunTime().getLastFrameTime();
+    pos += quaternion * posSpeed * dT;
+
+    if (glm::epsilonNotEqual(rotSpeed.x, 0.0f, 0.01f))
+        quaternion = glm::quat(upUnit * rotationDeltaX * rotSpeed.x * dT) * quaternion;
+
+    if (glm::epsilonNotEqual(rotSpeed.y, 0.0f, 0.01f))
+        quaternion = glm::quat(quaternion * -rightUnit * rotationDeltaY * rotSpeed.y * dT) * quaternion;
+
+    glm::mat4 translate = glm::translate(glm::mat4(1.0f), pos);
+    glm::mat4 rotate = glm::toMat4(quaternion);
+    view = glm::inverse(translate * rotate);
+
+    if (updateViewFrustum)
+        calculateFrustumPlanes();
+
+    return updateViewFrustum;
+}
+
+glm::vec2 Camera::getRotation() {
+    glm::vec3 euler = glm::eulerAngles(quaternion);
+    return glm::vec2(euler.y, euler.x);
+}
+
+// ----------------------------------------------------------------------------
 
-    glm::vec3 right(
-        glm::sin(rot.x - glm::pi<float>() / 2.0f),
-        0.0f,
-        glm::cos(rot.x - glm::pi<float>() / 2.0f)
-    );
+class FrustumPlane {
+  public:
+    FrustumPlane() : normal(glm::vec3(0.0f, 0.0f, 0.0f)), d(0.0f) { }
+    void set(glm::vec3 v1, glm::vec3 v2, glm::vec3 v3) {
+        normal = glm::normalize(glm::cross(v3 - v2, v1 - v2));
+        d = -glm::dot(normal, v2);
+    }
+    float distance(glm::vec3 p) {
+        return d + glm::dot(normal, p);
+    }
+  private:
+    glm::vec3 normal;
+    float d;
+};
 
-    glm::vec3 up = glm::cross(right, dir);
-    view = glm::lookAt(pos, pos + dir, up);
+// ----------------------------------------------------------------------------
 
-    if (!updateViewFrustum)
-        return false;
+static FrustumPlane planes[6];
+static glm::vec3 frustumColors[6] = {
+    glm::vec3(1.0f, 0.0f, 0.0f), // NEAR, red
+    glm::vec3(0.0f, 1.0f, 0.0f), // FAR, green
+    glm::vec3(0.0f, 0.0f, 1.0f), // TOP, blue
+    glm::vec3(1.0f, 1.0f, 0.0f), // BOTTOM, yellow
+    glm::vec3(0.0f, 1.0f, 1.0f), // LEFT, light-blue
+    glm::vec3(1.0f, 0.0f, 1.0f)  // RIGHT, pink
+};
+static glm::vec3 frustumVertices[8];
 
+void Camera::calculateFrustumPlanes() {
     glm::mat4 combo = projection * view;
 
     // Calculate frustum corners to display them
@@ -200,10 +211,6 @@ bool Camera::update() {
     planes[RIGHT].set(frustumVertices[NBR], frustumVertices[NTR], frustumVertices[FBR]);
     planes[NEAR].set(frustumVertices[NTL], frustumVertices[NTR], frustumVertices[NBR]);
     planes[FAR].set(frustumVertices[FTR], frustumVertices[FTL], frustumVertices[FBL]);
-
-    lastPos = pos;
-    lastRot = rot;
-    return true;
 }
 
 bool Camera::boxInFrustum(BoundingBox b) {

src/Game.cpp

@@ -31,6 +31,10 @@
 Game::Game() {
     mLoaded = false;
     mLara = -1;
+
+    for (int i = 0; i < ActionEventCount; i++) {
+        activeEvents[i] = false;
+    }
 }
 
 Game::~Game() {
@@ -124,10 +128,19 @@ int Game::loadLevel(const char* level) {
 }
 
 void Game::handleAction(ActionEvents action, bool isFinished) {
-    if (isFinished || (!mLoaded))
+    assert(action < ActionEventCount);
+
+    if (!mLoaded)
         return;
 
-    Camera::handleAction(action, isFinished);
+    if (isFinished) {
+        activeEvents[action] = false;
+        Camera::handleAction(action, isFinished);
+    } else {
+        if (!activeEvents[action])
+            Camera::handleAction(action, isFinished);
+        activeEvents[action] = true;
+    }
 }
 
 void Game::handleMouseMotion(int xrel, int yrel, int xabs, int yabs) {
@@ -137,6 +150,20 @@ void Game::handleMouseMotion(int xrel, int yrel, int xabs, int yabs) {
     Camera::handleMouseMotion(xrel, yrel);
 }
 
+void Game::handleControllerAxis(float value, KeyboardButton axis) {
+    if (!mLoaded)
+        return;
+
+    Camera::handleControllerAxis(value, axis);
+}
+
+void Game::handleControllerButton(KeyboardButton button, bool released) {
+    if (!mLoaded)
+        return;
+
+    Camera::handleControllerButton(button, released);
+}
+
 Entity& Game::getLara() {
     assert(mLara >= 0);
     assert(mLara < (int)getWorld().sizeEntity());

src/RunTime.cpp

@@ -103,8 +103,9 @@ void RunTime::setShowFPS(bool fps) {
 
 void RunTime::updateFPS() {
     frameCount++;
-    frameTimeSum += (systemTimerGet() - lastTime);
-    frameTimeSum2 += (systemTimerGet() - lastTime);
+    lastFrameTime = systemTimerGet() - lastTime;
+    frameTimeSum += lastFrameTime;
+    frameTimeSum2 += lastFrameTime;
     lastTime = systemTimerGet();
     if (frameTimeSum >= 200) {
         fps = frameCount * (1000 / frameTimeSum);
@@ -126,3 +127,7 @@ const std::vector<float>& RunTime::getHistoryFPS() {
     return history;
 }
 
+float RunTime::getLastFrameTime() {
+    return lastFrameTime / 1000.0f;
+}
+

src/UI.cpp

@@ -653,6 +653,14 @@ void UI::handleMouseScroll(int xrel, int yrel) {
     scrollEvents.push_back(std::make_tuple(xrel, yrel));
 }
 
+void UI::handleControllerAxis(float value, KeyboardButton axis) {
+    getGame().handleControllerAxis(value, axis);
+}
+
+void UI::handleControllerButton(KeyboardButton button, bool released) {
+    getGame().handleControllerButton(button, released);
+}
+
 void UI::setVisible(bool v) {
     visible = v;
 }

src/system/WindowSDL.cpp

@@ -8,12 +8,13 @@
 #include <iostream>
 
 #include "global.h"
+#include "Log.h"
 #include "RunTime.h"
 #include "UI.h"
 #include "utils/strings.h"
 #include "system/WindowSDL.h"
 
-#define SUBSYSTEMS_USED (SDL_INIT_VIDEO | SDL_INIT_EVENTS)
+#define SUBSYSTEMS_USED (SDL_INIT_VIDEO | SDL_INIT_EVENTS | SDL_INIT_JOYSTICK | SDL_INIT_GAMECONTROLLER)
 
 WindowSDL::WindowSDL() {
     mInit = false;
@@ -24,10 +25,14 @@ WindowSDL::WindowSDL() {
     mTextInput = false;
     mWindow = nullptr;
     mGLContext = nullptr;
+    controller = nullptr;
 }
 
 WindowSDL::~WindowSDL() {
     if (mInit) {
+        if (controller)
+            SDL_GameControllerClose(controller);
+
         SDL_QuitSubSystem(SUBSYSTEMS_USED);
         SDL_Quit();
     }
@@ -115,23 +120,108 @@ int WindowSDL::initialize() {
     setSize(mWidth, mHeight);
     setMousegrab(mMousegrab);
 
+    if (SDL_NumJoysticks() == 0) {
+        getLog() << "No Joystick found!" << Log::endl;
+        return 0;
+    }
+
+    SDL_GameControllerAddMapping("341a0000000000000208000000000000,"
+                                 "USB GAMEPAD 8116,"
+                                 "a:b0,x:b2,start:b7,back:b6,leftstick:b8,rightstick:b9,"
+                                 "leftshoulder:b4,rightshoulder:b5,"
+                                 "dpup:h0.1,dpleft:h0.8,dpdown:h0.4,dpright:h0.2,"
+                                 "leftx:a0,lefty:a1,rightx:a3,righty:a2,"
+                                 "lefttrigger:,b:b1,y:b3,lefttrigger:a4,righttrigger:a4");
+
+    for (int i = 0; i < SDL_NumJoysticks(); i++) {
+        if (SDL_IsGameController(i)) {
+            controller = SDL_GameControllerOpen(i);
+            if (controller) {
+                getLog() << "Using controller \"" << SDL_GameControllerName(controller)
+                         << "\"..." << Log::endl;
+                break;
+            } else {
+                getLog() << "Couldn't open controller \"" << SDL_GameControllerNameForIndex(i)
+                         << "\"!" << Log::endl;
+            }
+        } else {
+            getLog() << "Joystick \"" << SDL_JoystickNameForIndex(i)
+                     << "\" is no controller!" << Log::endl;
+        }
+    }
     return 0;
 }
 
 void WindowSDL::eventHandling() {
     SDL_Event event;
+    KeyboardButton button;
 
     assert(mInit == true);
 
     while (SDL_PollEvent(&event)) {
         switch (event.type) {
+            case SDL_CONTROLLERAXISMOTION:
+                button = unknownKey;
+                if (event.caxis.axis == SDL_CONTROLLER_AXIS_LEFTX)
+                    button = leftXAxis;
+                else if (event.caxis.axis == SDL_CONTROLLER_AXIS_LEFTY)
+                    button = leftYAxis;
+                else if (event.caxis.axis == SDL_CONTROLLER_AXIS_RIGHTX)
+                    button = rightXAxis;
+                else if (event.caxis.axis == SDL_CONTROLLER_AXIS_RIGHTY)
+                    button = rightYAxis;
+                else if (event.caxis.axis == SDL_CONTROLLER_AXIS_TRIGGERLEFT)
+                    button = leftTrigger;
+                else if (event.caxis.axis == SDL_CONTROLLER_AXIS_TRIGGERRIGHT)
+                    button = rightTrigger;
+                if (button != unknownKey)
+                    UI::handleControllerAxis(event.caxis.value / 32768.0f, button);
+                break;
+
+            case SDL_CONTROLLERBUTTONDOWN:
+            case SDL_CONTROLLERBUTTONUP:
+                button = unknownKey;
+                if (event.cbutton.button == SDL_CONTROLLER_BUTTON_A)
+                    button = aButton;
+                else if (event.cbutton.button == SDL_CONTROLLER_BUTTON_B)
+                    button = bButton;
+                else if (event.cbutton.button == SDL_CONTROLLER_BUTTON_X)
+                    button = xButton;
+                else if (event.cbutton.button == SDL_CONTROLLER_BUTTON_Y)
+                    button = yButton;
+                else if (event.cbutton.button == SDL_CONTROLLER_BUTTON_BACK)
+                    button = backButton;
+                else if (event.cbutton.button == SDL_CONTROLLER_BUTTON_GUIDE)
+                    button = guideButton;
+                else if (event.cbutton.button == SDL_CONTROLLER_BUTTON_START)
+                    button = startButton;
+                else if (event.cbutton.button == SDL_CONTROLLER_BUTTON_LEFTSTICK)
+                    button = leftStick;
+                else if (event.cbutton.button == SDL_CONTROLLER_BUTTON_RIGHTSTICK)
+                    button = rightStick;
+                else if (event.cbutton.button == SDL_CONTROLLER_BUTTON_LEFTSHOULDER)
+                    button = leftShoulder;
+                else if (event.cbutton.button == SDL_CONTROLLER_BUTTON_RIGHTSHOULDER)
+                    button = rightShoulder;
+                else if (event.cbutton.button == SDL_CONTROLLER_BUTTON_DPAD_UP)
+                    button = padUp;
+                else if (event.cbutton.button == SDL_CONTROLLER_BUTTON_DPAD_DOWN)
+                    button = padDown;
+                else if (event.cbutton.button == SDL_CONTROLLER_BUTTON_DPAD_LEFT)
+                    button = padLeft;
+                else if (event.cbutton.button == SDL_CONTROLLER_BUTTON_DPAD_RIGHT)
+                    button = padRight;
+                if (button != unknownKey)
+                    UI::handleControllerButton(button, (event.type == SDL_CONTROLLERBUTTONUP));
+                break;
+
             case SDL_MOUSEMOTION:
                 UI::handleMouseMotion(event.motion.xrel, event.motion.yrel, event.motion.x, event.motion.y);
                 break;
 
             case SDL_MOUSEBUTTONDOWN:
             case SDL_MOUSEBUTTONUP:
-                KeyboardButton button;
+                button = unknownKey;
                 if (event.button.button == SDL_BUTTON_LEFT)
                     button = leftmouseKey;
                 else if (event.button.button == SDL_BUTTON_RIGHT)
@@ -142,9 +232,9 @@ void WindowSDL::eventHandling() {
                     button = fourthmouseKey;
                 else if (event.button.button == SDL_BUTTON_X2)
                     button = fifthmouseKey;
-                else
-                    button = unknownKey;
-                UI::handleMouseClick(event.button.x, event.button.y, button, (event.type == SDL_MOUSEBUTTONUP));
+                if (button != unknownKey)
+                    UI::handleMouseClick(event.button.x, event.button.y, button,
+                                         (event.type == SDL_MOUSEBUTTONUP));
                 break;
 
             case SDL_MOUSEWHEEL: