Implement camera movement

imgui.ini

@@ -3,6 +3,6 @@ Pos=60,60
 Size=400,400
 
 [Window][Control]
-Pos=60,60
-Size=213,82
+Pos=50,64
+Size=393,284
 

src/camera.cpp

@@ -1,4 +1,5 @@
 #include "camera.h"
+#include <glm/ext/matrix_transform.hpp>
 
 Matrix4 get_camera_view_matrix(Camera *camera, Render_Data *render_data) {
   f32 azimuth_radians = glm::radians(render_data->view_azimuth);
@@ -10,8 +11,12 @@ Matrix4 get_camera_view_matrix(Camera *camera, Render_Data *render_data) {
   f32 cos_elevation = glm::cos(elevation_radians);
 
   camera->view_direction = glm::normalize(Vector3(sin_azimuth * cos_elevation, sin_elevation, -cos_azimuth * cos_elevation));
+  camera->right_direction = glm::normalize(glm::cross(camera->view_direction, camera->world_up_vector));
+  camera->up_direction = glm::normalize(glm::cross(camera->right_direction, camera->view_direction));
 
-  Matrix4 look_at = glm::lookAt(camera->world_position, camera->world_position + camera->view_direction, camera->world_up_vector);
+  render_data->camera_world_position += render_data->move_forward * render_data->tick_diff * camera->view_direction + render_data->move_right * render_data->tick_diff * camera->right_direction + render_data->move_up * render_data->tick_diff * camera->up_direction;
+
+  Matrix4 look_at = glm::lookAt(render_data->camera_world_position, render_data->camera_world_position + camera->view_direction, camera->world_up_vector);
 
   return look_at;
 }

src/camera.h

@@ -2,13 +2,14 @@
 
 #include "basic.h"
 #include <glm/glm.hpp>
-#include "renderer.h"
 #include "render_data.h"
 
 struct Camera {
   Vector3 world_position = Vector3(0.5f, 0.25f, 1.0f);
   Vector3 view_direction = Vector3(0.0f, 0.0f, 0.0f);
   Vector3 world_up_vector = Vector3(0.0f, 1.0f, 0.0f);
+  Vector3 right_direction = Vector3(0.0f, 0.0f, 0.0f);
+  Vector3 up_direction = Vector3(0.0f, 0.0f, 0.0f);
 };
 
 Matrix4 get_camera_view_matrix(Camera *camera, Render_Data *render_data);

src/render_data.h

@@ -27,4 +27,11 @@ struct Render_Data {
 
   f32 view_azimuth = 320.0f;
   f32 view_elevation = -15.0f;
+
+  s32 move_forward = 0;
+  s32 move_right = 0;
+  s32 move_up = 0;
+  f32 tick_diff = 0.0f;
+
+  Vector3 camera_world_position = Vector3(0.5f, 0.25f, 1.0f);
 };

src/renderer.cpp

@@ -91,10 +91,13 @@ void set_renderer_size(Renderer *renderer, u32 width, u32 height) {
 }
 
 void draw_renderer(Renderer *renderer) {
-  // FPS time
+  // @Todo why do we have two glfwGetTime() functions being called and setting to things that are relatively close in purpose?
   static f32 previous_frame_start_time = 0.0;
   f32 frame_start_time = glfwGetTime();
 
+  f64 tick_time = glfwGetTime();
+  renderer->render_data.tick_diff = tick_time - renderer->last_tick_time;
+
   while(renderer->render_data.width == 0 || renderer->render_data.height == 0) {
     glfwGetFramebufferSize(renderer->render_data.glfw_window, &renderer->render_data.width, &renderer->render_data.height);
     glfwWaitEvents();
@@ -106,10 +109,6 @@ void draw_renderer(Renderer *renderer) {
   glClearDepth(1.0f);
   glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 
-  Vector3 camera_position = Vector3(0.4f, 0.3f, 1.0f);
-  Vector3 camera_look_at_position = Vector3(0.0f, 0.0f, 0.0f);
-  Vector3 camera_up_vector = Vector3(0.0f, 1.0f, 0.0f);
-
   renderer->projection_matrix = glm::perspective(glm::radians(static_cast<f32>(renderer->render_data.field_of_view)), static_cast<f32>(renderer->render_data.width) / static_cast<f32>(renderer->render_data.height), 0.1f, 10.0f);
 
   f32 dt = glfwGetTime();
@@ -123,7 +122,7 @@ void draw_renderer(Renderer *renderer) {
     model = glm::rotate(Matrix4(1.0f), -dt, Vector3(0.0f, 0.0f, 1.0f));
   }
 
-  renderer->view_matrix = glm::lookAt(camera_position, camera_look_at_position, camera_up_vector) * model;
+  renderer->view_matrix = get_camera_view_matrix(&renderer->camera, &renderer->render_data);
   
   upload_uniform_buffer_data(&renderer->uniform_buffer, renderer->view_matrix, renderer->projection_matrix);
 
@@ -140,6 +139,9 @@ void draw_renderer(Renderer *renderer) {
 
   // Timer
   start_timer(&renderer->timer);
+
+  handle_movement_keys(renderer);
+
   create_user_interface_frame(&renderer->user_interface, &renderer->render_data);
   renderer->render_data.user_interface_generate_time = stop_timer(&renderer->timer);
 
@@ -148,6 +150,7 @@ void draw_renderer(Renderer *renderer) {
   // FPS time
   renderer->render_data.frame_time = frame_start_time - previous_frame_start_time;
   previous_frame_start_time = frame_start_time;
+  renderer->last_tick_time = tick_time;
 }
 
 void upload_renderer_data(Renderer *renderer, Mesh *vertex_data) {
@@ -170,6 +173,60 @@ void handle_key_events(Renderer *renderer, s32 key, s32 scancode, s32 action, s3
   }
 }
 
+void handle_movement_keys(Renderer *renderer) {
+  renderer->render_data.move_forward = 0;
+  if (glfwGetKey(renderer->render_data.glfw_window, GLFW_KEY_W) == GLFW_PRESS) {
+    renderer->render_data.move_forward += 1;
+  }
+
+  if (glfwGetKey(renderer->render_data.glfw_window, GLFW_KEY_S) == GLFW_PRESS) {
+    renderer->render_data.move_forward -= 1;
+  }
+
+  renderer->render_data.move_right = 0;
+  if (glfwGetKey(renderer->render_data.glfw_window, GLFW_KEY_D) == GLFW_PRESS) {
+    renderer->render_data.move_right += 1;
+  }
+
+  if (glfwGetKey(renderer->render_data.glfw_window, GLFW_KEY_A) == GLFW_PRESS) {
+    renderer->render_data.move_right -= 1;
+  }
+
+  renderer->render_data.move_up = 0;
+  if (glfwGetKey(renderer->render_data.glfw_window, GLFW_KEY_E) == GLFW_PRESS) {
+    renderer->render_data.move_up += 1;
+  }
+
+  if (glfwGetKey(renderer->render_data.glfw_window, GLFW_KEY_Q) == GLFW_PRESS) {
+    renderer->render_data.move_up -= 1;
+  }
+}
+
+void handle_mouse_button_events(Renderer *renderer, s32 button, s32 action, s32 mods) {
+  ImGuiIO& io = ImGui::GetIO();
+  if (button >= 0 && button < ImGuiMouseButton_COUNT) {
+    io.AddMouseButtonEvent(button, action == GLFW_PRESS);
+  }
+
+  if (io.WantCaptureMouse) {
+    return;
+  }
+
+  if (button == GLFW_MOUSE_BUTTON_RIGHT && action == GLFW_PRESS) {
+    renderer->mouse_lock = !renderer->mouse_lock;
+
+    if (renderer->mouse_lock) {
+      glfwSetInputMode(renderer->render_data.glfw_window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
+
+      if (glfwRawMouseMotionSupported()) {
+        glfwSetInputMode(renderer->render_data.glfw_window, GLFW_RAW_MOUSE_MOTION, GLFW_TRUE);
+      }
+    } else {
+      glfwSetInputMode(renderer->render_data.glfw_window, GLFW_CURSOR, GLFW_CURSOR_NORMAL);
+    }
+  }
+}
+
 void handle_mouse_position_events(Renderer *renderer, f64 x_pos, f64 y_pos) {
   ImGuiIO& io = ImGui::GetIO();
   io.AddMousePosEvent((f32)x_pos, (f32)y_pos);
@@ -207,28 +264,3 @@ void handle_mouse_position_events(Renderer *renderer, f64 x_pos, f64 y_pos) {
   renderer->mouse_y_position = static_cast<s32>(y_pos);
 }
 
-void handle_mouse_button_events(Renderer *renderer, s32 button, s32 action, s32 mods) {
-  ImGuiIO& io = ImGui::GetIO();
-  if (button >= 0 && button < ImGuiMouseButton_COUNT) {
-    io.AddMouseButtonEvent(button, action == GLFW_PRESS);
-  }
-
-  if (io.WantCaptureMouse) {
-    return;
-  }
-
-  if (button == GLFW_MOUSE_BUTTON_RIGHT && action == GLFW_PRESS) {
-    renderer->mouse_lock = !renderer->mouse_lock;
-
-    if (renderer->mouse_lock) {
-      glfwSetInputMode(renderer->render_data.glfw_window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
-
-      if (glfwRawMouseMotionSupported()) {
-        glfwSetInputMode(renderer->render_data.glfw_window, GLFW_RAW_MOUSE_MOTION, GLFW_TRUE);
-      }
-    } else {
-      glfwSetInputMode(renderer->render_data.glfw_window, GLFW_CURSOR, GLFW_CURSOR_NORMAL);
-    }
-  }
-}
-

src/renderer.h

@@ -31,6 +31,7 @@ struct Renderer {
   s32 mouse_x_position = 0;
   s32 mouse_y_position = 0;
   Timer timer;
+  f64 last_tick_time = 0.0;
 };
 
 
@@ -42,5 +43,6 @@ void cleanup_renderer(Renderer *renderer);
 
 // Event handling
 void handle_key_events(Renderer *renderer, s32 key, s32 scancode, s32 action, s32 mods);
+void handle_movement_keys(Renderer *renderer);
 void handle_mouse_position_events(Renderer *renderer, f64 x_pos, f64 y_pos);
 void handle_mouse_button_events(Renderer *renderer, s32 button, s32 action, s32 mods);

src/user_interface.cpp

@@ -78,6 +78,17 @@ void create_user_interface_frame(User_Interface *user_interface, Render_Data *re
   ImGui::SameLine();
   ImGui::SliderInt("##FOV", &render_data->field_of_view, 40, 150);
 
+  // Camera information
+  ImGui::Text("View Azimuth:");
+  ImGui::SameLine();
+  ImGui::Text("%s", std::to_string(render_data->view_azimuth).c_str());
+  ImGui::Text("View Elevation:");
+  ImGui::Text("%s", std::to_string(render_data->view_elevation).c_str());
+  ImGui::Separator();
+  ImGui::Text("Camera Position:");
+  ImGui::SameLine();
+  ImGui::Text("%f, %f, %f", render_data->camera_world_position.x, render_data->camera_world_position.y, render_data->camera_world_position.z);
+
   ImGui::End();
 }
 

src/window.cpp

@@ -52,9 +52,15 @@ bool init_window(Window *window, u32 width, u32 height, string title) {
     handle_key_events(renderer, key, scancode, action, mods);
   });
 
-  // Have to disable so ImGui will accept mouse events
-  // glfwSetCursorPosCallback(window->glfw_window, handle_mouse_position_events);
-  // glfwSetMouseButtonCallback(window->glfw_window, handle_mouse_button_events);
+  glfwSetMouseButtonCallback(window->glfw_window, [](GLFWwindow *glfw_window, s32 button, s32 action, s32 mods) {
+    Renderer* renderer = static_cast<Renderer*>(glfwGetWindowUserPointer(glfw_window));
+    handle_mouse_button_events(renderer, button, action, mods);
+  });
+
+  glfwSetCursorPosCallback(window->glfw_window, [](GLFWwindow *glfw_window, f64 x_pos, f64 y_pos) {
+    Renderer* renderer = static_cast<Renderer*>(glfwGetWindowUserPointer(glfw_window));
+    handle_mouse_position_events(renderer, x_pos, y_pos);
+  });
 
   window->model = new Model();
   init_model(window->model);