From df80f2cf0b851b527f715ebfe385dc4930a61512 Mon Sep 17 00:00:00 2001
From: omnisci3nce <17525998+omnisci3nce@users.noreply.github.com>
Date: Sat, 23 Mar 2024 12:19:52 +1100
Subject: required extensions and validation layers

---
 src/renderer/backends/vulkan_helpers.h | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
 create mode 100644 src/renderer/backends/vulkan_helpers.h

(limited to 'src/renderer/backends/vulkan_helpers.h')

diff --git a/src/renderer/backends/vulkan_helpers.h b/src/renderer/backends/vulkan_helpers.h
new file mode 100644
index 0000000..058ea91
--- /dev/null
+++ b/src/renderer/backends/vulkan_helpers.h
@@ -0,0 +1,19 @@
+#pragma once
+
+#include <assert.h>
+#include <vulkan/vulkan.h>
+
+#include "darray.h"
+#include "defines.h"
+
+DECL_TYPED_ARRAY(const char*, cstr)
+
+static void plat_get_required_extension_names(cstr_darray* extensions) {
+#ifdef CEL_PLATFORM_LINUX
+  cstr_darray_push(extensions, "VK_KHR_xcb_surface");
+#endif
+}
+
+// TODO(omni): port to using internal assert functions
+#define VK_CHECK(vulkan_expr) \
+  { assert(vulkan_expr == VK_SUCCESS); }
\ No newline at end of file
-- 
cgit v1.2.3-70-g09d2


From 411992fad179c4e45d044cd3dab86dc460ce15ac Mon Sep 17 00:00:00 2001
From: omnisci3nce <17525998+omnisci3nce@users.noreply.github.com>
Date: Sat, 23 Mar 2024 17:53:42 +1100
Subject: vk debugger and physical device selection

omg.
---
 src/renderer/backends/backend_vulkan.c | 176 ++++++++++++++++++++++++++++++++-
 src/renderer/backends/vulkan_helpers.h | 149 +++++++++++++++++++++++++++-
 src/renderer/render.c                  |   6 +-
 3 files changed, 325 insertions(+), 6 deletions(-)

(limited to 'src/renderer/backends/vulkan_helpers.h')

diff --git a/src/renderer/backends/backend_vulkan.c b/src/renderer/backends/backend_vulkan.c
index c21dfc2..481792a 100644
--- a/src/renderer/backends/backend_vulkan.c
+++ b/src/renderer/backends/backend_vulkan.c
@@ -1,5 +1,9 @@
-#include "str.h"
 #define CEL_PLATFORM_LINUX
+#include <assert.h>
+#include <vulkan/vk_platform.h>
+#include <vulkan/vulkan.h>
+#include <vulkan/vulkan_core.h>
+#include "str.h"
 
 #include "darray.h"
 #include "defines.h"
@@ -17,12 +21,29 @@
 #include <glad/glad.h>
 
 #include <glfw3.h>
-#include <vulkan/vulkan.h>
-#include <vulkan/vulkan_core.h>
+
+typedef struct vulkan_device {
+  VkPhysicalDevice physical_device;
+  VkDevice logical_device;
+  vulkan_swapchain_support_info swapchain_support;
+  i32 graphics_queue_index;
+  i32 present_queue_index;
+  i32 compute_queue_index;
+  i32 transfer_queue_index;
+  VkPhysicalDeviceProperties properties;
+  VkPhysicalDeviceFeatures features;
+  VkPhysicalDeviceMemoryProperties memory;
+} vulkan_device;
 
 typedef struct vulkan_context {
   VkInstance instance;
   VkAllocationCallbacks* allocator;
+  VkSurfaceKHR surface;
+  vulkan_device device;
+
+#if defined(DEBUG)
+  VkDebugUtilsMessengerEXT vk_debugger;
+#endif
 } vulkan_context;
 
 static vulkan_context context;
