Slight cleanup

Added Camera abstraction

src/camera.h

@@ -0,0 +1,118 @@
+#pragma once
+
+#include <glad/glad.h>
+#include <glm/glm.hpp>
+#include <glm/gtc/matrix_transform.hpp>
+
+#include <vector>
+
+enum Camera_Movement{
+    FORWARD,
+    BACKWARD,
+    LEFT,
+    RIGHT
+};
+
+const float YAW = -90.0f;
+const float PITCH = 0.0f;
+const float SPEED = 2.5f;
+const float SENSITIVITY = 0.1f;
+const float ZOOM = 45.0f;
+
+class Camera{
+    public: 
+        glm::vec3 Position;
+        glm::vec3 Front;
+        glm::vec3 Up;
+        glm::vec3 Right;
+        glm::vec3 WorldUp;
+
+        float Yaw;
+        float Pitch;
+
+        float MovementSpeed;
+        float MouseSensitivity;
+        float Zoom;
+
+
+    Camera(glm::vec3 position = glm::vec3(0.0f, 0.0f, 0.0f), glm::vec3 up = glm::vec3(0.0f, 1.0f, 0.0f), float yaw = YAW, float pitch = PITCH) : Front(glm::vec3(0.0f, 0.0f, -1.0f)), MovementSpeed(SPEED), MouseSensitivity(SENSITIVITY), Zoom(ZOOM)
+    {
+        Position = position;
+        WorldUp = up;
+        Yaw = yaw;
+        Pitch = pitch;
+        updateCameraVectors();
+    }
+
+    Camera(float posX, float posY, float posZ, float upX, float upY, float upZ, float yaw, float pitch) : Front(glm::vec3(0.0f, 0.0f, -1.0f)), MovementSpeed(SPEED), MouseSensitivity(SENSITIVITY), Zoom(ZOOM)
+    {
+        Position = glm::vec3(posX, posY, posZ);
+        WorldUp = glm::vec3(upX, upY, upZ);
+        Yaw = yaw;
+        Pitch = pitch;
+        updateCameraVectors();
+    }
+
+
+    glm::mat4 GetViewMatrix()
+    {
+        return glm::lookAt(Position, Position + Front, Up);
+    }
+
+
+    void ProcessKeyboard(Camera_Movement direction, float deltaTime)
+    {
+        float velocity = MovementSpeed * deltaTime;
+        if (direction == FORWARD)
+            Position += Front * velocity;
+        if (direction == BACKWARD)
+            Position -= Front * velocity;
+        if (direction == LEFT)
+            Position -= Right * velocity;
+        if (direction == RIGHT)
+            Position += Right * velocity;
+    }
+
+
+    void ProcessMouseMovement(float xoffset, float yoffset, GLboolean constrainPitch = true)
+    {
+        xoffset *= MouseSensitivity;
+        yoffset *= MouseSensitivity;
+
+        Yaw   += xoffset;
+        Pitch += yoffset;
+
+      
+        if (constrainPitch)
+        {
+            if (Pitch > 89.0f)
+                Pitch = 89.0f;
+            if (Pitch < -89.0f)
+                Pitch = -89.0f;
+        }
+
+      updateCameraVectors();
+    }
+
+
+    void ProcessMouseScroll(float yoffset)
+    {
+        Zoom -= (float)yoffset;
+        if (Zoom < 1.0f)
+            Zoom = 1.0f;
+        if (Zoom > 45.0f)
+            Zoom = 45.0f; 
+    }
+
+private:
+    void updateCameraVectors()
+    {
+        glm::vec3 front;
+        front.x = cos(glm::radians(Yaw)) * cos(glm::radians(Pitch));
+        front.y = sin(glm::radians(Pitch));
+        front.z = sin(glm::radians(Yaw)) * cos(glm::radians(Pitch));
+        Front = glm::normalize(front);
+        Right = glm::normalize(glm::cross(Front, WorldUp));  // normalize the vectors, because their length gets closer to 0 the more you look up or down which results in slower movement.
+        Up    = glm::normalize(glm::cross(Right, Front));
+    }
+};

src/main.cpp

@@ -11,19 +11,13 @@
 
 #include "stb_image.h"
 #include "shader.h"
-
+#include "camera.h"
- // stationary camera vectors
-glm::vec3 cameraPos = glm::vec3(0.0f, 0.0f, 3.0f);
-glm::vec3 cameraFront = glm::vec3(0.0f, 0.0f, -1.0f);
-glm::vec3 cameraUp = glm::vec3(0.0f, 1.0f, 0.0f);
-
 
 float deltaTime = 0.0f;	// Time between current frame and last frame
 float lastFrame = 0.0f; // Time of last frame
 
+Camera camera(glm::vec3(0.0f, 0.0f, 3.0f));
 float lastX = 400, lastY = 300;
