Add a vulkan renderer that renders an OBJ

1 files changed, 0 insertions, 1470 deletions

diff --git a/src/renderer.c b/src/renderer.c
deleted file mode 100644
index 7022af6..0000000
--- a/src/renderer.c
+++ /dev/null
@@ -1,1470 +0,0 @@
-#include "log.h"
-#include "renderer.h"
-#include "src/platform.h"
-#include "vulkan/vulkan_core.h"
-#include <assert.h>
-
-static const char *VALIDATION_LAYERS[] = {"VK_LAYER_KHRONOS_validation"};
-static constexpr int VALIDATION_LAYER_COUNT =
-    sizeof(VALIDATION_LAYERS) / sizeof(VALIDATION_LAYERS[0]);
-
-#ifdef VGLTF_DEBUG
-static constexpr bool enable_validation_layers = true;
-#else
-static constexpr bool enable_validation_layers = false;
-#endif
-
-static VKAPI_ATTR VkBool32 VKAPI_CALL
-debug_callback(VkDebugUtilsMessageSeverityFlagBitsEXT message_severity,
-               VkDebugUtilsMessageTypeFlagBitsEXT message_type,
-               const VkDebugUtilsMessengerCallbackDataEXT *callback_data,
-               void *user_data) {
-  (void)message_severity;
-  (void)message_type;
-  (void)user_data;
-  VGLTF_LOG_DBG("validation layer: %s", callback_data->pMessage);
-  return VK_FALSE;
-}
-
-static constexpr int REQUIRED_INSTANCE_EXTENSIONS_ARRAY_CAPACITY = 10;
-struct required_instance_extensions {
-  const char *extensions[REQUIRED_INSTANCE_EXTENSIONS_ARRAY_CAPACITY];
-  uint32_t count;
-};
-void required_instance_extensions_push(
-    struct required_instance_extensions *required_instance_extensions,
-    const char *required_instance_extension) {
-  if (required_instance_extensions->count ==
-      REQUIRED_INSTANCE_EXTENSIONS_ARRAY_CAPACITY) {
-    VGLTF_PANIC("required instance extensions array is full");
-  }
-  required_instance_extensions
-      ->extensions[required_instance_extensions->count++] =
-      required_instance_extension;
-}
-
-static constexpr int SUPPORTED_INSTANCE_EXTENSIONS_ARRAY_CAPACITY = 128;
-struct supported_instance_extensions {
-  VkExtensionProperties
-      properties[SUPPORTED_INSTANCE_EXTENSIONS_ARRAY_CAPACITY];
-  uint32_t count;
-};
-bool supported_instance_extensions_init(
-    struct supported_instance_extensions *supported_instance_extensions) {
-  if (vkEnumerateInstanceExtensionProperties(
-          nullptr, &supported_instance_extensions->count, nullptr) !=
-      VK_SUCCESS) {
-    goto err;
-  }
-
-  if (supported_instance_extensions->count >
-      SUPPORTED_INSTANCE_EXTENSIONS_ARRAY_CAPACITY) {
-    VGLTF_LOG_ERR("supported instance extensions array cannot fit all the "
-                  "VkExtensionProperties");
-    goto err;
-  }
-
-  if (vkEnumerateInstanceExtensionProperties(
-          nullptr, &supported_instance_extensions->count,
-          supported_instance_extensions->properties) != VK_SUCCESS) {
-    goto err;
-  }
-  return true;
-err:
-  return false;
-}
-void supported_instance_extensions_debug_print(
-    const struct supported_instance_extensions *supported_instance_extensions) {
-  VGLTF_LOG_DBG("Supported instance extensions:");
-  for (uint32_t i = 0; i < supported_instance_extensions->count; i++) {
-    VGLTF_LOG_DBG("\t- %s",
-                  supported_instance_extensions->properties[i].extensionName);
-  }
-}
-bool supported_instance_extensions_includes(
-    const struct supported_instance_extensions *supported_instance_extensions,
-    const char *extension_name) {
-  for (uint32_t supported_instance_extension_index = 0;
-       supported_instance_extension_index <
-       supported_instance_extensions->count;
-       supported_instance_extension_index++) {
-    const VkExtensionProperties *extension_properties =
-        &supported_instance_extensions
-             ->properties[supported_instance_extension_index];
-    if (strcmp(extension_properties->extensionName, extension_name) == 0) {
-      return true;
-    }
-  }
-
-  return false;
-}
-
-static constexpr uint32_t SUPPORTED_VALIDATION_LAYERS_ARRAY_CAPACITY = 64;
-struct supported_validation_layers {
-  VkLayerProperties properties[SUPPORTED_VALIDATION_LAYERS_ARRAY_CAPACITY];
-  uint32_t count;
-};
-bool supported_validation_layers_init(
-    struct supported_validation_layers *supported_validation_layers) {
-  if (vkEnumerateInstanceLayerProperties(&supported_validation_layers->count,
-                                         nullptr) != VK_SUCCESS) {
-    goto err;
-  }
-
-  if (supported_validation_layers->count >
-      SUPPORTED_VALIDATION_LAYERS_ARRAY_CAPACITY) {
-    VGLTF_LOG_ERR("supported validation layers array cannot fit all the "
-                  "VkLayerProperties");
-    goto err;
-  }
-
-  if (vkEnumerateInstanceLayerProperties(
-          &supported_validation_layers->count,
-          supported_validation_layers->properties) != VK_SUCCESS) {
-    goto err;
-  }
-
-  return true;
-err:
-  return false;
-}
-
-static bool are_validation_layer_supported() {
-  struct supported_validation_layers supported_layers = {};
-  if (!supported_validation_layers_init(&supported_layers)) {
-    goto err;
-  }
-
-  for (int requested_layer_index = 0;
-       requested_layer_index < VALIDATION_LAYER_COUNT;
-       requested_layer_index++) {
-    const char *requested_layer_name = VALIDATION_LAYERS[requested_layer_index];
-    bool requested_layer_found = false;
-    for (uint32_t supported_layer_index = 0;
-         supported_layer_index < supported_layers.count;
-         supported_layer_index++) {
-      VkLayerProperties *supported_layer =
-          &supported_layers.properties[supported_layer_index];
-      if (strcmp(requested_layer_name, supported_layer->layerName) == 0) {
-        requested_layer_found = true;
-        break;
-      }
-    }
-
-    if (!requested_layer_found) {
-      goto err;
-    }
-  }
-
-  return true;
-err:
-  return false;
-}
-
-static bool fetch_required_instance_extensions(
-    struct required_instance_extensions *required_extensions,
-    struct vgltf_platform *platform) {
-  struct supported_instance_extensions supported_extensions = {};
-  if (!supported_instance_extensions_init(&supported_extensions)) {
-    VGLTF_LOG_ERR(
-        "Couldn't fetch supported instance extensions details (OOM?)");
-    goto err;
-  }
-  supported_instance_extensions_debug_print(&supported_extensions);
-
-  uint32_t platform_required_extension_count = 0;
-  const char *const *platform_required_extensions =
-      vgltf_platform_get_vulkan_instance_extensions(
-          platform, &platform_required_extension_count);
-  for (uint32_t platform_required_extension_index = 0;
-       platform_required_extension_index < platform_required_extension_count;
-       platform_required_extension_index++) {
-    required_instance_extensions_push(
-        required_extensions,
-        platform_required_extensions[platform_required_extension_index]);
-  }
-  required_instance_extensions_push(
-      required_extensions, VK_KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME);
-
-  if (enable_validation_layers) {
-    required_instance_extensions_push(required_extensions,
-                                      VK_EXT_DEBUG_UTILS_EXTENSION_NAME);
-  }
-
-  bool all_extensions_supported = true;
-  for (uint32_t required_extension_index = 0;
-       required_extension_index < required_extensions->count;
-       required_extension_index++) {
-    const char *required_extension_name =
-        required_extensions->extensions[required_extension_index];
-    if (!supported_instance_extensions_includes(&supported_extensions,
-                                                required_extension_name)) {
-      VGLTF_LOG_ERR("Unsupported instance extension: %s",
-                    required_extension_name);
-      all_extensions_supported = false;
-    }
-  }
-
-  if (!all_extensions_supported) {
-    VGLTF_LOG_ERR("Some required extensions are unsupported.");
-    goto err;
-  }
-
-  return true;
-err:
-  return false;
-}
-
-static void populate_debug_messenger_create_info(
-    VkDebugUtilsMessengerCreateInfoEXT *create_info) {
-  *create_info = (VkDebugUtilsMessengerCreateInfoEXT){};
-  create_info->sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT;
-  create_info->messageSeverity =
-      VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT |
-      VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT |
-      VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT;
-  create_info->messageType = VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT |
-                             VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT |
-                             VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT;
-  create_info->pfnUserCallback = debug_callback;
-}
-
-static bool vgltf_renderer_create_instance(struct vgltf_renderer *renderer,
-                                           struct vgltf_platform *platform) {
-  VGLTF_LOG_INFO("Creating vulkan instance...");
-  if (enable_validation_layers && !are_validation_layer_supported()) {
-    VGLTF_LOG_ERR("Requested validation layers aren't supported");
-    goto err;
-  }
-
-  VkApplicationInfo application_info = {
-      .sType = VK_STRUCTURE_TYPE_APPLICATION_INFO,
-      .pApplicationName = "Visible GLTF",
-      .applicationVersion = VK_MAKE_VERSION(0, 1, 0),
-      .pEngineName = "No Engine",
-      .engineVersion = VK_MAKE_VERSION(1, 0, 0),
-      .apiVersion = VK_API_VERSION_1_2};
-
-  struct required_instance_extensions required_extensions = {};
-  fetch_required_instance_extensions(&required_extensions, platform);
-
-  VkInstanceCreateInfo create_info = {
-      .sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO,
-      .pApplicationInfo = &application_info,
-      .enabledExtensionCount = required_extensions.count,
-      .ppEnabledExtensionNames = required_extensions.extensions,
-      .flags = VK_INSTANCE_CREATE_ENUMERATE_PORTABILITY_BIT_KHR};
-
-  VkDebugUtilsMessengerCreateInfoEXT debug_create_info;
-  if (enable_validation_layers) {
-    create_info.enabledLayerCount = VALIDATION_LAYER_COUNT;
-    create_info.ppEnabledLayerNames = VALIDATION_LAYERS;
-    populate_debug_messenger_create_info(&debug_create_info);
-    create_info.pNext = &debug_create_info;
-  }
-
-  if (vkCreateInstance(&create_info, nullptr, &renderer->instance) !=
-      VK_SUCCESS) {
-    VGLTF_LOG_ERR("Failed to create VkInstance");
-    goto err;
-  }
-
-  return true;
-err:
-  return false;
-}
-
-static VkResult create_debug_utils_messenger_ext(
-    VkInstance instance, const VkDebugUtilsMessengerCreateInfoEXT *create_info,
-    const VkAllocationCallbacks *allocator,
-    VkDebugUtilsMessengerEXT *debug_messenger) {
-  auto func = (PFN_vkCreateDebugUtilsMessengerEXT)vkGetInstanceProcAddr(
-      instance, "vkCreateDebugUtilsMessengerEXT");
-  if (func != nullptr) {
-    return func(instance, create_info, allocator, debug_messenger);
-  }
-
-  return VK_ERROR_EXTENSION_NOT_PRESENT;
-}
-
-static void
-destroy_debug_utils_messenger_ext(VkInstance instance,
-                                  VkDebugUtilsMessengerEXT debug_messenger,
-                                  const VkAllocationCallbacks *allocator) {
-  auto func = (PFN_vkDestroyDebugUtilsMessengerEXT)vkGetInstanceProcAddr(
-      instance, "vkDestroyDebugUtilsMessengerEXT");
-  if (func != nullptr) {
-    func(instance, debug_messenger, allocator);
-  }
-}
-
-static void
-vgltf_renderer_setup_debug_messenger(struct vgltf_renderer *renderer) {
-  if (!enable_validation_layers)
-    return;
-  VkDebugUtilsMessengerCreateInfoEXT create_info;
-  populate_debug_messenger_create_info(&create_info);
-  create_debug_utils_messenger_ext(renderer->instance, &create_info, nullptr,
-                                   &renderer->debug_messenger);
-}
-
-static constexpr int AVAILABLE_PHYSICAL_DEVICE_ARRAY_CAPACITY = 128;
-struct available_physical_devices {
-  VkPhysicalDevice devices[AVAILABLE_PHYSICAL_DEVICE_ARRAY_CAPACITY];
-  uint32_t count;
-};
-static bool
-available_physical_devices_init(VkInstance instance,
-                                struct available_physical_devices *devices) {
-
-  if (vkEnumeratePhysicalDevices(instance, &devices->count, nullptr) !=
-      VK_SUCCESS) {
-    VGLTF_LOG_ERR("Couldn't enumerate physical devices");
-    goto err;
-  }
-
-  if (devices->count == 0) {
-    VGLTF_LOG_ERR("Failed to find any GPU with Vulkan support");
-    goto err;
-  }
-
-  if (devices->count > AVAILABLE_PHYSICAL_DEVICE_ARRAY_CAPACITY) {
-    VGLTF_LOG_ERR("available physical devices array cannot fit all available "
-                  "physical devices");
-    goto err;
-  }
-
-  if (vkEnumeratePhysicalDevices(instance, &devices->count, devices->devices) !=
-      VK_SUCCESS) {
-    VGLTF_LOG_ERR("Couldn't enumerate physical devices");
-    goto err;
-  }
-
-  return true;
-err:
-  return false;
-}
-
-struct queue_family_indices {
-  uint32_t graphics_family;
-  uint32_t present_family;
-  bool has_graphics_family;
-  bool has_present_family;
-};
-bool queue_family_indices_is_complete(
-    const struct queue_family_indices *indices) {
-  return indices->has_graphics_family && indices->has_present_family;
-}
-bool queue_family_indices_for_device(struct queue_family_indices *indices,
-                                     VkPhysicalDevice device,
-                                     VkSurfaceKHR surface) {
-  static constexpr uint32_t QUEUE_FAMILY_PROPERTIES_ARRAY_CAPACITY = 64;
-  uint32_t queue_family_count = 0;
-  vkGetPhysicalDeviceQueueFamilyProperties(device, &queue_family_count,
-                                           nullptr);
-
-  if (queue_family_count > QUEUE_FAMILY_PROPERTIES_ARRAY_CAPACITY) {
-    VGLTF_LOG_ERR(
-        "Queue family properties array cannot fit all queue family properties");
-    goto err;
-  }
-
-  VkQueueFamilyProperties
-      queue_family_properties[QUEUE_FAMILY_PROPERTIES_ARRAY_CAPACITY] = {};
-  vkGetPhysicalDeviceQueueFamilyProperties(device, &queue_family_count,
-                                           queue_family_properties);
-
-  for (uint32_t queue_family_index = 0; queue_family_index < queue_family_count;
-       queue_family_index++) {
-    VkQueueFamilyProperties *queue_family =
-        &queue_family_properties[queue_family_index];
-
-    VkBool32 present_support;
-    vkGetPhysicalDeviceSurfaceSupportKHR(device, queue_family_index, surface,
-                                         &present_support);
-
-    if (queue_family->queueFlags & VK_QUEUE_GRAPHICS_BIT) {
-      indices->graphics_family = queue_family_index;
-      indices->has_graphics_family = true;
-    }
-
-    if (present_support) {
-      indices->present_family = queue_family_index;
-      indices->has_present_family = true;
-    }
-
-    if (queue_family_indices_is_complete(indices)) {
-      break;
-    }
-  }
-
-  return true;
-err:
-  return false;
-}
-
-static bool is_in_array(uint32_t *array, int length, uint32_t value) {
-  for (int i = 0; i < length; i++) {
-    if (array[i] == value) {
-      return true;
-    }
-  }
-
-  return false;
-}
-
-static constexpr uint32_t SUPPORTED_EXTENSIONS_ARRAY_CAPACITY = 128;
-struct supported_extensions {
-  VkExtensionProperties properties[SUPPORTED_EXTENSIONS_ARRAY_CAPACITY];
-  uint32_t count;
-};
-bool supported_extensions_init(
-    struct supported_extensions *supported_extensions,
-    VkPhysicalDevice device) {
-  if (vkEnumerateDeviceExtensionProperties(device, nullptr,
-                                           &supported_extensions->count,
-                                           nullptr) != VK_SUCCESS) {
-    goto err;
-  }
-
-  if (supported_extensions->count > SUPPORTED_EXTENSIONS_ARRAY_CAPACITY) {
-    VGLTF_LOG_ERR(
-        "supported extensions aarray cannot fit all the VkExtensionProperties");
-    goto err;
-  }
-
-  if (vkEnumerateDeviceExtensionProperties(
-          device, nullptr, &supported_extensions->count,
-          supported_extensions->properties) != VK_SUCCESS) {
-    goto err;
-  }
-
-  return true;
-err:
-  return false;
-}
-
-static bool supported_extensions_includes_extension(
-    struct supported_extensions *supported_extensions,
-    const char *extension_name) {
-  for (uint32_t supported_extension_index = 0;
-       supported_extension_index < supported_extensions->count;
-       supported_extension_index++) {
-    if (strcmp(supported_extensions->properties[supported_extension_index]
-                   .extensionName,
-               extension_name) == 0) {
-      return true;
-    }
-  }
-  return false;
-}
-
-static const char *DEVICE_EXTENSIONS[] = {VK_KHR_SWAPCHAIN_EXTENSION_NAME,
-                                          "VK_KHR_portability_subset"};
-static constexpr int DEVICE_EXTENSION_COUNT =
-    sizeof(DEVICE_EXTENSIONS) / sizeof(DEVICE_EXTENSIONS[0]);
-static bool are_device_extensions_supported(VkPhysicalDevice device) {
-  struct supported_extensions supported_extensions = {};
-  if (!supported_extensions_init(&supported_extensions, device)) {
-    goto err;
-  }
-
-  for (uint32_t required_extension_index = 0;
-       required_extension_index < DEVICE_EXTENSION_COUNT;
-       required_extension_index++) {
-    if (!supported_extensions_includes_extension(
-            &supported_extensions,
-            DEVICE_EXTENSIONS[required_extension_index])) {
-      VGLTF_LOG_DBG("Unsupported: %s",
-                    DEVICE_EXTENSIONS[required_extension_index]);
-      goto err;
-    }
-  }
-
-  return true;
-
-err:
-  return false;
-}
-
-static constexpr int SWAPCHAIN_SUPPORT_DETAILS_MAX_SURFACE_FORMAT_COUNT = 256;
-static constexpr int SWAPCHAIN_SUPPORT_DETAILS_MAX_PRESENT_MODE_COUNT = 256;
-struct swapchain_support_details {
-  VkSurfaceCapabilitiesKHR capabilities;
-  VkSurfaceFormatKHR
-      formats[SWAPCHAIN_SUPPORT_DETAILS_MAX_SURFACE_FORMAT_COUNT];
-  VkPresentModeKHR
-      present_modes[SWAPCHAIN_SUPPORT_DETAILS_MAX_PRESENT_MODE_COUNT];
-  uint32_t format_count;
-  uint32_t present_mode_count;
-};
-bool swapchain_support_details_query_from_device(
-    struct swapchain_support_details *swapchain_support_details,
-    VkPhysicalDevice device, VkSurfaceKHR surface) {
-  if (vkGetPhysicalDeviceSurfaceCapabilitiesKHR(
-          device, surface, &swapchain_support_details->capabilities) !=
-      VK_SUCCESS) {
-    goto err;
-  }
-
-  if (vkGetPhysicalDeviceSurfaceFormatsKHR(
-          device, surface, &swapchain_support_details->format_count, nullptr) !=
-      VK_SUCCESS) {
-    goto err;
-  }
-
-  if (swapchain_support_details->format_count != 0 &&
-      swapchain_support_details->format_count <
-          SWAPCHAIN_SUPPORT_DETAILS_MAX_SURFACE_FORMAT_COUNT) {
-    if (vkGetPhysicalDeviceSurfaceFormatsKHR(
-            device, surface, &swapchain_support_details->format_count,
-            swapchain_support_details->formats) != VK_SUCCESS) {
-      goto err;
-    }
-  }
-
-  if (vkGetPhysicalDeviceSurfacePresentModesKHR(
-          device, surface, &swapchain_support_details->present_mode_count,
-          nullptr) != VK_SUCCESS) {
-    goto err;
-  }
-
-  if (swapchain_support_details->present_mode_count != 0 &&
-      swapchain_support_details->present_mode_count <
-          SWAPCHAIN_SUPPORT_DETAILS_MAX_PRESENT_MODE_COUNT) {
-    if (vkGetPhysicalDeviceSurfacePresentModesKHR(
-            device, surface, &swapchain_support_details->present_mode_count,
-            swapchain_support_details->present_modes) != VK_SUCCESS) {
-      goto err;
-    }
-  }
-
-  return true;
-err:
-  return false;
-}
-
-static bool is_physical_device_suitable(VkPhysicalDevice device,
-                                        VkSurfaceKHR surface) {
-  struct queue_family_indices indices = {};
-  queue_family_indices_for_device(&indices, device, surface);
-
-  VGLTF_LOG_DBG("Checking for physical device extension support");
-  bool extensions_supported = are_device_extensions_supported(device);
-  VGLTF_LOG_DBG("Supported: %d", extensions_supported);
-
-  bool swapchain_adequate = false;
-  if (extensions_supported) {
-
-    VGLTF_LOG_DBG("Checking for swapchain support details");
-    struct swapchain_support_details swapchain_support_details = {};
-    if (!swapchain_support_details_query_from_device(&swapchain_support_details,
-                                                     device, surface)) {
-      VGLTF_LOG_ERR("Couldn't query swapchain support details from device");
-      goto err;
-    }
-
-    swapchain_adequate = swapchain_support_details.format_count > 0 &&
-                         swapchain_support_details.present_mode_count > 0;
-  }
-
-  return queue_family_indices_is_complete(&indices) && extensions_supported &&
-         swapchain_adequate;
-err:
-  return false;
-}
-
-static bool
-vgltf_renderer_pick_physical_device(struct vgltf_renderer *renderer) {
-  VkPhysicalDevice physical_device = VK_NULL_HANDLE;
-
-  struct available_physical_devices available_physical_devices = {};
-  if (!available_physical_devices_init(renderer->instance,
-                                       &available_physical_devices)) {
-    VGLTF_LOG_ERR("Couldn't fetch available physical devices");
-    goto err;
-  }
-
-  for (uint32_t available_physical_device_index = 0;
-       available_physical_device_index < available_physical_devices.count;
-       available_physical_device_index++) {
-    VkPhysicalDevice available_physical_device =
-        available_physical_devices.devices[available_physical_device_index];
-    if (is_physical_device_suitable(available_physical_device,
-                                    renderer->surface)) {
-      physical_device = available_physical_device;
-      break;
-    }
-  }
-
-  if (physical_device == VK_NULL_HANDLE) {
-    VGLTF_LOG_ERR("Failed to find a suitable GPU");
-    goto err;
-  }
-
-  renderer->physical_device = physical_device;
-
-  return true;
-err:
-  return false;
-}
-
-static bool
-vgltf_renderer_create_logical_device(struct vgltf_renderer *renderer) {
-  struct queue_family_indices queue_family_indices = {};
-  queue_family_indices_for_device(&queue_family_indices,
-                                  renderer->physical_device, renderer->surface);
-  static constexpr int MAX_QUEUE_FAMILY_COUNT = 2;
-
-  uint32_t unique_queue_families[MAX_QUEUE_FAMILY_COUNT] = {};
-  int unique_queue_family_count = 0;
-
-  if (!is_in_array(unique_queue_families, unique_queue_family_count,
-                   queue_family_indices.graphics_family)) {
-    assert(unique_queue_family_count < MAX_QUEUE_FAMILY_COUNT);
-    unique_queue_families[unique_queue_family_count++] =
-        queue_family_indices.graphics_family;
-  }
-  if (!is_in_array(unique_queue_families, unique_queue_family_count,
-                   queue_family_indices.present_family)) {
-    assert(unique_queue_family_count < MAX_QUEUE_FAMILY_COUNT);
-    unique_queue_families[unique_queue_family_count++] =
-        queue_family_indices.present_family;
-  }
-
-  float queue_priority = 1.f;
-  VkDeviceQueueCreateInfo queue_create_infos[MAX_QUEUE_FAMILY_COUNT] = {};
-  int queue_create_info_count = 0;
-  for (int unique_queue_family_index = 0;
-       unique_queue_family_index < unique_queue_family_count;
-       unique_queue_family_index++) {
-    queue_create_infos[queue_create_info_count++] = (VkDeviceQueueCreateInfo){
-        .sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO,
-        .queueFamilyIndex = unique_queue_families[unique_queue_family_index],
-        .queueCount = 1,
-        .pQueuePriorities = &queue_priority};
-  }
-
-  VkPhysicalDeviceFeatures device_features = {};
-  VkDeviceCreateInfo create_info = {
-      .sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO,
-      .pQueueCreateInfos = queue_create_infos,
-      .queueCreateInfoCount = queue_create_info_count,
-      .pEnabledFeatures = &device_features,
-      .ppEnabledExtensionNames = DEVICE_EXTENSIONS,
-      .enabledExtensionCount = DEVICE_EXTENSION_COUNT};
-  if (vkCreateDevice(renderer->physical_device, &create_info, nullptr,
-                     &renderer->device) != VK_SUCCESS) {
-    VGLTF_LOG_ERR("Failed to create logical device");
-    goto err;
-  }
-
-  vkGetDeviceQueue(renderer->device, queue_family_indices.graphics_family, 0,
-                   &renderer->graphics_queue);
-  vkGetDeviceQueue(renderer->device, queue_family_indices.present_family, 0,
-                   &renderer->present_queue);
-
-  return true;
-err:
-  return false;
-}
-
-static bool vgltf_renderer_create_surface(struct vgltf_renderer *renderer,
-                                          struct vgltf_platform *platform) {
-  if (!vgltf_platform_create_vulkan_surface(platform, renderer->instance,
-                                            &renderer->surface)) {
-    VGLTF_LOG_ERR("Couldn't create surface");
-    goto err;
-  }
-
-  return true;
-err:
-  return false;
-}
-
-static VkSurfaceFormatKHR
-choose_swapchain_surface_format(VkSurfaceFormatKHR *available_formats,
-                                uint32_t available_format_count) {
-  for (uint32_t available_format_index = 0;
-       available_format_index < available_format_count;
-       available_format_index++) {
-    VkSurfaceFormatKHR *available_format =
-        &available_formats[available_format_index];
-    if (available_format->format == VK_FORMAT_B8G8R8A8_SRGB &&
-        available_format->colorSpace == VK_COLOR_SPACE_SRGB_NONLINEAR_KHR) {
-      return *available_format;
-    }
-  }
-
-  return available_formats[0];
-}
-
-static VkPresentModeKHR
-choose_swapchain_present_mode(VkPresentModeKHR *available_modes,
-                              uint32_t available_mode_count) {
-  for (uint32_t available_mode_index = 0;
-       available_mode_index < available_mode_count; available_mode_index++) {
-    VkPresentModeKHR available_mode = available_modes[available_mode_index];
-    if (available_mode == VK_PRESENT_MODE_MAILBOX_KHR) {
-      return available_mode;
-    }
-  }
-
-  return VK_PRESENT_MODE_FIFO_KHR;
-}
-
-static uint32_t clamp_uint32(uint32_t min, uint32_t max, uint32_t value) {
-  return value < min ? min : value > max ? max : value;
-}
-
-static VkExtent2D
-choose_swapchain_extent(const VkSurfaceCapabilitiesKHR *capabilities, int width,
-                        int height) {
-  if (capabilities->currentExtent.width != UINT32_MAX) {
-    return capabilities->currentExtent;
-  } else {
-    VkExtent2D actual_extent = {width, height};
-    actual_extent.width =
-        clamp_uint32(capabilities->minImageExtent.width,
-                     capabilities->maxImageExtent.width, actual_extent.width);
-    actual_extent.height =
-        clamp_uint32(capabilities->minImageExtent.height,
-                     capabilities->maxImageExtent.height, actual_extent.height);
-    return actual_extent;
-  }
-}
-
-static bool vgltf_renderer_create_swapchain(struct vgltf_renderer *renderer) {
-  struct swapchain_support_details swapchain_support_details = {};
-  swapchain_support_details_query_from_device(
-      &swapchain_support_details, renderer->physical_device, renderer->surface);
-
-  VkSurfaceFormatKHR surface_format =
-      choose_swapchain_surface_format(swapchain_support_details.formats,
-                                      swapchain_support_details.format_count);
-  VkPresentModeKHR present_mode = choose_swapchain_present_mode(
-      swapchain_support_details.present_modes,
-      swapchain_support_details.present_mode_count);
-
-  VkExtent2D extent = choose_swapchain_extent(
-      &swapchain_support_details.capabilities, renderer->window_size.width,
-      renderer->window_size.height);
-  uint32_t image_count =
-      swapchain_support_details.capabilities.minImageCount + 1;
-  if (swapchain_support_details.capabilities.maxImageCount > 0 &&
-      image_count > swapchain_support_details.capabilities.maxImageCount) {
-    image_count = swapchain_support_details.capabilities.maxImageCount;
-  }
-
-  VkSwapchainCreateInfoKHR create_info = {
-      .sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR,
-      .surface = renderer->surface,
-      .minImageCount = image_count,
-      .imageFormat = surface_format.format,
-      .imageColorSpace = surface_format.colorSpace,
-      .imageExtent = extent,
-      .imageArrayLayers = 1,
-      .imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT};
-  struct queue_family_indices indices = {};
-  queue_family_indices_for_device(&indices, renderer->physical_device,
-                                  renderer->surface);
-  uint32_t queue_family_indices[] = {indices.graphics_family,
-                                     indices.present_family};
-  if (indices.graphics_family != indices.present_family) {
-    create_info.imageSharingMode = VK_SHARING_MODE_CONCURRENT;
-    create_info.queueFamilyIndexCount = 2;
-    create_info.pQueueFamilyIndices = queue_family_indices;
-  } else {
-    create_info.imageSharingMode = VK_SHARING_MODE_EXCLUSIVE;
-  }
-
-  create_info.preTransform =
-      swapchain_support_details.capabilities.currentTransform;
-  create_info.compositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR;
-  create_info.presentMode = present_mode;
-  create_info.clipped = VK_TRUE;
-  create_info.oldSwapchain = VK_NULL_HANDLE;
-
-  if (vkCreateSwapchainKHR(renderer->device, &create_info, nullptr,
-                           &renderer->swapchain) != VK_SUCCESS) {
-    VGLTF_LOG_ERR("Swapchain creation failed!");
-    goto err;
-  }
-
-  if (vkGetSwapchainImagesKHR(renderer->device, renderer->swapchain,
-                              &renderer->swapchain_image_count,
-                              nullptr) != VK_SUCCESS) {
-    VGLTF_LOG_ERR("Couldn't get swapchain image count");
-    goto destroy_swapchain;
-  }
-
-  if (renderer->swapchain_image_count >
-      VGLTF_RENDERER_MAX_SWAPCHAIN_IMAGE_COUNT) {
-    VGLTF_LOG_ERR("Swapchain image array cannot fit all %d swapchain images",
-                  renderer->swapchain_image_count);
-    goto destroy_swapchain;
-  }
-
-  if (vkGetSwapchainImagesKHR(renderer->device, renderer->swapchain,
-                              &renderer->swapchain_image_count,
-                              renderer->swapchain_images) != VK_SUCCESS) {
-    VGLTF_LOG_ERR("Couldn't get swapchain images");
-    goto destroy_swapchain;
-  }
-
-  renderer->swapchain_image_format = surface_format.format;
-  renderer->swapchain_extent = extent;
-
-  return true;
-destroy_swapchain:
-  vkDestroySwapchainKHR(renderer->device, renderer->swapchain, nullptr);
-err:
-  return false;
-}
-
-static bool vgltf_renderer_create_image_views(struct vgltf_renderer *renderer) {
-  uint32_t swapchain_image_index;
-  for (swapchain_image_index = 0;
-       swapchain_image_index < renderer->swapchain_image_count;
-       swapchain_image_index++) {
-    VkImage swapchain_image = renderer->swapchain_images[swapchain_image_index];
-
-    VkImageViewCreateInfo create_info = {
-        .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
-        .image = swapchain_image,
-        .viewType = VK_IMAGE_VIEW_TYPE_2D,
-        .format = renderer->swapchain_image_format,
-        .components = {VK_COMPONENT_SWIZZLE_IDENTITY,
-                       VK_COMPONENT_SWIZZLE_IDENTITY,
-                       VK_COMPONENT_SWIZZLE_IDENTITY,
-                       VK_COMPONENT_SWIZZLE_IDENTITY},
-        .subresourceRange = {.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
-                             .levelCount = 1,
-                             .layerCount = 1}};
-
-    if (vkCreateImageView(
-            renderer->device, &create_info, nullptr,
-            &renderer->swapchain_image_views[swapchain_image_index]) !=
-        VK_SUCCESS) {
-      goto err;
-    }
-  }
-  return true;
-err:
-  for (uint32_t to_remove_index = 0; to_remove_index < swapchain_image_index;
-       to_remove_index++) {
-    vkDestroyImageView(renderer->device,
-                       renderer->swapchain_image_views[to_remove_index],
-                       nullptr);
-  }
-  return false;
-}
-
-static bool create_shader_module(VkDevice device, const unsigned char *code,
-                                 int size, VkShaderModule *out) {
-  VkShaderModuleCreateInfo create_info = {
-      .sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO,
-      .codeSize = size,
-      .pCode = (const uint32_t *)code,
-  };
-  if (vkCreateShaderModule(device, &create_info, nullptr, out) != VK_SUCCESS) {
-    VGLTF_LOG_ERR("Couldn't create shader module");
-    goto err;
-  }
-  return true;
-err:
-  return false;
-}
-
-static bool vgltf_renderer_create_render_pass(struct vgltf_renderer *renderer) {
-  VkAttachmentDescription color_attachment = {
-      .format = renderer->swapchain_image_format,
-      .samples = VK_SAMPLE_COUNT_1_BIT,
-      .loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR,
-      .storeOp = VK_ATTACHMENT_STORE_OP_STORE,
-      .stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE,
-      .stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE,
-      .initialLayout = VK_IMAGE_LAYOUT_UNDEFINED,
-      .finalLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR};
-  VkAttachmentReference color_attachment_ref = {
-      .attachment = 0,
-      .layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
-  };
-  VkSubpassDescription subpass = {.pipelineBindPoint =
-                                      VK_PIPELINE_BIND_POINT_GRAPHICS,
-                                  .pColorAttachments = &color_attachment_ref,
-                                  .colorAttachmentCount = 1};
-  VkSubpassDependency dependency = {
-      .srcSubpass = VK_SUBPASS_EXTERNAL,
-      .dstSubpass = 0,
-      .srcStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
-      .srcAccessMask = 0,
-      .dstStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
-      .dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT};
-
-  VkRenderPassCreateInfo render_pass_info = {
-      .sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO,
-      .attachmentCount = 1,
-      .pAttachments = &color_attachment,
-      .subpassCount = 1,
-      .pSubpasses = &subpass,
-      .dependencyCount = 1,
-      .pDependencies = &dependency};
-
-  if (vkCreateRenderPass(renderer->device, &render_pass_info, nullptr,
-                         &renderer->render_pass) != VK_SUCCESS) {
-    VGLTF_LOG_ERR("Failed to create render pass");
-    goto err;
-  }
-
-  return true;
-err:
-  return false;
-}
-
-static bool
-vgltf_renderer_create_graphics_pipeline(struct vgltf_renderer *renderer) {
-  static constexpr unsigned char triangle_shader_vert_code[] = {
-#embed "../compiled_shaders/triangle.vert.spv"
-  };
-  static constexpr unsigned char triangle_shader_frag_code[] = {
-#embed "../compiled_shaders/triangle.frag.spv"
-  };
-
-  VkShaderModule triangle_shader_vert_module;
-  if (!create_shader_module(renderer->device, triangle_shader_vert_code,
-                            sizeof(triangle_shader_vert_code),
-                            &triangle_shader_vert_module)) {
-    VGLTF_LOG_ERR("Couldn't create triangle vert shader module");
-    goto err;
-  }
-
-  VkShaderModule triangle_shader_frag_module;
-  if (!create_shader_module(renderer->device, triangle_shader_frag_code,
-                            sizeof(triangle_shader_frag_code),
-                            &triangle_shader_frag_module)) {
-    VGLTF_LOG_ERR("Couldn't create triangle frag shader module");
-    goto destroy_vert_shader_module;
-  }
-
-  VkPipelineShaderStageCreateInfo triangle_shader_vert_stage_create_info = {
-      .sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
-      .stage = VK_SHADER_STAGE_VERTEX_BIT,
-      .module = triangle_shader_vert_module,
-      .pName = "main"};
-  VkPipelineShaderStageCreateInfo triangle_shader_frag_stage_create_info = {
-      .sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
-      .stage = VK_SHADER_STAGE_FRAGMENT_BIT,
-      .module = triangle_shader_frag_module,
-      .pName = "main"};
-  VkPipelineShaderStageCreateInfo shader_stages[] = {
-      triangle_shader_vert_stage_create_info,
-      triangle_shader_frag_stage_create_info};
-
-  VkDynamicState dynamic_states[] = {
-      VK_DYNAMIC_STATE_VIEWPORT,
-      VK_DYNAMIC_STATE_SCISSOR,
-  };
-
-  VkPipelineDynamicStateCreateInfo dynamic_state = {
-      .sType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO,
-      .dynamicStateCount = sizeof(dynamic_states) / sizeof(dynamic_states[0]),
-      .pDynamicStates = dynamic_states};
-
-  VkPipelineVertexInputStateCreateInfo vertex_input_info = {
-      .sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO,
-      .vertexBindingDescriptionCount = 0,
-      .vertexAttributeDescriptionCount = 0,
-  };
-
-  VkPipelineInputAssemblyStateCreateInfo input_assembly = {
-      .sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO,
-      .topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST,
-      .primitiveRestartEnable = VK_FALSE,
-  };
-
-  VkPipelineViewportStateCreateInfo viewport_state = {
-      .sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO,
-      .viewportCount = 1,
-      .scissorCount = 1};
-
-  VkPipelineRasterizationStateCreateInfo rasterizer = {
-      .sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO,
-      .depthClampEnable = VK_FALSE,
-      .rasterizerDiscardEnable = VK_FALSE,
-      .polygonMode = VK_POLYGON_MODE_FILL,
-      .lineWidth = 1.f,
-      .cullMode = VK_CULL_MODE_BACK_BIT,
-      .frontFace = VK_FRONT_FACE_CLOCKWISE,
-      .depthBiasEnable = VK_FALSE};
-
-  VkPipelineMultisampleStateCreateInfo multisampling = {
-      .sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO,
-      .sampleShadingEnable = VK_FALSE,
-      .rasterizationSamples = VK_SAMPLE_COUNT_1_BIT,
-  };
-
-  VkPipelineColorBlendAttachmentState color_blend_attachment = {
-      .colorWriteMask = VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT |
-                        VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT,
-      .blendEnable = VK_FALSE,
-  };
-
-  VkPipelineColorBlendStateCreateInfo color_blending = {
-      .sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO,
-      .logicOpEnable = VK_FALSE,
-      .attachmentCount = 1,
-      .pAttachments = &color_blend_attachment};
-
-  VkPipelineLayoutCreateInfo pipeline_layout_info = {
-      .sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,
-  };
-
-  if (vkCreatePipelineLayout(renderer->device, &pipeline_layout_info, nullptr,
-                             &renderer->pipeline_layout) != VK_SUCCESS) {
-    VGLTF_LOG_ERR("Couldn't create pipeline layout");
-    goto destroy_frag_shader_module;
-  }
-
-  VkGraphicsPipelineCreateInfo pipeline_info = {
-      .sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO,
-      .stageCount = 2,
-      .pStages = shader_stages,
-      .pVertexInputState = &vertex_input_info,
-      .pInputAssemblyState = &input_assembly,
-      .pViewportState = &viewport_state,
-      .pRasterizationState = &rasterizer,
-      .pMultisampleState = &multisampling,
-      .pColorBlendState = &color_blending,
-      .pDynamicState = &dynamic_state,
-      .layout = renderer->pipeline_layout,
-      .renderPass = renderer->render_pass,
-      .subpass = 0,
-  };
-
-  if (vkCreateGraphicsPipelines(renderer->device, VK_NULL_HANDLE, 1,
-                                &pipeline_info, nullptr,
-                                &renderer->graphics_pipeline) != VK_SUCCESS) {
-    VGLTF_LOG_ERR("Couldn't create pipeline");
-    goto destroy_pipeline_layout;
-  }
-
-  vkDestroyShaderModule(renderer->device, triangle_shader_frag_module, nullptr);
-  vkDestroyShaderModule(renderer->device, triangle_shader_vert_module, nullptr);
-  return true;
-destroy_pipeline_layout:
-  vkDestroyPipelineLayout(renderer->device, renderer->pipeline_layout, nullptr);
-destroy_frag_shader_module:
-  vkDestroyShaderModule(renderer->device, triangle_shader_frag_module, nullptr);
-destroy_vert_shader_module:
-  vkDestroyShaderModule(renderer->device, triangle_shader_vert_module, nullptr);
-err:
-  return false;
-}
-
-static bool
-vgltf_renderer_create_framebuffers(struct vgltf_renderer *renderer) {
-  for (uint32_t i = 0; i < renderer->swapchain_image_count; i++) {
-    VkImageView attachments[] = {renderer->swapchain_image_views[i]};
-
-    VkFramebufferCreateInfo framebuffer_info = {
-        .sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO,
-        .renderPass = renderer->render_pass,
-        .attachmentCount = 1,
-        .pAttachments = attachments,
-        .width = renderer->swapchain_extent.width,
-        .height = renderer->swapchain_extent.height,
-        .layers = 1};
-
-    if (vkCreateFramebuffer(renderer->device, &framebuffer_info, nullptr,
-                            &renderer->swapchain_framebuffers[i]) !=
-        VK_SUCCESS) {
-      VGLTF_LOG_ERR("Failed to create framebuffer");
-      goto err;
-    }
-  }
-
-  return true;
-err:
-  return false;
-}
-
-static bool
-vgltf_renderer_create_command_pool(struct vgltf_renderer *renderer) {
-  struct queue_family_indices queue_family_indices = {};
-  if (!queue_family_indices_for_device(&queue_family_indices,
-                                       renderer->physical_device,
-                                       renderer->surface)) {
-    VGLTF_LOG_ERR("Couldn't fetch queue family indices");
-    goto err;
-  }
-
-  VkCommandPoolCreateInfo pool_info = {
-      .sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,
-      .flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT,
-      .queueFamilyIndex = queue_family_indices.graphics_family};
-
-  if (vkCreateCommandPool(renderer->device, &pool_info, nullptr,
-                          &renderer->command_pool) != VK_SUCCESS) {
-    VGLTF_LOG_ERR("Couldn't create command pool");
-    goto err;
-  }
-
-  return true;
-err:
-  return false;
-}
-
-static bool
-vgltf_renderer_create_command_buffer(struct vgltf_renderer *renderer) {
-  VkCommandBufferAllocateInfo allocate_info = {
-      .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,
-      .commandPool = renderer->command_pool,
-      .level = VK_COMMAND_BUFFER_LEVEL_PRIMARY,
-      .commandBufferCount = VGLTF_RENDERER_MAX_FRAME_IN_FLIGHT_COUNT};
-
-  if (vkAllocateCommandBuffers(renderer->device, &allocate_info,
-                               renderer->command_buffer) != VK_SUCCESS) {
-    VGLTF_LOG_ERR("Couldn't allocate command buffers");
-    goto err;
-  }
-
-  return true;
-err:
-  return false;
-}
-
-static bool
-vgltf_renderer_create_sync_objects(struct vgltf_renderer *renderer) {
-  VkSemaphoreCreateInfo semaphore_info = {
-      .sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO,
-  };
-
-  VkFenceCreateInfo fence_info = {.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO,
-                                  .flags = VK_FENCE_CREATE_SIGNALED_BIT};
-
-  int frame_in_flight_index = 0;
-  for (; frame_in_flight_index < VGLTF_RENDERER_MAX_FRAME_IN_FLIGHT_COUNT;
-       frame_in_flight_index++) {
-    if (vkCreateSemaphore(
-            renderer->device, &semaphore_info, nullptr,
-            &renderer->image_available_semaphores[frame_in_flight_index]) !=
-            VK_SUCCESS ||
-        vkCreateSemaphore(
-            renderer->device, &semaphore_info, nullptr,
-            &renderer->render_finished_semaphores[frame_in_flight_index]) !=
-            VK_SUCCESS ||
-        vkCreateFence(renderer->device, &fence_info, nullptr,
-                      &renderer->in_flight_fences[frame_in_flight_index]) !=
-            VK_SUCCESS) {
-      VGLTF_LOG_ERR("Couldn't create sync objects");
-      goto err;
-    }
-  }
-
-  return true;
-err:
-  for (int frame_in_flight_to_delete_index = 0;
-       frame_in_flight_to_delete_index < frame_in_flight_index;
-       frame_in_flight_to_delete_index++) {
-    vkDestroyFence(renderer->device,
-                   renderer->in_flight_fences[frame_in_flight_index], nullptr);
-    vkDestroySemaphore(
-        renderer->device,
-        renderer->render_finished_semaphores[frame_in_flight_index], nullptr);
-    vkDestroySemaphore(
-        renderer->device,
-        renderer->image_available_semaphores[frame_in_flight_index], nullptr);
-  }
-  return false;
-}
-
-static void vgltf_renderer_cleanup_swapchain(struct vgltf_renderer *renderer) {
-  for (uint32_t framebuffer_index = 0;
-       framebuffer_index < renderer->swapchain_image_count;
-       framebuffer_index++) {
-    vkDestroyFramebuffer(renderer->device,
-                         renderer->swapchain_framebuffers[framebuffer_index],
-                         nullptr);
-  }
-
-  for (uint32_t image_view_index = 0;
-       image_view_index < renderer->swapchain_image_count; image_view_index++) {
-    vkDestroyImageView(renderer->device,
-                       renderer->swapchain_image_views[image_view_index],
-                       nullptr);
-  }
-
-  vkDestroySwapchainKHR(renderer->device, renderer->swapchain, nullptr);
-}
-
-static bool vgltf_renderer_recreate_swapchain(struct vgltf_renderer *renderer) {
-  vkDeviceWaitIdle(renderer->device);
-  vgltf_renderer_cleanup_swapchain(renderer);
-
-  // TODO add error handling
-  vgltf_renderer_create_swapchain(renderer);
-  vgltf_renderer_create_image_views(renderer);
-  vgltf_renderer_create_framebuffers(renderer);
-  return true;
-}
-
-bool vgltf_renderer_triangle_pass(struct vgltf_renderer *renderer) {
-  vkWaitForFences(renderer->device, 1,
-                  &renderer->in_flight_fences[renderer->current_frame], VK_TRUE,
-                  UINT64_MAX);
-
-  uint32_t image_index;
-  VkResult acquire_swapchain_image_result = vkAcquireNextImageKHR(
-      renderer->device, renderer->swapchain, UINT64_MAX,
-      renderer->image_available_semaphores[renderer->current_frame],
-      VK_NULL_HANDLE, &image_index);
-  if (acquire_swapchain_image_result == VK_ERROR_OUT_OF_DATE_KHR ||
-      acquire_swapchain_image_result == VK_SUBOPTIMAL_KHR ||
-      renderer->framebuffer_resized) {
-    renderer->framebuffer_resized = false;
-    vgltf_renderer_recreate_swapchain(renderer);
-    return true;
-  } else if (acquire_swapchain_image_result != VK_SUCCESS) {
-    VGLTF_LOG_ERR("Failed to acquire a swapchain image");
-    goto err;
-  }
-
-  vkResetFences(renderer->device, 1,
-                &renderer->in_flight_fences[renderer->current_frame]);
-
-  vkResetCommandBuffer(renderer->command_buffer[renderer->current_frame], 0);
-  VkCommandBufferBeginInfo begin_info = {
-      .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
-  };
-
-  if (vkBeginCommandBuffer(renderer->command_buffer[renderer->current_frame],
-                           &begin_info) != VK_SUCCESS) {
-    VGLTF_LOG_ERR("Failed to begin recording command buffer");
-    goto err;
-  }
-
-  VkRenderPassBeginInfo render_pass_info = {
-      .sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO,
-      .renderPass = renderer->render_pass,
-      .framebuffer = renderer->swapchain_framebuffers[image_index],
-      .renderArea = {.offset = {}, .extent = renderer->swapchain_extent},
-      .clearValueCount = 1,
-      .pClearValues =
-          &(const VkClearValue){.color = {.float32 = {0.f, 0.f, 0.f, 1.f}}},
-
-  };
-
-  vkCmdBeginRenderPass(renderer->command_buffer[renderer->current_frame],
-                       &render_pass_info, VK_SUBPASS_CONTENTS_INLINE);
-  vkCmdBindPipeline(renderer->command_buffer[renderer->current_frame],
-                    VK_PIPELINE_BIND_POINT_GRAPHICS,
-                    renderer->graphics_pipeline);
-  VkViewport viewport = {.x = 0.f,
-                         .y = 0.f,
-                         .width = (float)renderer->swapchain_extent.width,
-                         .height = (float)renderer->swapchain_extent.height,
-                         .minDepth = 0.f,
-                         .maxDepth = 1.f};
-  vkCmdSetViewport(renderer->command_buffer[renderer->current_frame], 0, 1,
-                   &viewport);
-  VkRect2D scissor = {.offset = {}, .extent = renderer->swapchain_extent};
-  vkCmdSetScissor(renderer->command_buffer[renderer->current_frame], 0, 1,
-                  &scissor);
-
-  vkCmdDraw(renderer->command_buffer[renderer->current_frame], 3, 1, 0, 0);
-
-  vkCmdEndRenderPass(renderer->command_buffer[renderer->current_frame]);
-
-  if (vkEndCommandBuffer(renderer->command_buffer[renderer->current_frame]) !=
-      VK_SUCCESS) {
-    VGLTF_LOG_ERR("Failed to record command buffer");
-    goto err;
-  }
-
-  VkSubmitInfo submit_info = {
-      .sType = VK_STRUCTURE_TYPE_SUBMIT_INFO,
-  };
-
-  VkSemaphore wait_semaphores[] = {
-      renderer->image_available_semaphores[renderer->current_frame]};
-  VkPipelineStageFlags wait_stages[] = {
-      VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT};
-  submit_info.waitSemaphoreCount = 1;
-  submit_info.pWaitSemaphores = wait_semaphores;
-  submit_info.pWaitDstStageMask = wait_stages;
-  submit_info.commandBufferCount = 1;
-  submit_info.pCommandBuffers =
-      &renderer->command_buffer[renderer->current_frame];
-
-  VkSemaphore signal_semaphores[] = {
-      renderer->render_finished_semaphores[renderer->current_frame]};
-  submit_info.signalSemaphoreCount = 1;
-  submit_info.pSignalSemaphores = signal_semaphores;
-  if (vkQueueSubmit(renderer->graphics_queue, 1, &submit_info,
-                    renderer->in_flight_fences[renderer->current_frame]) !=
-      VK_SUCCESS) {
-    VGLTF_LOG_ERR("Failed to submit draw command buffer");
-    goto err;
-  }
-
-  VkPresentInfoKHR present_info = {.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR,
-                                   .waitSemaphoreCount = 1,
-                                   .pWaitSemaphores = signal_semaphores};
-
-  VkSwapchainKHR swapchains[] = {renderer->swapchain};
-  present_info.swapchainCount = 1;
-  present_info.pSwapchains = swapchains;
-  present_info.pImageIndices = &image_index;
-  VkResult result = vkQueuePresentKHR(renderer->present_queue, &present_info);
-  if (result == VK_ERROR_OUT_OF_DATE_KHR || result == VK_SUBOPTIMAL_KHR) {
-    vgltf_renderer_recreate_swapchain(renderer);
-  } else if (acquire_swapchain_image_result != VK_SUCCESS) {
-    VGLTF_LOG_ERR("Failed to acquire a swapchain image");
-    goto err;
-  }
-  renderer->current_frame =
-      (renderer->current_frame + 1) % VGLTF_RENDERER_MAX_FRAME_IN_FLIGHT_COUNT;
-  return true;
-err:
-  return false;
-}
-
-bool vgltf_renderer_init(struct vgltf_renderer *renderer,
-                         struct vgltf_platform *platform) {
-  if (!vgltf_renderer_create_instance(renderer, platform)) {
-    VGLTF_LOG_ERR("instance creation failed");
-    goto err;
-  }
-  vgltf_renderer_setup_debug_messenger(renderer);
-  if (!vgltf_renderer_create_surface(renderer, platform)) {
-    goto destroy_instance;
-  }
-
-  if (!vgltf_renderer_pick_physical_device(renderer)) {
-    VGLTF_LOG_ERR("Couldn't pick physical device");
-    goto destroy_surface;
-  }
-  if (!vgltf_renderer_create_logical_device(renderer)) {
-    VGLTF_LOG_ERR("Couldn't create logical device");
-    goto destroy_device;
-  }
-
-  struct vgltf_window_size window_size = {800, 600};
-  if (!vgltf_platform_get_window_size(platform, &window_size)) {
-    VGLTF_LOG_ERR("Couldn't get window size");
-    goto destroy_device;
-  }
-  renderer->window_size = window_size;
-
-  if (!vgltf_renderer_create_swapchain(renderer)) {
-    VGLTF_LOG_ERR("Couldn't create swapchain");
-    goto destroy_device;
-  }
-
-  if (!vgltf_renderer_create_image_views(renderer)) {
-    VGLTF_LOG_ERR("Couldn't create image views");
-    goto destroy_swapchain;
-  }
-
-  if (!vgltf_renderer_create_render_pass(renderer)) {
-    VGLTF_LOG_ERR("Couldn't create render pass");
-    goto destroy_image_views;
-  }
-
-  if (!vgltf_renderer_create_graphics_pipeline(renderer)) {
-    VGLTF_LOG_ERR("Couldn't create graphics pipeline");
-    goto destroy_render_pass;
-  }
-
-  if (!vgltf_renderer_create_framebuffers(renderer)) {
-    VGLTF_LOG_ERR("Couldn't create framebuffers");
-    goto destroy_graphics_pipeline;
-  }
-
-  if (!vgltf_renderer_create_command_pool(renderer)) {
-    VGLTF_LOG_ERR("Couldn't create command pool");
-    goto destroy_frame_buffers;
-  }
-
-  if (!vgltf_renderer_create_command_buffer(renderer)) {
-    VGLTF_LOG_ERR("Couldn't create command buffer");
-    goto destroy_command_pool;
-  }
-
-  if (!vgltf_renderer_create_sync_objects(renderer)) {
-    VGLTF_LOG_ERR("Couldn't create sync objects");
-    goto destroy_command_pool;
-  }
-
-  return true;
-
-destroy_command_pool:
-  vkDestroyCommandPool(renderer->device, renderer->command_pool, nullptr);
-destroy_frame_buffers:
-  for (uint32_t swapchain_framebuffer_index = 0;
-       swapchain_framebuffer_index < renderer->swapchain_image_count;
-       swapchain_framebuffer_index++) {
-    vkDestroyFramebuffer(
-        renderer->device,
-        renderer->swapchain_framebuffers[swapchain_framebuffer_index], nullptr);
-  }
-destroy_graphics_pipeline:
-  vkDestroyPipeline(renderer->device, renderer->graphics_pipeline, nullptr);
-  vkDestroyPipelineLayout(renderer->device, renderer->pipeline_layout, nullptr);
-destroy_render_pass:
-  vkDestroyRenderPass(renderer->device, renderer->render_pass, nullptr);
-destroy_image_views:
-  for (uint32_t swapchain_image_view_index = 0;
-       swapchain_image_view_index < renderer->swapchain_image_count;
-       swapchain_image_view_index++) {
-    vkDestroyImageView(
-        renderer->device,
-        renderer->swapchain_image_views[swapchain_image_view_index], nullptr);
-  }
-destroy_swapchain:
-  vkDestroySwapchainKHR(renderer->device, renderer->swapchain, nullptr);
-destroy_device:
-  vkDestroyDevice(renderer->device, nullptr);
-destroy_surface:
-  vkDestroySurfaceKHR(renderer->instance, renderer->surface, nullptr);
-destroy_instance:
-  if (enable_validation_layers) {
-    destroy_debug_utils_messenger_ext(renderer->instance,
-                                      renderer->debug_messenger, nullptr);
-  }
-  vkDestroyInstance(renderer->instance, nullptr);
-err:
-  return false;
-}
-void vgltf_renderer_deinit(struct vgltf_renderer *renderer) {
-  vkDeviceWaitIdle(renderer->device);
-  vgltf_renderer_cleanup_swapchain(renderer);
-  vkDestroyPipeline(renderer->device, renderer->graphics_pipeline, nullptr);
-  vkDestroyPipelineLayout(renderer->device, renderer->pipeline_layout, nullptr);
-  vkDestroyRenderPass(renderer->device, renderer->render_pass, nullptr);
-  for (int i = 0; i < VGLTF_RENDERER_MAX_FRAME_IN_FLIGHT_COUNT; i++) {
-    vkDestroySemaphore(renderer->device,
-                       renderer->image_available_semaphores[i], nullptr);
-    vkDestroySemaphore(renderer->device,
-                       renderer->render_finished_semaphores[i], nullptr);
-    vkDestroyFence(renderer->device, renderer->in_flight_fences[i], nullptr);
-  }
-  vkDestroyCommandPool(renderer->device, renderer->command_pool, nullptr);
-  vkDestroyDevice(renderer->device, nullptr);
-  if (enable_validation_layers) {
-    destroy_debug_utils_messenger_ext(renderer->instance,
-                                      renderer->debug_messenger, nullptr);
-  }
-  vkDestroySurfaceKHR(renderer->instance, renderer->surface, nullptr);
-  vkDestroyInstance(renderer->instance, nullptr);
-}
-void vgltf_renderer_on_window_resized(struct vgltf_renderer *renderer,
-                                      struct vgltf_window_size size) {
-  if (size.width > 0 && size.height > 0 &&
-      size.width != renderer->window_size.width &&
-      size.height != renderer->window_size.height) {
-    renderer->window_size = size;
-    renderer->framebuffer_resized = true;
-  }
-}