start adding mouse input processing

8 files changed, 99 insertions, 25 deletions

diff --git a/src/core.c b/src/core.c
index 4b3bd1b..0db8962 100644
--- a/src/core.c
+++ b/src/core.c
@@ -2,6 +2,9 @@
 
 #include <stdlib.h>
 
+#include "glfw3.h"
+#include "input.h"
+#include "keys.h"
 #include "log.h"
 #include "render.h"
 #include "render_types.h"
@@ -49,3 +52,13 @@ core* core_bringup() {
 
   return c;
 }
+
+void core_shutdown(core* core) {
+  // threadpool_destroy(&core->threadpool);
+  input_system_shutdown(&core->input);
+  renderer_shutdown(&core->renderer);
+}
+
+bool should_exit(core* core) {
+  return key_just_released(KEYCODE_ESCAPE) || glfwWindowShouldClose(core->renderer.window);
+}
\ No newline at end of file
diff --git a/src/core.h b/src/core.h
index f54631e..05e3aed 100644
--- a/src/core.h
+++ b/src/core.h
@@ -20,5 +20,6 @@ typedef struct core {
 // --- Lifecycle
 core* core_bringup();
 void core_shutdown(core* core);
+bool should_exit(core* core);
 
 void core_input_update(core* core);
diff --git a/src/maths/maths.h b/src/maths/maths.h
index 6816415..baa75e9 100644
--- a/src/maths/maths.h
+++ b/src/maths/maths.h
@@ -9,6 +9,7 @@
 #pragma once
 
 #include <math.h>
+#include <stdio.h>
 #include "maths_types.h"
 
 // --- Helpers
@@ -48,6 +49,10 @@ static inline vec3 vec3_cross(vec3 a, vec3 b) {
 #define VEC3_Z ((vec3){ .x = 0.0, .y = 0.0, .z = 1.0 })
 #define VEC3_NEG_Z ((vec3){ .x = 0.0, .y = 0.0, .z = -1.0 })
 
+static inline void print_vec3(vec3 v) {
+  printf("{ x: %f, y: %f, z: %f )\n", v.x, v.y, v.z);
+}
+
 // TODO: Dimension 2
 static inline vec2 vec2_create(f32 x, f32 y) { return (vec2){ x, y }; }
 
diff --git a/src/renderer/backends/backend_vulkan.c b/src/renderer/backends/backend_vulkan.c
index 7be5918..43ea658 100644
--- a/src/renderer/backends/backend_vulkan.c
+++ b/src/renderer/backends/backend_vulkan.c
@@ -1,3 +1,4 @@
+#include "camera.h"
 #define CDEBUG
 #define CEL_PLATFORM_LINUX
 // ^ Temporary
@@ -337,6 +338,16 @@ bool vulkan_graphics_pipeline_create(vulkan_context* context, vulkan_renderpass*
   VkPipelineLayoutCreateInfo pipeline_layout_create_info = {
     VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO
   };
+
+  // Pushconstants
+  VkPushConstantRange push_constant;
+  push_constant.stageFlags = VK_SHADER_STAGE_VERTEX_BIT;
+  push_constant.offset = sizeof(mat4) * 0;
+  push_constant.size = sizeof(mat4) * 2;
+
+  pipeline_layout_create_info.pushConstantRangeCount = 1;
+  pipeline_layout_create_info.pPushConstantRanges = &push_constant;
+
   pipeline_layout_create_info.setLayoutCount = descriptor_set_layout_count;
   pipeline_layout_create_info.pSetLayouts = descriptor_set_layouts;
 
@@ -600,9 +611,6 @@ void vulkan_object_shader_update_global_state(vulkan_context* context, vulkan_sh
   VkCommandBuffer cmd_buffer = context->gfx_command_buffers->data[image_index].handle;
   VkDescriptorSet global_descriptors = shader->descriptor_sets[image_index];
 
-  vkCmdBindDescriptorSets(cmd_buffer, VK_PIPELINE_BIND_POINT_GRAPHICS, shader->pipeline.layout, 0,
-                          1, &global_descriptors, 0, 0);
-
   u32 range = sizeof(global_object_uniform);
   u64 offset = 0;
 
@@ -624,6 +632,28 @@ void vulkan_object_shader_update_global_state(vulkan_context* context, vulkan_sh
   descriptor_write.pBufferInfo = &buffer_info;
 
   vkUpdateDescriptorSets(context->device.logical_device, 1, &descriptor_write, 0, 0);
+
+  vkCmdBindDescriptorSets(cmd_buffer, VK_PIPELINE_BIND_POINT_GRAPHICS, shader->pipeline.layout, 0,
+                          1, &global_descriptors, 0, 0);
+}
+
+void vulkan_object_shader_update_object(vulkan_context* context, vulkan_shader* shader,
+                                        mat4 model) {
+  u32 image_index = context->image_index;
+  VkCommandBuffer cmd_buffer = context->gfx_command_buffers->data[image_index].handle;
+  // vulkan_command_buffer* cmd_buffer = &context->gfx_command_buffers->data[context.image_index];
+
+  vkCmdPushConstants(cmd_buffer, shader->pipeline.layout, VK_SHADER_STAGE_VERTEX_BIT, 0,
+                     sizeof(mat4), &model);
+
+  // vulkan_object_shader_use(context, &context->object_shader);
+  VkDeviceSize offsets[1] = { 0 };
+  vkCmdBindVertexBuffers(cmd_buffer, 0, 1, &context->object_vertex_buffer.handle,
+                         (VkDeviceSize*)offsets);
+
+  vkCmdBindIndexBuffer(cmd_buffer, context->object_index_buffer.handle, 0, VK_INDEX_TYPE_UINT32);
+
+  vkCmdDrawIndexed(cmd_buffer, 6, 1, 0, 0, 0);
 }
 
 bool select_physical_device(vulkan_context* ctx) {
@@ -1555,13 +1585,13 @@ bool gfx_backend_init(renderer* ren) {
 
   const f32 s = 10.0;
 
-  verts[0].pos.x = 0.0 * s;
+  verts[0].pos.x = -0.5 * s;
   verts[0].pos.y = -0.5 * s;
 
   verts[1].pos.x = 0.5 * s;
   verts[1].pos.y = 0.5 * s;
 
-  verts[2].pos.x = 0.0 * s;
+  verts[2].pos.x = -0.5 * s;
   verts[2].pos.y = 0.5 * s;
 
   verts[3].pos.x = 0.5 * s;
@@ -1688,39 +1718,28 @@ void backend_end_frame(renderer* ren, f32 delta_time) {
       context.queue_complete_semaphores[context.current_frame], context.image_index);
 }
 
-void gfx_backend_draw_frame(renderer* ren) {
+void gfx_backend_draw_frame(renderer* ren, camera* cam, mat4 model) {
   backend_begin_frame(ren, 16.0);
 
-  static f32 z = -1.0;
-  z -= 0.2;
-  mat4 proj = mat4_perspective(deg_to_rad(45.0), 1000 / 1000.0, 0.1, 1000.0);
-  mat4 view = mat4_translation(vec3(0, 0, z));
+  mat4 proj;
+  mat4 view;
+
+  camera_view_projection(cam, SCR_HEIGHT, SCR_WIDTH, &view, &proj);
 
   gfx_backend_update_global_state(proj, view, VEC3_ZERO, vec4(1.0, 1.0, 1.0, 1.0), 0);
+  vulkan_object_shader_update_object(&context, &context.object_shader, model);
 
   backend_end_frame(ren, 16.0);
 }
 
 void gfx_backend_update_global_state(mat4 projection, mat4 view, vec3 view_pos, vec4 ambient_colour,
                                      i32 mode) {
-  vulkan_command_buffer* cmd_buffer = &context.gfx_command_buffers->data[context.image_index];
   vulkan_object_shader_use(&context, &context.object_shader);
 
   vulkan_object_shader_update_global_state(&context, &context.object_shader);
   context.object_shader.global_ubo.projection = projection;
   context.object_shader.global_ubo.view = view;
   // TODO: other UBO properties
-
-  // vulkan_object_shader_use(&context, &context.object_shader);
-
-  VkDeviceSize offsets[1] = { 0 };
-  vkCmdBindVertexBuffers(cmd_buffer->handle, 0, 1, &context.object_vertex_buffer.handle,
-                         (VkDeviceSize*)offsets);
-
-  vkCmdBindIndexBuffer(cmd_buffer->handle, context.object_index_buffer.handle, 0,
-                       VK_INDEX_TYPE_UINT32);
-
-  vkCmdDrawIndexed(cmd_buffer->handle, 6, 1, 0, 0, 0);
 }
 
 void clear_screen(vec3 colour) {}
diff --git a/src/renderer/render.c b/src/renderer/render.c
index 74b98cf..54b63b6 100644
--- a/src/renderer/render.c
+++ b/src/renderer/render.c
@@ -61,6 +61,8 @@ bool renderer_init(renderer* ren) {
   return true;
 }
 
+void renderer_shutdown(renderer* ren) {}
+
 void render_frame_begin(renderer* ren) {
   vec3 color = ren->config.clear_colour;
   clear_screen(color);
diff --git a/src/renderer/render_backend.h b/src/renderer/render_backend.h
index 69d14d8..ea84b27 100644
--- a/src/renderer/render_backend.h
+++ b/src/renderer/render_backend.h
@@ -3,6 +3,7 @@
  */
 #pragma once
 
+#include "camera.h"
 #include "maths_types.h"
 #include "render_types.h"
 
@@ -12,8 +13,9 @@
 bool gfx_backend_init(renderer* ren);
 void gfx_backend_shutdown(renderer* ren);
 
-void gfx_backend_draw_frame(renderer* ren);
-void gfx_backend_update_global_state(mat4 projection, mat4 view, vec3 view_pos, vec4 ambient_colour, i32 mode);
+void gfx_backend_draw_frame(renderer* ren, camera* camera, mat4 model);
+void gfx_backend_update_global_state(mat4 projection, mat4 view, vec3 view_pos, vec4 ambient_colour,
+                                     i32 mode);
 
 void clear_screen(vec3 colour);
 
diff --git a/src/systems/input.c b/src/systems/input.c
index 292d438..fc62db8 100644
--- a/src/systems/input.c
+++ b/src/systems/input.c
@@ -1,11 +1,17 @@
 #include "input.h"
 
+#include <assert.h>
 #include <glfw3.h>
+#include <string.h>
 
 #include "log.h"
 
+static input_state *g_input;  // Use a global to simplify caller code
+
 bool input_system_init(input_state *input, GLFWwindow *window) {
   INFO("Input init");
+  memset(input, 0, sizeof(input_state));
+
   input->window = window;
   // Set everything to false. Could just set memory to zero but where's the fun in that
   for (int i = 0; i < KEYCODE_MAX; i++) {
@@ -14,9 +20,16 @@ bool input_system_init(input_state *input, GLFWwindow *window) {
     input->just_released_keys[i] = false;
   }
 
+  g_input = input;
+
+  assert(input->mouse.x_delta == 0);
+  assert(input->mouse.y_delta == 0);
+
   return true;
 }
 
+void input_system_shutdown(input_state *input) {}
+
 void input_update(input_state *input) {
   // --- update keyboard input
 
@@ -75,3 +88,9 @@ void input_update(input_state *input) {
 
   input->mouse = new_mouse_state;
 }
+
+bool key_is_pressed(keycode key) { return g_input->depressed_keys[key]; }
+
+bool key_just_pressed(keycode key) { return g_input->just_pressed_keys[key]; }
+
+bool key_just_released(keycode key) { return g_input->just_released_keys[key]; }
\ No newline at end of file
diff --git a/src/systems/keys.h b/src/systems/keys.h
index 090bb49..a76e101 100644
--- a/src/systems/keys.h
+++ b/src/systems/keys.h
@@ -2,5 +2,18 @@
 
 typedef enum keycode {
   // TODO: add all keycodes
-  KEYCODE_MAX
+  KEYCODE_SPACE = 32,
+  KEYCODE_A = 65,
+  KEYCODE_D = 68,
+  KEYCODE_S = 83,
+  KEYCODE_W = 87,
+  KEYCODE_ESCAPE = 256,
+  KEYCODE_ENTER = 257,
+  KEYCODE_TAB = 258,
+  KEYCODE_BACKSPACE = 259,
+  KEYCODE_KEY_RIGHT = 262,
+  KEYCODE_KEY_LEFT = 263,
+  KEYCODE_KEY_DOWN = 264,
+  KEYCODE_KEY_UP = 265,
+  KEYCODE_MAX = 348
 } keycode;
\ No newline at end of file