-float yaw =0 , pitch =0 ;
-float fov = 45;
 bool firstMouse  = true;
 
 void framebuffer_size_callback(GLFWwindow* window, int width, int height) {
@@ -36,14 +30,13 @@ void processInput( GLFWwindow* window){
 
    const float CameraSpeed = 2.5f * deltaTime; 
    if(glfwGetKey(window, GLFW_KEY_W) == GLFW_PRESS)
-      cameraPos += CameraSpeed * cameraFront;
+      camera.ProcessKeyboard(FORWARD, deltaTime);
    if(glfwGetKey(window, GLFW_KEY_S) == GLFW_PRESS)
-      cameraPos -= CameraSpeed * cameraFront;
+      camera.ProcessKeyboard(BACKWARD, deltaTime);
    if(glfwGetKey(window, GLFW_KEY_A) == GLFW_PRESS)
-      cameraPos -= glm::normalize(glm::cross(cameraFront, cameraUp)) * CameraSpeed;
+      camera.ProcessKeyboard(LEFT, deltaTime);
    if(glfwGetKey(window, GLFW_KEY_D) == GLFW_PRESS)
-      cameraPos += glm::normalize(glm::cross(cameraFront, cameraUp)) * CameraSpeed;
+      camera.ProcessKeyboard(RIGHT,deltaTime);
-
 }
 
 
@@ -56,37 +49,16 @@ void mouse_callback(GLFWwindow* window, double xpos, double ypos){
    }
    float xoffset = xpos - lastX;
    float yoffset = lastY - ypos; // reversed since y-coordinates range from bottom to top
+   
    lastX = xpos;
    lastY = ypos;
 
-   const float sensitivity = 0.1f;
+   camera.ProcessMouseMovement(xoffset,yoffset);
-   xoffset *= sensitivity;
-   yoffset *= sensitivity;
-
-   yaw   += xoffset;
-   pitch += yoffset; 
-
-   if(pitch > 89.0f)
-      pitch =  89.0f;
-   if(pitch < -89.0f)
-      pitch = -89.0f;
-
-   
-
-   glm::vec3 direction;
-   direction.x = cos(glm::radians(yaw)) * cos(glm::radians(pitch));
-   direction.y = sin(glm::radians(pitch));
-   direction.z = sin(glm::radians(yaw)) * cos(glm::radians(pitch));
-   cameraFront = glm::normalize(direction);
 }
 
 void scroll_callback(GLFWwindow* window, double xoffset, double yoffset)
 {
-    fov -= (float)yoffset;
+   camera.ProcessMouseScroll(yoffset);
-    if (fov < 1.0f)
-        fov = 1.0f;
-    if (fov > 45.0f)
-        fov = 45.0f; 
 }
 
 int main() {
@@ -163,37 +135,6 @@ int main() {
     -0.5f,  0.5f, -0.5f,  0.0f, 1.0f
 };
 
-  /*  unsigned int indices[] = {
-      0,1,3, // first triangle
-      1,2,3  // second triangle
-   }; */
-
-  
-
-   // Vertex buffer objects!!
-  /*  unsigned int VBO, VAO, EBO;
-   glGenVertexArrays(1, &VAO);
-   glGenBuffers(1, &VBO);
-   glGenBuffers(1, &EBO);
-
-   glBindVertexArray(VAO);
-
-   glBindBuffer(GL_ARRAY_BUFFER, VBO);
-   glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
-
-   glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO);
-   glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW); */
-
-  /*  // Position attribute
-   glVertexAttribPointer(0,3, GL_FLOAT, GL_FALSE, 8 * sizeof(float), (void*)0);
-   glEnableVertexAttribArray(0);
-   // Color attribute
-   glVertexAttribPointer(1,3, GL_FLOAT, GL_FALSE, 8 * sizeof(float), (void*)(3* sizeof(float)));
-   glEnableVertexAttribArray(1);
-
-   // texture attribute
-   glVertexAttribPointer(2,2, GL_FLOAT, GL_FALSE, 8 * sizeof(float), (void*)(6*sizeof(float)));
-   glEnableVertexAttribArray(2); */
 
    unsigned int VBO, VAO;
    glGenVertexArrays(1, &VAO);
@@ -265,12 +206,6 @@ int main() {
    }
    
    stbi_image_free(data2);
-
-
- 
-   // WireFrame mode
-   // glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); 
-
    
 
    shader.use();
@@ -323,20 +258,12 @@ int main() {
       glm::mat4 view          = glm::mat4(1.0f);
       glm::mat4 projection    = glm::mat4(1.0f);
       model = glm::rotate(model, (float)glfwGetTime(), glm::vec3(0.5f, 1.0f, 0.0f));
-        
-      // orbiting camera vectors
-      const float radius = 10.0f;
-      float camX = sin(glfwGetTime()) * radius;
-      float camZ = cos(glfwGetTime()) * radius;
-     
-      view = glm::lookAt(cameraPos, cameraPos + cameraFront, cameraUp);
-
-      projection = glm::perspective(glm::radians(fov), (float)800 / (float)600, 0.1f, 100.0f);
-
       
       // Pass a matrix to the shader
+      view = camera.GetViewMatrix();
       shader.setMat4("view", view);
 
+      projection = glm::perspective(glm::radians(camera.Zoom), (float)800 / (float)600, 0.1f, 100.0f);
       shader.setMat4("projection", projection);