rename

1 files changed, 1950 insertions, 0 deletions

diff --git a/src/render.c b/src/render.c
new file mode 100644
index 0000000..50f686e
--- /dev/null
+++ b/src/render.c
@@ -0,0 +1,1950 @@
+#include <stddef.h>
+#include <stdlib.h>
+#include <time.h>
+
+#include <shaderc/shaderc.h>
+
+#define SDL_MAIN_HANDLED
+#define VK_USE_PLATFORM_XCB_KHR
+#include <SDL2/SDL.h>
+#include <SDL2/SDL_vulkan.h>
+
+#include <vulkan/vulkan.h>
+
+#define VMA_STATIC_VULKAN_FUNCTIONS 0
+#define VMA_DYNAMIC_VULKAN_FUNCTIONS 1
+#include "vk_mem_alloc.h"
+
+#define STB_IMAGE_IMPLEMENTATION
+#include "../lib/stb_image.h"
+
+//#include "cplusplus.h"
+#include "vkutil.h"
+#include "state.h"
+
+// embedded clgm library
+uint32_t currentFrame = 0;
+state_t s;
+
+const char *const validation_layers[] = {
+  "VK_LAYER_KHRONOS_validation"
+};
+const uint32_t validation_layer_count = VK_ARRAY_LEN(validation_layers);
+
+const char *const device_extensions[] = {
+    VK_KHR_SWAPCHAIN_EXTENSION_NAME,
+};
+const uint32_t deviceExtensionCount = VK_ARRAY_LEN(device_extensions);
+
+
+#ifdef VKDEBUG
+    const bool enableValidationLayers = true;
+#else
+    const bool enableValidationLayers = false;
+#endif
+
+typedef struct {
+  float x;
+  float y;
+} V2;
+
+typedef struct {
+  float x;
+  float y;
+  float z;
+} V3;
+
+typedef struct {
+  V3 pos;
+  V3 color;
+  V2 texCoord;
+} Vertex;
+
+/* Vertex vertices[] = { */
+/*   (Vertex) { (V2) {-0.2f, -0.5f}, (V3) {0.0f, 1.0f, 0.0f}}, */
+/*   (Vertex) { (V2) {0.5f,  0.3f}, (V3) {0.0f, 0.0f, 1.0f}}, */
+/*   (Vertex) { (V2) {-0.5f, 0.7f}, (V3) {1.0f, 0.0f, 0.0f}}, */
+
+/*   (Vertex) { (V2) {0.2f, -0.5f}, (V3) {0.0f, 0.0f, 1.0f}}, */
+/*   (Vertex) { (V2) {0.5f,  0.7f}, (V3) {1.0f, 0.0f, 0.0f}}, */
+/*   (Vertex) { (V2) {-0.5f, 0.3f}, (V3) {0.0f, 1.0f, 0.0f}}, */
+
+/*   (Vertex) { (V2) {0.0f, -0.5f}, (V3) {1.0f, 0.0f, 0.0f}}, */
+/*   (Vertex) { (V2) {0.5f,  0.5f}, (V3) {0.0f, 1.0f, 0.0f}}, */
+/*   (Vertex) { (V2) {-0.5f, 0.5f}, (V3) {0.0f, 0.0f, 1.0f}}, */
+/* }; */
+/* const int VERTICES_SIZE = VK_ARRAY_LEN(vertices); */
+
+/* const uint16_t indices[] = { */
+/*   0, 1, 2, 3, 4, 5, 6, 7, 8, */
+/* }; */
+/* const int INDICES_SIZE = VK_ARRAY_LEN(indices); */
+
+Vertex vertices[] = {
+  (Vertex) { (V3) {-0.5f, -0.5f, 0.0f}, (V3) {1.0f, 0.0f, 0.0f}, (V2) {0.0f, 0.0f}},
+  (Vertex) { (V3) {0.5f,  -0.5f, 0.0f}, (V3) {0.0f, 1.0f, 0.0f}, (V2) {1.0f, 0.0f}},
+  (Vertex) { (V3) {0.5f,   0.5f, 0.0f}, (V3) {0.0f, 0.0f, 1.0f}, (V2) {1.0f, 1.0f}},
+  (Vertex) { (V3) {-0.5f,  0.5f, 0.0f}, (V3) {1.0f, 1.0f, 1.0f}, (V2) {0.0f, 1.0f}},
+  (Vertex) { (V3) {-0.5f, -0.5f, -0.5f}, (V3) {1.0f, 0.0f, 0.0f}, (V2) {0.0f, 0.0f}},
+  (Vertex) { (V3) {0.5f,  -0.5f, -0.5f}, (V3) {0.0f, 1.0f, 0.0f}, (V2) {1.0f, 0.0f}},
+  (Vertex) { (V3) {0.5f,   0.5f, -0.5f}, (V3) {0.0f, 0.0f, 1.0f}, (V2) {1.0f, 1.0f}},
+  (Vertex) { (V3) {-0.5f,  0.5f, -0.5f}, (V3) {1.0f, 1.0f, 1.0f}, (V2) {0.0f, 1.0f}},
+};
+const int VERTICES_SIZE = VK_ARRAY_LEN(vertices);
+
+const uint16_t indices[] = {
+  0, 1, 2, 2, 3, 0, 4, 5, 6, 6, 7, 4
+};
+const int INDICES_SIZE = VK_ARRAY_LEN(indices);
+
+static int resizing_event_watcher(void* data, SDL_Event* event) {
+  if (event->type == SDL_WINDOWEVENT &&
+      event->window.event == SDL_WINDOWEVENT_RESIZED) {
+    s.sdl_window_resized = 1;
+  }
+  return 0;
+}
+
+bool
+init()
+{
+  if (SDL_Init(SDL_INIT_VIDEO) < 0) {
+    vk_log(VK_INFO, "SDL could not initialize! SDL_Error: %s\n", SDL_GetError());
+    return false;
+  }
+
+  s.sdl_window = SDL_CreateWindow("Vulkanizater",
+                                  SDL_WINDOWPOS_UNDEFINED,
+                                  SDL_WINDOWPOS_UNDEFINED,
+                                  s.window_w,
+                                  s.window_h,
+                                  SDL_WINDOW_SHOWN | SDL_WINDOW_RESIZABLE | SDL_WINDOW_VULKAN);
+  if (s.sdl_window == NULL) {
+    vk_log(VK_INFO, "Window could not be created! SDL_Error: %s\n", SDL_GetError());
+    return false;
+  }
+
+  SDL_AddEventWatch(resizing_event_watcher,NULL);
+
+  return true;
+}
+
+void
+closeSDL()
+{
+  SDL_DestroyWindow(s.sdl_window);
+  s.sdl_window = NULL;
+  SDL_Quit();
+}
+
+bool
+checkValidationLayerSupport()
+{
+  uint32_t layerCount;
+  vkEnumerateInstanceLayerProperties(&layerCount, NULL);
+
+  VkLayerProperties availableLayers[layerCount];
+  vkEnumerateInstanceLayerProperties(&layerCount, availableLayers);
+
+  for (uint32_t i = 0; i < validation_layer_count; i++) {
+    bool layerFound = false;
+
+    for (uint32_t j = 0; j < layerCount; j++) {
+      if (strcmp(validation_layers[i], availableLayers[j].layerName) == 0) {
+        layerFound = true;
+        break;
+      }
+    }
+
+    if (!layerFound) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+static VKAPI_ATTR VkBool32 VKAPI_CALL
+debugCallback(VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity,
+              VkDebugUtilsMessageTypeFlagsEXT messageType,
+              const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData,
+              void* pUserData)
+{
+  vk_log(VK_ERROR, "validation layer: %s\n", pCallbackData->pMessage);
+  return VK_FALSE;
+}
+
+void
+vulkan_setup_debug_messenger()
+{
+  if (!enableValidationLayers) return;
+  VkDebugUtilsMessengerCreateInfoEXT createInfo = {0};
+  createInfo.sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT;
+  createInfo.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;
+  createInfo.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;
+  createInfo.pfnUserCallback = debugCallback;
+  createInfo.pUserData = NULL; // Optional
+
+
+  // TODO: func pointers returned are NULL
+  s.pfnCreateDebugUtilsMessengerEXT = (PFN_vkCreateDebugUtilsMessengerEXT)vkGetInstanceProcAddr(s.vk_instance, "vkCreateDebugUtilsMessengerEXT");
+  s.pfnDestroyDebugUtilsMessengerEXT = (PFN_vkDestroyDebugUtilsMessengerEXT)vkGetInstanceProcAddr(s.vk_instance, "vkDestroyDebugUtilsMessengerEXT");
+
+  VkResult result = s.pfnCreateDebugUtilsMessengerEXT(s.vk_instance, &createInfo, NULL, &s.vk_debug_messenger);
+  if (result != VK_SUCCESS) {
+    vk_log(VK_WARN, "failed to set up debug messenger!\n");
+  } else {
+    vk_log(VK_INFO, "Debug messanger created!\n");
+  }
+}
+
+void
+vulkan_create_instance()
+{
+  if (enableValidationLayers && !checkValidationLayerSupport()) {
+    vk_log(VK_ERROR, "validation layers requested, but not available!\n");
+  }
+
+  uint32_t instanceVersion;
+  VkResult result = vkEnumerateInstanceVersion(&instanceVersion);
+  if (result == VK_SUCCESS) {
+    if (instanceVersion < VK_MAKE_API_VERSION(0, 1, 3, 0)) {
+      vk_log(VK_ERROR, "Vulkan version 1.3 or greater required!\n");
+      exit(1);
+    }
+    vk_log(VK_INFO, "Vulkan version found (%d) %d.%d.%d\n",
+           VK_API_VERSION_VARIANT(instanceVersion),
+           VK_API_VERSION_MAJOR(instanceVersion),
+           VK_API_VERSION_MINOR(instanceVersion),
+           VK_API_VERSION_PATCH(instanceVersion));
+  } else {
+    vk_log(VK_ERROR, "Failed to retrieve vulkan version, is vulkan supported in this system?\n");
+    exit(1);
+  }
+
+  // Load Vulkan and create instance
+  VkApplicationInfo appInfo = {
+    .sType = VK_STRUCTURE_TYPE_APPLICATION_INFO,
+    .pApplicationName = "Vulkan Application",
+    .applicationVersion = VK_MAKE_API_VERSION(0, 1, 3, 0),
+    .pEngineName = NULL,
+    .engineVersion = VK_MAKE_API_VERSION(0, 1, 3, 0),
+    .apiVersion = VK_MAKE_API_VERSION(0, 1, 3, 0),
+  };
+
+  uint32_t sdlExtensionCount = 0;
+
+  if (SDL_Vulkan_GetInstanceExtensions(s.sdl_window, &sdlExtensionCount, NULL) == SDL_FALSE) {
+    vk_log(VK_ERROR, "SDL_Vulkan_GetInstanceExtensions failed: %s\n", SDL_GetError());
+  }
+
+  // make space for debug extenetion
+  if (enableValidationLayers) {
+    sdlExtensionCount++;
+  }
+
+  const char* sdlExtensions[sdlExtensionCount];
+
+  if (SDL_Vulkan_GetInstanceExtensions(s.sdl_window, &sdlExtensionCount, sdlExtensions) == SDL_FALSE) {
+    vk_log(VK_ERROR, "SDL_Vulkan_GetInstanceExtensions failed: %s\n", SDL_GetError());
+  }
+
+  // add debug extenetion
+  if (enableValidationLayers) {
+    sdlExtensions[sdlExtensionCount] = VK_EXT_DEBUG_UTILS_EXTENSION_NAME;
+  }
+
+  vk_log(VK_INFO, "The sdl extensions:\n");
+  for (uint32_t i = 0; i < sdlExtensionCount; i++) {
+    vk_log(VK_INFO, "\t%s\n", sdlExtensions[i]);
+  }
+
+  VkInstanceCreateInfo createInfo = {
+    .sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO,
+    .pApplicationInfo = &appInfo,
+    .enabledExtensionCount = sdlExtensionCount,
+    .ppEnabledExtensionNames = sdlExtensions,
+    .enabledLayerCount = 0,
+  };
+
+  if (enableValidationLayers) {
+    createInfo.enabledLayerCount = validation_layer_count;
+    createInfo.ppEnabledLayerNames = validation_layers;
+  }
+
+  if (vkCreateInstance(&createInfo, NULL, &s.vk_instance) != VK_SUCCESS) {
+    vk_log(VK_ERROR, "Can't start vulkan instance\n");
+  }
+  vk_log(VK_INFO, "Vulkan instance created\n");
+}
+
+VkExtent2D
+chooseSwapExtent(const VkSurfaceCapabilitiesKHR * capabilities)
+{
+  if (capabilities->currentExtent.width != UINT32_MAX) {
+    return capabilities->currentExtent;
+  } else {
+    int width, height;
+    SDL_GetWindowSize(s.sdl_window, &width, &height);
+
+    VkExtent2D actualExtent;
+    actualExtent.width = (uint32_t) width;
+    actualExtent.height = (uint32_t) height;
+
+    // Manual implementation of std::clamp since it is not available in C
+    actualExtent.width = (actualExtent.width < capabilities->minImageExtent.width) ? capabilities->minImageExtent.width :
+                         (actualExtent.width > capabilities->maxImageExtent.width) ? capabilities->maxImageExtent.width :
+                         actualExtent.width;
+
+    actualExtent.height = (actualExtent.height < capabilities->minImageExtent.height) ? capabilities->minImageExtent.height :
+                          (actualExtent.height > capabilities->maxImageExtent.height) ? capabilities->maxImageExtent.height :
+                          actualExtent.height;
+
+    return actualExtent;
+  }
+}
+
+VkSurfaceFormatKHR
+chooseSwapSurfaceFormat(const VkSurfaceFormatKHR * availableFormats, uint32_t formatCount)
+{
+  for (uint32_t i = 0 ; i < formatCount; i ++) {
+    if (availableFormats[i].format == VK_FORMAT_B8G8R8A8_SRGB &&
+        availableFormats[i].colorSpace == VK_COLOR_SPACE_SRGB_NONLINEAR_KHR) {
+      return availableFormats[i];
+    }
+  }
+
+  // if it fails pick the first one
+  return availableFormats[0];
+}
+
+VkPresentModeKHR
+chooseSwapPresentMode(const VkPresentModeKHR * presentModes, uint32_t presentModeCount)
+{
+  for (uint32_t i = 0 ; i < presentModeCount; i ++) {
+    if (presentModes[i] == VK_PRESENT_MODE_MAILBOX_KHR) {
+      return presentModes[i];
+    }
+  }
+
+  // if it fails pick the the FIFO one
+  return VK_PRESENT_MODE_FIFO_KHR;
+}
+
+typedef struct SwapChainSupportDetails {
+  VkSurfaceCapabilitiesKHR capabilities;
+  VkSurfaceFormatKHR formats[100];
+  uint32_t formatCount;
+  VkPresentModeKHR presentModes[100];
+  uint32_t presentModeCount;
+} SwapChainSupportDetails;
+
+SwapChainSupportDetails
+querySwapChainSupport(VkPhysicalDevice device)
+{
+  // TODO Make SwapChainSupportDetails malloc it;s arrays and free it after it is used.
+  SwapChainSupportDetails details;
+
+  vkGetPhysicalDeviceSurfaceCapabilitiesKHR(device, s.vk_surface, &details.capabilities);
+
+  vkGetPhysicalDeviceSurfaceFormatsKHR(device, s.vk_surface, &details.formatCount, NULL);
+
+  if (details.formatCount != 0) {
+    // todo alloc format arrray
+    vkGetPhysicalDeviceSurfaceFormatsKHR(device, s.vk_surface, &details.formatCount, details.formats);
+  }
+
+  vkGetPhysicalDeviceSurfacePresentModesKHR(device, s.vk_surface, &details.presentModeCount, NULL);
+
+  if (details.presentModeCount != 0) {
+    // todo alloc presentModes array
+    vkGetPhysicalDeviceSurfacePresentModesKHR(device, s.vk_surface, &details.presentModeCount, details.presentModes);
+  }
+
+  return details;
+}
+
+typedef struct QueueFamilyIndices {
+  uint32_t graphicsFamily;
+  bool graphicsFlag;
+  uint32_t presentFamily;
+  bool presentFlag;
+} QueueFamilyIndices;
+
+bool
+vulkan_queue_family_check_flags(QueueFamilyIndices x)
+{
+  return x.graphicsFlag && x.presentFlag;
+}
+
+QueueFamilyIndices vulkan_find_queue_families(VkPhysicalDevice device) {
+  QueueFamilyIndices indices;
+  indices.graphicsFlag = false;
+  indices.presentFlag = false;
+
+  uint32_t queueFamilyCount = 0;
+  vkGetPhysicalDeviceQueueFamilyProperties(device, &queueFamilyCount, NULL);
+
+  VkQueueFamilyProperties queueFamilies[queueFamilyCount];
+  vkGetPhysicalDeviceQueueFamilyProperties(device, &queueFamilyCount, queueFamilies);
+
+  for (uint32_t i = 0; i < queueFamilyCount; i++) {
+    if (queueFamilies[i].queueFlags & VK_QUEUE_GRAPHICS_BIT) {
+      indices.graphicsFamily = i;
+      indices.graphicsFlag = true;
+    }
+
+    VkBool32 presentSupport = false;
+    vkGetPhysicalDeviceSurfaceSupportKHR(device, i, s.vk_surface, &presentSupport);
+    if (presentSupport) {
+      indices.presentFamily = i;
+      indices.presentFlag = true;
+    }
+
+    if (vulkan_queue_family_check_flags(indices)) break;
+  }
+
+  return indices;
+}
+
+bool
+vulkan_check_device_extension_support(VkPhysicalDevice device)
+{
+  uint32_t extensionCount;
+  vkEnumerateDeviceExtensionProperties(device, NULL, &extensionCount, NULL);
+
+  VkExtensionProperties availableExtensions[extensionCount];
+  vkEnumerateDeviceExtensionProperties(device, NULL, &extensionCount, availableExtensions);
+
+  uint32_t flag = 0;
+
+  for (uint32_t i = 0; i < deviceExtensionCount; i++) {
+    for (uint32_t j = 0; j < extensionCount; j++) {
+      if (strcmp(device_extensions[i], availableExtensions[j].extensionName) == 0) {
+        flag++;
+        break;
+      }
+    }
+  }
+
+  return flag == deviceExtensionCount;
+}
+
+bool
+vulkan_is_device_suitable(VkPhysicalDevice device)
+{
+  QueueFamilyIndices indices = vulkan_find_queue_families(device);
+  bool extensionsSupported = vulkan_check_device_extension_support(device);
+
+  bool swapChainAdequate = false;
+  if (extensionsSupported) {
+    SwapChainSupportDetails swapChainSupport = querySwapChainSupport(device);
+    swapChainAdequate = !(swapChainSupport.formatCount == 0) && !(swapChainSupport.presentModeCount == 0);
+  }
+
+  
+  VkPhysicalDeviceFeatures supportedFeatures;
+  vkGetPhysicalDeviceFeatures(device, &supportedFeatures);
+
+  return vulkan_queue_family_check_flags(indices) && extensionsSupported
+         && swapChainAdequate && supportedFeatures.samplerAnisotropy;
+}
+
+void
+vulkan_pick_physical_device()
+{
+  uint32_t deviceCount = 0;
+  vkEnumeratePhysicalDevices(s.vk_instance, &deviceCount, NULL);
+  if (deviceCount == 0) {
+    vk_log(VK_INFO, "failed to find GPUs with Vulkan support!\n");
+  }
+
+  VkPhysicalDevice devices[deviceCount];
+  vkEnumeratePhysicalDevices(s.vk_instance, &deviceCount, devices);
+
+  for (uint32_t i = 0; i < deviceCount; i++) {
+    if (vulkan_is_device_suitable(devices[i])) {
+      s.vk_physical_device = devices[i];
+      break;
+    }
+  }
+
+  if (s.vk_physical_device == VK_NULL_HANDLE) {
+    vk_log(VK_ERROR, "failed to find a suitable GPU!\n");
+  }
+
+  VkPhysicalDeviceProperties deviceProperties;
+  vkGetPhysicalDeviceProperties(s.vk_physical_device, &deviceProperties);
+  vk_log(VK_INFO, "Picked [%s] physical device.\n", deviceProperties.deviceName);
+
+  uint32_t extensionCount = 0;
+  vkEnumerateInstanceExtensionProperties(NULL, &extensionCount, NULL);
+  VkExtensionProperties extensions[extensionCount];
+  VkResult result = vkEnumerateInstanceExtensionProperties(NULL, &extensionCount, extensions);
+
+  vk_log(VK_INFO, "Vulkan enabled extensions: %s\n", string_VkResult(result));
+  for (uint32_t i = 0; i < extensionCount; i++) {
+    vk_log(VK_INFO, "\t%s\n", extensions[i].extensionName);
+  }
+
+}
+
+void
+vulkan_create_logical_device()
+{
+  QueueFamilyIndices indices = vulkan_find_queue_families(s.vk_physical_device);
+
+  // TODO CREATE MULPILE QUEUES
+  // https://vulkan-tutorial.com/en/Drawing_a_triangle/Presentation/Window_surface#page_Creating-the-presentation-queue
+
+  VkDeviceQueueCreateInfo queueCreateInfo = {
+    .sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO,
+    .queueFamilyIndex = indices.graphicsFamily,
+    .queueCount = 1,
+  };
+
+  float queuePriority = 1.0f;
+  queueCreateInfo.pQueuePriorities = &queuePriority;
+
+  VkPhysicalDeviceFeatures deviceFeatures = {0};
+  vkGetPhysicalDeviceFeatures(s.vk_physical_device, &deviceFeatures);
+  deviceFeatures.samplerAnisotropy = VK_TRUE;
+#ifndef NDEBUG
+  /* Disable robust buffer access when building without debug */
+  deviceFeatures.robustBufferAccess = VK_FALSE;
+#endif
+
+  VkPhysicalDeviceDynamicRenderingFeaturesKHR dynamic_rendering_feature = {
+    .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES_KHR,
+    .dynamicRendering = VK_TRUE,
+  };
+
+  VkDeviceCreateInfo createInfo = {
+    .sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO,
+    .pQueueCreateInfos = &queueCreateInfo,
+    .queueCreateInfoCount = 1,
+    .pNext = &dynamic_rendering_feature,
+    .pEnabledFeatures = &deviceFeatures,
+    .enabledExtensionCount = deviceExtensionCount,
+    .ppEnabledExtensionNames = device_extensions,
+    .enabledLayerCount = 0,
+  };
+
+  if (vkCreateDevice(s.vk_physical_device, &createInfo, NULL, &s.vk_device) != VK_SUCCESS) {
+    vk_log(VK_ERROR, "failed to create logical device!\n");
+  }
+  vk_log(VK_INFO, "Vulkan logical device created\n");
+
+  vkGetDeviceQueue(s.vk_device, indices.graphicsFamily, 0, &s.vk_graphics_queue);
+  vkGetDeviceQueue(s.vk_device, indices.presentFamily, 0, &s.vk_present_queue);
+}
+
+void
+update_camera(float xoffset, float yoffset)
+{
+  s.camera.yaw += xoffset;
+  s.camera.pitch += yoffset;
+
+  // Make sure that when pitch is out of bounds, the screen doesn't get flipped
+  if (s.camera.pitch > 89.0f)
+    s.camera.pitch = 89.0f;
+  if (s.camera.pitch < -89.0f)
+    s.camera.pitch = -89.0f;
+
+  /* vec3 front; */
+  /* front[0] = -sin(glm_rad(s.camera.yaw)) * cos(glm_rad(s.camera.pitch)); */
+  /* front[1] = sin(glm_rad(s.camera.pitch)); */
+  /* front[2] = -cos(glm_rad(s.camera.yaw)) * cos(glm_rad(s.camera.pitch)); */
+  /* glm_normalize_to(front, s.camera.front); */
+}
+
+void
+mouseCallback(SDL_Event *event)
+{
+  if (event->type != SDL_MOUSEMOTION) return;
+  if (!s.mouse_pressed) return;
+  float xoffset = event->motion.xrel;
+  float yoffset = -event->motion.yrel; // Reversed since y-coordinates range from bottom to top
+
+  float sensitivity = 0.1f; // Change this value to your liking
+  xoffset *= sensitivity;
+  yoffset *= sensitivity;
+
+  update_camera(xoffset, yoffset);
+}
+
+void
+vulkan_create_surface()
+{
+  if (SDL_Vulkan_CreateSurface(s.sdl_window, s.vk_instance, &s.vk_surface) == SDL_FALSE) {
+    vk_log(VK_ERROR, "Failed to create surface\n");
+  } else {
+    vk_log(VK_INFO, "Vulkan surface created\n");
+  }
+}
+
+void
+vulkan_create_swap_chain()
+{
+  SwapChainSupportDetails swapChainSupport = querySwapChainSupport(s.vk_physical_device);
+
+  VkSurfaceFormatKHR surfaceFormat = chooseSwapSurfaceFormat(swapChainSupport.formats, swapChainSupport.formatCount);
+  VkPresentModeKHR presentMode = chooseSwapPresentMode(swapChainSupport.presentModes, swapChainSupport.presentModeCount);
+  VkExtent2D extent = chooseSwapExtent(&swapChainSupport.capabilities);
+
+  uint32_t imageCount = swapChainSupport.capabilities.minImageCount + 1;
+
+  if (swapChainSupport.capabilities.maxImageCount > 0 && imageCount > swapChainSupport.capabilities.maxImageCount) {
+    imageCount = swapChainSupport.capabilities.maxImageCount;
+  }
+
+  VkSwapchainCreateInfoKHR createInfo = {
+    .sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR,
+    .surface = s.vk_surface,
+    .minImageCount = imageCount,
+    .imageFormat = surfaceFormat.format,
+    .imageColorSpace = surfaceFormat.colorSpace,
+    .imageExtent = extent,
+    .imageArrayLayers = 1,
+    .imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT,
+  };
+
+  QueueFamilyIndices indices = vulkan_find_queue_families(s.vk_physical_device);
+
+  uint32_t queueFamilyIndices[] = {indices.graphicsFamily, indices.presentFamily};
+
+  if (indices.graphicsFamily != indices.presentFamily) {
+    createInfo.imageSharingMode = VK_SHARING_MODE_CONCURRENT;
+    createInfo.queueFamilyIndexCount = 2;
+    createInfo.pQueueFamilyIndices = queueFamilyIndices;
+  } else {
+    createInfo.imageSharingMode = VK_SHARING_MODE_EXCLUSIVE;
+    createInfo.queueFamilyIndexCount = 0; // Optional
+    createInfo.pQueueFamilyIndices = NULL; // Optional
+  }
+
+  createInfo.preTransform = swapChainSupport.capabilities.currentTransform;
+  createInfo.compositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR;
+  createInfo.presentMode = presentMode;
+  createInfo.clipped = VK_TRUE;
+  createInfo.oldSwapchain = VK_NULL_HANDLE;
+
+  VK_CHECK(vkCreateSwapchainKHR(s.vk_device, &createInfo, NULL, &s.vk_swap_chain));
+  /* if (result != VK_SUCCESS) { */
+  /*   vk_log(VK_ERROR, "ERROR: failed to create swap chain!  %s\n", string_VkResult(result)); */
+  /* } */
+
+  VK_CHECK(vkGetSwapchainImagesKHR(s.vk_device, s.vk_swap_chain, &s.vk_swap_chain_image_count, NULL));
+  //vk_log(VK_INFO, "vk_swap_chain_images count: %d\n", s.vk_swap_chain_image_count);
+  // todo alloc space for images
+  VK_CHECK(vkGetSwapchainImagesKHR(s.vk_device, s.vk_swap_chain, &s.vk_swap_chain_image_count, s.vk_swap_chain_images));
+
+  s.vk_swap_chain_image_format = surfaceFormat.format;
+  s.vk_swap_chain_extent = extent;
+
+  vk_log(VK_INFO, "Vulkan swapchain created!\n");
+}
+
+
+VkImageView
+create_image_view(VkImage image, VkFormat format, VkImageAspectFlags aspectFlags)
+{
+  VkImageViewCreateInfo viewInfo = {0};
+  viewInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
+  viewInfo.image = image;
+  viewInfo.viewType = VK_IMAGE_VIEW_TYPE_2D;
+  viewInfo.format = format;
+  viewInfo.subresourceRange.aspectMask = aspectFlags;
+  viewInfo.subresourceRange.baseMipLevel = 0;
+  viewInfo.subresourceRange.levelCount = 1;
+  viewInfo.subresourceRange.baseArrayLayer = 0;
+  viewInfo.subresourceRange.layerCount = 1;
+
+  VkImageView imageView;
+  VK_CHECK(vkCreateImageView(s.vk_device, &viewInfo, NULL, &imageView));
+  
+  return imageView;
+}
+
+void
+vulkan_create_image_views()
+{
+  for (size_t i = 0; i < s.vk_swap_chain_image_count; i++) {
+    s.vk_swap_chain_image_views[i] = create_image_view(s.vk_swap_chain_images[i], s.vk_swap_chain_image_format, VK_IMAGE_ASPECT_COLOR_BIT);
+  }
+  vk_log(VK_INFO, "Vulkan image views created!\n");
+}
+
+VkShaderModule
+createShaderModule(const char * code, long size)
+{
+  VkShaderModuleCreateInfo createInfo = {0};
+  createInfo.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
+  createInfo.codeSize = size;
+  createInfo.pCode = (const uint32_t *)code;
+
+  VkShaderModule shaderModule;
+  if (vkCreateShaderModule(s.vk_device, &createInfo, NULL, &shaderModule) != VK_SUCCESS) {
+    vk_log(VK_ERROR, "failed to create shader module!\n");
+  }
+
+  return shaderModule;
+}
+
+shaderc_compilation_result_t
+load_compile_shader_data(const char * path, shaderc_shader_kind shader_kind)
+{
+  FILE* file = fopen(path, "r");
+  if (!file) {
+    vk_log(VK_ERROR, "SHADER COMPILATION: Failed to open file: %s\n", path);
+    return NULL;
+  }
+
+  fseek(file, 0, SEEK_END);
+  long glsl_length = ftell(file);
+  fseek(file, 0, SEEK_SET);
+
+  char* glsl_src = (char*)malloc(glsl_length + 1);
+  if (!glsl_src) {
+    vk_log(VK_ERROR, "SHADER COMPILATION: Failed to allocate memory\n");
+    fclose(file);
+    return NULL;
+  }
+
+  fread(glsl_src, 1, glsl_length, file);
+  glsl_src[glsl_length] = '\0';
+  fclose(file);
+
+  shaderc_compiler_t compiler = shaderc_compiler_initialize();
+  if (!compiler) {
+    vk_log(VK_ERROR, "SHADER COMPILATION: Failed to initialize shader compiler\n");
+    free(glsl_src);
+    return NULL;
+  }
+
+  shaderc_compile_options_t options = shaderc_compile_options_initialize();
+  shaderc_compilation_result_t result = shaderc_compile_into_spv(compiler,
+                                                                 glsl_src,
+                                                                 glsl_length,
+                                                                 shader_kind,
+                                                                 path, "main", options);
+
+  if (shaderc_result_get_compilation_status(result) != shaderc_compilation_status_success) {
+    vk_log(VK_ERROR, "SHADER COMPILATION: error: %s\n", shaderc_result_get_error_message(result));
+    shaderc_result_release(result);
+    shaderc_compiler_release(compiler);
+    free(glsl_src);
+    return NULL;
+  }
+
+  shaderc_compiler_release(compiler);
+  free(glsl_src);
+
+  return result;
+}
+
+uint32_t
+findMemoryType(uint32_t typeFilter, VkMemoryPropertyFlags properties)
+{
+  VkPhysicalDeviceMemoryProperties memProperties;
+  vkGetPhysicalDeviceMemoryProperties(s.vk_physical_device, &memProperties);
+
+  for (uint32_t i = 0; i < memProperties.memoryTypeCount; i++) {
+    if ((typeFilter & (1 << i)) && (memProperties.memoryTypes[i].propertyFlags & properties) == properties) {
+        return i;
+    }
+  }
+
+  vk_log(VK_ERROR, "failed to find suitable memory type!\n");
+  return 9999;
+}
+
+void
+createImage(uint32_t width, uint32_t height, VkFormat format,
+            VkImageTiling tiling, VkImageUsageFlags usage,
+            VkMemoryPropertyFlags properties, VkImage *image,
+            VkDeviceMemory *imageMemory)
+{
+  VkImageCreateInfo imageInfo = {0};
+  imageInfo.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
+  imageInfo.imageType = VK_IMAGE_TYPE_2D;
+  imageInfo.extent.width = width;
+  imageInfo.extent.height = height;
+  imageInfo.extent.depth = 1;
+  imageInfo.mipLevels = 1;
+  imageInfo.arrayLayers = 1;
+  imageInfo.format = format;
+  imageInfo.tiling = tiling;
+  imageInfo.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
+  imageInfo.usage = usage;
+  imageInfo.samples = VK_SAMPLE_COUNT_1_BIT;
+  imageInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
+
+  VK_CHECK(vkCreateImage(s.vk_device, &imageInfo, NULL, image));
+
+  VkMemoryRequirements memRequirements;
+  vkGetImageMemoryRequirements(s.vk_device, *image, &memRequirements);
+
+  VkMemoryAllocateInfo allocInfo = {0};
+  allocInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
+  allocInfo.allocationSize = memRequirements.size;
+  allocInfo.memoryTypeIndex = findMemoryType(memRequirements.memoryTypeBits, properties);
+
+  VK_CHECK(vkAllocateMemory(s.vk_device, &allocInfo, NULL, imageMemory));
+
+  vkBindImageMemory(s.vk_device, *image, *imageMemory , 0);
+}
+
+VkCommandBuffer
+beginSingleTimeCommands()
+{
+  VkCommandBufferAllocateInfo allocInfo = {0};
+  allocInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
+  allocInfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
+  allocInfo.commandPool = s.vk_command_pool;
+  allocInfo.commandBufferCount = 1;
+
+  VkCommandBuffer commandBuffer;
+  VK_CHECK(vkAllocateCommandBuffers(s.vk_device, &allocInfo, &commandBuffer));
+
+  VkCommandBufferBeginInfo beginInfo = {0};
+  beginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
+  beginInfo.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
+
+  VK_CHECK(vkBeginCommandBuffer(commandBuffer, &beginInfo));
+
+  return commandBuffer;
+}
+
+void
+endSingleTimeCommands(VkCommandBuffer commandBuffer)
+{
+  VK_CHECK(vkEndCommandBuffer(commandBuffer));
+
+  VkSubmitInfo submitInfo = {0};
+  submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
+  submitInfo.commandBufferCount = 1;
+  submitInfo.pCommandBuffers = &commandBuffer;
+
+  VK_CHECK(vkQueueSubmit(s.vk_graphics_queue, 1, &submitInfo, VK_NULL_HANDLE));
+  VK_CHECK(vkQueueWaitIdle(s.vk_graphics_queue));
+
+  vkFreeCommandBuffers(s.vk_device, s.vk_command_pool, 1, &commandBuffer);
+}
+
+int
+hasStencilComponent(VkFormat format)
+{
+  return format == VK_FORMAT_D32_SFLOAT_S8_UINT || format == VK_FORMAT_D24_UNORM_S8_UINT;
+}
+
+void
+transitionImageLayout(VkImage image, VkFormat format,
+                      VkAccessFlags srcAccessMask, VkAccessFlags dstAccessMask,
+                      VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask,
+                      VkImageLayout oldLayout, VkImageLayout newLayout)
+{
+  VkCommandBuffer commandBuffer = beginSingleTimeCommands();
+
+  VkImageMemoryBarrier barrier = {0};
+  barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
+  barrier.srcAccessMask = srcAccessMask;
+  barrier.dstAccessMask = dstAccessMask;
+  barrier.oldLayout = oldLayout;
+  barrier.newLayout = newLayout;
+  barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
+  barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
+  barrier.image = image;
+
+  // barrier.subresourceRange.aspectMask = 
+  if (newLayout == VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL) {
+    barrier.subresourceRange.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT;
+
+    if (hasStencilComponent(format)) {
+      barrier.subresourceRange.aspectMask |= VK_IMAGE_ASPECT_STENCIL_BIT;
+    }
+  } else {
+    barrier.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
+  }
+
+  barrier.subresourceRange.baseMipLevel = 0;
+  barrier.subresourceRange.levelCount = 1;
+  barrier.subresourceRange.baseArrayLayer = 0;
+  barrier.subresourceRange.layerCount = 1;
+
+  vkCmdPipelineBarrier(commandBuffer,
+                       srcStageMask, dstStageMask,
+                       0,
+                       0, NULL,
+                       0, NULL,
+                       1, &barrier);
+  endSingleTimeCommands(commandBuffer);
+}
+
+VkFormat
+findSupportedFormat(VkFormat *candidates, size_t n,
+                    VkImageTiling tiling,
+                    VkFormatFeatureFlags features)
+{
+  for (size_t i = 0; i < n; i++) {
+    VkFormat format = candidates[i];
+    VkFormatProperties props;
+    vkGetPhysicalDeviceFormatProperties(s.vk_physical_device, format, &props);
+
+    if (tiling == VK_IMAGE_TILING_LINEAR && (props.linearTilingFeatures & features) == features) {
+      return format;
+    } else if (tiling == VK_IMAGE_TILING_OPTIMAL && (props.optimalTilingFeatures & features) == features) {
+      return format;
+    }
+  }
+
+  vk_log(VK_ERROR, "failed to find supported format!\n");
+  abort();
+}
+
+VkFormat
+findDepthFormat()
+{
+  VkFormat formats[] = { VK_FORMAT_D32_SFLOAT, VK_FORMAT_D32_SFLOAT_S8_UINT, VK_FORMAT_D24_UNORM_S8_UINT};
+  return findSupportedFormat(formats, VK_ARRAY_LEN(formats),
+                             VK_IMAGE_TILING_OPTIMAL,
+                             VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT);
+}
+
+void
+vulkan_create_depth_resources()
+{
+  VkFormat depthFormat = findDepthFormat();
+  createImage(s.vk_swap_chain_extent.width, s.vk_swap_chain_extent.height,
+              depthFormat, VK_IMAGE_TILING_OPTIMAL,
+              VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT,
+              VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT,
+              &s.vk_depth_image, &s.vk_depth_image_memory);
+  s.vk_depth_image_view = create_image_view(s.vk_depth_image, depthFormat,
+                                            VK_IMAGE_ASPECT_DEPTH_BIT);
+
+  transitionImageLayout(s.vk_depth_image, depthFormat,
+                        VK_ACCESS_NONE, VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT,
+                        VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT,
+                        VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL);
+}
+
+void
+vulkan_create_graphics_pipeline()
+{
+  shaderc_compilation_result_t vert_result = load_compile_shader_data("src/shader.vert", shaderc_vertex_shader);
+  if (!vert_result) {
+    vk_log(VK_ERROR, "Can't load vertex shader\n");
+    if (s.prev_vert_result) {
+      vert_result = s.prev_vert_result;
+    }
+  }
+  if (s.prev_vert_result && vert_result != s.prev_vert_result) shaderc_result_release(s.prev_vert_result);
+  s.prev_vert_result = vert_result;
+  shaderc_compilation_result_t frag_result = load_compile_shader_data("src/shader.frag", shaderc_fragment_shader);
+  if (!frag_result) {
+    vk_log(VK_ERROR, "Can't load fragment shader\n");
+    if (s.prev_frag_result) {
+      frag_result = s.prev_frag_result;
+    }
+  }
+  if (s.prev_frag_result && frag_result != s.prev_frag_result) shaderc_result_release(s.prev_frag_result);
+  s.prev_frag_result = frag_result;
+
+  const char * vert_data = shaderc_result_get_bytes(vert_result);
+  long vert_size = shaderc_result_get_length(vert_result);
+  const char * frag_data = shaderc_result_get_bytes(frag_result);
+  long frag_size = shaderc_result_get_length(frag_result);
+
+  vk_log(VK_INFO, "Shaders loaded\n");
+
+  VkShaderModule vertShaderModule = createShaderModule(vert_data, vert_size);
+  VkShaderModule fragShaderModule = createShaderModule(frag_data, frag_size);
+
+  VkPipelineShaderStageCreateInfo vertShaderStageInfo = {0};
+  vertShaderStageInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
+  vertShaderStageInfo.stage = VK_SHADER_STAGE_VERTEX_BIT;
+  vertShaderStageInfo.module = vertShaderModule;
+  vertShaderStageInfo.pName = "main";
+
+  VkPipelineShaderStageCreateInfo fragShaderStageInfo = {0};
+  fragShaderStageInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
+  fragShaderStageInfo.stage = VK_SHADER_STAGE_FRAGMENT_BIT;
+  fragShaderStageInfo.module = fragShaderModule;
+  fragShaderStageInfo.pName = "main";
+
+  VkPipelineShaderStageCreateInfo shaderStages[] = {vertShaderStageInfo, fragShaderStageInfo};
+
+  VkDynamicState dynamicStates[] = {
+    VK_DYNAMIC_STATE_VIEWPORT,
+    VK_DYNAMIC_STATE_SCISSOR,
+    VK_DYNAMIC_STATE_DEPTH_TEST_ENABLE,
+    VK_DYNAMIC_STATE_DEPTH_WRITE_ENABLE
+  };
+
+  VkPipelineDynamicStateCreateInfo dynamicState = {0};
+  dynamicState.sType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO;
+  dynamicState.dynamicStateCount = VK_ARRAY_LEN(dynamicStates);
+  dynamicState.pDynamicStates = dynamicStates;
+
+  VkVertexInputBindingDescription bindingDescription = {0};
+  bindingDescription.binding = 0;
+  bindingDescription.stride = sizeof(Vertex);
+  bindingDescription.inputRate = VK_VERTEX_INPUT_RATE_VERTEX;
+
+  VkVertexInputAttributeDescription attributeDescriptions[3] = {0};
+  attributeDescriptions[0].binding = 0;
+  attributeDescriptions[0].location = 0;
+  attributeDescriptions[0].format = VK_FORMAT_R32G32B32_SFLOAT;
+  attributeDescriptions[0].offset = offsetof(Vertex, pos);
+
+  attributeDescriptions[1].binding = 0;
+  attributeDescriptions[1].location = 1;
+  attributeDescriptions[1].format = VK_FORMAT_R32G32B32_SFLOAT;
+  attributeDescriptions[1].offset = offsetof(Vertex, color);
+
+  attributeDescriptions[2].binding = 0;
+  attributeDescriptions[2].location = 2;
+  attributeDescriptions[2].format = VK_FORMAT_R32G32_SFLOAT;
+  attributeDescriptions[2].offset = offsetof(Vertex, texCoord);
+
+  VkPipelineVertexInputStateCreateInfo vertexInputInfo = {0};
+  vertexInputInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO;
+  vertexInputInfo.vertexBindingDescriptionCount = 1;
+  vertexInputInfo.pVertexBindingDescriptions = &bindingDescription;
+  vertexInputInfo.vertexAttributeDescriptionCount = VK_ARRAY_LEN(attributeDescriptions);
+  vertexInputInfo.pVertexAttributeDescriptions = attributeDescriptions;
+
+  VkPipelineInputAssemblyStateCreateInfo inputAssembly = {};
+  inputAssembly.sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO;
+  inputAssembly.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
+  inputAssembly.primitiveRestartEnable = VK_FALSE;
+
+  VkViewport viewport = {0};
+  viewport.x = 0.0f;
+  viewport.y = 0.0f;
+  viewport.width = (float) s.vk_swap_chain_extent.width;
+  viewport.height = (float) s.vk_swap_chain_extent.height;
+  viewport.minDepth = 0.0f;
+  viewport.maxDepth = 1.0f;
+
+  VkRect2D scissor = {0};
+  scissor.offset = (VkOffset2D){0, 0};
+  scissor.extent = s.vk_swap_chain_extent;
+
+  VkPipelineViewportStateCreateInfo viewportState = {
+    .sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO,
+    .viewportCount = 1,
+    .pViewports = &viewport,
+    .scissorCount = 1,
+    .pScissors = &scissor,
+  };
+
+  VkPipelineRasterizationStateCreateInfo rasterizer = {0};
+  rasterizer.sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO;
+  rasterizer.depthClampEnable = VK_FALSE;
+  rasterizer.rasterizerDiscardEnable = VK_FALSE;
+  rasterizer.polygonMode = VK_POLYGON_MODE_FILL;
+  rasterizer.lineWidth = 1.0f;
+  rasterizer.cullMode = VK_CULL_MODE_NONE;
+  //rasterizer.cullMode = VK_CULL_MODE_BACK_BIT;
+  //rasterizer.frontFace = VK_FRONT_FACE_COUNTER_CLOCKWISE;
+  rasterizer.depthBiasEnable = VK_FALSE;
+  rasterizer.depthBiasConstantFactor = 0.0f; // Optional
+  rasterizer.depthBiasClamp = 0.0f; // Optional
+  rasterizer.depthBiasSlopeFactor = 0.0f; // Optional
+
+  VkPipelineMultisampleStateCreateInfo multisampling = {0};
+  multisampling.sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO;
+  multisampling.sampleShadingEnable = VK_FALSE;
+  multisampling.rasterizationSamples = VK_SAMPLE_COUNT_1_BIT;
+  multisampling.minSampleShading = 1.0f; // Optional
+  multisampling.pSampleMask = NULL; // Optional
+  multisampling.alphaToCoverageEnable = VK_FALSE; // Optional
+  multisampling.alphaToOneEnable = VK_FALSE; // Optional
+
+  VkPipelineColorBlendAttachmentState colorBlendAttachment = {0};
+  colorBlendAttachment.colorWriteMask = VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT;
+  colorBlendAttachment.blendEnable = VK_TRUE;
+  colorBlendAttachment.srcColorBlendFactor = VK_BLEND_FACTOR_SRC_ALPHA;
+  colorBlendAttachment.dstColorBlendFactor = VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA;
+  colorBlendAttachment.colorBlendOp = VK_BLEND_OP_ADD;
+  colorBlendAttachment.srcAlphaBlendFactor = VK_BLEND_FACTOR_ONE;
+  colorBlendAttachment.dstAlphaBlendFactor = VK_BLEND_FACTOR_ZERO;
+  colorBlendAttachment.alphaBlendOp = VK_BLEND_OP_ADD;
+  /* colorBlendAttachment.blendEnable = VK_FALSE; */
+  /* colorBlendAttachment.srcColorBlendFactor = VK_BLEND_FACTOR_ONE; // Optional */
+  /* colorBlendAttachment.dstColorBlendFactor = VK_BLEND_FACTOR_ZERO; // Optional */
+  /* colorBlendAttachment.colorBlendOp = VK_BLEND_OP_ADD; // Optional */
+  /* colorBlendAttachment.srcAlphaBlendFactor = VK_BLEND_FACTOR_ONE; // Optional */
+  /* colorBlendAttachment.dstAlphaBlendFactor = VK_BLEND_FACTOR_ZERO; // Optional */
+  /* colorBlendAttachment.alphaBlendOp = VK_BLEND_OP_ADD; // Optional   */
+
+  VkPipelineColorBlendStateCreateInfo colorBlending = {0};
+  colorBlending.sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO;
+  colorBlending.logicOpEnable = VK_TRUE;
+  colorBlending.logicOp = VK_LOGIC_OP_COPY; // Optional
+  colorBlending.attachmentCount = 1;
+  colorBlending.pAttachments = &colorBlendAttachment;
+  colorBlending.blendConstants[0] = 0.0f; // Optional
+  colorBlending.blendConstants[1] = 0.0f; // Optional
+  colorBlending.blendConstants[2] = 0.0f; // Optional
+  colorBlending.blendConstants[3] = 0.0f; // Optional
+
+  VkPipelineLayoutCreateInfo pipelineLayoutInfo = {0};
+  pipelineLayoutInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO;
+  pipelineLayoutInfo.setLayoutCount = 1;
+  pipelineLayoutInfo.pSetLayouts = &s.vk_descriptor_set_layout;
+  pipelineLayoutInfo.pushConstantRangeCount = 0; // Optional
+  pipelineLayoutInfo.pPushConstantRanges = NULL; // Optional
+
+  if (vkCreatePipelineLayout(s.vk_device, &pipelineLayoutInfo, NULL, &s.vk_pipeline_layout) != VK_SUCCESS) {
+    vk_log(VK_ERROR, "failed to create pipeline layout!\n");
+  }
+
+  VkPipelineDepthStencilStateCreateInfo depthStencil = {0};
+  depthStencil.sType = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO;
+  depthStencil.depthTestEnable = VK_TRUE;
+  depthStencil.depthWriteEnable = VK_TRUE;
+  depthStencil.depthBoundsTestEnable = VK_FALSE;
+  depthStencil.stencilTestEnable = VK_FALSE;
+  depthStencil.depthCompareOp = VK_COMPARE_OP_LESS;
+  depthStencil.minDepthBounds = 0.0f; // Optional
+  depthStencil.maxDepthBounds = 1.0f; // Optional
+  depthStencil.front = (VkStencilOpState){0}; // Optional
+  depthStencil.back = (VkStencilOpState){0}; // Optional
+
+  // TODO depthAttachment
+  VkPipelineRenderingCreateInfo pipeline_rendering_create_info = {
+      .sType = VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO_KHR,
+      .colorAttachmentCount = 1,
+      .pColorAttachmentFormats = &s.vk_swap_chain_image_format,
+      .depthAttachmentFormat = findDepthFormat(),
+    };
+  VkGraphicsPipelineCreateInfo pipelineInfo = {0};
+  pipelineInfo.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO;
+  pipelineInfo.stageCount = 2;
+  pipelineInfo.pStages = shaderStages;
+
+  pipelineInfo.pNext = &pipeline_rendering_create_info,
+  pipelineInfo.pVertexInputState = &vertexInputInfo;
+  pipelineInfo.pInputAssemblyState = &inputAssembly;
+  pipelineInfo.pViewportState = &viewportState;
+  pipelineInfo.pRasterizationState = &rasterizer;
+  pipelineInfo.pMultisampleState = &multisampling;
+  pipelineInfo.pDepthStencilState = &depthStencil;
+  pipelineInfo.pColorBlendState = &colorBlending;
+  pipelineInfo.pDynamicState = &dynamicState;
+  pipelineInfo.layout = s.vk_pipeline_layout;
+  pipelineInfo.renderPass = VK_NULL_HANDLE;
+  pipelineInfo.subpass = 0;
+  pipelineInfo.basePipelineHandle = VK_NULL_HANDLE; // Optional
+  pipelineInfo.basePipelineIndex = -1; // Optional
+
+  if (vkCreateGraphicsPipelines(s.vk_device, VK_NULL_HANDLE, 1, &pipelineInfo, NULL, &s.vk_graphics_pipeline) != VK_SUCCESS) {
+    vk_log(VK_ERROR, "failed to create graphics pipeline!\n");
+  }
+
+  if (s.prev_vert_result != vert_result) {
+    shaderc_result_release(vert_result);
+  }
+  if (s.prev_frag_result != frag_result) {
+    shaderc_result_release(frag_result);
+  }
+
+  vkDestroyShaderModule(s.vk_device, fragShaderModule, NULL);
+  vkDestroyShaderModule(s.vk_device, vertShaderModule, NULL);
+}
+
+void
+vulkan_create_command_pool()
+{
+  QueueFamilyIndices queueFamilyIndices = vulkan_find_queue_families(s.vk_physical_device);
+
+  VkCommandPoolCreateInfo poolInfo = {0};
+  poolInfo.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
+  poolInfo.flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT;
+  poolInfo.queueFamilyIndex = queueFamilyIndices.graphicsFamily;
+
+  VK_CHECK(vkCreateCommandPool(s.vk_device, &poolInfo, NULL, &s.vk_command_pool));
+}
+
+void
+vulkan_create_command_buffer()
+{
+  // TODO Find a way to group allocation
+  for (int i = 0; i < MAX_FRAMES_IN_FLIGHT; i++) {
+    VkCommandBufferAllocateInfo allocInfo = {0};
+    allocInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
+    allocInfo.commandPool = s.vk_command_pool;
+    allocInfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
+    allocInfo.commandBufferCount = 1;
+
+    VK_CHECK(vkAllocateCommandBuffers(s.vk_device, &allocInfo, &s.frames[i].vk_command_buffer));
+  }
+}
+
+void
+recordCommandBuffer(VkCommandBuffer commandBuffer, uint32_t imageIndex)
+{
+  VkCommandBufferBeginInfo beginInfo = {0};
+  beginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
+  beginInfo.flags = 0; // Optional
+  beginInfo.pInheritanceInfo = NULL; // Optional
+
+  VK_CHECK(vkBeginCommandBuffer(commandBuffer, &beginInfo));
+  vkCmdSetDepthTestEnable(commandBuffer, 1);
+  vkCmdSetDepthWriteEnable(commandBuffer, 1);
+
+  transitionImageLayout(
+                        s.vk_swap_chain_images[imageIndex], VK_FORMAT_R8G8B8A8_SRGB, 0,
+                        VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
+                        VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, VK_IMAGE_LAYOUT_UNDEFINED,
+                        VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL);
+
+  VkRenderingAttachmentInfo colorAttachment = {0};
+  colorAttachment.sType = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO;
+  colorAttachment.imageView = s.vk_swap_chain_image_views[imageIndex];
+  colorAttachment.imageLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
+  colorAttachment.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
+  colorAttachment.storeOp = VK_ATTACHMENT_STORE_OP_STORE;
+  colorAttachment.clearValue.color =
+    (VkClearColorValue){0.0f, 0.0f, 0.0f, 1.0f};
+
+  VkRenderingAttachmentInfo depthAttachment = {0};
+  depthAttachment.sType = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO;
+  depthAttachment.imageView = s.vk_depth_image_view;
+  depthAttachment.imageLayout = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL;
+  depthAttachment.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
+  depthAttachment.storeOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
+  depthAttachment.clearValue.depthStencil = (VkClearDepthStencilValue){1.0f, 0u};
+
+  VkRenderingInfo renderingInfo = {};
+  renderingInfo.sType = VK_STRUCTURE_TYPE_RENDERING_INFO;
+  renderingInfo.renderArea =
+      (VkRect2D){{0, 0}, s.vk_swap_chain_extent};
+  renderingInfo.layerCount = 1;
+  renderingInfo.colorAttachmentCount = 1;
+  renderingInfo.pColorAttachments = &colorAttachment;
+  renderingInfo.pDepthAttachment = &depthAttachment;
+
+  vkCmdBeginRendering(commandBuffer, &renderingInfo);
+
+  vkCmdBindPipeline(commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS,
+                    s.vk_graphics_pipeline);
+
+  VkViewport viewport = {0};
+  viewport.x = 0.0f;
+  viewport.y = 0.0f;
+  viewport.width = (float)(s.vk_swap_chain_extent.width);
+  viewport.height = (float)(s.vk_swap_chain_extent.height);
+  viewport.minDepth = 0.0f;
+  viewport.maxDepth = 1.0f;
+  vkCmdSetViewport(commandBuffer, 0, 1, &viewport);
+
+  VkRect2D scissor = {0};
+  scissor.offset = (VkOffset2D){0, 0};
+  scissor.extent = s.vk_swap_chain_extent;
+  vkCmdSetScissor(commandBuffer, 0, 1, &scissor);
+
+  VkBuffer vertexBuffers[] = {s.vk_vertex_buffer};
+  VkDeviceSize offsets[] = {0};
+  vkCmdBindVertexBuffers(commandBuffer, 0, 1, vertexBuffers, offsets);
+  vkCmdBindIndexBuffer(commandBuffer, s.vk_index_buffer, 0,
+                       VK_INDEX_TYPE_UINT16);
+  vkCmdBindDescriptorSets(commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS,
+                          s.vk_pipeline_layout, 0, 1,
+                          &s.frames[currentFrame].vk_descriptor_set, 0, NULL);
+
+  
+  vkCmdDrawIndexed(commandBuffer, INDICES_SIZE, 1, 0, 0, 0);
+  vkCmdEndRendering(commandBuffer);
+
+  transitionImageLayout(s.vk_swap_chain_images[imageIndex],
+                        VK_FORMAT_R8G8B8A8_SRGB,
+                        VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, 0,
+                        VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
+                        VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT,
+                        VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
+                        VK_IMAGE_LAYOUT_PRESENT_SRC_KHR);
+
+  VK_CHECK(vkEndCommandBuffer(commandBuffer));
+}
+
+void
+vulkan_create_sync_objects()
+{
+  VkSemaphoreCreateInfo semaphoreInfo = {0};
+  semaphoreInfo.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO;
+
+  VkFenceCreateInfo fenceInfo = {0};
+  fenceInfo.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
+  fenceInfo.flags = VK_FENCE_CREATE_SIGNALED_BIT;
+
+  for (size_t i = 0; i < MAX_FRAMES_IN_FLIGHT; i++) {
+    VK_CHECK(vkCreateSemaphore(s.vk_device, &semaphoreInfo, NULL, &s.frames[i].image_available_semaphore));
+    VK_CHECK(vkCreateSemaphore(s.vk_device, &semaphoreInfo, NULL, &s.frames[i].render_finished_semaphore));
+    VK_CHECK(vkCreateFence(s.vk_device, &fenceInfo, NULL, &s.frames[i].in_flight_fence));
+  }
+}
+
+void
+createBuffer(VkDeviceSize size,
+             VkBufferUsageFlags usage,
+             VkMemoryPropertyFlags properties,
+             VkBuffer *buffer, VkDeviceMemory *bufferMemory)
+{
+  VkBufferCreateInfo bufferInfo = {0};
+  bufferInfo.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
+  bufferInfo.size = size;
+  bufferInfo.usage = usage;
+  bufferInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
+
+  VK_CHECK(vkCreateBuffer(s.vk_device, &bufferInfo, NULL, buffer));
+
+  VkMemoryRequirements memRequirements;
+  vkGetBufferMemoryRequirements(s.vk_device, *buffer, &memRequirements);
+
+  VkMemoryAllocateInfo allocInfo = {0};
+  allocInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
+  allocInfo.allocationSize = memRequirements.size;
+  allocInfo.memoryTypeIndex = findMemoryType(memRequirements.memoryTypeBits, properties);
+
+  // TODO: group allocations etc... (allocations limited by hardware)
+  VK_CHECK(vkAllocateMemory(s.vk_device, &allocInfo, NULL, bufferMemory));
+
+  VK_CHECK(vkBindBufferMemory(s.vk_device, *buffer, *bufferMemory, 0));
+}
+
+void copy_buffer(VkBuffer srcBuffer, VkBuffer dstBuffer, VkDeviceSize size) {
+  VkCommandBuffer commandBuffer = beginSingleTimeCommands();
+    VkBufferCopy copyRegion = {0};
+    copyRegion.srcOffset = 0; // Optional
+    copyRegion.dstOffset = 0; // Optional
+    copyRegion.size = size;
+    vkCmdCopyBuffer(commandBuffer, srcBuffer, dstBuffer, 1, &copyRegion);
+  endSingleTimeCommands(commandBuffer);
+}
+
+void
+vulkan_create_vertex_buffer()
+{
+  VkDeviceSize bufferSize = sizeof(vertices[0]) * VERTICES_SIZE;
+
+  VkBuffer stagingBuffer;
+  VkDeviceMemory stagingBufferMemory;
+
+  createBuffer(bufferSize,
+               VK_BUFFER_USAGE_TRANSFER_SRC_BIT,
+               VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
+               &stagingBuffer, &stagingBufferMemory);
+
+  void* data;
+  VK_CHECK(vkMapMemory(s.vk_device, stagingBufferMemory, 0, bufferSize, 0, &data));
+  memcpy(data, vertices, (size_t) bufferSize);
+  vkUnmapMemory(s.vk_device, stagingBufferMemory);
+
+  createBuffer(bufferSize,
+               VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_VERTEX_BUFFER_BIT,
+               VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT,
+               &s.vk_vertex_buffer, &s.vk_vertex_buffer_memory);
+
+  copy_buffer(stagingBuffer, s.vk_vertex_buffer, bufferSize);
+
+  vkDestroyBuffer(s.vk_device, stagingBuffer, NULL);
+  vkFreeMemory(s.vk_device, stagingBufferMemory, NULL);
+}
+
+void
+vulkan_create_index_buffer()
+{
+  VkDeviceSize bufferSize = sizeof(indices[0]) * INDICES_SIZE;
+
+  VkBuffer stagingBuffer;
+  VkDeviceMemory stagingBufferMemory;
+
+  createBuffer(bufferSize,
+               VK_BUFFER_USAGE_TRANSFER_SRC_BIT,
+               VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
+               &stagingBuffer, &stagingBufferMemory);
+
+  void* data;
+  VK_CHECK(vkMapMemory(s.vk_device, stagingBufferMemory, 0, bufferSize, 0, &data));
+  memcpy(data, indices, (size_t) bufferSize);
+  vkUnmapMemory(s.vk_device, stagingBufferMemory);
+
+  createBuffer(bufferSize,
+               VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_INDEX_BUFFER_BIT,
+               VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT,
+               &s.vk_index_buffer, &s.vk_index_buffer_memory);
+
+  copy_buffer(stagingBuffer, s.vk_index_buffer, bufferSize);
+
+  vkDestroyBuffer(s.vk_device, stagingBuffer, NULL);
+  vkFreeMemory(s.vk_device, stagingBufferMemory, NULL);
+}
+
+void
+vulkan_create_descriptor_set_layout()
+{
+  VkDescriptorSetLayoutBinding uboLayoutBinding = {0};
+  uboLayoutBinding.binding = 0;
+  uboLayoutBinding.descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
+  uboLayoutBinding.descriptorCount = 1;
+  uboLayoutBinding.stageFlags = VK_SHADER_STAGE_ALL;
+  //uboLayoutBinding.stageFlags = VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT;
+  uboLayoutBinding.pImmutableSamplers = NULL; // optional
+
+  VkDescriptorSetLayoutBinding samplerLayoutBinding = {0};
+  samplerLayoutBinding.binding = 1;
+  samplerLayoutBinding.descriptorCount = 1;
+  samplerLayoutBinding.descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
+  samplerLayoutBinding.pImmutableSamplers = NULL;
+  samplerLayoutBinding.stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT;
+
+  VkDescriptorSetLayoutBinding bindings[2] = {uboLayoutBinding, samplerLayoutBinding};
+  
+  VkDescriptorSetLayoutCreateInfo layoutInfo = {0};
+  layoutInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO;
+  layoutInfo.bindingCount = VK_ARRAY_LEN(bindings);
+  layoutInfo.pBindings = bindings;
+
+  VK_CHECK(vkCreateDescriptorSetLayout(s.vk_device, &layoutInfo, NULL, &s.vk_descriptor_set_layout));
+}
+
+void
+vulkan_create_uniform_buffers()
+{
+  VkDeviceSize bufferSize = sizeof(UniformBufferObject);
+
+  for (size_t i = 0; i < MAX_FRAMES_IN_FLIGHT; i++) {
+    createBuffer(bufferSize,
+                 VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT,
+                 VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
+                 &s.frames[i].vk_uniform_buffer, &s.frames[i].vk_uniform_buffer_memory);
+
+    VK_CHECK(vkMapMemory(s.vk_device, s.frames[i].vk_uniform_buffer_memory, 0, bufferSize, 0, &s.frames[i].vk_uniform_buffer_mapped));
+  }
+}
+
+void
+vulkan_create_descriptor_pool()
+{
+  VkDescriptorPoolSize poolSizes[2] = {0};
+  poolSizes[0].type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
+  poolSizes[0].descriptorCount = MAX_FRAMES_IN_FLIGHT;
+  poolSizes[1].type = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
+  poolSizes[1].descriptorCount = MAX_FRAMES_IN_FLIGHT;
+
+  VkDescriptorPoolCreateInfo poolInfo = {0};
+  poolInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
+  poolInfo.poolSizeCount = VK_ARRAY_LEN(poolSizes);
+  poolInfo.pPoolSizes = poolSizes;
+  poolInfo.maxSets = MAX_FRAMES_IN_FLIGHT;
+
+  VK_CHECK(vkCreateDescriptorPool(s.vk_device, &poolInfo, NULL, &s.vk_descriptor_pool));
+}
+
+void
+vulkan_create_descriptor_sets()
+{
+  VkDescriptorSetLayout layouts[MAX_FRAMES_IN_FLIGHT] = {0};
+
+  for (int i = 0; i < MAX_FRAMES_IN_FLIGHT; i++) {
+    layouts[i] = s.vk_descriptor_set_layout;
+  }
+
+  // TODO Find a way to group allocation
+  for (size_t i = 0; i < MAX_FRAMES_IN_FLIGHT; i++) {
+    VkDescriptorSetAllocateInfo allocInfo = {0};
+    allocInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO;
+    allocInfo.descriptorPool = s.vk_descriptor_pool;
+    allocInfo.descriptorSetCount = 1;
+    allocInfo.pSetLayouts = layouts;
+
+    VK_CHECK(vkAllocateDescriptorSets(s.vk_device, &allocInfo, &s.frames[i].vk_descriptor_set));
+  }
+
+  for (size_t i = 0; i < MAX_FRAMES_IN_FLIGHT; i++) {
+    VkDescriptorBufferInfo bufferInfo = {0};
+    bufferInfo.buffer = s.frames[i].vk_uniform_buffer;
+    bufferInfo.offset = 0;
+    bufferInfo.range = sizeof(UniformBufferObject);
+
+    VkDescriptorImageInfo imageInfo = {0};
+    imageInfo.imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
+    imageInfo.imageView = s.vk_texture_image_view;
+    imageInfo.sampler = s.vk_texture_sampler;
+
+    VkWriteDescriptorSet descriptorWrites[2] = {0};
+    descriptorWrites[0].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
+    descriptorWrites[0].dstSet = s.frames[i].vk_descriptor_set;
+    descriptorWrites[0].dstBinding = 0;
+    descriptorWrites[0].dstArrayElement = 0;
+    descriptorWrites[0].descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
+    descriptorWrites[0].descriptorCount = 1;
+    descriptorWrites[0].pBufferInfo = &bufferInfo;
+
+    descriptorWrites[1].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
+    descriptorWrites[1].dstSet = s.frames[i].vk_descriptor_set;
+    descriptorWrites[1].dstBinding = 1;
+    descriptorWrites[1].dstArrayElement = 0;
+    descriptorWrites[1].descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
+    descriptorWrites[1].descriptorCount = 1;
+    descriptorWrites[1].pImageInfo = &imageInfo;
+
+    vkUpdateDescriptorSets(s.vk_device, VK_ARRAY_LEN(descriptorWrites), descriptorWrites, 0, NULL);
+  }
+}
+
+void
+cleanupSwapChain()
+{
+  vkDestroyImageView(s.vk_device, s.vk_depth_image_view, NULL);
+  vkDestroyImage(s.vk_device, s.vk_depth_image, NULL);
+  vkFreeMemory(s.vk_device, s.vk_depth_image_memory, NULL);
+
+  for (uint32_t i = 0; i < s.vk_swap_chain_image_count; i++) {
+    vkDestroyImageView(s.vk_device, s.vk_swap_chain_image_views[i], NULL);
+  }
+  vkDestroySwapchainKHR(s.vk_device, s.vk_swap_chain, NULL);
+}
+
+void
+recreateSwapChain()
+{
+  vkDeviceWaitIdle(s.vk_device);
+
+  cleanupSwapChain();
+
+  vulkan_create_swap_chain();
+  vulkan_create_image_views();
+  vulkan_create_depth_resources();
+}
+
+void
+handle_input(bool * quit)
+{
+  SDL_Event e;
+
+  while (SDL_PollEvent(&e) != 0) {
+    // User requests quit
+    if (e.type == SDL_QUIT) {
+      *quit = true;
+    }
+      // User presses a key
+    else if (e.type == SDL_KEYDOWN) {
+      switch (e.key.keysym.sym) {
+      case SDLK_w:
+        s.camera.pos[0] += 0.1f;
+        break;
+      case SDLK_s:
+        s.camera.pos[0] -= 0.1f;
+        break;
+      case SDLK_LEFT:
+        break;
+      case SDLK_g: // reload shaders
+        recreateSwapChain();
+        vkDestroyPipeline(s.vk_device, s.vk_graphics_pipeline, NULL);
+        vkDestroyPipelineLayout(s.vk_device, s.vk_pipeline_layout, NULL);
+        vulkan_create_graphics_pipeline();
+        break;
+      case SDLK_l:
+        s.rotate = s.rotate ? 0 : 1;
+        break;
+      case SDLK_r:
+        s.camera.pos[0] = 1.0f;
+        s.camera.pos[1] = 1.0f;
+        s.camera.pos[2] = 1.0f;
+
+        s.camera.front[0] = 0.0f;
+        s.camera.front[1] = 0.0f;
+        s.camera.front[2] = 0.0f;
+
+        s.camera.up[0] = 0.0f;
+        s.camera.up[1] = 0.0f;
+        s.camera.up[2] = 1.0f;
+
+        s.camera.yaw = 0.0f;
+        s.camera.pitch = 90.0f;
+        s.camera.lastX = 400.0f;
+        s.camera.lastY = 300.0f;
+        s.camera.fov = 45.0f;
+        update_camera(0,0);
+        break;
+      }
+    }
+    else if (e.type == SDL_MOUSEWHEEL) {
+      if(e.wheel.y > 0) // scroll up
+        {
+          s.zoom += 1;
+        }
+      else if(e.wheel.y < 0) // scroll down
+        {
+          s.zoom -= 1;
+          if (s.zoom == -100) s.zoom = 1;
+        }
+    }
+    else if (e.type == SDL_MOUSEBUTTONDOWN) {
+      s.mouse_pressed = 1;
+    }
+    else if (e.type == SDL_MOUSEBUTTONUP) {
+      s.mouse_pressed = 0;
+    }
+    mouseCallback(&e);
+  }
+}
+
+void
+copyBufferToImage(VkBuffer buffer, VkImage image, uint32_t width,
+                  uint32_t height)
+{
+  VkCommandBuffer commandBuffer = beginSingleTimeCommands();
+
+  VkBufferImageCopy region = {0};
+  region.bufferOffset = 0;
+  region.bufferRowLength = 0;
+  region.bufferImageHeight = 0;
+
+  region.imageSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
+  region.imageSubresource.mipLevel = 0;
+  region.imageSubresource.baseArrayLayer = 0;
+  region.imageSubresource.layerCount = 1;
+
+  region.imageOffset = (VkOffset3D){0, 0, 0};
+  region.imageExtent = (VkExtent3D){width, height, 1};
+
+  vkCmdCopyBufferToImage(commandBuffer,
+                         buffer,
+                         image,
+                         VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
+                         1,
+                         &region
+                         );
+
+  endSingleTimeCommands(commandBuffer);
+}
+
+void
+vulkan_create_texture_image()
+{
+  int texWidth, texHeight, texChannels;
+  stbi_uc* pixels = stbi_load("assets/texture.jpg", &texWidth, &texHeight, &texChannels, STBI_rgb_alpha);
+  VkDeviceSize imageSize = texWidth * texHeight * 4;
+
+  if (!pixels) {
+    vk_log(VK_ERROR, "failed to load texture image!\n");
+  }
+
+  VkBuffer stagingBuffer;
+  VkDeviceMemory stagingBufferMemory;
+
+  createBuffer(imageSize, VK_BUFFER_USAGE_TRANSFER_SRC_BIT, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT, &stagingBuffer, &stagingBufferMemory);
+  void* data;
+  vkMapMemory(s.vk_device, stagingBufferMemory, 0, imageSize, 0, &data);
+  memcpy(data, pixels, (size_t)imageSize);
+  vkUnmapMemory(s.vk_device, stagingBufferMemory);
+
+  stbi_image_free(pixels);
+
+  createImage(texWidth, texHeight, VK_FORMAT_R8G8B8A8_SRGB,
+              VK_IMAGE_TILING_OPTIMAL,
+              VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_SAMPLED_BIT,
+              VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, &s.vk_texture_image,
+              &s.vk_texture_image_memory);
+
+  transitionImageLayout(
+                        s.vk_texture_image, VK_FORMAT_R8G8B8A8_SRGB, 0,
+                        VK_ACCESS_TRANSFER_WRITE_BIT, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
+                        VK_PIPELINE_STAGE_TRANSFER_BIT, VK_IMAGE_LAYOUT_UNDEFINED,
+                        VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);
+  copyBufferToImage(stagingBuffer, s.vk_texture_image, (uint32_t)texWidth,
+                    (uint32_t)texHeight);
+  transitionImageLayout(
+                        s.vk_texture_image, VK_FORMAT_R8G8B8A8_SRGB,
+                        VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_SHADER_READ_BIT,
+                        VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT,
+                        VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
+                        VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL);
+
+  vkDestroyBuffer(s.vk_device, stagingBuffer, NULL);
+  vkFreeMemory(s.vk_device, stagingBufferMemory, NULL);
+}
+
+void
+vulkan_create_texture_image_view()
+{
+  s.vk_texture_image_view = create_image_view(s.vk_texture_image, VK_FORMAT_R8G8B8A8_SRGB, VK_IMAGE_ASPECT_COLOR_BIT);
+}
+
+void vulkan_create_texture_sampler() {
+  VkSamplerCreateInfo samplerInfo = {0};
+  samplerInfo.sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO;
+  samplerInfo.magFilter = VK_FILTER_LINEAR;
+  samplerInfo.minFilter = VK_FILTER_LINEAR;
+  samplerInfo.addressModeU = VK_SAMPLER_ADDRESS_MODE_REPEAT;
+  samplerInfo.addressModeV = VK_SAMPLER_ADDRESS_MODE_REPEAT;
+  samplerInfo.addressModeW = VK_SAMPLER_ADDRESS_MODE_REPEAT;
+  samplerInfo.anisotropyEnable = VK_TRUE;
+
+  VkPhysicalDeviceProperties properties = {0};
+  vkGetPhysicalDeviceProperties(s.vk_physical_device, &properties);
+
+  samplerInfo.maxAnisotropy = properties.limits.maxSamplerAnisotropy;
+  samplerInfo.borderColor = VK_BORDER_COLOR_INT_OPAQUE_BLACK;
+  samplerInfo.unnormalizedCoordinates = VK_FALSE;
+  samplerInfo.compareEnable = VK_FALSE;
+  samplerInfo.compareOp = VK_COMPARE_OP_ALWAYS;
+  samplerInfo.mipmapMode = VK_SAMPLER_MIPMAP_MODE_LINEAR;
+  samplerInfo.mipLodBias = 0.0f;
+  samplerInfo.minLod = 0.0f;
+  samplerInfo.maxLod = 0.0f;
+
+  VK_CHECK(vkCreateSampler(s.vk_device, &samplerInfo, NULL, &s.vk_texture_sampler));
+}
+
+void
+init_vulkan()
+{
+  vk_log(VK_WARN, "====================================\n");
+  vk_log(VK_WARN, "              DEBUG ON              \n");
+  vk_log(VK_WARN, "====================================\n");
+
+  vulkan_create_instance();
+  // vulkan_setup_debug_messenger();
+  vulkan_create_surface();
+  vulkan_pick_physical_device();
+  vulkan_create_logical_device();
+  vulkan_create_swap_chain();
+  vulkan_create_image_views();
+  vulkan_create_descriptor_set_layout();
+  vulkan_create_graphics_pipeline();
+  vulkan_create_command_pool();
+  vulkan_create_depth_resources();
+  vulkan_create_texture_image();
+  vulkan_create_texture_image_view();
+  vulkan_create_texture_sampler();
+  vulkan_create_vertex_buffer();
+  vulkan_create_index_buffer();
+  vulkan_create_uniform_buffers();
+  vulkan_create_descriptor_pool();
+  vulkan_create_descriptor_sets();
+  vulkan_create_command_buffer();
+  vulkan_create_sync_objects();
+}
+
+void
+close_vulkan()
+{
+  vkDeviceWaitIdle(s.vk_device);
+  // Cleanup
+  for (size_t i = 0; i < MAX_FRAMES_IN_FLIGHT; i++) {
+    vkDestroySemaphore(s.vk_device, s.frames[i].image_available_semaphore, NULL);
+    vkDestroySemaphore(s.vk_device, s.frames[i].render_finished_semaphore, NULL);
+    vkDestroyFence(s.vk_device, s.frames[i].in_flight_fence, NULL);
+  }
+
+  vkDestroyCommandPool(s.vk_device, s.vk_command_pool, NULL);
+
+  cleanupSwapChain();
+
+  vkDestroySampler(s.vk_device, s.vk_texture_sampler, NULL);
+  vkDestroyImageView(s.vk_device, s.vk_texture_image_view, NULL);
+
+  vkDestroyImage(s.vk_device, s.vk_texture_image, NULL);
+  vkFreeMemory(s.vk_device, s.vk_texture_image_memory, NULL);
+
+  for (size_t i = 0; i < MAX_FRAMES_IN_FLIGHT; i++) {
+    vkDestroyBuffer(s.vk_device, s.frames[i].vk_uniform_buffer, NULL);
+    vkFreeMemory(s.vk_device, s.frames[i].vk_uniform_buffer_memory, NULL);
+  }
+  vkDestroyDescriptorPool(s.vk_device, s.vk_descriptor_pool, NULL);
+  vkDestroyDescriptorSetLayout(s.vk_device, s.vk_descriptor_set_layout, NULL);
+
+  vkDestroyBuffer(s.vk_device, s.vk_vertex_buffer, NULL);
+  vkFreeMemory(s.vk_device, s.vk_vertex_buffer_memory, NULL);
+
+  vkDestroyBuffer(s.vk_device, s.vk_index_buffer, NULL);
+  vkFreeMemory(s.vk_device, s.vk_index_buffer_memory, NULL);
+
+  vkDestroyPipeline(s.vk_device, s.vk_graphics_pipeline, NULL);
+  vkDestroyPipelineLayout(s.vk_device, s.vk_pipeline_layout, NULL);
+  vkDestroyDevice(s.vk_device, NULL);
+  vkDestroySurfaceKHR(s.vk_instance, s.vk_surface, NULL);
+  /* if (enableValidationLayers) { */
+  /*   DestroyDebugUtilsMessengerEXT(s.vk_instance, s.vk_debug_messenger, NULL); */
+  /* } */
+  vkDestroyInstance(s.vk_instance, NULL);
+
+  if (s.prev_vert_result) {
+    shaderc_result_release(s.prev_vert_result);
+  }
+  if (s.prev_frag_result) {
+    shaderc_result_release(s.prev_frag_result);
+  }
+}
+
+float
+current_time()
+{
+  static struct timespec startTime;
+  static int isStartTimeInitialized = 0;
+
+  if (!isStartTimeInitialized) {
+    clock_gettime(CLOCK_MONOTONIC, &startTime);
+    isStartTimeInitialized = 1;
+  }
+
+  struct timespec currentTime;
+  clock_gettime(CLOCK_MONOTONIC, &currentTime);
+
+  return (currentTime.tv_sec - startTime.tv_sec) +
+         (currentTime.tv_nsec - startTime.tv_nsec) / 1e9f;
+}
+
+void
+updateUniformBuffer(uint32_t currentImage)
+{
+  float time = current_time();
+
+  UniformBufferObject ubo = {0};
+
+  ubo.resolution[0] = s.vk_swap_chain_extent.width;
+  ubo.resolution[1] = s.vk_swap_chain_extent.height;
+  
+  glm_mat4_identity(ubo.model);
+
+  if (s.rotate)
+    glm_rotate(ubo.model, glm_rad(50 * time * glm_rad(90.0f)), GLM_ZUP);
+
+  vec3 eye = GLM_VEC3_ONE_INIT;
+  vec3 center = GLM_VEC3_ZERO_INIT;
+
+//  vk_log(VK_INFO, "{%.2f, %.2f, %.2f}\n", s.camera.front[0], s.camera.front[1], s.camera.front[2]);
+  /* glm_vec3_add(s.camera.pos, s.camera.front, center); */
+  glm_lookat(s.camera.pos, s.camera.front, s.camera.up, ubo.view);
+
+  /* glm_lookat(eye, center, GLM_ZUP, ubo.view); */
+  
+  float aspect = s.vk_swap_chain_extent.width / (float)s.vk_swap_chain_extent.height;
+  glm_perspective(glm_rad(45.0f ), aspect, 1.0f, 10.0f, ubo.proj);
+
+  // Inverting the Y axis for Vulkan
+  ubo.proj[1][1] *= -1;
+
+  memcpy(s.frames[currentImage].vk_uniform_buffer_mapped, &ubo, sizeof(ubo));
+}
+
+void
+draw_frame() {
+  vkWaitForFences(s.vk_device, 1, &s.frames[currentFrame].in_flight_fence, VK_TRUE, UINT64_MAX);
+
+  uint32_t imageIndex;
+  VkResult result = vkAcquireNextImageKHR(s.vk_device, s.vk_swap_chain, UINT64_MAX, s.frames[currentFrame].image_available_semaphore, VK_NULL_HANDLE, &imageIndex);
+
+  if (result == VK_ERROR_OUT_OF_DATE_KHR) {
+    recreateSwapChain();
+    return;
+  } else if (result != VK_SUCCESS && result != VK_SUBOPTIMAL_KHR) {
+    vk_log(VK_ERROR, "failed to acquire swap chain image!\n");
+  }
+
+  updateUniformBuffer(currentFrame);
+
+  vkResetFences(s.vk_device, 1, &s.frames[currentFrame].in_flight_fence);
+
+  vkResetCommandBuffer(s.frames[currentFrame].vk_command_buffer, 0);
+  recordCommandBuffer(s.frames[currentFrame].vk_command_buffer, imageIndex);
+
+  VkSubmitInfo submitInfo = {0};
+  submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
+
+  VkSemaphore waitSemaphores[] = {s.frames[currentFrame].image_available_semaphore};
+  VkPipelineStageFlags waitStages[] = {VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT};
+  submitInfo.waitSemaphoreCount = 1;
+  submitInfo.pWaitSemaphores = waitSemaphores;
+  submitInfo.pWaitDstStageMask = waitStages;
+  submitInfo.commandBufferCount = 1;
+  submitInfo.pCommandBuffers = &s.frames[currentFrame].vk_command_buffer;
+
+  VkSemaphore signalSemaphores[] = {s.frames[currentFrame].render_finished_semaphore};
+  submitInfo.signalSemaphoreCount = 1;
+  submitInfo.pSignalSemaphores = signalSemaphores;
+
+  if (vkQueueSubmit(s.vk_graphics_queue, 1, &submitInfo, s.frames[currentFrame].in_flight_fence) != VK_SUCCESS) {
+    vk_log(VK_ERROR, "failed to submit draw command buffer!\n");
+  }
+
+  VkSwapchainKHR swapChains[] = {s.vk_swap_chain};
+  VkPresentInfoKHR presentInfo = {0};
+  presentInfo.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR;
+  presentInfo.waitSemaphoreCount = 1;
+  presentInfo.pWaitSemaphores = signalSemaphores;
+  presentInfo.swapchainCount = 1;
+  presentInfo.pSwapchains = swapChains;
+  presentInfo.pImageIndices = &imageIndex;
+  presentInfo.pResults = NULL;
+
+  result = vkQueuePresentKHR(s.vk_present_queue, &presentInfo);
+
+  if (result == VK_ERROR_OUT_OF_DATE_KHR || result == VK_SUBOPTIMAL_KHR || s.sdl_window_resized) {
+    s.sdl_window_resized = 0;
+    recreateSwapChain();
+  } else if (result != VK_SUCCESS) {
+    vk_log(VK_ERROR, "failed to present swap chain image!\n");
+  }
+
+  currentFrame = (currentFrame + 1) % MAX_FRAMES_IN_FLIGHT;
+}
+
+int
+main(int argc, char* args[])
+{
+  init_state(&s);
+  if (!init()) {
+    vk_log(VK_INFO, "Failed to initialize!\n");
+  }
+  else {
+    init_vulkan();
+
+    bool quit = false;
+
+
+    /* VMA POC */
+    VmaVulkanFunctions vulkanFunctions = {0};
+    vulkanFunctions.vkGetInstanceProcAddr = &vkGetInstanceProcAddr;
+    vulkanFunctions.vkGetDeviceProcAddr = &vkGetDeviceProcAddr;
+
+    VmaAllocatorCreateInfo allocatorCreateInfo = {0};
+    allocatorCreateInfo.flags = VMA_ALLOCATOR_CREATE_EXT_MEMORY_BUDGET_BIT;
+    allocatorCreateInfo.vulkanApiVersion = VK_API_VERSION_1_2;
+    allocatorCreateInfo.physicalDevice = s.vk_physical_device;
+    allocatorCreateInfo.device = s.vk_device;
+    allocatorCreateInfo.instance = s.vk_instance;
+    allocatorCreateInfo.pVulkanFunctions = &vulkanFunctions;
+
+    VmaAllocator allocator;
+    vmaCreateAllocator(&allocatorCreateInfo, &allocator);
+
+    // Entire program...
+
+    // At the end, don't forget to:
+    vmaDestroyAllocator(allocator);
+
+    // Game loop
+    update_camera(0, 0);
+    while (!quit) {
+      handle_input(&quit);
+      draw_frame();
+      //SDL_Delay(16);
+    }
+
+    close_vulkan();
+  }
+
+  // Free resources and close SDL
+  closeSDL();
+
+  return 0;
+
+}