[#35] refactor Camera to move functions to camera.cpp

modules/camera/include/vkcv/camera/Camera.hpp

@@ -21,7 +21,12 @@ namespace vkcv {
 		float m_fov;
 		float m_ratio;
 
-		glm::vec3 m_up;
+        glm::vec3 m_up;
+        glm::vec3 m_position;
+        float m_cameraSpeed;
+        float m_roll;
+        float m_pitch;
+        float m_yaw;
 
     public:
         Camera();
@@ -34,7 +39,7 @@ namespace vkcv {
 
         void getView(glm::vec3 &x, glm::vec3 &y, glm::vec3 &z, glm::vec3 &pos);
 
-        void setView(const glm::mat4 view);
+        glm::mat4 updateView();
 
         void lookAt(glm::vec3 position, glm::vec3 center, glm::vec3 up);
 
@@ -44,6 +49,8 @@ namespace vkcv {
 
         void getNearFar(float &near, float &far);
 
+        void setUp(const glm::vec3 &Up);
+
         float getFov();
 
         void setFov(float fov);
@@ -60,6 +67,24 @@ namespace vkcv {
 
         void setPosition( glm::vec3 position );
 
+        float getPitch() const;
+
+        void setPitch(float pitch);
+
+        float getYaw() const;
+
+        void setYaw(float yaw);
+
+        void panView( double xOffset, double yOffset );
+
+        void moveForward();
+
+        void moveBackward();
+
+        void moveLeft();
+
+        void moveRight();
+
 
     };
 

modules/camera/include/vkcv/camera/CameraManager.hpp

@@ -14,17 +14,12 @@ namespace vkcv{
         std::function<void(double, double)> m_mouseScrollHandle;
         std::function<void(int, int, int)> m_mouseButtonHandle;
 
+        int i;
         Window &m_window;
         Camera m_camera;
         float m_width;
         float m_height;
 //        std::shared_ptr<vkcv::TrackballCamera> m_trackball;
-        glm::vec3 m_up;
-        float m_radius;
-        float m_cameraSpeed;
-        float m_roll;
-        float m_pitch;
-        float m_yaw;
 
         bool m_roationActive = false;
         double m_lastX ;
@@ -37,7 +32,7 @@ namespace vkcv{
         void mouseButtonCallback(int button, int action, int mods);
 
     public:
-        CameraManager(Window &window, float width, float height, glm::vec3 up = glm::vec3(0.0f,1.0f,0.0f), glm::vec3 position = glm::vec3(0.0f,0.0f,0.0f) , glm::vec3 front = glm::vec3(0.0f,0.0f,-1.0f));
+        CameraManager(Window &window, float width, float height, glm::vec3 up = glm::vec3(0.0f,-1.0f,0.0f), glm::vec3 position = glm::vec3(0.0f,0.0f,0.0f));
 
         Camera getCamera();
     };

modules/camera/src/vkcv/camera/Camera.cpp

@@ -3,7 +3,15 @@
 
 namespace vkcv {
 
-    Camera::Camera() = default;
+    Camera::Camera(){
+        m_up = glm::vec3(0.0f, -1.0f, 0.0f);
+        m_position = glm::vec3(0.0f, 0.0f, 0.0f);
+        m_cameraSpeed = 0.05f;
+        // front
+        m_roll = 0.0;
+        m_pitch = 0.0;
+        m_yaw = 180.0;
+    }
 
     Camera::~Camera() = default;
 
@@ -11,6 +19,10 @@ namespace vkcv {
         m_view = glm::lookAt(position, center, up);
     }
 
+    glm::mat4 Camera::updateView(){
+        return m_view = glm::lookAt(m_position, m_position + getFront() , m_up);
+    }
+
     void Camera::getView(glm::vec3 &x, glm::vec3 &y, glm::vec3 &z, glm::vec3 &pos){
         x = glm::vec3( glm::row(m_view, 0));
         y = glm::vec3( glm::row(m_view, 1));
@@ -28,13 +40,10 @@ namespace vkcv {
 
 
     const glm::mat4& Camera::getView() {
+        updateView();
         return m_view;
     }
 
-    void Camera::setView( const glm::mat4 view ) {
-        m_view = view;
-    }
-
     const glm::mat4& Camera::getProjection() {
         return m_projection;
     }
@@ -76,7 +85,11 @@ namespace vkcv {
     }
 
     glm::vec3 Camera::getFront(){
-        return glm::vec3( m_view[2].x,m_view[2].y,-m_view[2].z);
+        glm::vec3 direction;
+        direction.x = sin(glm::radians(m_yaw)) * cos(glm::radians(m_pitch));
+        direction.y = sin(glm::radians(m_pitch));
+        direction.z = cos(glm::radians(m_yaw)) * cos(glm::radians(m_pitch));
+        return glm::normalize(direction);
     }
 
     glm::vec3 Camera::getPosition(){
@@ -91,4 +104,53 @@ namespace vkcv {
         translation[3] = glm::vec4(-position, 1.0f);
         m_view = m_view * translation;
     }
+
+    void Camera::setUp(const glm::vec3 &up) {
+        m_up = up;
+    }
+
+    float Camera::getPitch() const {
+        return m_pitch;
+    }
+
+    void Camera::setPitch(float pitch) {
+        if (pitch > 89.0f) {
+            pitch = 89.0f;
+        }
+        if (pitch < -89.0f) {
+            pitch = -89.0f;
+        }
+        m_pitch = pitch;
+    }
+
+    float Camera::getYaw() const {
+        return m_yaw;
+    }
+
+    void Camera::setYaw(float yaw) {
+        m_yaw = yaw;
+    }
+
+    void Camera::panView(double xOffset, double yOffset) {
+        m_yaw += xOffset;
+        m_pitch += yOffset;
+    }
+
+    void Camera::moveForward(){
+        m_position +=  m_cameraSpeed * getFront();
+
+    }
+
+    void Camera::moveBackward(){
+        m_position -= m_cameraSpeed * getFront();
+    }
+
+    void Camera::moveLeft(){
+
+        m_position -= glm::normalize(glm::cross(getFront(), m_up)) * m_cameraSpeed;
+    }
+
+    void Camera::moveRight(){
+        m_position += glm::normalize(glm::cross(getFront(), m_up)) * m_cameraSpeed;
+    }
 }
\ No newline at end of file

modules/camera/src/vkcv/camera/CameraManager.cpp

@@ -3,18 +3,12 @@
 
 namespace vkcv{
 
-    CameraManager::CameraManager(Window &window, float width, float height, glm::vec3 up, glm::vec3 position, glm::vec3 front):
-    m_window(window), m_width(width), m_height(height), m_up(up)
+    CameraManager::CameraManager(Window &window, float width, float height, glm::vec3 up, glm::vec3 position):
+    m_window(window), m_width(width), m_height(height)
     {
-        // initialize viewMatrix
-        m_camera.lookAt(position, position + front, m_up);
+        m_camera.setUp(up);
+        m_camera.setPosition(position);
         m_camera.setPerspective( glm::radians(60.0f), m_width / m_height, 0.1f, 10.f);
-        m_up = glm::vec3(0.0f, 1.0f, 0.0f);
-        m_radius = 10.0f;
-        m_cameraSpeed = 0.05f;
-        m_roll = 0.0;
-        m_pitch = 0.0;
-        m_yaw = 180.0;
         m_lastX = width/2.0;
         m_lastY = height/2.0;
         bindCamera();
@@ -52,24 +46,7 @@ namespace vkcv{
         xoffset *= sensitivity;
         yoffset *= sensitivity;
 
-        m_yaw += xoffset;
-        m_pitch += yoffset;
-
-        if (m_pitch > 89.0f) {
-            m_pitch = 89.0f;
-        }
-        if (m_pitch < -89.0f) {
-            m_pitch = -89.0f;
-        }
-
-        glm::vec3 direction;
-        direction.x = sin(glm::radians(m_yaw)) * cos(glm::radians(m_pitch));
-        direction.y = sin(glm::radians(m_pitch));
-        direction.z = cos(glm::radians(m_yaw)) * cos(glm::radians(m_pitch));
-
-        glm::vec3 front = glm::normalize(direction);
-
-        m_camera.lookAt(m_camera.getPosition(), m_camera.getPosition() + front, m_up);
+        m_camera.panView( xoffset , yoffset );
     }
 
     void CameraManager::scrollCallback(double offsetX, double offsetY) {
@@ -86,24 +63,19 @@ namespace vkcv{
     }
 
     void CameraManager::keyCallback(int key, int scancode, int action, int mods) {
-        glm::vec3 newPos;
 
         switch (key) {
             case GLFW_KEY_W:
-                newPos = m_camera.getPosition() + m_cameraSpeed * m_camera.getFront();
-                m_camera.lookAt(newPos, newPos + m_camera.getFront(), m_up);
+                m_camera.moveForward();
                 break;
             case GLFW_KEY_S:
-                newPos = m_camera.getPosition() -m_cameraSpeed * m_camera.getFront();
-                m_camera.lookAt(newPos, newPos + m_camera.getFront(), m_up);
+                m_camera.moveBackward();
                 break;
             case GLFW_KEY_A:
-                newPos = m_camera.getPosition() -glm::normalize(glm::cross(m_camera.getFront(), m_up)) * m_cameraSpeed;
-                m_camera.lookAt(newPos, newPos + m_camera.getFront(), m_up);
+                m_camera.moveLeft();
                 break;
             case GLFW_KEY_D:
-                newPos = m_camera.getPosition() + glm::normalize(glm::cross(m_camera.getFront(), m_up)) * m_cameraSpeed;
-                m_camera.lookAt(newPos, newPos + m_camera.getFront(), m_up);
+                m_camera.moveRight();
                 break;
             case GLFW_KEY_ESCAPE:
                 glfwSetWindowShouldClose(m_window.getWindow(), 1);