title: OpenGL First Person Camera Doesn't Move
body: <p>I have created a simple cube in OpenGL, and am still coming to grips with developing an FPS camera to move around it. For now, the code only allows for left, right, up and down movements via the W,A,S,D keys. The application code is as follows:</p>
  
  <pre><code>#include &lt;iostream&gt;
  #include &lt;cmath&gt;
  
  // GLEW
  #define GLEW_STATIC
  #include &lt;GL/glew.h&gt;
  
  // GLFW
  #include &lt;GLFW/glfw3.h&gt;
  
  // GLM Mathematics
  #include &lt;glm/glm.hpp&gt;
  #include &lt;glm/gtc/matrix_transform.hpp&gt;
  #include &lt;glm/gtc/type_ptr.hpp&gt;
  
  // Other includes
  #include "Shader.h"
  
  
  // Function prototypes
  void key_callback(GLFWwindow* window, int key, int scancode, int action, int mode);
  void do_movement();
  
  // Window dimensions
  const GLuint WIDTH = 800, HEIGHT = 600;
  
  // Camera
  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);
  bool keys[1024];
  
  // Deltatime
  GLfloat deltaTime = 0.0f;   // Time between current frame and last frame
  GLfloat lastFrame = 0.0f;   // Time of last frame
  
  // The MAIN function, from here we start the application and run the game loop
  int main()
  {
      // Init GLFW
      glfwInit();
      // Set all the required options for GLFW
      glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
      glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
      glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
      glfwWindowHint(GLFW_RESIZABLE, GL_FALSE);
  
      // Create a GLFWwindow object that we can use for GLFW's functions
      GLFWwindow* window = glfwCreateWindow(WIDTH, HEIGHT, "LearnOpenGL", nullptr, nullptr);
      glfwMakeContextCurrent(window);
  
      // Set the required callback functions
      glfwSetKeyCallback(window, key_callback);
  
      // Set this to true so GLEW knows to use a modern approach to retrieving function pointers and extensions
      glewExperimental = GL_TRUE;
      // Initialize GLEW to setup the OpenGL Function pointers
      glewInit();
  
      // Define the viewport dimensions
      glViewport(0, 0, WIDTH, HEIGHT);
  
      //Enable depth test
      glEnable(GL_DEPTH_TEST);
  
  
      // Build and compile our shader program
      Shader ourShader("C:/Users/Noel/Documents/Visual Studio 2013/Projects/RoomSim/Vertexshader.vs", "C:/Users/Noel/Documents/Visual Studio 2013/Projects/RoomSim/FragShader.frag");
  
  
      // Set up vertex data (and buffer(s)) and attribute pointers
      GLfloat vertices[] = {
          -0.5f, -0.5f, -0.5f,
          0.5f, -0.5f, -0.5f, 
          0.5f, 0.5f, -0.5f, 
          0.5f, 0.5f, -0.5f, 
          -0.5f, 0.5f, -0.5f,
          -0.5f, -0.5f, -0.5f,
  
          -0.5f, -0.5f, 0.5f,
          0.5f, -0.5f, 0.5f,
          0.5f, 0.5f, 0.5f,
          0.5f, 0.5f, 0.5f,
          -0.5f, 0.5f, 0.5f,
          -0.5f, -0.5f, 0.5f,
  
          -0.5f, 0.5f, 0.5f,
          -0.5f, 0.5f, -0.5f,
          -0.5f, -0.5f, -0.5f,
          -0.5f, -0.5f, -0.5f,
          -0.5f, -0.5f, 0.5f, 
          -0.5f, 0.5f, 0.5f, 
  
          0.5f, 0.5f, 0.5f,
          0.5f, 0.5f, -0.5f, 
          0.5f, -0.5f, -0.5f,
          0.5f, -0.5f, -0.5f,
          0.5f, -0.5f, 0.5f, 
          0.5f, 0.5f, 0.5f, 
  
          -0.5f, -0.5f, -0.5f,
          0.5f, -0.5f, -0.5f,
          0.5f, -0.5f, 0.5f, 
          0.5f, -0.5f, 0.5f, 
          -0.5f, -0.5f, 0.5f,
          -0.5f, -0.5f, -0.5f,
  
          -0.5f, 0.5f, -0.5f, 
          0.5f, 0.5f, -0.5f, 
          0.5f, 0.5f, 0.5f, 
          0.5f, 0.5f, 0.5f, 
          -0.5f, 0.5f, 0.5f,
          -0.5f, 0.5f, -0.5f,
      };
  
      GLuint VBO, VAO;
      glGenVertexArrays(1, &amp;VAO);
      glGenBuffers(1, &amp;VBO);
  
      // Bind the Vertex Array Object first, then bind and set vertex buffer(s) and attribute pointer(s).
      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, 3* sizeof(GLfloat), (GLvoid*)0);
      glEnableVertexAttribArray(0);
      // Color attribute
      //glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(GLfloat), (GLvoid*)(3 * sizeof(GLfloat)));
      //glEnableVertexAttribArray(1);
  
      glBindVertexArray(0); // Unbind VAO
  
  
      // Game loop
      while (!glfwWindowShouldClose(window))
      {
          // Calculate deltatime of current frame
          GLfloat currentFrame = glfwGetTime();
          deltaTime = currentFrame - lastFrame;
          lastFrame = currentFrame;
  
          // Check if any events have been activiated (key pressed, mouse moved etc.) and call corresponding response functions
          glfwPollEvents();
          do_movement();
  
          // Render
          // Clear the colorbuffer
          glClearColor(0.2f, 0.3f, 0.3f, 1.0f);
  
          glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  
          //Transformations
          // Create transformations
          //glm::mat4 transform;
          //transform = glm::translate(transform, glm::vec3(0.5f, -0.5f, 0.0f));
          //transform = glm::rotate(transform, (GLfloat)glfwGetTime() * 50.0f, glm::vec3(0.0f, 0.0f, 1.0f));
  
          // Get matrix's uniform location and set matrix
  
          //GLint transformLoc = glGetUniformLocation(ourShader.Program, "transform");
  
          //glUniformMatrix4fv(transformLoc, 1, GL_FALSE, glm::value_ptr(transform));
  
          // Draw the triangle
          ourShader.Use();
  
          // Create transformations
          glm::mat4 model;
          glm::mat4 view;
          glm::mat4 projection;
  
          //Camera particulars for view
          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);
  
          model = glm::rotate(model, 50.0f, glm::vec3(1.0f, 0.0f, 0.0f));
  
  
          view = glm::lookAt(cameraPos, cameraPos + cameraFront, cameraUp);
          projection = glm::perspective(45.0f, (GLfloat)WIDTH / (GLfloat)HEIGHT, 0.1f, 100.0f);
  
          // Get their uniform location
          GLint modelLoc = glGetUniformLocation(ourShader.Program, "model");
          GLint viewLoc = glGetUniformLocation(ourShader.Program, "view");
          GLint projLoc = glGetUniformLocation(ourShader.Program, "projection");
          glBindVertexArray(VAO);
          // Pass them to the shaders
          glUniformMatrix4fv(modelLoc, 1, GL_FALSE, glm::value_ptr(model));
          glUniformMatrix4fv(viewLoc, 1, GL_FALSE, glm::value_ptr(view));
          glUniformMatrix4fv(projLoc, 1, GL_FALSE, glm::value_ptr(projection));
  
  
          glDrawArrays(GL_TRIANGLES, 0, 36);
          glBindVertexArray(0);
  
          // Swap the screen buffers
          glfwSwapBuffers(window);
      }
      // Properly de-allocate all resources once they've outlived their purpose
      glDeleteVertexArrays(1, &amp;VAO);
      glDeleteBuffers(1, &amp;VBO);
  
      // Terminate GLFW, clearing any resources allocated by GLFW.
      glfwTerminate();
      return 0;
  }
  
  // Is called whenever a key is pressed/released via GLFW
  void key_callback(GLFWwindow* window, int key, int scancode, int action, int mode)
  {
      if (key == GLFW_KEY_ESCAPE &amp;&amp; action == GLFW_PRESS)
          glfwSetWindowShouldClose(window, GL_TRUE);
      if (key &gt;= 0 &amp;&amp; key &lt; 1024)
      {
          if (action == GLFW_PRESS)
              keys[key] = true;
          else if (action == GLFW_RELEASE)
              keys[key] = false;
      }
  }
  
  void do_movement()
  {
      GLfloat cameraSpeed = 5.0f * deltaTime;
      // Camera controls
  
      if (keys[GLFW_KEY_W])
          cameraPos += cameraSpeed * cameraFront;
      if (keys[GLFW_KEY_S])
          cameraPos -= cameraSpeed * cameraFront;
      if (keys[GLFW_KEY_A])
          cameraPos -= glm::normalize(glm::cross(cameraFront, cameraUp)) * cameraSpeed;
      if (keys[GLFW_KEY_D])
          cameraPos += glm::normalize(glm::cross(cameraFront, cameraUp)) * cameraSpeed;
  }
  </code></pre>
  
  <p>The issue is that nothing happens on pressing the W,A,S,D keys whatsover. The Vertex shader implemented is as below:</p>
  
  <pre><code>#version 330 core
  layout(location = 0) in vec3 position;
  layout(location = 1) in vec3 color;
  
  out vec3 ourColor;
  uniform mat4 model;
  uniform mat4 view;
  uniform mat4 projection;
  
  void main()
  {
  gl_Position = projection * view * model * vec4(position, 1.0f);
      ourColor = color;
  
  }
  </code></pre>
  
  <p>What could be the cause for no movement?</p>