Fixed Camera Z rotation bug

ChangeLog.md

     [ 20140108 ]
     * FPS and Camera position now displayed in imgui Overlay
     * Removed many unnecessary includes
+    * Camera now using combination of quaternion and X/Y angle.
+        * Fixes strange bug that sometimes rotated Camera on Z Axis.
 
     [ 20140107 ]
     * Fixed problems with FontTTFs Glyph Baseline

include/Camera.h

 #ifndef _CAMERA_H_
 #define _CAMERA_H_
 
-#include <glm/gtc/quaternion.hpp>
 #include <glm/gtc/type_precision.hpp>
 
 #include "RoomData.h"
 
     //! \fixme The Y axis seems to be the source of all evil?
     static void setPosition(glm::vec3 p) { pos = glm::vec3(p.x, -p.y, p.z); }
-    static glm::vec3 getPosition() { return glm::vec3(pos.x, -pos.y, pos.z); }
+    static glm::vec3 getPosition() { return pos; }
 
-    static glm::vec2 getRotation();
+    static glm::vec2 getRotation() { return rot; }
     static glm::mat4 getProjectionMatrix() { return projection; }
     static glm::mat4 getViewMatrix() { return view; }
 
     static void calculateFrustumPlanes();
 
     static glm::vec3 pos;
-    static glm::quat quaternion;
+    static glm::vec2 rot;
     static glm::vec3 posSpeed;
     static glm::vec2 rotSpeed;
     static glm::mat4 projection;

src/Camera.cpp

 
 #include <glm/gtc/epsilon.hpp>
 #include <glm/gtc/matrix_transform.hpp>
+#include <glm/gtc/quaternion.hpp>
 #include <glm/gtx/quaternion.hpp>
 
 static bool equal(float a, float b) {
 const static float nearDist = 0.1f;
 const static float farDist = 75000.0f;
 const static float maxSpeed = 2048.0f;
-const static float controllerViewFactor = 384.0f;
+const static float controllerViewFactor = glm::pi<float>();
 const static float controllerDeadZone = 0.1f;
 
 const static glm::vec3 rightUnit(1.0f, 0.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::quat Camera::quaternion(glm::vec3(0.0f, 0.0f, 0.0f));
+glm::vec2 Camera::rot(glm::pi<float>(), 0.0f);
 glm::vec3 Camera::posSpeed(0.0f, 0.0f, 0.0f);
 glm::vec2 Camera::rotSpeed(0.0f, 0.0f);
 glm::mat4 Camera::projection(1.0f);
 
 void Camera::reset() {
     pos = glm::vec3(0.0f, 0.0f, 0.0f);
-    quaternion = glm::quat(glm::vec3(0.0f, 0.0f, 0.0f));
+    rot = glm::vec2(glm::pi<float>(), 0.0f);
     posSpeed = glm::vec3(0.0f, 0.0f, 0.0f);
     rotSpeed = glm::vec2(0.0f, 0.0f);
     dirty = true;
 }
 
 void Camera::handleMouseMotion(int x, int y) {
-    if (x != 0) {
-        quaternion = glm::quat(upUnit * (rotationDeltaX * x)) * quaternion;
+    if ((x != 0) || (y != 0))
         dirty = true;
+
+    while (x > 0) {
+        rot.x += rotationDeltaX;
+        x--;
+    }
+
+    while (x < 0) {
+        rot.x -= rotationDeltaX;
+        x++;
     }
 
-    if (y != 0) {
-        static int lastDir = 0;
-        float a = glm::dot(upUnit, quaternion * upUnit);
-        if (((lastDir >= 0) && (y < 0)) || ((lastDir <= 0) && (y > 0)) || (a > 0.5f)) {
-            quaternion = glm::quat(quaternion * -rightUnit * (rotationDeltaY * y)) * quaternion;
-            dirty = true;
+    while (y > 0) {
+        if (rot.y > -(glm::pi<float>() / 2.0f)) {
+            rot.y -= rotationDeltaY;
+        }
+        y--;
+    }
 
-            // TODO find better way to clamp Y rotation axis!
-            if (a > 0.5f)
-                lastDir = y;
+    while (y < 0) {
+        if (rot.y < (glm::pi<float>() / 2.0f)) {
+            rot.y += rotationDeltaY;
         }
+        y++;
     }
+
+    while (rot.x > (glm::pi<float>() * 2.0f))
+        rot.x -= glm::pi<float>() * 2.0f;
+
+    while (rot.x < -(glm::pi<float>() * 2.0f))
+        rot.x += glm::pi<float>() * 2.0f;
 }
 
 void Camera::handleControllerAxis(float value, KeyboardButton axis) {
     } else if (axis == rightXAxis) {
         rotSpeed.x = controllerViewFactor * value;
     } else if (axis == rightYAxis) {
-        rotSpeed.y = controllerViewFactor * value;
+        rotSpeed.y = -controllerViewFactor * value;
     } else {
         return;
     }
         return false;
 
     float dT = RunTime::getLastFrameTime();
-    pos += quaternion * posSpeed * dT;
+    rot += rotSpeed * dT;
 
-    if (glm::epsilonNotEqual(rotSpeed.x, 0.0f, controllerDeadZone))
-        quaternion = glm::quat(upUnit * rotationDeltaX * rotSpeed.x * dT) * quaternion;
+    glm::quat quatY = glm::angleAxis(rot.x, glm::vec3(0.0f, 1.0f, 0.0f));
+    glm::quat quatX = glm::angleAxis(rot.y, glm::vec3(1.0f, 0.0f, 0.0f));
+    glm::quat quaternion = quatY * quatX;
 
-    if (glm::epsilonNotEqual(rotSpeed.y, 0.0f, controllerDeadZone))
-        quaternion = glm::quat(quaternion * -rightUnit * rotationDeltaY * rotSpeed.y * dT) * quaternion;
+    pos += quaternion * posSpeed * dT;
 
     glm::mat4 translate = glm::translate(glm::mat4(1.0f), pos);
     glm::mat4 rotate = glm::toMat4(quaternion);
     return updateViewFrustum;
 }
 
-glm::vec2 Camera::getRotation() {
-    float x = glm::dot(dirUnit, quaternion * dirUnit);
-    float y = glm::dot(upUnit, quaternion * upUnit);
-    return glm::vec2(x, y);
-}
-
 // ----------------------------------------------------------------------------
 
 class FrustumPlane {