@@ -33,6 +54,85 @@ typedef struct vulkan_state {
 
 KITC_DECL_TYPED_ARRAY(VkLayerProperties)
 
+bool select_physical_device(vulkan_context* ctx) {
+  u32 physical_device_count = 0;
+  VK_CHECK(vkEnumeratePhysicalDevices(ctx->instance, &physical_device_count, 0));
+  if (physical_device_count == 0) {
+    FATAL("No devices that support vulkan were found");
+    return false;
+  }
+  TRACE("Number of devices found %d", physical_device_count);
+
+  VkPhysicalDevice physical_devices[physical_device_count];
+  VK_CHECK(vkEnumeratePhysicalDevices(ctx->instance, &physical_device_count, physical_devices));
+
+  for (u32 i = 0; i < physical_device_count; i++) {
+    VkPhysicalDeviceProperties properties;
+    vkGetPhysicalDeviceProperties(physical_devices[i], &properties);
+
+    VkPhysicalDeviceFeatures features;
+    vkGetPhysicalDeviceFeatures(physical_devices[i], &features);
+
+    VkPhysicalDeviceMemoryProperties memory;
+    vkGetPhysicalDeviceMemoryProperties(physical_devices[i], &memory);
+
+    vulkan_physical_device_requirements requirements = {};
+    requirements.graphics = true;
+    requirements.present = true;
+    requirements.compute = true;
+    requirements.transfer = true;
+
+    requirements.sampler_anistropy = true;
+    requirements.discrete_gpu = true;
+    requirements.device_ext_names[0] = str8lit(VK_KHR_SWAPCHAIN_EXTENSION_NAME);
+    requirements.device_ext_name_count = 1;
+
+    vulkan_physical_device_queue_family_info queue_info = {};
+
+    bool result = physical_device_meets_requirements(physical_devices[i], ctx->surface, &properties,
+                                                     &features, &requirements, &queue_info,
+                                                     &ctx->device.swapchain_support);
+
+    if (result) {
+      INFO("GPU Driver version: %d.%d.%d", VK_VERSION_MAJOR(properties.driverVersion),
+           VK_VERSION_MINOR(properties.driverVersion), VK_VERSION_PATCH(properties.driverVersion));
+
+      INFO("Vulkan API version: %d.%d.%d", VK_VERSION_MAJOR(properties.apiVersion),
+           VK_VERSION_MINOR(properties.apiVersion), VK_VERSION_PATCH(properties.apiVersion));
+
+      // TODO: print gpu memory information -
+      // https://youtu.be/6Kj3O2Ov1RU?si=pXfP5NvXXcXjJsrG&t=2439
+
+      ctx->device.physical_device = physical_devices[i];
+      ctx->device.graphics_queue_index = queue_info.graphics_family_index;
+      ctx->device.present_queue_index = queue_info.present_family_index;
+      ctx->device.compute_queue_index = queue_info.compute_family_index;
+      ctx->device.transfer_queue_index = queue_info.transfer_family_index;
+      ctx->device.properties = properties;
+      ctx->device.features = features;
+      ctx->device.memory = memory;
+      break;
+    }
+  }
+
+  if (!ctx->device.physical_device) {
+    ERROR("No suitable physical devices were found :(");
+    return false;
+  }
+
+  INFO("Physical device selected: %s\n", ctx->device.properties.deviceName);
+  return true;
+}
+
+bool vulkan_device_create(vulkan_context* ctx) {
+  if (!select_physical_device(ctx)) {
+    return false;
+  }
+
+  return true;
+}
+void vulkan_device_destroy(vulkan_context* ctx) {}
+
 bool gfx_backend_init(renderer* ren) {
   INFO("loading Vulkan backend");
 
@@ -111,11 +211,58 @@ bool gfx_backend_init(renderer* ren) {
     return false;
   }
 
+  // Debugger
+#if defined(DEBUG)
+  DEBUG("Creating Vulkan debugger")
+  u32 log_severity = VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT |
+                     VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT;
+  VkDebugUtilsMessengerCreateInfoEXT debug_create_info = {
+    VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT
+  };
+  debug_create_info.messageSeverity = log_severity;
+  debug_create_info.messageType = VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT |
+                                  VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT |
+                                  VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT;
+  debug_create_info.pfnUserCallback = vk_debug_callback;
+
+  PFN_vkCreateDebugUtilsMessengerEXT func =
+      (PFN_vkCreateDebugUtilsMessengerEXT)vkGetInstanceProcAddr(context.instance,
+                                                                "vkCreateDebugUtilsMessengerEXT");
+  assert(func);
+  VK_CHECK(func(context.instance, &debug_create_info, context.allocator, &context.vk_debugger));
+  DEBUG("Vulkan debugger created");
+
+#endif
+
+  // Surface creation
+  DEBUG("Create SurfaceKHR")
+  VkSurfaceKHR surface;
+  VK_CHECK(glfwCreateWindowSurface(context.instance, ren->window, NULL, &surface));
+  context.surface = surface;
+  DEBUG("Vulkan surface created")
+
+  // Device creation
+  if (!vulkan_device_create(&context)) {
+    FATAL("device creation failed");
+    return false;
+  }
+
   INFO("Vulkan renderer initialisation succeeded");
   return true;
 }
 
-void gfx_backend_shutdown(renderer* ren) {}
+void gfx_backend_shutdown(renderer* ren) {
+  DEBUG("Destroying Vulkan debugger");
+  if (context.vk_debugger) {
+    PFN_vkDestroyDebugUtilsMessengerEXT func =
+        (PFN_vkDestroyDebugUtilsMessengerEXT)vkGetInstanceProcAddr(
+            context.instance, "vkDestroyDebugUtilsMessengerEXT");
+    func(context.instance, context.vk_debugger, context.allocator);
+  }
+
+  DEBUG("Destroying Vulkan instance...");
+  vkDestroyInstance(context.instance, context.allocator);
+}
 
 void clear_screen(vec3 colour) {}
 
@@ -131,4 +278,25 @@ void uniform_f32(u32 program_id, const char* uniform_name, f32 value) {}
 void uniform_i32(u32 program_id, const char* uniform_name, i32 value) {}
 void uniform_mat4f(u32 program_id, const char* uniform_name, mat4* value) {}
 
+VKAPI_ATTR VkBool32 VKAPI_CALL vk_debug_callback(
+    VkDebugUtilsMessageSeverityFlagBitsEXT severity, VkDebugUtilsMessageTypeFlagsEXT flags,
+    const VkDebugUtilsMessengerCallbackDataEXT callback_data, void* user_data) {
+  switch (severity) {
+    default:
+    case VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT:
+      ERROR(callback_data.pMessage);
+      break;
+    case VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT:
+      WARN(callback_data.pMessage);
+      break;
+    case VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT:
+      INFO(callback_data.pMessage);
+      break;
+    case VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT:
+      TRACE(callback_data.pMessage);
+      break;
+  }
+  return VK_FALSE;
+}
+
 #endif
\ No newline at end of file
diff --git a/src/renderer/backends/vulkan_helpers.h b/src/renderer/backends/vulkan_helpers.h
index 058ea91..8f4d48a 100644
--- a/src/renderer/backends/vulkan_helpers.h
+++ b/src/renderer/backends/vulkan_helpers.h
@@ -2,9 +2,14 @@
 
 #include <assert.h>
 #include <vulkan/vulkan.h>
+#include <vulkan/vulkan_core.h>
 
 #include "darray.h"
 #include "defines.h"
+#include "log.h"
+#include "str.h"
+
+#define VULKAN_PHYS_DEVICE_MAX_EXTENSION_NAMES 36
 
 DECL_TYPED_ARRAY(const char*, cstr)
 
@@ -16,4 +21,146 @@ static void plat_get_required_extension_names(cstr_darray* extensions) {
 
 // TODO(omni): port to using internal assert functions
 #define VK_CHECK(vulkan_expr) \
-  { assert(vulkan_expr == VK_SUCCESS); }
\ No newline at end of file
+  { assert(vulkan_expr == VK_SUCCESS); }
+
+// TODO: typedef struct vk_debugger {} vk_debugger;
+
+typedef struct vulkan_physical_device_requirements {
+  bool graphics;
+  bool present;
+  bool compute;
+  bool transfer;
+  str8 device_ext_names[VULKAN_PHYS_DEVICE_MAX_EXTENSION_NAMES];
+  size_t device_ext_name_count;
+  bool sampler_anistropy;
+  bool discrete_gpu;
+} vulkan_physical_device_requirements;
+
+typedef struct vulkan_physical_device_queue_family_info {
+  u32 graphics_family_index;
+  u32 present_family_index;
+  u32 compute_family_index;
+  u32 transfer_family_index;
+} vulkan_physical_device_queue_family_info;
+
+#define VULKAN_MAX_DEFAULT 32
+
+typedef struct vulkan_swapchain_support_info {
+  VkSurfaceCapabilitiesKHR capabilities;
+  VkSurfaceFormatKHR formats[VULKAN_MAX_DEFAULT];
+  u32 format_count;
+  VkPresentModeKHR present_modes[VULKAN_MAX_DEFAULT];
+  u32 mode_count;
+} vulkan_swapchain_support_info;
+
+VKAPI_ATTR VkBool32 VKAPI_CALL vk_debug_callback(
+    VkDebugUtilsMessageSeverityFlagBitsEXT severity, VkDebugUtilsMessageTypeFlagsEXT flags,
+    const VkDebugUtilsMessengerCallbackDataEXT callback_data, void* user_data);
+
+void vulkan_device_query_swapchain_support(VkPhysicalDevice device, VkSurfaceKHR surface,
+                                           vulkan_swapchain_support_info* out_support_info) {
+  // TODO: add VK_CHECK to these calls!
+
+  // Surface capabilities
+  vkGetPhysicalDeviceSurfaceCapabilitiesKHR(device, surface, &out_support_info->capabilities);
+
+  // Surface formats
+  vkGetPhysicalDeviceSurfaceFormatsKHR(device, surface, &out_support_info->format_count,
+                                       0);  // Get number of formats
+  if (out_support_info->format_count > 0) {
+    vkGetPhysicalDeviceSurfaceFormatsKHR(device, surface, &out_support_info->format_count,
+                                         out_support_info->formats);
+  }
+
+  // Present Modes
+  vkGetPhysicalDeviceSurfacePresentModesKHR(device, surface, &out_support_info->mode_count,
+                                            0);  // Get number of formats
+  if (out_support_info->mode_count > 0) {
+    vkGetPhysicalDeviceSurfacePresentModesKHR(device, surface, &out_support_info->mode_count,
+                                              out_support_info->present_modes);
+  }
+}
+
+static bool physical_device_meets_requirements(
+    VkPhysicalDevice device, VkSurfaceKHR surface, const VkPhysicalDeviceProperties* properties,
+    const VkPhysicalDeviceFeatures* features,
+    const vulkan_physical_device_requirements* requirements,
+    vulkan_physical_device_queue_family_info* out_queue_info,
+    vulkan_swapchain_support_info* out_swapchain_support) {
+  // TODO: pass in an arena
+
+  out_queue_info->graphics_family_index = -1;
+  out_queue_info->present_family_index = -1;
+  out_queue_info->compute_family_index = -1;
+  out_queue_info->transfer_family_index = -1;
+
+  if (requirements->discrete_gpu) {
+    if (properties->deviceType != VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU) {
+      TRACE("Device is not a physical GPU. Skipping.");
+      return false;
+    }
+  }
+
+  u32 queue_family_count = 0;
+  vkGetPhysicalDeviceQueueFamilyProperties(device, &queue_family_count, 0);
+  VkQueueFamilyProperties queue_families[queue_family_count];
+  vkGetPhysicalDeviceQueueFamilyProperties(device, &queue_family_count, queue_families);
+
+  INFO("Graphics | Present | Compute | Transfer | Name");
+  u8 min_transfer_score = 255;
+  for (u32 i = 0; i < queue_family_count; i++) {
+    u8 current_transfer_score = 0;
+
+    // Graphics queue
+    if (queue_families[i].queueFlags & VK_QUEUE_GRAPHICS_BIT) {
+      out_queue_info->graphics_family_index = i;
+      current_transfer_score++;
+    }
+
+    // Compute queue
+    if (queue_families[i].queueFlags & VK_QUEUE_COMPUTE_BIT) {
+      out_queue_info->compute_family_index = i;
+      current_transfer_score++;
+    }
+
+    // Transfer queue
+    if (queue_families[i].queueFlags & VK_QUEUE_TRANSFER_BIT) {
+      // always take the lowest score transfer index
+      if (current_transfer_score <= min_transfer_score) {
+        min_transfer_score = current_transfer_score;
+        out_queue_info->transfer_family_index = i;
+      }
+    }
+
+    // Present Queue
+    VkBool32 supports_present = VK_FALSE;
+    vkGetPhysicalDeviceSurfaceSupportKHR(device, i, surface, &supports_present);
+    if (supports_present) {
+      out_queue_info->present_family_index = i;
+    }
+  }
+
+  INFO("       %d |       %d |       %d |        %d | %s",
+       out_queue_info->graphics_family_index != -1, out_queue_info->present_family_index != -1,
+       out_queue_info->compute_family_index != -1, out_queue_info->transfer_family_index != -1,
+       properties->deviceName);
+  TRACE("Graphics Family queue index: %d", out_queue_info->graphics_family_index);
+  TRACE("Present Family queue index: %d", out_queue_info->present_family_index);
+  TRACE("Compute Family queue index: %d", out_queue_info->compute_family_index);
+  TRACE("Transfer Family queue index: %d", out_queue_info->transfer_family_index);
+
+  if ((!requirements->graphics ||
+       (requirements->graphics && out_queue_info->graphics_family_index != -1))) {
+    INFO("Physical device meets our requirements! Proceed.");
+
+    vulkan_device_query_swapchain_support(
+        device, surface, out_swapchain_support
+
+        // TODO: error handling i.e. format count = 0 or present mode = 0
+
+    );
+    return true;
+  }
+
+  return false;
+}
\ No newline at end of file
diff --git a/src/renderer/render.c b/src/renderer/render.c
index 8e67fa6..45762d4 100644
--- a/src/renderer/render.c
+++ b/src/renderer/render.c
@@ -28,11 +28,14 @@ bool renderer_init(renderer* ren) {
   // NOTE: all platforms use GLFW at the moment but thats subject to change
   glfwInit();
 
-  DEBUG("init graphics api (OpenGL) backend");
+#if defined(CEL_REND_BACKEND_OPENGL)
   glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 4);
   glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 1);
   glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
   glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
+#elif defined(CEL_REND_BACKEND_VULKAN)
+  glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API);
+#endif
 
   // glfw window creation
   GLFWwindow* window = glfwCreateWindow(ren->config.scr_width, ren->config.scr_height,
@@ -46,6 +49,7 @@ bool renderer_init(renderer* ren) {
 
   glfwMakeContextCurrent(ren->window);
 
+  DEBUG("init graphics api backend");
   if (!gfx_backend_init(ren)) {
     FATAL("Couldnt load graphics api backend");
     return false;
-- 
cgit v1.2.3-70-g09d2


From b1e9a0f5e8731226d6dde11a5aabe002fa1a6a7d Mon Sep 17 00:00:00 2001
From: omnisci3nce <17525998+omnisci3nce@users.noreply.github.com>
Date: Sat, 23 Mar 2024 21:40:56 +1100
Subject: fix vulkan debug callback

---
 src/renderer/backends/vulkan_helpers.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'src/renderer/backends/vulkan_helpers.h')

diff --git a/src/renderer/backends/vulkan_helpers.h b/src/renderer/backends/vulkan_helpers.h
index 8f4d48a..3465aed 100644
--- a/src/renderer/backends/vulkan_helpers.h
+++ b/src/renderer/backends/vulkan_helpers.h
@@ -55,7 +55,7 @@ typedef struct vulkan_swapchain_support_info {
 
 VKAPI_ATTR VkBool32 VKAPI_CALL vk_debug_callback(
     VkDebugUtilsMessageSeverityFlagBitsEXT severity, VkDebugUtilsMessageTypeFlagsEXT flags,
-    const VkDebugUtilsMessengerCallbackDataEXT callback_data, void* user_data);
+    const VkDebugUtilsMessengerCallbackDataEXT* callback_data, void* user_data);
 
 void vulkan_device_query_swapchain_support(VkPhysicalDevice device, VkSurfaceKHR surface,
                                            vulkan_swapchain_support_info* out_support_info) {
-- 
cgit v1.2.3-70-g09d2


From 24e2e5f0b8675d498c188f221ea0a309d5911206 Mon Sep 17 00:00:00 2001
From: omnisci3nce <omniscient.oce@gmail.com>
Date: Sun, 28 Apr 2024 21:52:10 +1000
Subject: start on pipeline layout, pipeline, renderpass

---
 examples/triangle/ex_triangle.c        |  39 +++++++--
 src/renderer/backends/backend_dx11.h   |   3 +-
 src/renderer/backends/backend_vulkan.c | 142 ++++++++++++++++++++++++++++++---
 src/renderer/backends/backend_vulkan.h |  11 ++-
 src/renderer/backends/vulkan_helpers.h |   7 +-
 src/renderer/bind_group_layouts.h      |  30 +++++++
 src/renderer/ral.h                     |  22 ++++-
 src/renderer/ral_types.h               |   6 ++
 src/renderer/render.h                  |   1 +
 src/renderer/render_types.h            |   5 +-
 src/renderer/renderpasses.h            |  31 +++++++
 11 files changed, 274 insertions(+), 23 deletions(-)
 create mode 100644 src/renderer/bind_group_layouts.h
 create mode 100644 src/renderer/renderpasses.h

(limited to 'src/renderer/backends/vulkan_helpers.h')

diff --git a/examples/triangle/ex_triangle.c b/examples/triangle/ex_triangle.c
index 4e31313..9b993c1 100644
--- a/examples/triangle/ex_triangle.c
+++ b/examples/triangle/ex_triangle.c
@@ -1,27 +1,52 @@
 #include <glfw3.h>
 
+#include "backend_vulkan.h"
 #include "camera.h"
 #include "core.h"
+#include "file.h"
+#include "log.h"
 #include "maths.h"
+#include "mem.h"
+#include "ral.h"
 #include "render.h"
 
+// Example setting up a renderer
+
 int main() {
   core* core = core_bringup();
+  arena scratch = arena_create(malloc(1024 * 1024), 1024 * 1024);
+
+  gpu_renderpass_desc pass_description = {};
+  gpu_renderpass* renderpass = gpu_renderpass_create(&pass_description);
 
-  camera camera = camera_create(vec3_create(0, 0, 20), VEC3_NEG_Z, VEC3_Y, deg_to_rad(45.0));
+  str8_opt vertex_shader = str8_from_file(&scratch, str8lit("assets/shaders/triangle.vert"));
+  str8_opt fragment_shader = str8_from_file(&scratch, str8lit("assets/shaders/triangle.frag"));
+  if (!vertex_shader.has_value || !fragment_shader.has_value) {
+    ERROR_EXIT("Failed to load shaders from disk")
+  }
+
+  struct graphics_pipeline_desc pipeline_description = {
+    .debug_name = "Basic Pipeline",
+    .vs = { .debug_name = "Triangle Vertex Shader",
+            .filepath = str8lit("assets/shaders/triangle.vert"),
+            .glsl = vertex_shader.contents },
+    .fs = { .debug_name = "Triangle Fragment Shader",
+            .filepath = str8lit("assets/shaders/triangle.frag"),
+            .glsl = fragment_shader.contents },
+    .renderpass = renderpass,
+    .wireframe = false,
+    .depth_test = false
+  };
+  gpu_pipeline* gfx_pipeline = gpu_graphics_pipeline_create(pipeline_description);
 
   // Main loop
-  while (!glfwWindowShouldClose(core->renderer.window)) {
+  while (!should_exit(core)) {
     input_update(&core->input);
-    // threadpool_process_results(&core->threadpool, 1);
 
     render_frame_begin(&core->renderer);
 
-    static f32 x = 0.0;
+    static f64 x = 0.0;
     x += 0.01;
-    mat4 model = mat4_translation(vec3(x, 0, 0));
-
-    gfx_backend_draw_frame(&core->renderer, &camera, model, NULL);
 
     // insert work here
 
diff --git a/src/renderer/backends/backend_dx11.h b/src/renderer/backends/backend_dx11.h
index e076659..8e3a513 100644
--- a/src/renderer/backends/backend_dx11.h
+++ b/src/renderer/backends/backend_dx11.h
@@ -6,8 +6,7 @@
 
 #define GPU_SWAPCHAIN_IMG_COUNT 2
 
-typedef struct gpu_swapchain {
-} gpu_swapchain;
+// typedef struct gpu_swapchain gpu_swapchain;
 typedef struct gpu_device {
     
   // VkPhysicalDevice physical_device;
diff --git a/src/renderer/backends/backend_vulkan.c b/src/renderer/backends/backend_vulkan.c
index 2502dd2..ae857a0 100644
--- a/src/renderer/backends/backend_vulkan.c
+++ b/src/renderer/backends/backend_vulkan.c
@@ -141,7 +141,7 @@ bool gpu_swapchain_create(gpu_swapchain* out_swapchain) {
 
   VkSwapchainCreateInfoKHR swapchain_create_info = { VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR };
 
-  // swapchain_create_info.minImageCount = 
+  // swapchain_create_info.minImageCount =
 
   VK_CHECK(vkCreateSwapchainKHR(context.device->logical_device, &swapchain_create_info,
                                 context.allocator, &out_swapchain->handle));
@@ -149,6 +149,11 @@ bool gpu_swapchain_create(gpu_swapchain* out_swapchain) {
 }
 
 gpu_pipeline* gpu_graphics_pipeline_create(struct graphics_pipeline_desc description) {
+  // Allocate
+  gpu_pipeline_layout* layout = malloc(sizeof(gpu_pipeline_layout));
+  gpu_pipeline* pipeline = malloc(sizeof(gpu_pipeline));
+
+  // Viewport
   VkViewport viewport = { .x = 0,
                           .y = 0,
                           .width = (f32)context.screen_width,
@@ -158,11 +163,6 @@ gpu_pipeline* gpu_graphics_pipeline_create(struct graphics_pipeline_desc descrip
   VkRect2D scissor = { .offset = { .x = 0, .y = 0 },
                        .extent = { .width = context.screen_width,
                                    .height = context.screen_height } };
-
-  // TODO: Attributes
-
-  // TODO: layouts
-
   VkPipelineViewportStateCreateInfo viewport_state = {
     VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO
   };
@@ -170,12 +170,136 @@ gpu_pipeline* gpu_graphics_pipeline_create(struct graphics_pipeline_desc descrip
   viewport_state.pViewports = &viewport;
   viewport_state.scissorCount = 1;
   viewport_state.pScissors = &scissor;
+
+  // Rasterizer
+  VkPipelineRasterizationStateCreateInfo rasterizer_create_info = {
+    VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO
+  };
+  rasterizer_create_info.depthClampEnable = VK_FALSE;
+  rasterizer_create_info.rasterizerDiscardEnable = VK_FALSE;
+  rasterizer_create_info.polygonMode =
+      description.wireframe ? VK_POLYGON_MODE_LINE : VK_POLYGON_MODE_FILL;
+  rasterizer_create_info.lineWidth = 1.0f;
+  rasterizer_create_info.cullMode = VK_CULL_MODE_BACK_BIT;
+  rasterizer_create_info.frontFace = VK_FRONT_FACE_COUNTER_CLOCKWISE;
+  rasterizer_create_info.depthBiasEnable = VK_FALSE;
+  rasterizer_create_info.depthBiasConstantFactor = 0.0;
+  rasterizer_create_info.depthBiasClamp = 0.0;
+  rasterizer_create_info.depthBiasSlopeFactor = 0.0;
+
+  // Multisampling
+  VkPipelineMultisampleStateCreateInfo ms_create_info = {
+    VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO
+  };
+  ms_create_info.sampleShadingEnable = VK_FALSE;
+  ms_create_info.rasterizationSamples = VK_SAMPLE_COUNT_1_BIT;
+  ms_create_info.minSampleShading = 1.0;
+  ms_create_info.pSampleMask = 0;
+  ms_create_info.alphaToCoverageEnable = VK_FALSE;
+  ms_create_info.alphaToOneEnable = VK_FALSE;
+
+  // Depth and stencil testing
+  VkPipelineDepthStencilStateCreateInfo depth_stencil = {
+    VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO
+  };
+  depth_stencil.depthTestEnable = description.depth_test ? VK_TRUE : VK_FALSE;
+  depth_stencil.depthWriteEnable = description.depth_test ? VK_TRUE : VK_FALSE;
+  depth_stencil.depthCompareOp = VK_COMPARE_OP_LESS;
+  depth_stencil.depthBoundsTestEnable = VK_FALSE;
+  depth_stencil.stencilTestEnable = VK_FALSE;
+  depth_stencil.pNext = 0;
+
+  // TODO: Blending
+
+  // TODO: Vertex Input
+
+  // TODO: Attributes
+
+  // TODO: layouts
+  VkPipelineLayoutCreateInfo pipeline_layout_create_info = {
+    VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO
+  };
+  pipeline_layout_create_info.setLayoutCount = 0;
+  pipeline_layout_create_info.pSetLayouts = NULL;
+  pipeline_layout_create_info.pushConstantRangeCount = 0;
+  pipeline_layout_create_info.pPushConstantRanges = NULL;
+  VK_CHECK(vkCreatePipelineLayout(context.device->logical_device, &pipeline_layout_create_info,
+                                  context.allocator, &layout->handle));
+  pipeline->layout_handle = layout->handle;  // keep a copy of the layout on the pipeline object
+
+  VkGraphicsPipelineCreateInfo pipeline_create_info = {
+    VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO
+  };
+  // pipeline_create_info.stageCount = stage_count;
+  // pipeline_create_info.pStages = stages;
+  // pipeline_create_info.pVertexInputState = &vertex_input_info;
+  // pipeline_create_info.pInputAssemblyState = &input_assembly;
+
+  // pipeline_create_info.pViewportState = &viewport_state;
+  // pipeline_create_info.pRasterizationState = &rasterizer_create_info;
+  // pipeline_create_info.pMultisampleState = &ms_create_info;
+  // pipeline_create_info.pDepthStencilState = &depth_stencil;
+  // pipeline_create_info.pColorBlendState = &color_blend;
+  // pipeline_create_info.pDynamicState = &dynamic_state;
+  // pipeline_create_info.pTessellationState = 0;
+
+  // pipeline_create_info.layout = out_pipeline->layout;
+
+  // pipeline_create_info.renderPass = renderpass->handle;
+  // pipeline_create_info.subpass = 0;
+  // pipeline_create_info.basePipelineHandle = VK_NULL_HANDLE;
+  // pipeline_create_info.basePipelineIndex = -1;
+
+  VkResult result =
+      vkCreateGraphicsPipelines(context.device->logical_device, VK_NULL_HANDLE, 1,
+                                &pipeline_create_info, context.allocator, &pipeline->handle);
+  if (result != VK_SUCCESS) {
+    FATAL("graphics pipeline creation failed. its fked mate");
+    ERROR_EXIT("Doomed");
+  }
+
+  return pipeline;
 }
 
-gpu_renderpass* gpu_renderpass_create() {
-  // Allocate it
+gpu_renderpass* gpu_renderpass_create(const gpu_renderpass_desc* description) {
+  // TEMP: allocate with malloc. in the future we will have a pool allocator on the context
+  gpu_renderpass* renderpass = malloc(sizeof(gpu_renderpass));
+
+  // Colour attachment
+  VkAttachmentDescription color_attachment;
+  // color_attachment.format = context->swapchain.image_format.format;
+  color_attachment.samples = VK_SAMPLE_COUNT_1_BIT;
+  color_attachment.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
+  color_attachment.storeOp = VK_ATTACHMENT_STORE_OP_STORE;
+  color_attachment.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
+  color_attachment.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
+  color_attachment.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
+  color_attachment.finalLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR;
+  color_attachment.flags = 0;
+
+  // attachment_descriptions[0] = color_attachment;
+
+  VkAttachmentReference color_attachment_reference;
+  color_attachment_reference.attachment = 0;
+  color_attachment_reference.layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
+
+  // subpass.colorAttachmentCount = 1;
+  // subpass.pColorAttachments = &color_attachment_reference;
+
+  // TODO: Depth attachment
+
+  // main subpass
+  VkSubpassDescription subpass = { 0 };
+  subpass.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS;
+  subpass.colorAttachmentCount = 1;
+  subpass.pColorAttachments = &color_attachment_reference;
+
   // sets everything up
-  // return pointer to it
+
+  // Finally, create the RenderPass
+  VkRenderPassCreateInfo render_pass_create_info = { VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO };
+
+  return renderpass;
 }
 
 void encode_set_pipeline(gpu_cmd_encoder* encoder, gpu_pipeline* pipeline) {
diff --git a/src/renderer/backends/backend_vulkan.h b/src/renderer/backends/backend_vulkan.h
index dfe6a0f..9802311 100644
--- a/src/renderer/backends/backend_vulkan.h
+++ b/src/renderer/backends/backend_vulkan.h
@@ -4,6 +4,7 @@
 #include <vulkan/vulkan_core.h>
 
 #include "defines.h"
+#include "ral.h"
 
 #define GPU_SWAPCHAIN_IMG_COUNT 2
 
@@ -16,6 +17,7 @@ Conventions:
 typedef struct gpu_swapchain {
   VkSwapchainKHR handle;
 } gpu_swapchain;
+
 typedef struct gpu_device {
   // In Vulkan we store both physical and logical device here
   VkPhysicalDevice physical_device;
@@ -25,11 +27,18 @@ typedef struct gpu_device {
   VkPhysicalDeviceMemoryProperties memory;
   VkCommandPool pool;
 } gpu_device;
+
+typedef struct gpu_pipeline_layout {
+  VkPipelineLayout handle;
+} gpu_pipeline_layout;
+
 typedef struct gpu_pipeline {
+  VkPipeline handle;
+  VkPipelineLayout layout_handle;
 } gpu_pipeline;
 
 typedef struct gpu_renderpass {
-  VkRenderPass vk_handle;
+  VkRenderPass handle;
   VkFramebuffer framebuffers[GPU_SWAPCHAIN_IMG_COUNT];
 } gpu_renderpass;
 
diff --git a/src/renderer/backends/vulkan_helpers.h b/src/renderer/backends/vulkan_helpers.h
index 3465aed..4bd02f1 100644
--- a/src/renderer/backends/vulkan_helpers.h
+++ b/src/renderer/backends/vulkan_helpers.h
@@ -21,7 +21,12 @@ static void plat_get_required_extension_names(cstr_darray* extensions) {
 
 // TODO(omni): port to using internal assert functions
 #define VK_CHECK(vulkan_expr) \
-  { assert(vulkan_expr == VK_SUCCESS); }
+  do {                        \
+    VkResult res = vulkan_expr; \
+    if (res != VK_SUCCESS) { \
+      ERROR_EXIT("Vulkan error: %u", res); \
+    } \
+  } while (0)
 
 // TODO: typedef struct vk_debugger {} vk_debugger;
 
diff --git a/src/renderer/bind_group_layouts.h b/src/renderer/bind_group_layouts.h
new file mode 100644
index 0000000..d163fab
--- /dev/null
+++ b/src/renderer/bind_group_layouts.h
@@ -0,0 +1,30 @@
+/**
+ * @file bind_group_layouts.h
+ * @author your name (you@domain.com)
+ * @brief Common bindgroups (descriptor set layouts)
+ * @version 0.1
+ * @date 2024-04-28
+ * 
+ * @copyright Copyright (c) 2024
+ * 
+ */
+#pragma once
+#include "defines.h"
+#include "maths_types.h"
+
+// Three major sets
+
+// 1. Scene / Global
+typedef struct bg_globals {
+  f32 total_time;
+  f32 delta_time;
+  mat4 view;
+  mat4 projection;
+} bg_globals;
+
+// 2. Material (once per object)
+
+// 3. Per draw call
+typedef struct bg_model {
+  mat4 model;
+} bg_model;
diff --git a/src/renderer/ral.h b/src/renderer/ral.h
index 6c165c9..8e49dbe 100644
--- a/src/renderer/ral.h
+++ b/src/renderer/ral.h
@@ -23,11 +23,20 @@ struct GLFWwindow;
 // Forward declare structs
 typedef struct gpu_swapchain gpu_swapchain;
 typedef struct gpu_device gpu_device;
+typedef struct gpu_pipeline_layout gpu_pipeline_layout;
 typedef struct gpu_pipeline gpu_pipeline;
 typedef struct gpu_renderpass gpu_renderpass;
 typedef struct gpu_cmd_encoder gpu_cmd_encoder;  // Recording
 typedef struct gpu_cmd_buffer gpu_cmd_buffer;    // Ready for submission
 
+/** @brief A*/
+// typedef struct gpu_bind_group
+
+// Pools
+typedef struct gpu_backend_pools {
+  // pools for each gpu structure
+} gpu_backend_pools;
+
 typedef enum pipeline_kind {
   PIPELINE_GRAPHICS,
   PIPELINE_COMPUTE,
@@ -40,10 +49,20 @@ typedef struct shader_desc {
 } shader_desc;
 
 struct graphics_pipeline_desc {
+  const char* debug_name;
   shader_desc vs; /** @brief Vertex shader stage */
   shader_desc fs; /** @brief Fragment shader stage */
+  // gpu_pipeline_layout* layout;
+  gpu_renderpass* renderpass;
+
+  bool wireframe;
+  bool depth_test;
 };
 
+typedef struct gpu_renderpass_desc {
+
+} gpu_renderpass_desc;
+
 // --- Lifecycle functions
 
 bool gpu_backend_init(const char* window_name, struct GLFWwindow* window);
@@ -52,7 +71,7 @@ void gpu_backend_shutdown();
 bool gpu_device_create(gpu_device* out_device);
 void gpu_device_destroy();
 
-gpu_renderpass* gpu_renderpass_create();
+gpu_renderpass* gpu_renderpass_create(const gpu_renderpass_desc* description);
 void gpu_renderpass_destroy(gpu_renderpass* pass);
 
 gpu_pipeline* gpu_graphics_pipeline_create(struct graphics_pipeline_desc description);
@@ -75,6 +94,7 @@ void encode_set_pipeline(gpu_cmd_encoder* encoder, gpu_pipeline* pipeline);
 void buffer_upload_bytes(buffer_handle gpu_buf, bytebuffer cpu_buf, u64 offset, u64 size);
 
 // render pass
+void encode_bind_pipeline(gpu_cmd_encoder* encoder, pipeline_kind kind, gpu_pipeline* pipeline);
 void encode_set_vertex_buffer(gpu_cmd_encoder* encoder, buffer_handle buf);
 void encode_set_index_buffer(gpu_cmd_encoder* encoder, buffer_handle buf);
 void encode_set_bind_group(); // TODO
diff --git a/src/renderer/ral_types.h b/src/renderer/ral_types.h
index 5f41b55..0b1c02e 100644
--- a/src/renderer/ral_types.h
+++ b/src/renderer/ral_types.h
@@ -99,6 +99,12 @@ KITC_DECL_TYPED_ARRAY(u32)
 #define TYPED_VERTEX_ARRAY
 #endif
 
+typedef enum gpu_cull_mode {
+  CULL_BACK_FACE,
+  CULL_FRONT_FACE,
+  CULL_COUNT
+} gpu_cull_mode;
+
 // ? How to tie together materials and shaders
 
 // Three registers
diff --git a/src/renderer/render.h b/src/renderer/render.h
index a5a5928..a9370e0 100644
--- a/src/renderer/render.h
+++ b/src/renderer/render.h
@@ -17,6 +17,7 @@ bool renderer_init(renderer* ren);
 void renderer_shutdown(renderer* ren);
 
 void render_frame_begin(renderer* ren);
+void render_frame_update_globals(renderer* ren);
 void render_frame_end(renderer* ren);
 void render_frame_draw(renderer* ren);
 
diff --git a/src/renderer/render_types.h b/src/renderer/render_types.h
index 6ef2461..4866ef4 100644
--- a/src/renderer/render_types.h
+++ b/src/renderer/render_types.h
@@ -13,7 +13,8 @@
 #include "ral_types.h"
 #include "ral.h"
 #if defined(CEL_PLATFORM_WINDOWS)
-#include "backend_dx11.h"
+// #include "backend_dx11.h"
+#include "backend_vulkan.h"
 #endif
 
 struct GLFWwindow;
@@ -36,7 +37,7 @@ typedef struct renderer {
 
 typedef struct geometry_data {
   vertex_format format;
-  vertex_darray* vertices; // TODO: make it not a pointe
+  vertex_darray* vertices; // TODO: make it not a pointer
   bool has_indices;
   u32_darray indices;
   vec3 colour; /** Optional: set vertex colours */
diff --git a/src/renderer/renderpasses.h b/src/renderer/renderpasses.h
new file mode 100644
index 0000000..67badaa
--- /dev/null
+++ b/src/renderer/renderpasses.h
@@ -0,0 +1,31 @@
+/**
+ * @file renderpasses.h
+ * @author your name (you@domain.com)
+ * @brief Built-in renderpasses to the engine
+ * @version 0.1
+ * @date 2024-04-28
+ * 
+ * @copyright Copyright (c) 2024
+ * 
+ */
+#pragma once
+#include "maths_types.h"
+#include "ral.h"
+#include "render.h"
+
+// Shadowmap pass
+// Blinn-phong pass
+// Unlit pass
+// Debug visualisations pass
+
+typedef struct render_entity {
+  model* model;
+  transform tf;
+} render_entity;
+
+// Don't need to pass in *anything*.
+gpu_renderpass* renderpass_blinn_phong_create();
+void renderpass_blinn_phong_execute(gpu_renderpass* pass, render_entity* entities, size_t entity_count);
+
+gpu_renderpass* renderpass_shadows_create();
+void renderpass_shadows_execute(gpu_renderpass* pass, render_entity* entities, size_t entity_count);
\ No newline at end of file
-- 
cgit v1.2.3-70-g09d2


From aed7d1b7ac340c19656059c9cbd94aff40952f83 Mon Sep 17 00:00:00 2001
From: Omniscient <17525998+omnisci3nce@users.noreply.github.com>
Date: Fri, 3 May 2024 21:37:51 +1000
Subject: create logical device

---
 src/defines.h                          |   4 +-
 src/renderer/backends/backend_dx11.h   |   1 -
 src/renderer/backends/backend_vulkan.c | 237 +++++++++++++++++++++++++++++----
 src/renderer/backends/vulkan_helpers.h |  42 +++++-
 src/renderer/bind_group_layouts.h      |   4 +-
 src/renderer/cleanroom/types.h         |   2 +-
 src/renderer/immediate.h               |   6 +-
 src/renderer/ral.h                     |   7 +-
 src/renderer/ral_types.h               |  14 +-
 src/renderer/render.h                  |   2 +-
 src/renderer/render_types.h            |  16 +--
 src/renderer/renderpasses.h            |   7 +-
 src/scene.h                            |  10 +-
 src/std/buf.h                          |   6 +-
 src/std/mem.c                          |   9 +-
 src/std/mem.h                          |   7 +
 src/systems/terrain.h                  |   2 +-
 xmake.lua                              |   2 +-
 18 files changed, 299 insertions(+), 79 deletions(-)

(limited to 'src/renderer/backends/vulkan_helpers.h')

diff --git a/src/defines.h b/src/defines.h
index ec526e0..4b6f8c7 100644
--- a/src/defines.h
+++ b/src/defines.h
@@ -66,8 +66,8 @@ Renderer backend defines:
 
 // Platform will inform renderer backend (unless user overrides)
 #if defined(CEL_PLATFORM_LINUX)
-#define CEL_REND_BACKEND_OPENGL 1
-// #define CEL_REND_BACKEND_VULKAN 1
+// #define CEL_REND_BACKEND_OPENGL 1
+#define CEL_REND_BACKEND_VULKAN 1
 #endif
 
 #if defined(CEL_PLATFORM_WINDOWS)
diff --git a/src/renderer/backends/backend_dx11.h b/src/renderer/backends/backend_dx11.h
index 8e3a513..53738aa 100644
--- a/src/renderer/backends/backend_dx11.h
+++ b/src/renderer/backends/backend_dx11.h
@@ -8,7 +8,6 @@
 
 // typedef struct gpu_swapchain gpu_swapchain;
 typedef struct gpu_device {
-    
   // VkPhysicalDevice physical_device;
   // VkDevice logical_device;
   // VkPhysicalDeviceProperties properties;
diff --git a/src/renderer/backends/backend_vulkan.c b/src/renderer/backends/backend_vulkan.c
index ae857a0..c21a6b9 100644
--- a/src/renderer/backends/backend_vulkan.c
+++ b/src/renderer/backends/backend_vulkan.c
@@ -5,6 +5,7 @@
 #include <vulkan/vulkan_core.h>
 
 #include "backend_vulkan.h"
+#include "maths_types.h"
 #include "mem.h"
 #include "vulkan_helpers.h"
 
@@ -31,6 +32,8 @@ typedef struct vulkan_context {
 
   u32 screen_width;
   u32 screen_height;
+
+  VkDebugUtilsMessengerEXT vk_debugger;
 } vulkan_context;
 
 static vulkan_context context;
@@ -39,6 +42,13 @@ static vulkan_context context;
 
 /** @brief Enumerates and selects the most appropriate graphics device */
 bool select_physical_device(gpu_device* out_device);
+
+bool is_physical_device_suitable(VkPhysicalDevice device);
+
+queue_family_indices find_queue_families(VkPhysicalDevice device);
+
+bool create_logical_device(gpu_device* out_device);
+
 /** @brief Helper function for creating array of all extensions we want */
 cstr_darray* get_all_extensions();
 
@@ -49,7 +59,7 @@ bool gpu_backend_init(const char* window_name, GLFWwindow* window) {
 
   // Create an allocator
   size_t temp_arena_size = 1024 * 1024;
-  arena_create(malloc(temp_arena_size), temp_arena_size);
+  context.temp_arena = arena_create(malloc(temp_arena_size), temp_arena_size);
 
   // Setup Vulkan instance
   VkApplicationInfo app_info = { VK_STRUCTURE_TYPE_APPLICATION_INFO };
@@ -63,20 +73,61 @@ bool gpu_backend_init(const char* window_name, GLFWwindow* window) {
   create_info.pApplicationInfo = &app_info;
 
   // Extensions
-  // FIXME: Use my own extension choices
-  // cstr_darray* required_extensions = cstr_darray_new(2);
+  cstr_darray* required_extensions = cstr_darray_new(2);
   // cstr_darray_push(required_extensions, VK_KHR_SURFACE_EXTENSION_NAME);
-  // create_info.enabledExtensionCount = cstr_darray_len(required_extensions);
-  // create_info.ppEnabledExtensionNames = required_extensions->data;
+
   uint32_t count;
   const char** extensions = glfwGetRequiredInstanceExtensions(&count);
-  create_info.enabledExtensionCount = count;
-  create_info.ppEnabledExtensionNames = extensions;
+  for (u32 i = 0; i < count; i++) {
+    cstr_darray_push(required_extensions, extensions[i]);
+  }
+
+  cstr_darray_push(required_extensions, VK_EXT_DEBUG_UTILS_EXTENSION_NAME);
+
+  DEBUG("Required extensions:");
+  for (u32 i = 0; i < cstr_darray_len(required_extensions); i++) {
+    DEBUG("  %s", required_extensions->data[i]);
+  }
+
+  create_info.enabledExtensionCount = cstr_darray_len(required_extensions);
+  create_info.ppEnabledExtensionNames = required_extensions->data;
 
   // TODO: Validation layers
   create_info.enabledLayerCount = 0;
   create_info.ppEnabledLayerNames = NULL;
 
+  INFO("Validation layers enabled");
+  cstr_darray* desired_validation_layers = cstr_darray_new(1);
+  cstr_darray_push(desired_validation_layers, "VK_LAYER_KHRONOS_validation");
+
+  u32 n_available_layers = 0;
+  VK_CHECK(vkEnumerateInstanceLayerProperties(&n_available_layers, 0));
+  TRACE("%d available layers", n_available_layers);
+  VkLayerProperties* available_layers =
+      arena_alloc(&context.temp_arena, n_available_layers * sizeof(VkLayerProperties));
+  VK_CHECK(vkEnumerateInstanceLayerProperties(&n_available_layers, available_layers));
+
+  for (int i = 0; i < cstr_darray_len(desired_validation_layers); i++) {
+    // look through layers to make sure we can find the ones we want
+    bool found = false;
+    for (int j = 0; j < n_available_layers; j++) {
+      if (str8_equals(str8_cstr_view(desired_validation_layers->data[i]),
+                      str8_cstr_view(available_layers[j].layerName))) {
+        found = true;
+        TRACE("Found layer %s", desired_validation_layers->data[i]);
+        break;
+      }
+    }
+
+    if (!found) {
+      FATAL("Required validation is missing %s", desired_validation_layers->data[i]);
+      return false;
+    }
+  }
+  INFO("All validation layers are present");
+  create_info.enabledLayerCount = cstr_darray_len(desired_validation_layers);
+  create_info.ppEnabledLayerNames = desired_validation_layers->data;
+
   VkResult result = vkCreateInstance(&create_info, NULL, &context.instance);
   if (result != VK_SUCCESS) {
     ERROR("vkCreateInstance failed with result: %u", result);
@@ -84,6 +135,25 @@ bool gpu_backend_init(const char* window_name, GLFWwindow* window) {
   }
   TRACE("Vulkan Instance created");
 
+  DEBUG("Creating Vulkan debugger");
+  u32 log_severity = VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT |
+                     VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT;
+  VkDebugUtilsMessengerCreateInfoEXT debug_create_info = {
+    VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT
+  };
+  debug_create_info.messageSeverity = log_severity;
+  debug_create_info.messageType = VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT |
+                                  VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT |
+                                  VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT;
+  debug_create_info.pfnUserCallback = vk_debug_callback;
+
+  PFN_vkCreateDebugUtilsMessengerEXT func =
+      (PFN_vkCreateDebugUtilsMessengerEXT)vkGetInstanceProcAddr(context.instance,
+                                                                "vkCreateDebugUtilsMessengerEXT");
+  assert(func);
+  VK_CHECK(func(context.instance, &debug_create_info, context.allocator, &context.vk_debugger));
+  DEBUG("Vulkan Debugger created");
+
   // Surface creation
   VkSurfaceKHR surface;
   VK_CHECK(glfwCreateWindowSurface(context.instance, window, NULL, &surface));
@@ -96,39 +166,43 @@ bool gpu_backend_init(const char* window_name, GLFWwindow* window) {
 void gpu_backend_shutdown() { arena_free_storage(&context.temp_arena); }
 
 bool gpu_device_create(gpu_device* out_device) {
+  // First things first store this poitner from the renderer
+  context.device = out_device;
+
+  arena_save savept = arena_savepoint(&context.temp_arena);
   // Physical device
   if (!select_physical_device(out_device)) {
     return false;
   }
   TRACE("Physical device selected");
 
-  // Features
-  VkPhysicalDeviceFeatures device_features = { 0 };
-  device_features.samplerAnisotropy = VK_TRUE;  // request anistrophy
-
   // Logical device
-  VkDeviceQueueCreateInfo queue_create_info[2];
-  //..
-  VkDeviceCreateInfo device_create_info = { VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO };
-  device_create_info.queueCreateInfoCount = VULKAN_QUEUES_COUNT;
-  device_create_info.pQueueCreateInfos = queue_create_info;
-  device_create_info.pEnabledFeatures = &device_features;
-  device_create_info.enabledExtensionCount = 1;
-  const char* extension_names = VK_KHR_SWAPCHAIN_EXTENSION_NAME;
-  device_create_info.ppEnabledExtensionNames = &extension_names;
-
-  VkResult result = vkCreateDevice(out_device->physical_device, &device_create_info,
-                                   context.allocator, &out_device->logical_device);
-  if (result != VK_SUCCESS) {
-    FATAL("Error creating logical device with status %u\n", result);
-    exit(1);
-  }
-  TRACE("Logical device created");
+  create_logical_device(out_device);
+  // VkDeviceQueueCreateInfo queue_create_info = {};
+
+  // queue_family_indices indices = find_queue_families(context.device->physical_device);
+  // //..
+  // VkDeviceCreateInfo device_create_info = { VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO };
+  // device_create_info.queueCreateInfoCount = VULKAN_QUEUES_COUNT;
+  // device_create_info.pQueueCreateInfos = queue_create_info;
+  // device_create_info.pEnabledFeatures = &device_features;
+  // device_create_info.enabledExtensionCount = 1;
+  // const char* extension_names = VK_KHR_SWAPCHAIN_EXTENSION_NAME;
+  // device_create_info.ppEnabledExtensionNames = &extension_names;
+
+  // VkResult result = vkCreateDevice(out_device->physical_device, &device_create_info,
+  //                                  context.allocator, &out_device->logical_device);
+  // if (result != VK_SUCCESS) {
+  //   FATAL("Error creating logical device with status %u\n", result);
+  //   exit(1);
+  // }
+  // TRACE("Logical device created");
 
   // Queues
 
   // Create the command pool
 
+  arena_rewind(savept);  // Free any temp data
   return true;
 }
 
@@ -316,4 +390,109 @@ inline void encode_draw_indexed(gpu_cmd_encoder* encoder, u64 index_count) {
   vkCmdDrawIndexed(encoder->cmd_buffer, index_count, 1, 0, 0, 0);
 }
 
-bool select_physical_device(gpu_device* out_device) {}
\ No newline at end of file
+bool select_physical_device(gpu_device* out_device) {
+  u32 physical_device_count = 0;
+  VK_CHECK(vkEnumeratePhysicalDevices(context.instance, &physical_device_count, 0));
+  if (physical_device_count == 0) {
+    FATAL("No devices that support vulkan were found");
+    return false;
+  }
+  TRACE("Number of devices found %d", physical_device_count);
+
+  VkPhysicalDevice* physical_devices =
+      arena_alloc(&context.temp_arena, physical_device_count * sizeof(VkPhysicalDevice));
+  VK_CHECK(vkEnumeratePhysicalDevices(context.instance, &physical_device_count, physical_devices));
+
+  bool found = false;
+  for (u32 device_i = 0; device_i < physical_device_count; device_i++) {
+    if (is_physical_device_suitable(physical_devices[device_i])) {
+      out_device->physical_device = physical_devices[device_i];
+      found = true;
+      break;
+    }
+  }
+
+  if (!found) {
+    FATAL("Couldn't find a suitable physical device");
+    return false;
+  }
+
+  return true;
+}
+
+bool is_physical_device_suitable(VkPhysicalDevice device) {
+  VkPhysicalDeviceProperties properties;
+  vkGetPhysicalDeviceProperties(device, &properties);
+
+  VkPhysicalDeviceFeatures features;
+  vkGetPhysicalDeviceFeatures(device, &features);
+
+  VkPhysicalDeviceMemoryProperties memory;
+  vkGetPhysicalDeviceMemoryProperties(device, &memory);
+
+  // TODO: Check against these device properties
+
+  queue_family_indices indices = find_queue_families(device);
+
+  return indices.has_graphics;
+}
+
+queue_family_indices find_queue_families(VkPhysicalDevice device) {
+  queue_family_indices indices = { 0 };
+
+  u32 queue_family_count = 0;
+  vkGetPhysicalDeviceQueueFamilyProperties(device, &queue_family_count, 0);
+
+  VkQueueFamilyProperties* queue_families =
+      arena_alloc(&context.temp_arena, queue_family_count * sizeof(VkQueueFamilyProperties));
+  vkGetPhysicalDeviceQueueFamilyProperties(device, &queue_family_count, queue_families);
+
+  for (u32 queue_i = 0; queue_i < queue_family_count; queue_i++) {
+    // Graphics queue
+    if (queue_families[queue_i].queueFlags & VK_QUEUE_GRAPHICS_BIT) {
+      indices.graphics_queue_index = queue_i;
+      indices.has_graphics = true;
+    }
+  }
+
+  return indices;
+}
+
+bool create_logical_device(gpu_device* out_device) {
+  queue_family_indices indices = find_queue_families(out_device->physical_device);
+
+  f32 prio_one = 1.0;
+  VkDeviceQueueCreateInfo queue_create_info = { VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO };
+  queue_create_info.queueFamilyIndex = indices.graphics_queue_index;
+  queue_create_info.queueCount = 1;
+  queue_create_info.pQueuePriorities = &prio_one;
+  queue_create_info.flags = 0;
+  queue_create_info.pNext = 0;
+
+  // Features
+  VkPhysicalDeviceFeatures device_features = { 0 };
+  device_features.samplerAnisotropy = VK_TRUE;  // request anistrophy
+
+  // Device itself
+  VkDeviceCreateInfo device_create_info = { VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO };
+  device_create_info.queueCreateInfoCount = 1;
+  device_create_info.pQueueCreateInfos = &queue_create_info;
+  device_create_info.pEnabledFeatures = &device_features;
+  device_create_info.enabledExtensionCount = 1;
+  const char* extension_names = VK_KHR_SWAPCHAIN_EXTENSION_NAME;
+  device_create_info.ppEnabledExtensionNames = &extension_names;
+
+  // deprecated
+  device_create_info.enabledLayerCount = 0;
+  device_create_info.ppEnabledLayerNames = 0;
+
+  VkResult result = vkCreateDevice(context.device->physical_device, &device_create_info,
+                                   context.allocator, &context.device->logical_device);
+  if (result != VK_SUCCESS) {
+    printf("error creating logical device with status %u\n", result);
+    ERROR_EXIT("Unable to create vulkan logical device. Exiting..");
+  }
+  TRACE("Logical device created");
+
+  return true;
+}
\ No newline at end of file
diff --git a/src/renderer/backends/vulkan_helpers.h b/src/renderer/backends/vulkan_helpers.h
index 4bd02f1..baff4e7 100644
--- a/src/renderer/backends/vulkan_helpers.h
+++ b/src/renderer/backends/vulkan_helpers.h
@@ -20,16 +20,27 @@ static void plat_get_required_extension_names(cstr_darray* extensions) {
 }
 
 // TODO(omni): port to using internal assert functions
-#define VK_CHECK(vulkan_expr) \
-  do {                        \
-    VkResult res = vulkan_expr; \
-    if (res != VK_SUCCESS) { \
+#define VK_CHECK(vulkan_expr)              \
+  do {                                     \
+    VkResult res = vulkan_expr;            \
+    if (res != VK_SUCCESS) {               \
       ERROR_EXIT("Vulkan error: %u", res); \
-    } \
+    }                                      \
   } while (0)
 
 // TODO: typedef struct vk_debugger {} vk_debugger;
 
+typedef struct queue_family_indices {
+  u32 graphics_queue_index;
+  u32 present_queue_index;
+  u32 compute_queue_index;
+  u32 transfer_queue_index;
+  bool has_graphics;
+  bool has_present;
+  bool has_compute;
+  bool has_transfer;
+} queue_family_indices;
+
 typedef struct vulkan_physical_device_requirements {
   bool graphics;
   bool present;
@@ -168,4 +179,25 @@ static bool physical_device_meets_requirements(
   }
 
   return false;
+}
+
+VKAPI_ATTR VkBool32 VKAPI_CALL vk_debug_callback(
+    VkDebugUtilsMessageSeverityFlagBitsEXT severity, VkDebugUtilsMessageTypeFlagsEXT flags,
+    const VkDebugUtilsMessengerCallbackDataEXT* callback_data, void* user_data) {
+  switch (severity) {
+    default:
+    case VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT:
+      ERROR("%s", callback_data->pMessage);
+      break;
+    case VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT:
+      WARN("%s", callback_data->pMessage);
+      break;
+    case VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT:
+      INFO("%s", callback_data->pMessage);
+      break;
+    case VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT:
+      TRACE("%s", callback_data->pMessage);
+      break;
+  }
+  return VK_FALSE;
 }
\ No newline at end of file
diff --git a/src/renderer/bind_group_layouts.h b/src/renderer/bind_group_layouts.h
index d163fab..d2571ef 100644
--- a/src/renderer/bind_group_layouts.h
+++ b/src/renderer/bind_group_layouts.h
@@ -4,9 +4,9 @@
  * @brief Common bindgroups (descriptor set layouts)
  * @version 0.1
  * @date 2024-04-28
- * 
+ *
  * @copyright Copyright (c) 2024
- * 
+ *
  */
 #pragma once
 #include "defines.h"
diff --git a/src/renderer/cleanroom/types.h b/src/renderer/cleanroom/types.h
index 7360ebe..6686be5 100644
--- a/src/renderer/cleanroom/types.h
+++ b/src/renderer/cleanroom/types.h
@@ -2,5 +2,5 @@
 #include "darray.h"
 #include "defines.h"
 #include "maths_types.h"
-#include "str.h"
 #include "render_types.h"
+#include "str.h"
diff --git a/src/renderer/immediate.h b/src/renderer/immediate.h
index 6d93c53..b9d7c61 100644
--- a/src/renderer/immediate.h
+++ b/src/renderer/immediate.h
@@ -14,7 +14,7 @@ void imm_draw_camera_frustum();
 //     const char* model_filepath);  // tracks internally whether the model is loaded
 
 // static void imm_draw_model(const char* model_filepath) {
-  // check that model is loaded
-  // if not loaded, load model and upload to gpu - LRU cache for models
-  // else submit draw call
+// check that model is loaded
+// if not loaded, load model and upload to gpu - LRU cache for models
+// else submit draw call
 // }
\ No newline at end of file
diff --git a/src/renderer/ral.h b/src/renderer/ral.h
index 8e49dbe..7c143f2 100644
--- a/src/renderer/ral.h
+++ b/src/renderer/ral.h
@@ -11,10 +11,10 @@
  */
 #pragma once
 
-#include "ral_types.h"
+#include "buf.h"
 #include "defines.h"
+#include "ral_types.h"
 #include "str.h"
-#include "buf.h"
 
 // Unrelated forward declares
 typedef struct arena arena;
@@ -60,7 +60,6 @@ struct graphics_pipeline_desc {
 };
 
 typedef struct gpu_renderpass_desc {
-
 } gpu_renderpass_desc;
 
 // --- Lifecycle functions
@@ -97,7 +96,7 @@ void buffer_upload_bytes(buffer_handle gpu_buf, bytebuffer cpu_buf, u64 offset,
 void encode_bind_pipeline(gpu_cmd_encoder* encoder, pipeline_kind kind, gpu_pipeline* pipeline);
 void encode_set_vertex_buffer(gpu_cmd_encoder* encoder, buffer_handle buf);
 void encode_set_index_buffer(gpu_cmd_encoder* encoder, buffer_handle buf);
-void encode_set_bind_group(); // TODO
+void encode_set_bind_group();  // TODO
 void encode_draw(gpu_cmd_encoder* encoder);
 void encode_draw_indexed(gpu_cmd_encoder* encoder, u64 index_count);
 
diff --git a/src/renderer/ral_types.h b/src/renderer/ral_types.h
index d6c5865..ae54b53 100644
--- a/src/renderer/ral_types.h
+++ b/src/renderer/ral_types.h
@@ -1,18 +1,18 @@
 /**
  * @file ral_types.h
  * @author your name (you@domain.com)
- * @brief 
+ * @brief
  * @version 0.1
  * @date 2024-04-27
- * 
+ *
  * @copyright Copyright (c) 2024
- * 
+ *
  */
 #pragma once
 
+#include "darray.h"
 #include "defines.h"
 #include "maths_types.h"
-#include "darray.h"
 
 #ifndef RENDERER_TYPED_HANDLES
 CORE_DEFINE_HANDLE(buffer_handle);
@@ -99,11 +99,7 @@ KITC_DECL_TYPED_ARRAY(u32)
 #define TYPED_VERTEX_ARRAY
 #endif
 
-typedef enum gpu_cull_mode {
-  CULL_BACK_FACE,
-  CULL_FRONT_FACE,
-  CULL_COUNT
-} gpu_cull_mode;
+typedef enum gpu_cull_mode { CULL_BACK_FACE, CULL_FRONT_FACE, CULL_COUNT } gpu_cull_mode;
 
 // ? How to tie together materials and shaders
 
diff --git a/src/renderer/render.h b/src/renderer/render.h
index a9370e0..e6dd8b8 100644
--- a/src/renderer/render.h
+++ b/src/renderer/render.h
@@ -10,8 +10,8 @@
  */
 #pragma once
 
-#include "render_types.h"
 #include "ral_types.h"
+#include "render_types.h"
 
 bool renderer_init(renderer* ren);
 void renderer_shutdown(renderer* ren);
diff --git a/src/renderer/render_types.h b/src/renderer/render_types.h
index 4866ef4..a5c0c1a 100644
--- a/src/renderer/render_types.h
+++ b/src/renderer/render_types.h
@@ -1,21 +1,21 @@
 /**
  * @file render_types.h
  * @author your name (you@domain.com)
- * @brief 
+ * @brief
  * @version 0.1
  * @date 2024-04-27
- * 
+ *
  * @copyright Copyright (c) 2024
- * 
+ *
  */
 #pragma once
 
-#include "ral_types.h"
 #include "ral.h"
+#include "ral_types.h"
 #if defined(CEL_PLATFORM_WINDOWS)
 // #include "backend_dx11.h"
-#include "backend_vulkan.h"
 #endif
+#include "backend_vulkan.h"
 
 struct GLFWwindow;
 
@@ -37,7 +37,7 @@ typedef struct renderer {
 
 typedef struct geometry_data {
   vertex_format format;
-  vertex_darray* vertices; // TODO: make it not a pointer
+  vertex_darray* vertices;  // TODO: make it not a pointer
   bool has_indices;
   u32_darray indices;
   vec3 colour; /** Optional: set vertex colours */
@@ -66,8 +66,8 @@ typedef struct model {
 typedef struct texture {
   u32 texture_id;
   char name[256];
-  void *image_data;
-  void *backend_data;
+  void* image_data;
+  void* backend_data;
   u32 width;
   u32 height;
   u8 channel_count;
diff --git a/src/renderer/renderpasses.h b/src/renderer/renderpasses.h
index 67badaa..91970d8 100644
--- a/src/renderer/renderpasses.h
+++ b/src/renderer/renderpasses.h
@@ -4,9 +4,9 @@
  * @brief Built-in renderpasses to the engine
  * @version 0.1
  * @date 2024-04-28
- * 
+ *
  * @copyright Copyright (c) 2024
- * 
+ *
  */
 #pragma once
 #include "maths_types.h"
@@ -25,7 +25,8 @@ typedef struct render_entity {
 
 // Don't need to pass in *anything*.
 gpu_renderpass* renderpass_blinn_phong_create();
-void renderpass_blinn_phong_execute(gpu_renderpass* pass, render_entity* entities, size_t entity_count);
+void renderpass_blinn_phong_execute(gpu_renderpass* pass, render_entity* entities,
+                                    size_t entity_count);
 
 gpu_renderpass* renderpass_shadows_create();
 void renderpass_shadows_execute(gpu_renderpass* pass, render_entity* entities, size_t entity_count);
\ No newline at end of file
diff --git a/src/scene.h b/src/scene.h
index 2cc4d8a..6cac061 100644
--- a/src/scene.h
+++ b/src/scene.h
@@ -1,12 +1,12 @@
 /**
  * @file scene.h
  * @author your name (you@domain.com)
- * @brief 
+ * @brief
  * @version 0.1
  * @date 2024-04-27
- * 
+ *
  * @copyright Copyright (c) 2024
- * 
+ *
  */
 #include "defines.h"
 #include "types.h"
@@ -24,7 +24,7 @@ bool scene_add_point_light(scene* s /* TODO */);
 bool scene_add_heightmap(scene* s /* TODO */);
 bool scene_delete_heightmap(scene* s);
 
-bool scene_add_model(scene *s, model_handle model);
-void scene_remove_model(scene *s, model_handle model);
+bool scene_add_model(scene* s, model_handle model);
+void scene_remove_model(scene* s, model_handle model);
 
 // TODO: functions to load and save scenes from disk
\ No newline at end of file
diff --git a/src/std/buf.h b/src/std/buf.h
index b0f8b85..de093ec 100644
--- a/src/std/buf.h
+++ b/src/std/buf.h
@@ -1,12 +1,12 @@
 /**
  * @file buf.h
  * @author your name (you@domain.com)
- * @brief 
+ * @brief
  * @version 0.1
  * @date 2024-04-28
- * 
+ *
  * @copyright Copyright (c) 2024
- * 
+ *
  */
 #pragma once
 #include "defines.h"
diff --git a/src/std/mem.c b/src/std/mem.c
index 5468898..4886d72 100644
--- a/src/std/mem.c
+++ b/src/std/mem.c
@@ -31,4 +31,11 @@ void arena_free_all(arena* a) {
   a->curr = a->begin;  // pop everything at once and reset to the start.
 }
 
-void arena_free_storage(arena* a) { free(a->begin); }
\ No newline at end of file
+void arena_free_storage(arena* a) { free(a->begin); }
+
+arena_save arena_savepoint(arena* a) {
+  arena_save savept = { .arena = a, .savepoint = a->curr };
+  return savept;
+}
+
+void arena_rewind(arena_save savepoint) { savepoint.arena->curr = savepoint.savepoint; }
\ No newline at end of file
diff --git a/src/std/mem.h b/src/std/mem.h
index 2f92894..bbfb852 100644
--- a/src/std/mem.h
+++ b/src/std/mem.h
@@ -18,9 +18,16 @@ typedef struct arena {
   char* end;
 } arena;
 
+typedef struct arena_save {
+  arena* arena;
+  char* savepoint;
+} arena_save;
+
 arena arena_create(void* backing_buffer, size_t capacity);
 void* arena_alloc(arena* a, size_t size);
 void* arena_alloc_align(arena* a, size_t size, size_t align);
 void arena_free_all(arena* a);
 void arena_free_storage(arena* a);
+arena_save arena_savepoint(arena* a);
+void arena_rewind(arena_save savepoint);
 // TODO: arena_resize
\ No newline at end of file
diff --git a/src/systems/terrain.h b/src/systems/terrain.h
index 3d6f1c1..a8bff17 100644
--- a/src/systems/terrain.h
+++ b/src/systems/terrain.h
@@ -29,7 +29,7 @@ typedef struct heightmap {
 
 typedef struct terrain_state {
   arena terrain_allocator;
-  heightmap* heightmap; // NULL = no heightmap
+  heightmap* heightmap;  // NULL = no heightmap
 } terrain_state;
 
 bool terrain_system_init(terrain_state* state);
diff --git a/xmake.lua b/xmake.lua
index ab6a7a6..949dd76 100644
--- a/xmake.lua
+++ b/xmake.lua
@@ -1,6 +1,6 @@
 set_project("celeritas")
 set_version("0.1.0")
-set_config("cc", "clang-cl")
+set_config("cc", "gcc")
 
 add_rules("mode.debug", "mode.release") -- we have two modes: debug & release
 
-- 
cgit v1.2.3-70-g09d2


From 8aad3ce06da4c8e9d2e41b39607640a5e9c7ded7 Mon Sep 17 00:00:00 2001
From: Omniscient <17525998+omnisci3nce@users.noreply.github.com>
Date: Fri, 3 May 2024 23:31:02 +1000
Subject: get present queue

---
 src/renderer/backends/backend_vulkan.c | 67 +++++++++++++++++++++++++++-------
 src/renderer/backends/backend_vulkan.h | 17 +++++++++
 src/renderer/backends/vulkan_helpers.h | 12 ------
 3 files changed, 70 insertions(+), 26 deletions(-)

(limited to 'src/renderer/backends/vulkan_helpers.h')

diff --git a/src/renderer/backends/backend_vulkan.c b/src/renderer/backends/backend_vulkan.c
index c21a6b9..900b592 100644
--- a/src/renderer/backends/backend_vulkan.c
+++ b/src/renderer/backends/backend_vulkan.c
@@ -1,3 +1,4 @@
+#include <assert.h>
 #include <glfw3.h>
 #include <stdlib.h>
 #include <vulkan/vk_platform.h>
@@ -163,7 +164,11 @@ bool gpu_backend_init(const char* window_name, GLFWwindow* window) {
   return true;
 }
 
-void gpu_backend_shutdown() { arena_free_storage(&context.temp_arena); }
+void gpu_backend_shutdown() {
+  arena_free_storage(&context.temp_arena);
+  vkDestroySurfaceKHR(context.instance, context.surface, context.allocator);
+  vkDestroyInstance(context.instance, context.allocator);
+}
 
 bool gpu_device_create(gpu_device* out_device) {
   // First things first store this poitner from the renderer
@@ -214,8 +219,18 @@ bool gpu_swapchain_create(gpu_swapchain* out_swapchain) {
   VkPresentModeKHR present_mode = VK_PRESENT_MODE_FIFO_KHR;  // guaranteed to be implemented
 
   VkSwapchainCreateInfoKHR swapchain_create_info = { VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR };
+  swapchain_create_info.surface = context.surface;
+  swapchain_create_info.minImageCount = 2;
+  // TODO: image_ fields
+  swapchain_create_info.queueFamilyIndexCount = 0;
+  swapchain_create_info.pQueueFamilyIndices = 0;
+
+  // TODO: preTransform
+  swapchain_create_info.compositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR;
+  swapchain_create_info.presentMode = present_mode;
 
-  // swapchain_create_info.minImageCount =
+  swapchain_create_info.clipped = VK_TRUE;
+  swapchain_create_info.oldSwapchain = 0;
 
   VK_CHECK(vkCreateSwapchainKHR(context.device->logical_device, &swapchain_create_info,
                                 context.allocator, &out_swapchain->handle));
@@ -434,7 +449,7 @@ bool is_physical_device_suitable(VkPhysicalDevice device) {
 
   queue_family_indices indices = find_queue_families(device);
 
-  return indices.has_graphics;
+  return indices.has_graphics && indices.has_present;
 }
 
 queue_family_indices find_queue_families(VkPhysicalDevice device) {
@@ -447,12 +462,19 @@ queue_family_indices find_queue_families(VkPhysicalDevice device) {
       arena_alloc(&context.temp_arena, queue_family_count * sizeof(VkQueueFamilyProperties));
   vkGetPhysicalDeviceQueueFamilyProperties(device, &queue_family_count, queue_families);
 
-  for (u32 queue_i = 0; queue_i < queue_family_count; queue_i++) {
+  for (u32 q_fam_i = 0; q_fam_i < queue_family_count; q_fam_i++) {
     // Graphics queue
-    if (queue_families[queue_i].queueFlags & VK_QUEUE_GRAPHICS_BIT) {
-      indices.graphics_queue_index = queue_i;
+    if (queue_families[q_fam_i].queueFlags & VK_QUEUE_GRAPHICS_BIT) {
+      indices.graphics_family_index = q_fam_i;
       indices.has_graphics = true;
     }
+
+    VkBool32 present_support = false;
+    vkGetPhysicalDeviceSurfaceSupportKHR(device, q_fam_i, context.surface, &present_support);
+    if (present_support) {
+      indices.present_family_index = q_fam_i;
+      indices.has_present = true;
+    }
   }
 
   return indices;
@@ -461,13 +483,22 @@ queue_family_indices find_queue_families(VkPhysicalDevice device) {
 bool create_logical_device(gpu_device* out_device) {
   queue_family_indices indices = find_queue_families(out_device->physical_device);
 
+  // Queues
   f32 prio_one = 1.0;
-  VkDeviceQueueCreateInfo queue_create_info = { VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO };
-  queue_create_info.queueFamilyIndex = indices.graphics_queue_index;
-  queue_create_info.queueCount = 1;
-  queue_create_info.pQueuePriorities = &prio_one;
-  queue_create_info.flags = 0;
-  queue_create_info.pNext = 0;
+  VkDeviceQueueCreateInfo queue_create_infos[2] = { 0 };
+  queue_create_infos[0].sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
+  queue_create_infos[0].queueFamilyIndex = indices.graphics_family_index;
+  queue_create_infos[0].queueCount = 1;
+  queue_create_infos[0].pQueuePriorities = &prio_one;
+  queue_create_infos[0].flags = 0;
+  queue_create_infos[0].pNext = 0;
+
+  queue_create_infos[1].sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
+  queue_create_infos[1].queueFamilyIndex = indices.present_family_index;
+  queue_create_infos[1].queueCount = 1;
+  queue_create_infos[1].pQueuePriorities = &prio_one;
+  queue_create_infos[1].flags = 0;
+  queue_create_infos[1].pNext = 0;
 
   // Features
   VkPhysicalDeviceFeatures device_features = { 0 };
@@ -475,8 +506,8 @@ bool create_logical_device(gpu_device* out_device) {
 
   // Device itself
   VkDeviceCreateInfo device_create_info = { VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO };
-  device_create_info.queueCreateInfoCount = 1;
-  device_create_info.pQueueCreateInfos = &queue_create_info;
+  device_create_info.queueCreateInfoCount = 2;
+  device_create_info.pQueueCreateInfos = queue_create_infos;
   device_create_info.pEnabledFeatures = &device_features;
   device_create_info.enabledExtensionCount = 1;
   const char* extension_names = VK_KHR_SWAPCHAIN_EXTENSION_NAME;
@@ -494,5 +525,13 @@ bool create_logical_device(gpu_device* out_device) {
   }
   TRACE("Logical device created");
 
+  context.device->queue_family_indicies = indices;
+
+  // Retrieve queue handles
+  vkGetDeviceQueue(context.device->logical_device, indices.graphics_family_index, 0,
+                   &context.device->graphics_queue);
+  vkGetDeviceQueue(context.device->logical_device, indices.present_family_index, 0,
+                   &context.device->present_queue);
+
   return true;
 }
\ No newline at end of file
diff --git a/src/renderer/backends/backend_vulkan.h b/src/renderer/backends/backend_vulkan.h
index 9802311..8c6b772 100644
--- a/src/renderer/backends/backend_vulkan.h
+++ b/src/renderer/backends/backend_vulkan.h
@@ -5,6 +5,7 @@
 
 #include "defines.h"
 #include "ral.h"
+// #include "vulkan_helpers.h"
 
 #define GPU_SWAPCHAIN_IMG_COUNT 2
 
@@ -14,6 +15,17 @@ Conventions:
   - Vulkan specific data goes at the top, followed by our internal data
 */
 
+typedef struct queue_family_indices {
+  u32 graphics_family_index;
+  u32 present_family_index;
+  u32 compute_family_index;
+  u32 transfer_family_index;
+  bool has_graphics;
+  bool has_present;
+  bool has_compute;
+  bool has_transfer;
+} queue_family_indices;
+
 typedef struct gpu_swapchain {
   VkSwapchainKHR handle;
 } gpu_swapchain;
@@ -25,6 +37,11 @@ typedef struct gpu_device {
   VkPhysicalDeviceProperties properties;
   VkPhysicalDeviceFeatures features;
   VkPhysicalDeviceMemoryProperties memory;
+  queue_family_indices queue_family_indicies;
+  VkQueue graphics_queue;
+  VkQueue present_queue;
+  VkQueue compute_queue;
+  VkQueue transfer_queue;
   VkCommandPool pool;
 } gpu_device;
 
diff --git a/src/renderer/backends/vulkan_helpers.h b/src/renderer/backends/vulkan_helpers.h
index baff4e7..d91b4a9 100644
--- a/src/renderer/backends/vulkan_helpers.h
+++ b/src/renderer/backends/vulkan_helpers.h
@@ -1,6 +1,5 @@
 #pragma once
 
-#include <assert.h>
 #include <vulkan/vulkan.h>
 #include <vulkan/vulkan_core.h>
 
@@ -30,17 +29,6 @@ static void plat_get_required_extension_names(cstr_darray* extensions) {
 
 // TODO: typedef struct vk_debugger {} vk_debugger;
 
-typedef struct queue_family_indices {
-  u32 graphics_queue_index;
-  u32 present_queue_index;
-  u32 compute_queue_index;
-  u32 transfer_queue_index;
-  bool has_graphics;
-  bool has_present;
-  bool has_compute;
-  bool has_transfer;
-} queue_family_indices;
-
 typedef struct vulkan_physical_device_requirements {
   bool graphics;
   bool present;
-- 
cgit v1.2.3-70-g09d2


From 74fd8a8424aeaccfaf7985f4ad2129fd54ae9fba Mon Sep 17 00:00:00 2001
From: Omniscient <17525998+omnisci3nce@users.noreply.github.com>
Date: Sat, 4 May 2024 13:02:31 +1000
Subject: swapchain support

---
 src/renderer/backends/backend_opengl.c |   2 -
 src/renderer/backends/backend_vulkan.c |  22 ++++-
 src/renderer/backends/vulkan_helpers.h | 173 ++++++++++++++++-----------------
 src/systems/text.h                     |   1 -
 4 files changed, 104 insertions(+), 94 deletions(-)

(limited to 'src/renderer/backends/vulkan_helpers.h')

diff --git a/src/renderer/backends/backend_opengl.c b/src/renderer/backends/backend_opengl.c
index 7fc277f..4cd97b5 100644
--- a/src/renderer/backends/backend_opengl.c
+++ b/src/renderer/backends/backend_opengl.c
@@ -6,8 +6,6 @@
 #include "file.h"
 #include "log.h"
 #include "maths_types.h"
-// #include "render_types.h"
-#include "cleanroom/types.h"
 #include "ral.h"
 
 #if CEL_REND_BACKEND_OPENGL
diff --git a/src/renderer/backends/backend_vulkan.c b/src/renderer/backends/backend_vulkan.c
index 900b592..08e62bf 100644
--- a/src/renderer/backends/backend_vulkan.c
+++ b/src/renderer/backends/backend_vulkan.c
@@ -26,6 +26,7 @@ typedef struct vulkan_context {
   VkInstance instance;
   VkAllocationCallbacks* allocator;
   VkSurfaceKHR surface;
+  vulkan_swapchain_support_info swapchain_support;
 
   arena temp_arena;
   gpu_device* device;
@@ -181,6 +182,9 @@ bool gpu_device_create(gpu_device* out_device) {
   }
   TRACE("Physical device selected");
 
+  // vulkan_device_query_swapchain_support(out_device->physical_device, context.surface,
+  //                                       &context.swapchain_support);
+
   // Logical device
   create_logical_device(out_device);
   // VkDeviceQueueCreateInfo queue_create_info = {};
@@ -432,6 +436,10 @@ bool select_physical_device(gpu_device* out_device) {
     return false;
   }
 
+  vkGetPhysicalDeviceProperties(out_device->physical_device, &out_device->properties);
+  vkGetPhysicalDeviceFeatures(out_device->physical_device, &out_device->features);
+  vkGetPhysicalDeviceMemoryProperties(out_device->physical_device, &out_device->memory);
+
   return true;
 }
 
@@ -449,7 +457,10 @@ bool is_physical_device_suitable(VkPhysicalDevice device) {
 
   queue_family_indices indices = find_queue_families(device);
 
-  return indices.has_graphics && indices.has_present;
+  vulkan_device_query_swapchain_support(device, context.surface, &context.swapchain_support);
+
+  return indices.has_graphics && indices.has_present && context.swapchain_support.mode_count > 0 &&
+         context.swapchain_support.format_count > 0;
 }
 
 queue_family_indices find_queue_families(VkPhysicalDevice device) {
@@ -480,8 +491,17 @@ queue_family_indices find_queue_families(VkPhysicalDevice device) {
   return indices;
 }
 
+const char* bool_str(bool input) { return input ? "True" : "False"; }
+
 bool create_logical_device(gpu_device* out_device) {
   queue_family_indices indices = find_queue_families(out_device->physical_device);
+  INFO(" %s | %s | %s | %s | %s", bool_str(indices.has_graphics), bool_str(indices.has_present),
+       bool_str(indices.has_compute), bool_str(indices.has_transfer),
+       out_device->properties.deviceName);
+  TRACE("Graphics Family queue index: %d", indices.graphics_family_index);
+  TRACE("Present Family queue index: %d", indices.present_family_index);
+  TRACE("Compute Family queue index: %d", indices.compute_family_index);
+  TRACE("Transfer Family queue index: %d", indices.transfer_family_index);
 
   // Queues
   f32 prio_one = 1.0;
diff --git a/src/renderer/backends/vulkan_helpers.h b/src/renderer/backends/vulkan_helpers.h
index d91b4a9..03ee814 100644
--- a/src/renderer/backends/vulkan_helpers.h
+++ b/src/renderer/backends/vulkan_helpers.h
@@ -40,13 +40,6 @@ typedef struct vulkan_physical_device_requirements {
   bool discrete_gpu;
 } vulkan_physical_device_requirements;
 
-typedef struct vulkan_physical_device_queue_family_info {
-  u32 graphics_family_index;
-  u32 present_family_index;
-  u32 compute_family_index;
-  u32 transfer_family_index;
-} vulkan_physical_device_queue_family_info;
-
 #define VULKAN_MAX_DEFAULT 32
 
 typedef struct vulkan_swapchain_support_info {
@@ -85,89 +78,89 @@ void vulkan_device_query_swapchain_support(VkPhysicalDevice device, VkSurfaceKHR
   }
 }
 
-static bool physical_device_meets_requirements(
-    VkPhysicalDevice device, VkSurfaceKHR surface, const VkPhysicalDeviceProperties* properties,
-    const VkPhysicalDeviceFeatures* features,
-    const vulkan_physical_device_requirements* requirements,
-    vulkan_physical_device_queue_family_info* out_queue_info,
-    vulkan_swapchain_support_info* out_swapchain_support) {
-  // TODO: pass in an arena
-
-  out_queue_info->graphics_family_index = -1;
-  out_queue_info->present_family_index = -1;
-  out_queue_info->compute_family_index = -1;
-  out_queue_info->transfer_family_index = -1;
-
-  if (requirements->discrete_gpu) {
-    if (properties->deviceType != VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU) {
-      TRACE("Device is not a physical GPU. Skipping.");
-      return false;
-    }
-  }
-
-  u32 queue_family_count = 0;
-  vkGetPhysicalDeviceQueueFamilyProperties(device, &queue_family_count, 0);
-  VkQueueFamilyProperties queue_families[queue_family_count];
-  vkGetPhysicalDeviceQueueFamilyProperties(device, &queue_family_count, queue_families);
-
-  INFO("Graphics | Present | Compute | Transfer | Name");
-  u8 min_transfer_score = 255;
-  for (u32 i = 0; i < queue_family_count; i++) {
-    u8 current_transfer_score = 0;
-
-    // Graphics queue
-    if (queue_families[i].queueFlags & VK_QUEUE_GRAPHICS_BIT) {
-      out_queue_info->graphics_family_index = i;
-      current_transfer_score++;
-    }
-
-    // Compute queue
-    if (queue_families[i].queueFlags & VK_QUEUE_COMPUTE_BIT) {
-      out_queue_info->compute_family_index = i;
-      current_transfer_score++;
-    }
-
-    // Transfer queue
-    if (queue_families[i].queueFlags & VK_QUEUE_TRANSFER_BIT) {
-      // always take the lowest score transfer index
-      if (current_transfer_score <= min_transfer_score) {
-        min_transfer_score = current_transfer_score;
-        out_queue_info->transfer_family_index = i;
-      }
-    }
-
-    // Present Queue
-    VkBool32 supports_present = VK_FALSE;
-    vkGetPhysicalDeviceSurfaceSupportKHR(device, i, surface, &supports_present);
-    if (supports_present) {
-      out_queue_info->present_family_index = i;
-    }
-  }
-
-  INFO("       %d |       %d |       %d |        %d | %s",
-       out_queue_info->graphics_family_index != -1, out_queue_info->present_family_index != -1,
-       out_queue_info->compute_family_index != -1, out_queue_info->transfer_family_index != -1,
-       properties->deviceName);
-  TRACE("Graphics Family queue index: %d", out_queue_info->graphics_family_index);
-  TRACE("Present Family queue index: %d", out_queue_info->present_family_index);
-  TRACE("Compute Family queue index: %d", out_queue_info->compute_family_index);
-  TRACE("Transfer Family queue index: %d", out_queue_info->transfer_family_index);
-
-  if ((!requirements->graphics ||
-       (requirements->graphics && out_queue_info->graphics_family_index != -1))) {
-    INFO("Physical device meets our requirements! Proceed.");
-
-    vulkan_device_query_swapchain_support(
-        device, surface, out_swapchain_support
-
-        // TODO: error handling i.e. format count = 0 or present mode = 0
-
-    );
-    return true;
-  }
-
-  return false;
-}
+// static bool physical_device_meets_requirements(
+//     VkPhysicalDevice device, VkSurfaceKHR surface, const VkPhysicalDeviceProperties* properties,
+//     const VkPhysicalDeviceFeatures* features,
+//     const vulkan_physical_device_requirements* requirements,
+//     vulkan_physical_device_queue_family_info* out_queue_info,
+//     vulkan_swapchain_support_info* out_swapchain_support) {
+//   // TODO: pass in an arena
+
+//   out_queue_info->graphics_family_index = -1;
+//   out_queue_info->present_family_index = -1;
+//   out_queue_info->compute_family_index = -1;
+//   out_queue_info->transfer_family_index = -1;
+
+//   if (requirements->discrete_gpu) {
+//     if (properties->deviceType != VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU) {
+//       TRACE("Device is not a physical GPU. Skipping.");
+//       return false;
+//     }
+//   }
+
+//   u32 queue_family_count = 0;
+//   vkGetPhysicalDeviceQueueFamilyProperties(device, &queue_family_count, 0);
+//   VkQueueFamilyProperties queue_families[queue_family_count];
+//   vkGetPhysicalDeviceQueueFamilyProperties(device, &queue_family_count, queue_families);
+
+//   INFO("Graphics | Present | Compute | Transfer | Name");
+//   u8 min_transfer_score = 255;
+//   for (u32 i = 0; i < queue_family_count; i++) {
+//     u8 current_transfer_score = 0;
+
+//     // Graphics queue
+//     if (queue_families[i].queueFlags & VK_QUEUE_GRAPHICS_BIT) {
+//       out_queue_info->graphics_family_index = i;
+//       current_transfer_score++;
+//     }
+
+//     // Compute queue
+//     if (queue_families[i].queueFlags & VK_QUEUE_COMPUTE_BIT) {
+//       out_queue_info->compute_family_index = i;
+//       current_transfer_score++;
+//     }
+
+//     // Transfer queue
+//     if (queue_families[i].queueFlags & VK_QUEUE_TRANSFER_BIT) {
+//       // always take the lowest score transfer index
+//       if (current_transfer_score <= min_transfer_score) {
+//         min_transfer_score = current_transfer_score;
+//         out_queue_info->transfer_family_index = i;
+//       }
+//     }
+
+//     // Present Queue
+//     VkBool32 supports_present = VK_FALSE;
+//     vkGetPhysicalDeviceSurfaceSupportKHR(device, i, surface, &supports_present);
+//     if (supports_present) {
+//       out_queue_info->present_family_index = i;
+//     }
+//   }
+
+//   INFO("       %d |       %d |       %d |        %d | %s",
+//        out_queue_info->graphics_family_index != -1, out_queue_info->present_family_index != -1,
+//        out_queue_info->compute_family_index != -1, out_queue_info->transfer_family_index != -1,
+//        properties->deviceName);
+//   TRACE("Graphics Family queue index: %d", out_queue_info->graphics_family_index);
+//   TRACE("Present Family queue index: %d", out_queue_info->present_family_index);
+//   TRACE("Compute Family queue index: %d", out_queue_info->compute_family_index);
+//   TRACE("Transfer Family queue index: %d", out_queue_info->transfer_family_index);
+
+//   if ((!requirements->graphics ||
+//        (requirements->graphics && out_queue_info->graphics_family_index != -1))) {
+//     INFO("Physical device meets our requirements! Proceed.");
+
+//     vulkan_device_query_swapchain_support(
+//         device, surface, out_swapchain_support
+
+//         // TODO: error handling i.e. format count = 0 or present mode = 0
+
+//     );
+//     return true;
+//   }
+
+//   return false;
+// }
 
 VKAPI_ATTR VkBool32 VKAPI_CALL vk_debug_callback(
     VkDebugUtilsMessageSeverityFlagBitsEXT severity, VkDebugUtilsMessageTypeFlagsEXT flags,
diff --git a/src/systems/text.h b/src/systems/text.h
index dc396f0..f40cfd6 100644
--- a/src/systems/text.h
+++ b/src/systems/text.h
@@ -5,7 +5,6 @@
 
 #include <stb_truetype.h>
 
-#include "cleanroom/types.h"
 #include "darray.h"
 #include "defines.h"
 #include "ral.h"
-- 
cgit v1.2.3-70-g09d2


From a51ef12d8583522ee229a0195a4132652f0f9cd8 Mon Sep 17 00:00:00 2001
From: Omniscient <17525998+omnisci3nce@users.noreply.github.com>
Date: Sat, 4 May 2024 15:47:54 +1000
Subject: finish swapchain creation

---
 assets/shaders/triangle.frag           |  0
 assets/shaders/triangle.vert           |  0
 src/renderer/backends/backend_vulkan.c | 74 +++++++++++++++++-----------------
 src/renderer/backends/backend_vulkan.h |  6 +++
 src/renderer/backends/vulkan_helpers.h | 19 ++++++++-
 src/renderer/ral.h                     |  2 +-
 src/std/utils.h                        |  4 ++
 src/systems/terrain.h                  |  2 +-
 8 files changed, 66 insertions(+), 41 deletions(-)
 create mode 100644 assets/shaders/triangle.frag
 create mode 100644 assets/shaders/triangle.vert
 create mode 100644 src/std/utils.h

(limited to 'src/renderer/backends/vulkan_helpers.h')

diff --git a/assets/shaders/triangle.frag b/assets/shaders/triangle.frag
new file mode 100644
index 0000000..e69de29
diff --git a/assets/shaders/triangle.vert b/assets/shaders/triangle.vert
new file mode 100644
index 0000000..e69de29
diff --git a/src/renderer/backends/backend_vulkan.c b/src/renderer/backends/backend_vulkan.c
index 08e62bf..028cde8 100644
--- a/src/renderer/backends/backend_vulkan.c
+++ b/src/renderer/backends/backend_vulkan.c
@@ -13,7 +13,7 @@
 #include "defines.h"
 #include "log.h"
 #include "ral.h"
-#include "ral_types.h"
+#include "utils.h"
 
 // TEMP
 #define SCREEN_WIDTH 1000
@@ -182,32 +182,8 @@ bool gpu_device_create(gpu_device* out_device) {
   }
   TRACE("Physical device selected");
 
-  // vulkan_device_query_swapchain_support(out_device->physical_device, context.surface,
-  //                                       &context.swapchain_support);
-
-  // Logical device
+  // Logical device & Queues
   create_logical_device(out_device);
-  // VkDeviceQueueCreateInfo queue_create_info = {};
-
-  // queue_family_indices indices = find_queue_families(context.device->physical_device);
-  // //..
-  // VkDeviceCreateInfo device_create_info = { VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO };
-  // device_create_info.queueCreateInfoCount = VULKAN_QUEUES_COUNT;
-  // device_create_info.pQueueCreateInfos = queue_create_info;
-  // device_create_info.pEnabledFeatures = &device_features;
-  // device_create_info.enabledExtensionCount = 1;
-  // const char* extension_names = VK_KHR_SWAPCHAIN_EXTENSION_NAME;
-  // device_create_info.ppEnabledExtensionNames = &extension_names;
-
-  // VkResult result = vkCreateDevice(out_device->physical_device, &device_create_info,
-  //                                  context.allocator, &out_device->logical_device);
-  // if (result != VK_SUCCESS) {
-  //   FATAL("Error creating logical device with status %u\n", result);
-  //   exit(1);
-  // }
-  // TRACE("Logical device created");
-
-  // Queues
 
   // Create the command pool
 
@@ -216,29 +192,55 @@ bool gpu_device_create(gpu_device* out_device) {
 }
 
 bool gpu_swapchain_create(gpu_swapchain* out_swapchain) {
-  VkExtent2D swapchain_extent = { context.screen_width, context.screen_height };
+  out_swapchain->swapchain_arena = arena_create(malloc(1024), 1024);
+  vulkan_swapchain_support_info swapchain_support = context.swapchain_support;
 
-  // find a format
+  // TODO: custom swapchain extents VkExtent2D swapchain_extent = { width, height };
 
+  VkSurfaceFormatKHR image_format = choose_swapchain_format(&swapchain_support);
+  out_swapchain->image_format = image_format;
   VkPresentModeKHR present_mode = VK_PRESENT_MODE_FIFO_KHR;  // guaranteed to be implemented
+  out_swapchain->present_mode = present_mode;
+
+  u32 image_count = swapchain_support.capabilities.minImageCount + 1;
+  out_swapchain->image_count = image_count;
 
   VkSwapchainCreateInfoKHR swapchain_create_info = { VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR };
   swapchain_create_info.surface = context.surface;
-  swapchain_create_info.minImageCount = 2;
-  // TODO: image_ fields
+  swapchain_create_info.minImageCount = image_count;
+  swapchain_create_info.imageFormat = image_format.format;
+  swapchain_create_info.imageColorSpace = image_format.colorSpace;
+  swapchain_create_info.imageExtent = swapchain_support.capabilities.currentExtent;
+  swapchain_create_info.imageArrayLayers = 1;
+  swapchain_create_info.imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
+  swapchain_create_info.imageSharingMode = VK_SHARING_MODE_EXCLUSIVE;
   swapchain_create_info.queueFamilyIndexCount = 0;
-  swapchain_create_info.pQueueFamilyIndices = 0;
+  swapchain_create_info.pQueueFamilyIndices = NULL;
 
-  // TODO: preTransform
+  swapchain_create_info.preTransform = swapchain_support.capabilities.currentTransform;
   swapchain_create_info.compositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR;
   swapchain_create_info.presentMode = present_mode;
-
   swapchain_create_info.clipped = VK_TRUE;
-  swapchain_create_info.oldSwapchain = 0;
+  swapchain_create_info.oldSwapchain = VK_NULL_HANDLE;
+
+  out_swapchain->extent = swapchain_support.capabilities.currentExtent;
 
   VK_CHECK(vkCreateSwapchainKHR(context.device->logical_device, &swapchain_create_info,
                                 context.allocator, &out_swapchain->handle));
   TRACE("Vulkan Swapchain created");
+
+  // Retrieve Images
+  out_swapchain->images =
+      arena_alloc(&out_swapchain->swapchain_arena, image_count * sizeof(VkImage));
+  VK_CHECK(vkGetSwapchainImagesKHR(context.device->logical_device, out_swapchain->handle,
+                                   &image_count, out_swapchain->images));
+
+  return true;
+}
+
+void gpu_swapchain_destroy(gpu_swapchain* swapchain) {
+  arena_free_storage(&swapchain->swapchain_arena);
+  vkDestroySwapchainKHR(context.device, swapchain->handle, context.allocator);
 }
 
 gpu_pipeline* gpu_graphics_pipeline_create(struct graphics_pipeline_desc description) {
@@ -482,7 +484,7 @@ queue_family_indices find_queue_families(VkPhysicalDevice device) {
 
     VkBool32 present_support = false;
     vkGetPhysicalDeviceSurfaceSupportKHR(device, q_fam_i, context.surface, &present_support);
-    if (present_support) {
+    if (present_support && !indices.has_present) {
       indices.present_family_index = q_fam_i;
       indices.has_present = true;
     }
@@ -491,8 +493,6 @@ queue_family_indices find_queue_families(VkPhysicalDevice device) {
   return indices;
 }
 
-const char* bool_str(bool input) { return input ? "True" : "False"; }
-
 bool create_logical_device(gpu_device* out_device) {
   queue_family_indices indices = find_queue_families(out_device->physical_device);
   INFO(" %s | %s | %s | %s | %s", bool_str(indices.has_graphics), bool_str(indices.has_present),
diff --git a/src/renderer/backends/backend_vulkan.h b/src/renderer/backends/backend_vulkan.h
index 8c6b772..0114d7a 100644
--- a/src/renderer/backends/backend_vulkan.h
+++ b/src/renderer/backends/backend_vulkan.h
@@ -28,6 +28,12 @@ typedef struct queue_family_indices {
 
 typedef struct gpu_swapchain {
   VkSwapchainKHR handle;
+  arena swapchain_arena;
+  VkExtent2D extent;
+  VkSurfaceFormatKHR image_format;
+  VkPresentModeKHR present_mode;
+  VkImage* images;
+  u32 image_count;
 } gpu_swapchain;
 
 typedef struct gpu_device {
diff --git a/src/renderer/backends/vulkan_helpers.h b/src/renderer/backends/vulkan_helpers.h
index 03ee814..55d8846 100644
--- a/src/renderer/backends/vulkan_helpers.h
+++ b/src/renderer/backends/vulkan_helpers.h
@@ -1,5 +1,6 @@
 #pragma once
 
+#include <assert.h>
 #include <vulkan/vulkan.h>
 #include <vulkan/vulkan_core.h>
 
@@ -54,8 +55,8 @@ VKAPI_ATTR VkBool32 VKAPI_CALL vk_debug_callback(
     VkDebugUtilsMessageSeverityFlagBitsEXT severity, VkDebugUtilsMessageTypeFlagsEXT flags,
     const VkDebugUtilsMessengerCallbackDataEXT* callback_data, void* user_data);
 
-void vulkan_device_query_swapchain_support(VkPhysicalDevice device, VkSurfaceKHR surface,
-                                           vulkan_swapchain_support_info* out_support_info) {
+static void vulkan_device_query_swapchain_support(VkPhysicalDevice device, VkSurfaceKHR surface,
+                                                  vulkan_swapchain_support_info* out_support_info) {
   // TODO: add VK_CHECK to these calls!
 
   // Surface capabilities
@@ -78,6 +79,20 @@ void vulkan_device_query_swapchain_support(VkPhysicalDevice device, VkSurfaceKHR
   }
 }
 
+static VkSurfaceFormatKHR choose_swapchain_format(
+    vulkan_swapchain_support_info* swapchain_support) {
+      assert(swapchain_support->format_count > 0);
+  // find a format
+  for (u32 i = 0; i < swapchain_support->format_count; i++) {
+    VkSurfaceFormatKHR format = swapchain_support->formats[i];
+    if (format.format == VK_FORMAT_B8G8R8A8_SRGB &&
+        format.colorSpace == VK_COLOR_SPACE_SRGB_NONLINEAR_KHR) {
+      return format;
+    }
+  }
+  return swapchain_support->formats[0];
+}
+
 // static bool physical_device_meets_requirements(
 //     VkPhysicalDevice device, VkSurfaceKHR surface, const VkPhysicalDeviceProperties* properties,
 //     const VkPhysicalDeviceFeatures* features,
diff --git a/src/renderer/ral.h b/src/renderer/ral.h
index 7c143f2..f202e51 100644
--- a/src/renderer/ral.h
+++ b/src/renderer/ral.h
@@ -77,7 +77,7 @@ gpu_pipeline* gpu_graphics_pipeline_create(struct graphics_pipeline_desc descrip
 void gpu_pipeline_destroy(gpu_pipeline* pipeline);
 
 bool gpu_swapchain_create(gpu_swapchain* out_swapchain);
-void gpu_swapchain_destroy();
+void gpu_swapchain_destroy(gpu_swapchain* swapchain);
 
 void gpu_cmd_encoder_begin();
 void gpu_cmd_encoder_begin_render();
diff --git a/src/std/utils.h b/src/std/utils.h
new file mode 100644
index 0000000..c9827a3
--- /dev/null
+++ b/src/std/utils.h
@@ -0,0 +1,4 @@
+#pragma once
+#include <stdbool.h>
+
+const char* bool_str(bool input) { return input ? "True" : "False"; }
\ No newline at end of file
diff --git a/src/systems/terrain.h b/src/systems/terrain.h
index 745ca22..bfd90b5 100644
--- a/src/systems/terrain.h
+++ b/src/systems/terrain.h
@@ -18,8 +18,8 @@ Future:
 #include "defines.h"
 #include "maths_types.h"
 #include "mem.h"
-#include "str.h"
 #include "render_types.h"
+#include "str.h"
 
 typedef struct heightmap {
   str8 filepath;
-- 
cgit v1.2.3-70-g09d2


From 1c27e3c4d42b79e38feb56974f66a2caf3f5a53d Mon Sep 17 00:00:00 2001
From: Omniscient <17525998+omnisci3nce@users.noreply.github.com>
Date: Sat, 4 May 2024 22:28:07 +1000
Subject: set up most of basic pipeline state

---
 examples/triangle/ex_triangle.c        |  16 ++--
 src/renderer/backends/backend_vulkan.c | 163 +++++++++++++++++++++++++--------
 src/renderer/backends/vulkan_helpers.h |   2 +-
 src/renderer/ral.h                     |   3 +-
 4 files changed, 140 insertions(+), 44 deletions(-)

(limited to 'src/renderer/backends/vulkan_helpers.h')

diff --git a/examples/triangle/ex_triangle.c b/examples/triangle/ex_triangle.c
index 9b993c1..bdb2d70 100644
--- a/examples/triangle/ex_triangle.c
+++ b/examples/triangle/ex_triangle.c
@@ -19,8 +19,10 @@ int main() {
   gpu_renderpass_desc pass_description = {};
   gpu_renderpass* renderpass = gpu_renderpass_create(&pass_description);
 
-  str8_opt vertex_shader = str8_from_file(&scratch, str8lit("assets/shaders/triangle.vert"));
-  str8_opt fragment_shader = str8_from_file(&scratch, str8lit("assets/shaders/triangle.frag"));
+  str8 vert_path = str8lit("build/linux/x86_64/debug/triangle.vert.spv");
+  str8 frag_path = str8lit("build/linux/x86_64/debug/triangle.frag.spv");
+  str8_opt vertex_shader = str8_from_file(&scratch, vert_path);
+  str8_opt fragment_shader = str8_from_file(&scratch, frag_path);
   if (!vertex_shader.has_value || !fragment_shader.has_value) {
     ERROR_EXIT("Failed to load shaders from disk")
   }
@@ -28,11 +30,13 @@ int main() {
   struct graphics_pipeline_desc pipeline_description = {
     .debug_name = "Basic Pipeline",
     .vs = { .debug_name = "Triangle Vertex Shader",
-            .filepath = str8lit("assets/shaders/triangle.vert"),
-            .glsl = vertex_shader.contents },
+            .filepath = vert_path,
+            .code = vertex_shader.contents,
+            .is_spirv = true },
     .fs = { .debug_name = "Triangle Fragment Shader",
-            .filepath = str8lit("assets/shaders/triangle.frag"),
-            .glsl = fragment_shader.contents },
+            .filepath = frag_path,
+            .code = fragment_shader.contents,
+            .is_spirv = true },
     .renderpass = renderpass,
     .wireframe = false,
     .depth_test = false
diff --git a/src/renderer/backends/backend_vulkan.c b/src/renderer/backends/backend_vulkan.c
index 45bb0e7..5a01303 100644
--- a/src/renderer/backends/backend_vulkan.c
+++ b/src/renderer/backends/backend_vulkan.c
@@ -1,5 +1,6 @@
 #include <assert.h>
 #include <glfw3.h>
+#include <stdint.h>
 #include <stdlib.h>
 #include <vulkan/vk_platform.h>
 #include <vulkan/vulkan.h>
@@ -8,9 +9,11 @@
 #include "backend_vulkan.h"
 #include "maths_types.h"
 #include "mem.h"
+#include "str.h"
 #include "vulkan_helpers.h"
 
 #include "defines.h"
+#include "file.h"
 #include "log.h"
 #include "ral.h"
 #include "utils.h"
@@ -51,6 +54,8 @@ queue_family_indices find_queue_families(VkPhysicalDevice device);
 
 bool create_logical_device(gpu_device* out_device);
 
+VkShaderModule create_shader_module(str8 spirv);
+
 /** @brief Helper function for creating array of all extensions we want */
 cstr_darray* get_all_extensions();
 
@@ -192,6 +197,8 @@ bool gpu_device_create(gpu_device* out_device) {
 }
 
 bool gpu_swapchain_create(gpu_swapchain* out_swapchain) {
+  context.swapchain = out_swapchain;
+
   out_swapchain->swapchain_arena = arena_create(malloc(1024), 1024);
   vulkan_swapchain_support_info swapchain_support = context.swapchain_support;
 
@@ -262,7 +269,7 @@ bool gpu_swapchain_create(gpu_swapchain* out_swapchain) {
 
 void gpu_swapchain_destroy(gpu_swapchain* swapchain) {
   arena_free_storage(&swapchain->swapchain_arena);
-  vkDestroySwapchainKHR(context.device, swapchain->handle, context.allocator);
+  vkDestroySwapchainKHR(context.device->logical_device, swapchain->handle, context.allocator);
 }
 
 gpu_pipeline* gpu_graphics_pipeline_create(struct graphics_pipeline_desc description) {
@@ -270,16 +277,55 @@ gpu_pipeline* gpu_graphics_pipeline_create(struct graphics_pipeline_desc descrip
   gpu_pipeline_layout* layout = malloc(sizeof(gpu_pipeline_layout));
   gpu_pipeline* pipeline = malloc(sizeof(gpu_pipeline));
 
+  // Shaders
+  VkShaderModule vertex_shader = create_shader_module(description.vs.code);
+  VkShaderModule fragment_shader = create_shader_module(description.fs.code);
+
+  // Vertex
+  VkPipelineShaderStageCreateInfo vert_shader_stage_info = {
+    VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO
+  };
+  vert_shader_stage_info.stage = VK_SHADER_STAGE_VERTEX_BIT;
+  vert_shader_stage_info.module = vertex_shader;
+  vert_shader_stage_info.pName = "main";
+  // Fragment
+  VkPipelineShaderStageCreateInfo frag_shader_stage_info = {
+    VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO
+  };
+  frag_shader_stage_info.stage = VK_SHADER_STAGE_FRAGMENT_BIT;
+  frag_shader_stage_info.module = fragment_shader;
+  frag_shader_stage_info.pName = "main";
+
+  VkPipelineShaderStageCreateInfo shader_stages[2] = { vert_shader_stage_info,
+                                                       frag_shader_stage_info };
+
+  // Vertex Input
+
+  // TODO: Attributes
+
+  VkPipelineVertexInputStateCreateInfo vertex_input_info = {
+    VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO
+  };
+  vertex_input_info.vertexBindingDescriptionCount = 0;
+  vertex_input_info.pVertexBindingDescriptions = NULL;
+  vertex_input_info.vertexAttributeDescriptionCount = 0;
+  vertex_input_info.pVertexAttributeDescriptions = NULL;
+
+  // Input Assembly
+  VkPipelineInputAssemblyStateCreateInfo input_assembly = {
+    VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO
+  };
+  input_assembly.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
+  input_assembly.primitiveRestartEnable = VK_FALSE;
+
   // Viewport
   VkViewport viewport = { .x = 0,
                           .y = 0,
-                          .width = (f32)context.screen_width,
-                          .height = (f32)context.screen_height,
+                          .width = (f32)context.swapchain->extent.width,
+                          .height = (f32)context.swapchain->extent.height,
                           .minDepth = 0.0,
                           .maxDepth = 1.0 };
-  VkRect2D scissor = { .offset = { .x = 0, .y = 0 },
-                       .extent = { .width = context.screen_width,
-                                   .height = context.screen_height } };
+  VkRect2D scissor = { .offset = { .x = 0, .y = 0 }, .extent = context.swapchain->extent };
   VkPipelineViewportStateCreateInfo viewport_state = {
     VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO
   };
@@ -315,24 +361,52 @@ gpu_pipeline* gpu_graphics_pipeline_create(struct graphics_pipeline_desc descrip
   ms_create_info.alphaToCoverageEnable = VK_FALSE;
   ms_create_info.alphaToOneEnable = VK_FALSE;
 
-  // Depth and stencil testing
-  VkPipelineDepthStencilStateCreateInfo depth_stencil = {
-    VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO
+  // TODO: Depth and stencil testing
+  // VkPipelineDepthStencilStateCreateInfo depth_stencil = {
+  //   VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO
+  // };
+  // depth_stencil.depthTestEnable = description.depth_test ? VK_TRUE : VK_FALSE;
+  // depth_stencil.depthWriteEnable = description.depth_test ? VK_TRUE : VK_FALSE;
+  // depth_stencil.depthCompareOp = VK_COMPARE_OP_LESS;
+  // depth_stencil.depthBoundsTestEnable = VK_FALSE;
+  // depth_stencil.stencilTestEnable = VK_FALSE;
+  // depth_stencil.pNext = 0;
+
+  // Blending
+  VkPipelineColorBlendAttachmentState color_blend_attachment_state;
+  color_blend_attachment_state.blendEnable = VK_TRUE;
+  color_blend_attachment_state.srcColorBlendFactor = VK_BLEND_FACTOR_SRC_ALPHA;
+  color_blend_attachment_state.dstColorBlendFactor = VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA;
+  color_blend_attachment_state.colorBlendOp = VK_BLEND_OP_ADD;
+  color_blend_attachment_state.srcAlphaBlendFactor = VK_BLEND_FACTOR_SRC_ALPHA;
+  color_blend_attachment_state.dstAlphaBlendFactor = VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA;
+  color_blend_attachment_state.alphaBlendOp = VK_BLEND_OP_ADD;
+  color_blend_attachment_state.colorWriteMask = VK_COLOR_COMPONENT_R_BIT |
+                                                VK_COLOR_COMPONENT_G_BIT |
+                                                VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT;
+
+  VkPipelineColorBlendStateCreateInfo color_blend = {
+    VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO
+  };
+  color_blend.logicOpEnable = VK_FALSE;
+  color_blend.logicOp = VK_LOGIC_OP_COPY;
+  color_blend.attachmentCount = 1;
+  color_blend.pAttachments = &color_blend_attachment_state;
+
+// Dynamic state
+#define DYNAMIC_STATE_COUNT 2
+  VkDynamicState dynamic_states[DYNAMIC_STATE_COUNT] = {
+    VK_DYNAMIC_STATE_VIEWPORT,
+    VK_DYNAMIC_STATE_SCISSOR,
   };
-  depth_stencil.depthTestEnable = description.depth_test ? VK_TRUE : VK_FALSE;
-  depth_stencil.depthWriteEnable = description.depth_test ? VK_TRUE : VK_FALSE;
-  depth_stencil.depthCompareOp = VK_COMPARE_OP_LESS;
-  depth_stencil.depthBoundsTestEnable = VK_FALSE;
-  depth_stencil.stencilTestEnable = VK_FALSE;
-  depth_stencil.pNext = 0;
-
-  // TODO: Blending
-
-  // TODO: Vertex Input
 
-  // TODO: Attributes
+  VkPipelineDynamicStateCreateInfo dynamic_state = {
+    VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO
+  };
+  dynamic_state.dynamicStateCount = DYNAMIC_STATE_COUNT;
+  dynamic_state.pDynamicStates = dynamic_states;
 
-  // TODO: layouts
+  // Layout
   VkPipelineLayoutCreateInfo pipeline_layout_create_info = {
     VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO
   };
@@ -347,25 +421,26 @@ gpu_pipeline* gpu_graphics_pipeline_create(struct graphics_pipeline_desc descrip
   VkGraphicsPipelineCreateInfo pipeline_create_info = {
     VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO
   };
-  // pipeline_create_info.stageCount = stage_count;
-  // pipeline_create_info.pStages = stages;
-  // pipeline_create_info.pVertexInputState = &vertex_input_info;
-  // pipeline_create_info.pInputAssemblyState = &input_assembly;
 
-  // pipeline_create_info.pViewportState = &viewport_state;
-  // pipeline_create_info.pRasterizationState = &rasterizer_create_info;
-  // pipeline_create_info.pMultisampleState = &ms_create_info;
-  // pipeline_create_info.pDepthStencilState = &depth_stencil;
-  // pipeline_create_info.pColorBlendState = &color_blend;
-  // pipeline_create_info.pDynamicState = &dynamic_state;
-  // pipeline_create_info.pTessellationState = 0;
+  pipeline_create_info.stageCount = 2;
+  pipeline_create_info.pStages = shader_stages;
+  pipeline_create_info.pVertexInputState = &vertex_input_info;
+  pipeline_create_info.pInputAssemblyState = &input_assembly;
 
-  // pipeline_create_info.layout = out_pipeline->layout;
+  pipeline_create_info.pViewportState = &viewport_state;
+  pipeline_create_info.pRasterizationState = &rasterizer_create_info;
+  pipeline_create_info.pMultisampleState = &ms_create_info;
+  pipeline_create_info.pDepthStencilState = NULL;  // &depth_stencil;
+  pipeline_create_info.pColorBlendState = &color_blend;
+  pipeline_create_info.pDynamicState = &dynamic_state;
+  pipeline_create_info.pTessellationState = 0;
+
+  pipeline_create_info.layout = layout->handle;
 
   // pipeline_create_info.renderPass = renderpass->handle;
-  // pipeline_create_info.subpass = 0;
-  // pipeline_create_info.basePipelineHandle = VK_NULL_HANDLE;
-  // pipeline_create_info.basePipelineIndex = -1;
+  pipeline_create_info.subpass = 0;
+  pipeline_create_info.basePipelineHandle = VK_NULL_HANDLE;
+  pipeline_create_info.basePipelineIndex = -1;
 
   VkResult result =
       vkCreateGraphicsPipelines(context.device->logical_device, VK_NULL_HANDLE, 1,
@@ -375,6 +450,10 @@ gpu_pipeline* gpu_graphics_pipeline_create(struct graphics_pipeline_desc descrip
     ERROR_EXIT("Doomed");
   }
 
+  // once the pipeline has been created we can destroy these
+  vkDestroyShaderModule(context.device->logical_device, vertex_shader, context.allocator);
+  vkDestroyShaderModule(context.device->logical_device, fragment_shader, context.allocator);
+
   return pipeline;
 }
 
@@ -576,4 +655,16 @@ bool create_logical_device(gpu_device* out_device) {
                    &context.device->present_queue);
 
   return true;
+}
+
+VkShaderModule create_shader_module(str8 spirv) {
+  VkShaderModuleCreateInfo create_info = { VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO };
+  create_info.codeSize = spirv.len;
+  create_info.pCode = (uint32_t*)spirv.buf;
+
+  VkShaderModule shader_module;
+  VK_CHECK(vkCreateShaderModule(context.device->logical_device, &create_info, context.allocator,
+                                &shader_module));
+
+  return shader_module;
 }
\ No newline at end of file
diff --git a/src/renderer/backends/vulkan_helpers.h b/src/renderer/backends/vulkan_helpers.h
index 55d8846..aa43c62 100644
--- a/src/renderer/backends/vulkan_helpers.h
+++ b/src/renderer/backends/vulkan_helpers.h
@@ -81,7 +81,7 @@ static void vulkan_device_query_swapchain_support(VkPhysicalDevice device, VkSur
 
 static VkSurfaceFormatKHR choose_swapchain_format(
     vulkan_swapchain_support_info* swapchain_support) {
-      assert(swapchain_support->format_count > 0);
+  assert(swapchain_support->format_count > 0);
   // find a format
   for (u32 i = 0; i < swapchain_support->format_count; i++) {
     VkSurfaceFormatKHR format = swapchain_support->formats[i];
diff --git a/src/renderer/ral.h b/src/renderer/ral.h
index f202e51..15c66ef 100644
--- a/src/renderer/ral.h
+++ b/src/renderer/ral.h
@@ -45,7 +45,8 @@ typedef enum pipeline_kind {
 typedef struct shader_desc {
   const char* debug_name;
   str8 filepath;  // where it came from
-  str8 glsl;      // contents
+  str8 code;      // Either GLSL or SPIRV bytecode
+  bool is_spirv;
 } shader_desc;
 
 struct graphics_pipeline_desc {
-- 
cgit v1.2.3-70-g09d2


From d52d39d7843ed2203b001a822efe6d4b692c2642 Mon Sep 17 00:00:00 2001
From: Omniscient <17525998+omnisci3nce@users.noreply.github.com>
Date: Sun, 12 May 2024 12:31:24 +1000
Subject: uniforms working with hardcoded stuff

---
 assets/shaders/cube.frag               |  0
 assets/shaders/cube.vert               | 18 ++++++++
 examples/cube/ex_cube.c                | 16 ++++---
 src/renderer/backends/backend_vulkan.c | 76 ++++++++++++++++++++++++++++------
 src/renderer/backends/vulkan_helpers.h |  2 +-
 xmake.lua                              |  1 +
 6 files changed, 95 insertions(+), 18 deletions(-)
 create mode 100644 assets/shaders/cube.frag
 create mode 100644 assets/shaders/cube.vert

(limited to 'src/renderer/backends/vulkan_helpers.h')

diff --git a/assets/shaders/cube.frag b/assets/shaders/cube.frag
new file mode 100644
index 0000000..e69de29
diff --git a/assets/shaders/cube.vert b/assets/shaders/cube.vert
new file mode 100644
index 0000000..80ad854
--- /dev/null
+++ b/assets/shaders/cube.vert
@@ -0,0 +1,18 @@
+#version 450
+
+layout(binding = 0) uniform UniformBufferObject {
+  mat4 model;
+  mat4 view;
+  mat4 proj;
+}
+ubo;
+
+layout(location = 0) in vec2 inPosition;
+layout(location = 1) in vec3 inColor;
+
+layout(location = 0) out vec3 fragColor;
+
+void main() {
+  gl_Position = ubo.proj * ubo.view * ubo.model * vec4(inPosition, 0.0, 1.0);
+  fragColor = inColor;
+}
diff --git a/examples/cube/ex_cube.c b/examples/cube/ex_cube.c
index 699cf55..712485c 100644
--- a/examples/cube/ex_cube.c
+++ b/examples/cube/ex_cube.c
@@ -6,6 +6,7 @@
 #include "file.h"
 #include "log.h"
 #include "maths.h"
+#include "maths_types.h"
 #include "mem.h"
 #include "ral.h"
 #include "ral_types.h"
@@ -39,7 +40,10 @@ shader_data_layout mvp_uniforms_layout(void* data) {
   if (has_data) {
     b1.data.bytes.data = d;
   }
-  return (shader_data_layout){ .name = "global_ubo", .bindings = { b1 } };
+  /*   char* name; */
+  /*   shader_binding bindings[MAX_LAYOUT_BINDINGS]; */
+  /*   u32 bindings_count; */
+  return (shader_data_layout){ .name = "global_ubo", .bindings = { b1 }, .bindings_count = 1 };
 }
 
 int main() {
@@ -53,7 +57,7 @@ int main() {
   gpu_renderpass_desc pass_description = {};
   gpu_renderpass* renderpass = gpu_renderpass_create(&pass_description);
 
-  str8 vert_path = str8lit("build/linux/x86_64/debug/triangle.vert.spv");
+  str8 vert_path = str8lit("build/linux/x86_64/debug/cube.vert.spv");
   str8 frag_path = str8lit("build/linux/x86_64/debug/triangle.frag.spv");
   str8_opt vertex_shader = str8_from_file(&scratch, vert_path);
   str8_opt fragment_shader = str8_from_file(&scratch, frag_path);
@@ -104,9 +108,11 @@ int main() {
 
     /* shader_data_layout mvp_layout = mvp_uniforms_layout(NULL); */
 
-    mvp_uniforms mvp_data = { .model = mat4_ident(),
-                              .view = mat4_ident(),
-                              .projection = mat4_ident() };
+    static f32 x = 0.0;
+    x += 0.01;
+    quat rotation = quat_from_axis_angle(VEC3_Z, x, true);
+    mat4 model = mat4_rotation(rotation);
+    mvp_uniforms mvp_data = { .model = model, .view = mat4_ident(), .projection = mat4_ident() };
     mvp_uniforms_data.data = &mvp_data;
 
     // Record draw calls
diff --git a/src/renderer/backends/backend_vulkan.c b/src/renderer/backends/backend_vulkan.c
index c145c1a..a845ebf 100644
--- a/src/renderer/backends/backend_vulkan.c
+++ b/src/renderer/backends/backend_vulkan.c
@@ -10,6 +10,7 @@
 
 #include "backend_vulkan.h"
 #include "buf.h"
+#include "darray.h"
 #include "maths_types.h"
 #include "mem.h"
 #include "ral_types.h"
@@ -26,10 +27,12 @@
 #define SCREEN_WIDTH 1000
 #define SCREEN_HEIGHT 1000
 #define VULKAN_QUEUES_COUNT 2
-#define MAX_DESCRIPTOR_SETS 100
+#define MAX_DESCRIPTOR_SETS 10
 
 const char* queue_names[VULKAN_QUEUES_COUNT] = { "GRAPHICS", "TRANSFER" };
 
+KITC_DECL_TYPED_ARRAY(VkDescriptorSet)
+
 typedef struct vulkan_context {
   VkInstance instance;
   VkAllocationCallbacks* allocator;
@@ -61,6 +64,7 @@ typedef struct vulkan_context {
   // Storage
   gpu_buffer buffers[1024];
   size_t buffer_count;
+  VkDescriptorSet_darray* free_set_queue;
 
   VkDebugUtilsMessengerEXT vk_debugger;
 } vulkan_context;
@@ -94,6 +98,7 @@ bool gpu_backend_init(const char* window_name, GLFWwindow* window) {
   context.window = window;
   context.current_img_index = 0;
   context.current_frame = 0;
+  context.free_set_queue = VkDescriptorSet_darray_new(100);
 
   // Create an allocator
   size_t temp_arena_size = 1024 * 1024;
@@ -505,6 +510,7 @@ gpu_pipeline* gpu_graphics_pipeline_create(struct graphics_pipeline_desc descrip
   pipeline->uniform_pointers =
       malloc(description.data_layouts_count * sizeof(desc_set_uniform_buffer));
 
+  assert(description.data_layouts_count == 1);
   for (u32 i = 0; i < description.data_layouts_count; i++) {
     shader_data_layout sdl = description.data_layouts[i].shader_data_get_layout(NULL);
 
@@ -512,6 +518,7 @@ gpu_pipeline* gpu_graphics_pipeline_create(struct graphics_pipeline_desc descrip
     VkDescriptorSetLayoutBinding desc_set_bindings[description.data_layouts_count];
 
     // Bindings
+    assert(sdl.bindings_count == 1);
     for (u32 j = 0; j < sdl.bindings_count; j++) {
       desc_set_bindings[j].binding = j;
       desc_set_bindings[j].descriptorCount = 1;
@@ -519,6 +526,7 @@ gpu_pipeline* gpu_graphics_pipeline_create(struct graphics_pipeline_desc descrip
         case SHADER_BINDING_BUFFER:
         case SHADER_BINDING_BYTES:
           desc_set_bindings[j].descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
+          desc_set_bindings[j].stageFlags = VK_SHADER_STAGE_VERTEX_BIT;  // FIXME: dont hardcode
 
           u64 buffer_size = sdl.bindings[j].data.bytes.size;
           VkDeviceSize uniform_buf_size = buffer_size;
@@ -531,9 +539,12 @@ gpu_pipeline* gpu_graphics_pipeline_create(struct graphics_pipeline_desc descrip
           for (size_t frame_i = 0; frame_i < MAX_FRAMES_IN_FLIGHT; frame_i++) {
             buffer_handle uniform_buf_handle =
                 gpu_buffer_create(buffer_size, CEL_BUFFER_UNIFORM, CEL_BUFFER_FLAG_CPU, NULL);
-            buffers[frame_i] = context.buffers[uniform_buf_handle.raw].handle;
+            gpu_buffer created_gpu_buffer = context.buffers[uniform_buf_handle.raw];
+            buffers[frame_i] = created_gpu_buffer.handle;
+            uniform_buf_memorys[frame_i] = created_gpu_buffer.memory;
             vkMapMemory(context.device->logical_device, uniform_buf_memorys[frame_i], 0,
                         uniform_buf_size, 0, &uniform_buf_mem_mappings[frame_i]);
+            // now we have a pointer in unifrom_buf_mem_mappings we can write to
           }
 
           desc_set_uniform_buffer uniform_data;
@@ -577,8 +588,8 @@ gpu_pipeline* gpu_graphics_pipeline_create(struct graphics_pipeline_desc descrip
   VkPipelineLayoutCreateInfo pipeline_layout_create_info = {
     VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO
   };
-  pipeline_layout_create_info.setLayoutCount = 0;
-  pipeline_layout_create_info.pSetLayouts = NULL;
+  pipeline_layout_create_info.setLayoutCount = description.data_layouts_count;
+  pipeline_layout_create_info.pSetLayouts = desc_set_layouts;
   pipeline_layout_create_info.pushConstantRangeCount = 0;
   pipeline_layout_create_info.pPushConstantRanges = NULL;
   VK_CHECK(vkCreatePipelineLayout(context.device->logical_device, &pipeline_layout_create_info,
@@ -733,12 +744,12 @@ gpu_cmd_encoder gpu_cmd_encoder_create() {
 
   VkDescriptorPoolSize uniform_pool_size;
   uniform_pool_size.type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
-  uniform_pool_size.descriptorCount = MAX_FRAMES_IN_FLIGHT *  MAX_DESCRIPTOR_SETS;
+  uniform_pool_size.descriptorCount = MAX_FRAMES_IN_FLIGHT * MAX_DESCRIPTOR_SETS;
 
   VkDescriptorPoolCreateInfo pool_info = { VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO };
   pool_info.poolSizeCount = 1;
   pool_info.pPoolSizes = &uniform_pool_size;
-  pool_info.maxSets = 10000;
+  pool_info.maxSets = 100;
 
   VK_CHECK(vkCreateDescriptorPool(context.device->logical_device, &pool_info, context.allocator,
                                   &encoder.descriptor_pool));
@@ -751,6 +762,8 @@ void gpu_cmd_encoder_destroy(gpu_cmd_encoder* encoder) {
 }
 
 void gpu_cmd_encoder_begin(gpu_cmd_encoder encoder) {
+  VK_CHECK(vkResetDescriptorPool(context.device->logical_device, encoder.descriptor_pool, 0));
+
   VkCommandBufferBeginInfo begin_info = { VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO };
   VK_CHECK(vkBeginCommandBuffer(encoder.cmd_buffer, &begin_info));
 }
@@ -782,6 +795,7 @@ void gpu_cmd_encoder_end_render(gpu_cmd_encoder* encoder) {
 
 gpu_cmd_buffer gpu_cmd_encoder_finish(gpu_cmd_encoder* encoder) {
   vkEndCommandBuffer(encoder->cmd_buffer);
+
   // TEMP: submit
   return (gpu_cmd_buffer){ .cmd_buffer = encoder->cmd_buffer };
 }
@@ -800,14 +814,50 @@ void encode_bind_shader_data(gpu_cmd_encoder* encoder, u32 group, shader_data* d
   memcpy(ubo.uniform_buf_mem_mappings[context.current_frame], data->data, ubo.size);
 
   VkDescriptorSetAllocateInfo alloc_info = { VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO };
-  alloc_info.descriptorPool =encoder->descriptor_pool;
+  alloc_info.descriptorPool = encoder->descriptor_pool;
   alloc_info.descriptorSetCount = 1;
-    alloc_info.pSetLayouts = &encoder->pipeline->desc_set_layouts[group];
+  alloc_info.pSetLayouts = &encoder->pipeline->desc_set_layouts[group];
+
+  VkDescriptorSet sets[1];
+  /* VK_CHECK( */
+  vkAllocateDescriptorSets(context.device->logical_device, &alloc_info, sets);
+  /* ); */
+  VkDescriptorSet_darray_push(context.free_set_queue, sets[0]);
+
+  shader_data_layout sdl = data->shader_data_get_layout(NULL);
+  assert(sdl.bindings_count == 1);
+
+  VkWriteDescriptorSet write_sets[1];
+  memset(&write_sets, 0, sizeof(write_sets));
+
+  assert(sdl.bindings_count == 1);
+  for (u32 i = 0; i < sdl.bindings_count; i++) {
+    shader_binding binding = sdl.bindings[i];
+
+    if (binding.type == SHADER_BINDING_BUFFER || binding.type == SHADER_BINDING_BYTES) {
+      VkDescriptorBufferInfo buffer_info;
+      buffer_info.buffer = ubo.buffers[context.current_frame];
+      buffer_info.offset = 0;
+      buffer_info.range = binding.data.bytes.size;
+
+      write_sets[0].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
+      write_sets[0].descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
+      write_sets[0].descriptorCount = 1;
+      write_sets[0].dstSet = sets[0];
+      write_sets[0].dstBinding = 0;
+      write_sets[0].dstArrayElement = 0;
+      write_sets[0].pBufferInfo = &buffer_info;
+    } else {
+      WARN("Unknown binding");
+    }
+  }
 
-    VkDescriptorSet sets[1];
-  VK_CHECK(vkAllocateDescriptorSets(context.device->logical_device, &alloc_info,
-                                    sets));
+  // Update
+  vkUpdateDescriptorSets(context.device->logical_device, 1, write_sets, 0, NULL);
 
+  // Bind
+  vkCmdBindDescriptorSets(encoder->cmd_buffer, VK_PIPELINE_BIND_POINT_GRAPHICS,
+                          encoder->pipeline->layout_handle, 0, 1, sets, 0, NULL);
 }
 
 void encode_set_vertex_buffer(gpu_cmd_encoder* encoder, buffer_handle buf) {
@@ -1081,7 +1131,6 @@ VkShaderModule create_shader_module(str8 spirv) {
   return shader_module;
 }
 
-
 void create_descriptor_pools() {}
 
 void create_swapchain_framebuffers() {
@@ -1155,6 +1204,9 @@ buffer_handle gpu_buffer_create(u64 size, gpu_buffer_type buf_type, gpu_buffer_f
     case CEL_BUFFER_INDEX:
       buffer_info.usage |= VK_BUFFER_USAGE_INDEX_BUFFER_BIT;
       break;
+    case CEL_BUFFER_UNIFORM:
+      buffer_info.usage |= VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT;
+      break;
     case CEL_BUFFER_COUNT:
       WARN("Incorrect gpu_buffer_type provided. using default");
       break;
diff --git a/src/renderer/backends/vulkan_helpers.h b/src/renderer/backends/vulkan_helpers.h
index aa43c62..db9b5a4 100644
--- a/src/renderer/backends/vulkan_helpers.h
+++ b/src/renderer/backends/vulkan_helpers.h
@@ -24,7 +24,7 @@ static void plat_get_required_extension_names(cstr_darray* extensions) {
   do {                                     \
     VkResult res = vulkan_expr;            \
     if (res != VK_SUCCESS) {               \
-      ERROR_EXIT("Vulkan error: %u", res); \
+      ERROR_EXIT("Vulkan error: %u (%s:%d)", res, __FILE__, __LINE__); \
     }                                      \
   } while (0)
 
diff --git a/xmake.lua b/xmake.lua
index 7ebd63d..f1b648b 100644
--- a/xmake.lua
+++ b/xmake.lua
@@ -114,6 +114,7 @@ target("core_config")
     add_rules("compile_glsl_frag_shaders")
     add_files("assets/shaders/triangle.vert")
     add_files("assets/shaders/triangle.frag")
+    add_files("assets/shaders/cube.vert")
     -- add_files("assets/shaders/*.frag")
     if is_plat("windows") then
         add_includedirs("$(env VULKAN_SDK)/Include", {public = true})
-- 
cgit v1.2.3-70-g09d2


From 519329e98467d0cdcc39720cef0f69c9936b6d55 Mon Sep 17 00:00:00 2001
From: Omniscient <omniscient.oce@gmail.com>
Date: Fri, 17 May 2024 13:50:33 +1000
Subject: pool tests and try get macro working

---
 src/physics/broadphase.h               |  6 +--
 src/physics/collision.h                |  8 ++--
 src/physics/narrowphase.h              |  6 +--
 src/renderer/backends/backend_vulkan.h |  3 +-
 src/renderer/backends/vulkan_helpers.h | 10 ++---
 src/renderer/ral.c                     | 22 +++++++++++
 src/renderer/ral.h                     |  9 ++---
 src/renderer/ral_types.h               | 30 ++++++++++----
 src/renderer/render.h                  | 16 ++++----
 src/std/mem.c                          | 67 ++++++++++++++++++++++++++++++-
 src/std/mem.h                          | 24 +++++++++++-
 tests/pool_test_runner.c               | 12 ++++++
 tests/pool_tests.c                     | 72 ++++++++++++++++++++++++++++++++++
 xmake.lua                              | 17 ++++++++
 14 files changed, 261 insertions(+), 41 deletions(-)
 create mode 100644 src/renderer/ral.c
 create mode 100644 tests/pool_test_runner.c
 create mode 100644 tests/pool_tests.c

(limited to 'src/renderer/backends/vulkan_helpers.h')

diff --git a/src/physics/broadphase.h b/src/physics/broadphase.h
index 43b57f6..8b49716 100644
--- a/src/physics/broadphase.h
+++ b/src/physics/broadphase.h
@@ -1,10 +1,10 @@
 /**
  * @file broadphase.h
  * @author your name (you@domain.com)
- * @brief 
+ * @brief
  * @version 0.1
  * @date 2024-05-12
- * 
+ *
  * @copyright Copyright (c) 2024
- * 
+ *
  */
\ No newline at end of file
diff --git a/src/physics/collision.h b/src/physics/collision.h
index 3b65b1b..cca6042 100644
--- a/src/physics/collision.h
+++ b/src/physics/collision.h
@@ -1,17 +1,17 @@
 /**
  * @file collision.h
  * @author your name (you@domain.com)
- * @brief 
+ * @brief
  * @version 0.1
  * @date 2024-05-12
- * 
+ *
  * @copyright Copyright (c) 2024
- * 
+ *
  */
 #pragma once
 #include "geometry.h"
 
- enum collider_type {
+enum collider_type {
   cuboid_collider,
   sphere_collider,
 };
diff --git a/src/physics/narrowphase.h b/src/physics/narrowphase.h
index 501c690..2368c49 100644
--- a/src/physics/narrowphase.h
+++ b/src/physics/narrowphase.h
@@ -1,10 +1,10 @@
 /**
  * @file narrowphase.h
  * @author your name (you@domain.com)
- * @brief 
+ * @brief
  * @version 0.1
  * @date 2024-05-12
- * 
+ *
  * @copyright Copyright (c) 2024
- * 
+ *
  */
\ No newline at end of file
diff --git a/src/renderer/backends/backend_vulkan.h b/src/renderer/backends/backend_vulkan.h
index 7bdf821..77b9f94 100644
--- a/src/renderer/backends/backend_vulkan.h
+++ b/src/renderer/backends/backend_vulkan.h
@@ -4,8 +4,8 @@
 #include <vulkan/vulkan_core.h>
 
 #include "defines.h"
+#include "mem.h"
 #include "ral.h"
-// #include "vulkan_helpers.h"
 
 #define MAX_FRAMES_IN_FLIGHT 2
 #define GPU_SWAPCHAIN_IMG_COUNT 2
@@ -102,4 +102,3 @@ typedef struct gpu_buffer {
   VkDeviceMemory memory;
   u64 size;
 } gpu_buffer;
-
diff --git a/src/renderer/backends/vulkan_helpers.h b/src/renderer/backends/vulkan_helpers.h
index db9b5a4..23666c6 100644
--- a/src/renderer/backends/vulkan_helpers.h
+++ b/src/renderer/backends/vulkan_helpers.h
@@ -20,12 +20,12 @@ static void plat_get_required_extension_names(cstr_darray* extensions) {
 }
 
 // TODO(omni): port to using internal assert functions
-#define VK_CHECK(vulkan_expr)              \
-  do {                                     \
-    VkResult res = vulkan_expr;            \
-    if (res != VK_SUCCESS) {               \
+#define VK_CHECK(vulkan_expr)                                          \
+  do {                                                                 \
+    VkResult res = vulkan_expr;                                        \
+    if (res != VK_SUCCESS) {                                           \
       ERROR_EXIT("Vulkan error: %u (%s:%d)", res, __FILE__, __LINE__); \
-    }                                      \
+    }                                                                  \
   } while (0)
 
 // TODO: typedef struct vk_debugger {} vk_debugger;
diff --git a/src/renderer/ral.c b/src/renderer/ral.c
new file mode 100644
index 0000000..25c2909
--- /dev/null
+++ b/src/renderer/ral.c
@@ -0,0 +1,22 @@
+#include "ral.h"
+
+/* typedef struct foo { */
+/*   u32 a; */
+/*   f32 b; */
+/*   char c; */
+/* } foo; */
+
+/* TYPED_POOL(gpu_buffer, buffer); */
+
+/* typedef struct buffer_handle { */
+/*   u32 raw; */
+/* } buffer_handle; */
+
+/* typedef struct gpu_buffer gpu_buffer; */
+TYPED_POOL(gpu_buffer, buffer);
+TYPED_POOL(gpu_texture, texture);
+
+struct resource_pools {
+  buffer_pool buffers;
+  texture_pool textures;
+};
diff --git a/src/renderer/ral.h b/src/renderer/ral.h
index ee65233..03bdeab 100644
--- a/src/renderer/ral.h
+++ b/src/renderer/ral.h
@@ -13,6 +13,7 @@
 
 #include "buf.h"
 #include "defines.h"
+#include "mem.h"
 #include "ral_types.h"
 #include "str.h"
 
@@ -40,6 +41,8 @@ typedef struct gpu_backend_pools {
   // pools for each gpu structure
 } gpu_backend_pools;
 
+typedef struct resource_pools resource_pools;
+
 typedef enum pipeline_kind {
   PIPELINE_GRAPHICS,
   PIPELINE_COMPUTE,
@@ -78,11 +81,6 @@ struct graphics_pipeline_desc {
 typedef struct gpu_renderpass_desc {
 } gpu_renderpass_desc;
 
-typedef struct resource_pools {
- // TODO: buffer pool
- // TODO: texture pool
-} resource_pools;
-
 // --- Lifecycle functions
 
 bool gpu_backend_init(const char* window_name, struct GLFWwindow* window);
@@ -163,4 +161,3 @@ void vertex_desc_add(vertex_description* builder, const char* name, vertex_attri
 // TEMP
 
 void gpu_temp_draw(size_t n_verts);
-
diff --git a/src/renderer/ral_types.h b/src/renderer/ral_types.h
index c802a9b..5d4e88a 100644
--- a/src/renderer/ral_types.h
+++ b/src/renderer/ral_types.h
@@ -16,15 +16,24 @@
 
 #define MAX_VERTEX_ATTRIBUTES 16
 
-#ifndef RENDERER_TYPED_HANDLES
+/* #ifndef RENDERER_TYPED_HANDLES */
 CORE_DEFINE_HANDLE(buffer_handle);
 CORE_DEFINE_HANDLE(texture_handle);
 CORE_DEFINE_HANDLE(sampler_handle);
 CORE_DEFINE_HANDLE(shader_handle);
 CORE_DEFINE_HANDLE(model_handle);
 #define ABSENT_MODEL_HANDLE 999999999
-#define RENDERER_TYPED_HANDLES
-#endif
+
+/* #define RENDERER_TYPED_HANDLES */
+/* #endif */
+
+/* typedef struct gpu_buffer { */
+/* u32 a; */
+/* } gpu_buffer; */
+
+/* #ifndef RAL_TYPED_POOLS */
+/* #define RAL_TYPED_POOLS */
+/* #endif */
 
 // gpu types
 typedef enum gpu_primitive_topology {
@@ -57,6 +66,9 @@ typedef struct texture_desc {
   u32x2 extents;
 } texture_desc;
 
+typedef struct gpu_texture {
+} gpu_texture;
+
 typedef enum gpu_buffer_type {
   CEL_BUFFER_DEFAULT,  // on Vulkan this would be a storage buffer?
   CEL_BUFFER_VERTEX,
@@ -157,11 +169,12 @@ typedef struct vertex_description {
 
 typedef enum shader_visibility {
   VISIBILITY_VERTEX = 1 << 0,
-  VISIBILITY_FRAGMENT = 1 << 1 ,
+  VISIBILITY_FRAGMENT = 1 << 1,
   VISIBILITY_COMPUTE = 1 << 2,
 } shader_visibility;
 
-/** @brief Describes the kind of binding a `shader_binding` is for. This changes how we create backing data for it. */
+/** @brief Describes the kind of binding a `shader_binding` is for. This changes how we create
+ * backing data for it. */
 typedef enum shader_binding_type {
   /**
    * @brief Binds a buffer to a shader
@@ -205,7 +218,7 @@ typedef struct shader_binding {
 
 #define MAX_LAYOUT_BINDINGS 8
 
-/** @brief A list of bindings that describe what data a shader / pipeline expects 
+/** @brief A list of bindings that describe what data a shader / pipeline expects
     @note This roughly correlates to a descriptor set layout in Vulkan
 */
 typedef struct shader_data_layout {
@@ -221,8 +234,9 @@ typedef struct shader_data {
 
 /*
   Usage:
-    1. When we create the pipeline, we must call a function that return a layout without .data fields
-    2. When binding 
+    1. When we create the pipeline, we must call a function that return a layout without .data
+  fields
+    2. When binding
 */
 
 typedef enum gpu_cull_mode { CULL_BACK_FACE, CULL_FRONT_FACE, CULL_COUNT } gpu_cull_mode;
diff --git a/src/renderer/render.h b/src/renderer/render.h
index c87e5f7..5657fc1 100644
--- a/src/renderer/render.h
+++ b/src/renderer/render.h
@@ -26,8 +26,8 @@ typedef struct camera camera;
 void gfx_backend_draw_frame(renderer* ren, camera* camera, mat4 model, texture* tex);
 
 typedef struct render_ctx {
-    mat4 view;
-    mat4 projection;
+  mat4 view;
+  mat4 projection;
 } render_ctx;
 
 // frontend -- these can be called from say a loop in an example, or via FFI
@@ -47,15 +47,15 @@ void shader_hot_reload(const char* filepath);
 
 /**
  * @brief Creates buffers and returns a struct that holds handles to our resources
- * 
- * @param geometry 
- * @param free_on_upload frees the CPU-side vertex/index data stored in geometry_data when we successfully upload
-                         that data to the GPU-side buffer
- * @return mesh 
+ *
+ * @param geometry
+ * @param free_on_upload frees the CPU-side vertex/index data stored in geometry_data when we
+ successfully upload that data to the GPU-side buffer
+ * @return mesh
  */
 mesh mesh_create(geometry_data* geometry, bool free_on_upload);
 
-void draw_mesh(mesh* mesh, mat4* model);//, mat4* view, mat4* proj); // TODO: material
+void draw_mesh(mesh* mesh, mat4* model);  //, mat4* view, mat4* proj); // TODO: material
 
 model_handle model_load(const char* debug_name, const char* filepath);
 
diff --git a/src/std/mem.c b/src/std/mem.c
index 7d768c9..a5321fb 100644
--- a/src/std/mem.c
+++ b/src/std/mem.c
@@ -1,8 +1,10 @@
-#include "mem.h"
+#include <assert.h>
 #include <stddef.h>
 #include <stdint.h>
 #include <string.h>
+
 #include "log.h"
+#include "mem.h"
 
 #ifndef DEFAULT_ALIGNMENT
 #define DEFAULT_ALIGNMENT (2 * sizeof(void*))
@@ -58,3 +60,66 @@ void_pool void_pool_create(arena* a, u64 capacity, u64 entry_size) {
 
   return pool;
 }
+
+void void_pool_free_all(void_pool* pool) {
+  // set all entries to be free
+  for (u64 i = 0; i < pool->capacity; i++) {
+    void* ptr = &pool->backing_buffer[i * pool->entry_size];
+    void_pool_header* free_node =
+        (void_pool_header*)ptr;  // we reuse the actual entry itself to hold the header
+    if (i == (pool->capacity - 1)) {
+      // if the last one we make its next pointer NULL indicating its full
+      free_node->next = NULL;
+    }
+    free_node->next = pool->free_list_head;
+    // now the head points to this entry
+    pool->free_list_head = free_node;
+  }
+}
+
+void* void_pool_get(void_pool* pool, u32 raw_handle) {
+  // An handle is an index into the array essentially
+  void* ptr = pool->backing_buffer + (raw_handle * pool->entry_size);
+  return ptr;
+}
+
+void* void_pool_alloc(void_pool* pool, u32* out_raw_handle) {
+  // get the next free node
+  if (pool->count == pool->capacity) {
+    WARN("Pool is full!");
+    return NULL;
+  }
+  if (pool->free_list_head == NULL) {
+    ERROR("Pool is full (head = null)");
+    return NULL;
+  }
+  void_pool_header* free_node = pool->free_list_head;
+
+  // What index does this become?
+  uintptr_t start = (uintptr_t)pool->backing_buffer;
+  uintptr_t cur = (uintptr_t)free_node;
+  TRACE("%ld %ld ", start, cur);
+  /* assert(cur > start); */
+  u32 index = (u32)((cur - start) / pool->entry_size);
+  printf("Index %d\n", index);
+  if (out_raw_handle != NULL) {
+    *out_raw_handle = index;
+  }
+
+  pool->free_list_head = free_node->next;
+
+  memset(free_node, 0, pool->entry_size);
+  pool->count++;
+  return (void*)free_node;
+}
+
+void void_pool_dealloc(void_pool* pool, u32 raw_handle) {
+  // push free node back onto the free list
+  void* ptr = void_pool_get(pool, raw_handle);
+  void_pool_header* freed_node = (void_pool_header*)ptr;
+
+  freed_node->next = pool->free_list_head;
+  pool->free_list_head = freed_node;
+
+  pool->count--;
+}
diff --git a/src/std/mem.h b/src/std/mem.h
index eef97a0..26da778 100644
--- a/src/std/mem.h
+++ b/src/std/mem.h
@@ -54,6 +54,28 @@ void_pool void_pool_create(arena* a, u64 capacity, u64 entry_size);
 void void_pool_free_all(void_pool* pool);
 bool void_pool_is_empty(void_pool* pool);
 bool void_pool_is_full(void_pool* pool);
-void* void_pool_get(u32 raw_handle);
+void* void_pool_get(void_pool* pool, u32 raw_handle);
+void* void_pool_alloc(void_pool* pool, u32* out_raw_handle);
+void void_pool_dealloc(void_pool* pool, u32 raw_handle);
 
 // TODO: macro that lets us specialise
+
+/* typedef struct Name##_handle Name##_handle;      \ */
+#define TYPED_POOL(T, Name)                                                          \
+  typedef struct Name##_pool {                                                       \
+    void_pool inner;                                                                 \
+  } Name##_pool;                                                                     \
+                                                                                     \
+  static Name##_pool Name##_pool_create(arena* a, u64 cap, u64 entry_size) {         \
+    void_pool p = void_pool_create(a, cap, entry_size);                              \
+    return (Name##_pool){ .inner = p };                                              \
+  }                                                                                  \
+  static inline T* Name##_pool_get(Name##_pool* pool, Name##_handle handle) {        \
+    return (T*)void_pool_get(&pool->inner, handle.raw);                              \
+  }                                                                                  \
+  static inline T* Name##_pool_alloc(Name##_pool* pool, Name##_handle* out_handle) { \
+    return (T*)void_pool_alloc(&pool->inner, &out_handle->raw);                      \
+  }                                                                                  \
+  static inline void Name##_pool_dealloc(Name##_pool* pool, Name##_handle handle) {  \
+    void_pool_dealloc(&pool->inner, handle.raw);                                     \
+  }\
diff --git a/tests/pool_test_runner.c b/tests/pool_test_runner.c
new file mode 100644
index 0000000..a6eff69
--- /dev/null
+++ b/tests/pool_test_runner.c
@@ -0,0 +1,12 @@
+#include "unity.h"
+#include "unity_fixture.h"
+
+TEST_GROUP_RUNNER(Pool) {
+  // TODO: test cases
+  RUN_TEST_CASE(Pool, Initialisation);
+  RUN_TEST_CASE(Pool, TypedPool);
+}
+
+static void RunAllTests(void) { RUN_TEST_GROUP(Pool); }
+
+int main(int argc, const char* argv[]) { return UnityMain(argc, argv, RunAllTests); }
diff --git a/tests/pool_tests.c b/tests/pool_tests.c
new file mode 100644
index 0000000..df65773
--- /dev/null
+++ b/tests/pool_tests.c
@@ -0,0 +1,72 @@
+#include <stdbool.h>
+#include <stdlib.h>
+#include "defines.h"
+#include "unity.h"
+#include "unity_fixture.h"
+
+#include "mem.h"
+
+#define ARENA_SIZE (1024 * 1024)
+
+static arena a;
+
+TEST_GROUP(Pool);
+
+TEST_SETUP(Pool) { a = arena_create(malloc(ARENA_SIZE), ARENA_SIZE); }
+
+TEST_TEAR_DOWN(Pool) { arena_free_all(&a); }
+
+TEST(Pool, SanityCheckTest) { TEST_ASSERT_EQUAL(true, true); }
+
+TEST(Pool, Initialisation) {
+  // u32 pool
+  void_pool pool = void_pool_create(&a, 256, sizeof(u32));
+  u32 x_handle;
+  u32* x_ptr = (u32*)void_pool_alloc(&pool, &x_handle);
+  // store something in it
+  *x_ptr = 1024;
+  u32* x = void_pool_get(&pool, x_handle);
+
+  TEST_ASSERT_EQUAL_UINT32(1024, *x);
+  /* TEST_ASSERT_EQUAL_MEMORY(&expected, &actual, sizeof(vec3)); */
+}
+
+typedef struct foo {
+  u32 a;
+  f32 b;
+  char c;
+} foo;
+
+CORE_DEFINE_HANDLE(bar);
+typedef struct bar_handle {
+  u32 raw;
+} bar_handle;
+TYPED_POOL(foo, bar);
+
+TEST(Pool, TypedPool) {
+  printf("Typed pool test\n");
+  // create pool
+  bar_pool pool = bar_pool_create(&a, 2, sizeof(foo));
+
+  bar_handle first_handle, second_handle, third_handle;
+  foo* first = bar_pool_alloc(&pool, &first_handle);
+  foo* second = bar_pool_alloc(&pool, &second_handle);
+  // Third one shouldnt work
+  foo* third = bar_pool_alloc(&pool, &third_handle);
+  TEST_ASSERT_NULL(third);
+
+  first->a = 32;
+  first->b = 2.0;
+  first->c = 'X';
+
+  foo* my_foo = bar_pool_get(&pool, first_handle);
+  TEST_ASSERT_EQUAL_UINT32(32, my_foo->a);
+  TEST_ASSERT_EQUAL(2.0, my_foo->b);
+  TEST_ASSERT_EQUAL_CHAR('X', my_foo->c);
+
+  bar_pool_dealloc(&pool, first_handle);
+
+  // next alloc should succeed
+  third = bar_pool_alloc(&pool, &third_handle);
+  TEST_ASSERT_NOT_NULL(third);
+}
diff --git a/xmake.lua b/xmake.lua
index 1d576c7..9b06db0 100644
--- a/xmake.lua
+++ b/xmake.lua
@@ -68,6 +68,12 @@ local core_sources = {
     "src/systems/*.c",
 }
 
+local unity_sources = {
+    "deps/Unity/src/unity.c",
+    "deps/Unity/extras/fixture/src/unity_fixture.c",
+    "deps/Unity/extras/memory/src/unity_memory.c",
+}
+
 rule("compile_glsl_vert_shaders")
     set_extensions(".vert")
     on_buildcmd_file(function (target, batchcmds, sourcefile, opt) 
@@ -229,3 +235,14 @@ target("cube")
 --     add_deps("core_static")
 --     add_files("examples/demo/demo.c")
 --     set_rundir("$(projectdir)")
+
+target("pool_tests")
+    set_kind("binary")
+    set_group("tests")
+    add_deps("core_static")
+    add_files(unity_sources)
+    add_includedirs("deps/Unity/src", {public = true})
+    add_includedirs("deps/Unity/extras/fixture/src", {public = true})
+    add_includedirs("deps/Unity/extras/memory/src", {public = true})
+    add_files("tests/pool_tests.c")
+    add_files("tests/pool_test_runner.c")
-- 
cgit v1.2.3-70-g09d2