Gears-C/src/renderer_vulkan.c

// ::Vulkan::Globals::Start::

static vRenderer v_Renderer = {
	.state = {
		.vk = {
			.gfx_queue_idx 	= UINT32_MAX,
			.tfer_queue_idx = UINT32_MAX,
		},
		.swapchain = {
			.format 				= INT_MAX,
			.color_space 		= INT_MAX,
			.present_mode 	= INT_MAX,
		},
	},
};

/*
static vRenderer renderer = {
	.vk = {
		.queues = {
			.graphics = -1,
			.transfer = -1,
		},
		.sc = {
			.format = INT_MAX,
			.color_space = INT_MAX,
			.present_mode = INT_MAX,
		},
	}
};
*/

// ::Vulkan::Globals::End::



// ::Vulkan::Includes::CFiles::Start::

#include "renderer_vulkan_public.c"

// ::Vulkan::Includes::CFiles::End::



// ::Vulkan::Util::Functions::Start::

static inline u32 vFrameIndex()
{
	return v_Renderer.state.renderer.frame_count % FRAME_OVERLAP;
}

static inline VkCommandBuffer vFrameCmdBuf()
{
	return v_Renderer.frame_handles[vFrameIndex()].buffer;
}

static inline VkFence vFrameRenderFence()
{
	return v_Renderer.frame_handles[vFrameIndex()].r_fence;
}

static inline VkImage vFrameImage()
{
	return v_Renderer.images.sc.data[v_Renderer.state.vk.image_idx].image.image;
}

static inline Arena *vFrameArena()
{
	return v_Renderer.mem.frame_arenas[vFrameIndex()];
}

static inline VkSemaphore vFrameRenderSem()
{
	return v_Renderer.frame_handles[vFrameIndex()].r_sem;
}

static inline VkSemaphore vFrameSwapSem()
{
	return v_Renderer.frame_handles[vFrameIndex()].sc_sem;
}

static inline vBufferAllocPtrArray *vFrameBuffers()
{
	return v_Renderer.buffers.frame + vFrameIndex();
}

static inline void vImageCopyToImage(VkCommandBuffer cmd, VkImage src, VkImage dst, VkExtent2D src_ext, VkExtent2D dst_ext)
{
	VkImageBlit2 blit = {
		.sType = STYPE(IMAGE_BLIT_2),
		.srcOffsets = {
			{0},
			{ .x = (i32)src_ext.width, .y = (i32)src_ext.height, .z = 1 },
		},
		.dstOffsets = {
			{0},
			{ .x = (i32)dst_ext.width, .y = (i32)dst_ext.height, .z = 1 },
		},
		.srcSubresource = {
			.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
			.baseArrayLayer = 0,
			.layerCount = 1,
			.mipLevel = 0,
		},
		.dstSubresource = {
			.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
			.baseArrayLayer = 0,
			.layerCount = 1,
			.mipLevel = 0,
		},
	};

	VkBlitImageInfo2 blit_info = {
		.sType = STYPE(BLIT_IMAGE_INFO_2),
		.srcImage = src,
		.srcImageLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
		.dstImage = dst,
		.dstImageLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
		.filter = VK_FILTER_LINEAR,
		.regionCount = 1,
		.pRegions = &blit,
	};

	vkCmdBlitImage2(cmd, &blit_info);
}

static inline void vImageTransitionLayout(VkCommandBuffer cmd, VkImage img, VkImageLayout curr, VkImageLayout new)
{
	VkImageMemoryBarrier2 barrier = {
		.sType = STYPE(IMAGE_MEMORY_BARRIER_2),
		.srcStageMask = VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT,
		.srcAccessMask = VK_ACCESS_2_MEMORY_WRITE_BIT,
		.dstStageMask = VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT,
		.dstAccessMask = VK_ACCESS_2_MEMORY_WRITE_BIT | VK_ACCESS_2_MEMORY_READ_BIT,
		.oldLayout = curr,
		.newLayout = new,
		.image = img,
		.subresourceRange = {
			.aspectMask = new == VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL ? VK_IMAGE_ASPECT_DEPTH_BIT : VK_IMAGE_ASPECT_COLOR_BIT,
			.baseMipLevel = 0,
			.levelCount = VK_REMAINING_MIP_LEVELS,
			.baseArrayLayer = 0,
			.layerCount = VK_REMAINING_ARRAY_LAYERS,
		},
	};

	VkDependencyInfo dep_info = {
		.sType = STYPE(DEPENDENCY_INFO),
		.imageMemoryBarrierCount = 1,
		.pImageMemoryBarriers = &barrier,
	};

	vkCmdPipelineBarrier2(cmd, &dep_info);
}

static inline void vImageTransition(VkCommandBuffer cmd, vImage *img, VkImageLayout new)
{
	vImageTransitionLayout(cmd, img->image, img->layout, new);
	img->layout = new;
}

// ::Vulkan::Util::Functions::End::



// ::Vulkan::Rendering::Functions::Start::

static void vRenderingBegin()
{
	VkCommandBuffer cmd = vFrameCmdBuf();
	VkImage curr_img = v_Renderer.images.sc.data[v_Renderer.state.vk.image_idx].image.image;

	vImageTransition(cmd, &v_Renderer.images.draw.image, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL);
	vImageTransition(cmd, &v_Renderer.images.depth.image, VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL);

	vImageTransitionLayout(cmd, curr_img, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);

	VkRenderingAttachmentInfo col_attach_info = {
		.sType = STYPE(RENDERING_ATTACHMENT_INFO),
		.imageView = v_Renderer.images.draw.view,
		.imageLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
		.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR,
		.storeOp = VK_ATTACHMENT_STORE_OP_STORE,
		.clearValue = { { 0.2f, 0.2f, 0.2f, 1.0f } },
	};

	VkRenderingAttachmentInfo depth_attach_info = {
		.sType = STYPE(RENDERING_ATTACHMENT_INFO),
		.imageView = v_Renderer.images.depth.view,
		.imageLayout = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL,
		.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR,
		.storeOp = VK_ATTACHMENT_STORE_OP_STORE,
	};

	VkRenderingInfo render_info = {
		.sType = STYPE(RENDERING_INFO),
		.layerCount = 1,
		.colorAttachmentCount = 1,
		.pColorAttachments = &col_attach_info,
		.pDepthAttachment = &depth_attach_info,
		.renderArea = {
			.extent = {
				.width = v_Renderer.state.swapchain.extent.width,
				.height = v_Renderer.state.swapchain.extent.height,
			},
		},
	};

	vkCmdBeginRendering(cmd, &render_info);
	
	vkCmdBindDescriptorSets(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, v_Renderer.handles.pipeline_layout, 0, vDT_MAX, v_Renderer.handles.desc_sets, 0, NULL);
}

// ::Vulkan::Rendering::Functions::End::



// ::Vulkan::ImmediateSubmit::Functions::Start::

static b32 vImmSubmitBegin(VkDevice device, VkFence fence, VkCommandBuffer cmd)
{
	b32 success = true;

	VkFence f = fence;
	VkResult result = vkResetFences(device, 1, &f);
	if (result != VK_SUCCESS)
	{
		Printfln("vkResetFences failure: %s", vVkResultStr(result));
		success = false;
	}

	if (success)
	{
		result = vkResetCommandBuffer(cmd, 0);
		if (result != VK_SUCCESS)
		{
			Printfln("vkResetCommandBuffer failure: %s", vVkResultStr(result));
			success = false;
		}
	}

	if (success)
	{
		VkCommandBufferBeginInfo buf_info = {
			.sType = STYPE(COMMAND_BUFFER_BEGIN_INFO),
			.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT,
		};

		result = vkBeginCommandBuffer(cmd, &buf_info);
		if (result != VK_SUCCESS)
		{
			Printfln("vkBeginCommandBuffer failure: %s", vVkResultStr(result));
			success = false;
		}
	}

	return success;
}

static b32 vImmSubmitFinish(VkDevice device, VkFence fence, VkCommandBuffer cmd, VkQueue queue)
{
	b32 success = true;
	VkFence f = fence;

	VkResult result = vkEndCommandBuffer(cmd);
	if (result != VK_SUCCESS)
	{
		Printfln("vkEndCommandBuffer imm failure: %s", vVkResultStr(result));
		success = false;
	}

	if (success)
	{
		VkCommandBufferSubmitInfo cmd_submit_info = {
			.sType = STYPE(COMMAND_BUFFER_SUBMIT_INFO),
			.commandBuffer = cmd,
		};

		VkSubmitInfo2 submit_info = {
			.sType = STYPE(SUBMIT_INFO_2),
			.commandBufferInfoCount = 1,
			.pCommandBufferInfos = &cmd_submit_info,
		};

		result = vkQueueSubmit2(queue, 1, &submit_info, f);
		if (result != VK_SUCCESS)
		{
			Printfln("vkQueueSubmit2 imm failure: %s", vVkResultStr(result));
			success = false;
		}
	}

	if (success)
	{
		result = vkWaitForFences(device, 1, &f, true, 9999999999);
		if (result != VK_SUCCESS)
		{
			Printfln("vkWaitForFences imm failure: %s", vVkResultStr(result));
			success = false;
		}
	}

	return success;
}

// ::Vulkan::ImmediateSubmit::Functions::End::



// ::Vulkan::Swapchain::Functions::Start::

static void vSwapchainResize()
{
	vkDeviceWaitIdle(v_Renderer.handles.device);

	vSwapchainDestroy();

	vDrawImagesDestroy();

	// TODO: fix
	//v_Renderer.state.swapchain.extent.width = v_Renderer.state.renderer.width;
	//v_Renderer.state.swapchain.extent.height = v_Renderer.state.renderer.height;

	Assert(vSwapchainInit(), "Unable to recreate swapchain");
	Assert(vDrawImagesInit(), "Unable to recreate draw images");
}

// ::Vulkan::Swapchain::Functions::End::



// ::Vulkan::Images::Functions::Start::

static b32 vSamplerCreate(rTextureBuffer *buffer)
{
	/*
	b32 success = true;
	vImage *image = &buffer->image;

	rRenderBuffer staging_buffer = {
		.type = rRBT_STAGING,
		.size = buffer->width * buffer->height,
	};

	VmaAllocationCreateInfo alloc_create_info = {
		.usage = VMA_MEMORY_USAGE_GPU_ONLY,
		.requiredFlags = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT,
	};

	VkImageCreateInfo image_info = {
		.sType = STYPE(IMAGE_CREATE_INFO),
		.imageType = VK_IMAGE_TYPE_2D,
		.mipLevels = 1,
		.arrayLayers = 1,
		.format = VK_FORMAT_R8G8B8A8_SRGB,
		.tiling = VK_IMAGE_TILING_OPTIMAL,
		.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED,
		.usage = VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_SAMPLED_BIT,
		.sharingMode = VK_SHARING_MODE_EXCLUSIVE,
		.samples = VK_SAMPLE_COUNT_1_BIT,
		.extent = {
			.width = buffer->width,
			.height = buffer->height,
			.depth = 1,
		},
	};

	if (v_Renderer.state.vk.gfx_queue_idx != v_Renderer.state.vk.tfer_queue_idx)
	{
		image_info.sharingMode = VK_SHARING_MODE_CONCURRENT;
		image_info.queueFamilyIndexCount = 2;
		image_info.pQueueFamilyIndices = (u32[]){v_Renderer.state.vk.gfx_queue_idx, v_Renderer.state.vk.tfer_queue_idx};
	}

	VkResult result = vmaCreateImage(v_Renderer.handles.vma_alloc, &image_info, 
																	&alloc_create_info, &image->img, &image->alloc, NULL);
	if (result != VK_SUCCESS)
	{
		success = false;
		Printfln("vmaCreateImage failure: %s", vVkResultStr(result));
	}

	if (success)
	{
		image->curr_layout = VK_IMAGE_LAYOUT_UNDEFINED;

		VkImageViewCreateInfo view_info = {
			.sType = STYPE(IMAGE_VIEW_CREATE_INFO),
			.image = image->img,
			.viewType = VK_IMAGE_VIEW_TYPE_2D,
			.format = VK_FORMAT_R8G8B8A8_SRGB,
			.subresourceRange = {
				.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
				.levelCount = 1,
				.layerCount = 1,
			}
		};

		result = vkCreateImageView(v_Renderer.handles.device, &view_info, NULL, &image->view);
		if (result != VK_SUCCESS)
			success = false;
	}

	if (success)
	{
		VkPhysicalDeviceProperties properties;
		vkGetPhysicalDeviceProperties(v_Renderer.handles.phys_device, &properties);

		// TODO: handle no anisotropy
		VkSamplerCreateInfo sampler_info = {
			.sType = STYPE(SAMPLER_CREATE_INFO),
			.magFilter = VK_FILTER_LINEAR,
			.minFilter = VK_FILTER_LINEAR,
			.addressModeU = VK_SAMPLER_ADDRESS_MODE_REPEAT,
			.addressModeV = VK_SAMPLER_ADDRESS_MODE_REPEAT,
			.addressModeW = VK_SAMPLER_ADDRESS_MODE_REPEAT,
			.anisotropyEnable = VK_TRUE,
			.maxAnisotropy = properties.limits.maxSamplerAnisotropy,
			.borderColor = VK_BORDER_COLOR_INT_OPAQUE_BLACK,
			.compareOp = VK_COMPARE_OP_ALWAYS,
			.mipmapMode = VK_SAMPLER_MIPMAP_MODE_LINEAR,
		};

		result = vkCreateSampler(v_Renderer.handles.device, &sampler_info, NULL, &image->sampler);
		if (result != VK_SUCCESS)
			success = false;
	}

	return success;
	*/

	return false;
}

static void vImageUpload(rTextureBuffer *buffer, u8 *data, u32 thread_idx)
{
	/*
	b32 success = true;

	VkDevice device 		= v_Renderer.handles.device;
	VkCommandBuffer cmd = renderer.vk.imm.cmds[thread_idx];
	VkFence fence 			= renderer.vk.imm.fences[thread_idx];
	VkQueue queue 			= renderer.vk.queues.transfer_queue;
	vImage *image 				= &buffer->image;
	u32 width 					= buffer->width;
	u32 height 					= buffer->height;
	u32 channels 				= buffer->channels;
	rRenderBuffer staging_buffer = {
		.type = rRBT_STAGING,
		.size = width * height * channels,
	};

	vImageTransition(cmd, image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);

	success = vImmSubmitBegin(device, fence, cmd);

	// TODO: FIX
	//if (success)
		//Assert(rBufferCreate(&staging_buffer), "vImageUpload failure: error creating buffer");

	if (success)
	{
		rawptr mapped_buf = NULL;
		vmaMapMemory(v_Renderer.handles.vma_alloc, staging_buffer.alloc, &mapped_buf);
		MemCpy(mapped_buf, data, width * height * channels);

		VkBufferImageCopy buffer_copy = { 
			.bufferRowLength = width,
			.bufferImageHeight = height,
			.imageSubresource = {
				.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
				.layerCount = 1,
			},
			.imageExtent = {
				.width = width,
				.height = height,
				.depth = 1,
			},
		};

		vkCmdCopyBufferToImage(cmd, staging_buffer.buffer, image->img, image->curr_layout, 1, &buffer_copy);

		vmaUnmapMemory(v_Renderer.handles.vma_alloc, staging_buffer.alloc);
		vmaDestroyBuffer(v_Renderer.handles.vma_alloc, staging_buffer.buffer, staging_buffer.alloc);

		success = vImmSubmitFinish(device, fence, cmd, queue);
	}
	*/
}

// ::Vulkan::Images::Functions::End::



// ::Vulkan::Descriptors::Functions::Start::

static void vDescHandlePush(vDescType type, rDescHandle handle)
{
	vDescBindings *bindings = v_Renderer.desc_bindings + type;

	Assert(bindings->free_count < DESC_MAX_BINDINGS-1, "vDescHandlePush failure: free_count equal to DESC_MAX_BINDINGS-1");

	bindings->free[bindings->free_count] = handle;
	bindings->free_count += 1;
}

static rDescHandle vDescHandlePop(vDescType type)
{
	vDescBindings *bindings = v_Renderer.desc_bindings + type;

	Assert(bindings->free_count > 0, "vDescHandlePop failure: free_count is 0");

	bindings->free_count -= 1;
	return bindings->free[bindings->free_count];
}

static vAssetInfo *vDescHandleSearch(vDescType type, u64 asset_id)
{
	vAssetInfo *asset_info = NULL;

	HashTable *table = &v_Renderer.desc_bindings[type].lookup_table;

	KeyValuePair *kv_pair = HashTableSearchU64(table, asset_id);
	if (kv_pair != NULL)
	{
		asset_info = (vAssetInfo *)kv_pair->value_rawptr;
	}

	return asset_info;
}

static void DescriptorTableInsert(vDescType type, u64 asset_id, rDescHandle handle)
{
	vAssetInfo *asset_info = FLMemAlloc(sizeof(vAssetInfo));

	asset_info->handle = handle;
	asset_info->type = type;
	asset_info->asset_id = asset_id;

	HashTable *table = &v_Renderer.desc_bindings[type].lookup_table;
	HashTablePushU64Rawptr(table, asset_id, asset_info);
}

static void vDescHandleDelete(vDescType type, u64 asset_id)
{
	HashTable *table = &v_Renderer.desc_bindings[type].lookup_table;
	HashTableDeleteU64(table, asset_id);
}

// ::Vulkan::Descriptors::Functions::End::



// ::Vulkan::Buffers::Functions::Start::


static VkResult vBufferCreate(vBufferAlloc* buf, rRenderBufferType type, u64 size)
{
	Assert(type != rRBT_NONE, "vBufferCreate: rRenderBufferType must not be rRBT_NONE");

	VkResult result;

	u32 gfx_queue = v_Renderer.state.vk.gfx_queue_idx;
	u32 tfer_queue = v_Renderer.state.vk.tfer_queue_idx;
	VmaAllocator alloc = v_Renderer.handles.vma_alloc;

	VkBufferCreateInfo buffer_info = {
		.sType = STYPE(BUFFER_CREATE_INFO),
		.size = size,
	};

	VmaAllocationCreateInfo alloc_info = {
		.usage = VMA_MEMORY_USAGE_UNKNOWN,
		.flags = VMA_ALLOCATION_CREATE_MAPPED_BIT,
	};

	if (BitEq(type, rRBT_VERTEX))
	{
		buffer_info.usage = VK_BUFFER_USAGE_VERTEX_BUFFER_BIT;
	}
	else if (BitEq(type, rRBT_INDEX))
	{
		buffer_info.usage = VK_BUFFER_USAGE_INDEX_BUFFER_BIT;
	}
	else if (BitEq(type, rRBT_UNIFORM))
	{
		buffer_info.usage = VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT;
	}
	else if (BitEq(type, rRBT_STAGING))
	{
		buffer_info.usage = VK_BUFFER_USAGE_TRANSFER_SRC_BIT;
	}
	else if (BitEq(type, rRBT_STORAGE))
	{
		buffer_info.usage = VK_BUFFER_USAGE_STORAGE_BUFFER_BIT;
	}

	if ((type & rRBT_HOST) == rRBT_HOST || type == rRBT_STAGING)
	{
		alloc_info.requiredFlags = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT;
		alloc_info.preferredFlags = VK_MEMORY_PROPERTY_HOST_CACHED_BIT;
	}
	else
	{
		buffer_info.usage |= VK_BUFFER_USAGE_TRANSFER_DST_BIT;
		alloc_info.requiredFlags = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
	}
	
	if (tfer_queue != gfx_queue)
	{
		buffer_info.sharingMode = VK_SHARING_MODE_CONCURRENT;
		buffer_info.queueFamilyIndexCount = 2;
		buffer_info.pQueueFamilyIndices = (u32[]){gfx_queue, tfer_queue};
	}

	VmaAllocationInfo vma_info;
	result = vmaCreateBuffer(alloc, &buffer_info, &alloc_info, &buf->buffer, &buf->alloc, &vma_info);
	if (result != VK_SUCCESS)
	{
		Printfln("vmaCreateBuffer failure: %s", vVkResultStr(result));
	}

	return result;
}

static rawptr vMapBuffer(VmaAllocation alloc)
{
	rawptr ptr;
	vmaMapMemory(v_Renderer.handles.vma_alloc, alloc, &ptr);
	return ptr;
}

// ::Vulkan::Buffers::Functions::Start::



// ::Vulkan::Init::Functions::Start::

static b32 vInitInstance()
{
	b32 success = true;

	Assert(vGlobalFunctionsInit(), "Unable to load vulkan functions");

	VkResult result = vkCreateInstance(&inst_info, NULL, &v_Renderer.handles.inst);
	if (result != VK_SUCCESS)
	{
		success = false;
		Printfln("vkCreateInstance failure: %s", vVkResultStr(result));
	}

	return success;
}

static void vEnableDebug()
{
		if (vValidationSupported())
		{
			Assert(vkCreateDebugUtilsMessengerEXT(v_Renderer.handles.inst, &debug_msg_info, NULL, &v_Renderer.handles.debug) == VK_SUCCESS, 
					"Unable to initialize debug messenger");
		}
		else
		{
			Printfln("Validation layers not supported, continuing without.");
		}
}

static void vInitArenas()
{
	v_Renderer.mem.perm_arena = ArenaCreateDebug(MB(16), __LINE__);

	for (u32 i = 0; i < FRAME_OVERLAP; i++)
	{
		v_Renderer.mem.frame_arenas[i] = ArenaCreateDebug(MB(8), i);
	}
}

static b32 vVmaAllocatorInit() 
{
	VmaVulkanFunctions vk_functions = {
		.vkGetInstanceProcAddr = vkGetInstanceProcAddr,
		.vkGetDeviceProcAddr = vkGetDeviceProcAddr,
	};
	vma_create_info.pVulkanFunctions = &vk_functions;
	vma_create_info.physicalDevice = v_Renderer.handles.phys_device;
	vma_create_info.device = v_Renderer.handles.device;
	vma_create_info.instance = v_Renderer.handles.inst;

	VkResult result = vmaCreateAllocator(&vma_create_info, &v_Renderer.handles.vma_alloc);
	if (result != VK_SUCCESS) 
	{
		Printf("vmaCreateAllocator failure: %d", result);
	}

	return result == VK_SUCCESS;
}

static b32 vQueueCheckSurfaceSupport(i32 index, VkPhysicalDevice device, VkSurfaceKHR surface) 
{
	b32 surface_supported;
	vkGetPhysicalDeviceSurfaceSupportKHR(device, (u32)index, surface, &surface_supported);
	return surface_supported;
}

static vDeviceQueues vQueueCheckSupport(VkPhysicalDevice device, VkSurfaceKHR surface) 
{
	vDeviceQueues queues = { .graphics = -1, .transfer = -1 };
	Arena *arena = vFrameArena();

	u32 queue_count;
	vkGetPhysicalDeviceQueueFamilyProperties(device, &queue_count, NULL);
	VkQueueFamilyProperties *families = MakeArray(arena, VkQueueFamilyProperties, queue_count);
	vkGetPhysicalDeviceQueueFamilyProperties(device, &queue_count, families);

	if (queue_count == 1 && 
			BitEq(families[0].queueFlags, VK_QUEUE_TRANSFER_BIT | VK_QUEUE_COMPUTE_BIT | VK_QUEUE_TRANSFER_BIT) &&
			families[0].queueCount == 1)
	{
		queues.graphics = queues.transfer = 0;
		queues.single_queue = true;
	}
	else 
	{
		b8 sparse_binding = false;
		b8 transfer_only = false;
		for (i32 i = 0; i < queue_count; i++) 
		{
			if (queues.graphics < 0 && vQueueCheckSurfaceSupport(i, device, surface) && BitEq(families[i].queueFlags, VK_QUEUE_GRAPHICS_BIT)) 
			{
				queues.graphics = i;
				continue;
			}

			if (BitEq(families[i].queueFlags, VK_QUEUE_TRANSFER_BIT | VK_QUEUE_SPARSE_BINDING_BIT) && !BitEq(families[i].queueFlags, VK_QUEUE_GRAPHICS_BIT | VK_QUEUE_COMPUTE_BIT))
			{
				sparse_binding = true;
				transfer_only = true;
				queues.transfer = i;
				continue;
			}

			if (BitEq(families[i].queueFlags, VK_QUEUE_TRANSFER_BIT | VK_QUEUE_SPARSE_BINDING_BIT) && !(sparse_binding && transfer_only))
			{
				sparse_binding = true;
				queues.transfer = i;
				continue;
			}

			if (BitEq(families[i].queueFlags, VK_QUEUE_TRANSFER_BIT) && !BitEq(families[i].queueFlags, VK_QUEUE_COMPUTE_BIT) && !sparse_binding)
			{
				transfer_only = true;
				queues.transfer = i;
				continue;
			}

			if (BitEq(families[i].queueFlags, VK_QUEUE_TRANSFER_BIT) && !sparse_binding && !transfer_only)
				queues.transfer = i;
		}

		if (queues.transfer < 0) 
			queues.transfer = queues.graphics;
	}

	return queues;
}

static b32 vDeviceCheckPropertiesSupport(VkPhysicalDevice device, VkSurfaceKHR surface, b32 *discrete) 
{
	b32 success = false;
	Arena *arena = vFrameArena();

	VkPhysicalDeviceProperties properties = {0};
	vkGetPhysicalDeviceProperties(device, &properties);

	if (VK_API_VERSION_MINOR(properties.apiVersion) >= 3) 
	{
		u32 ext_count;
		vkEnumerateDeviceExtensionProperties(device, NULL, &ext_count, NULL);
		VkExtensionProperties *ext_properties = ArenaAlloc(arena, sizeof(VkExtensionProperties) * ext_count);
		vkEnumerateDeviceExtensionProperties(device, NULL, &ext_count, ext_properties);

		i32 matched = 0;
		for (u32 i = 0; i < ext_count; i++) {
			for (i32 j = 0; j < Len(device_extensions); j++) {
				if (StrEq(ext_properties[i].extensionName, device_extensions[j])) {
					matched++;
					break;
				}
			}
		}

		if (matched == Len(device_extensions)) 
		{
			u32 fmt_count, present_count;
			vkGetPhysicalDeviceSurfaceFormatsKHR(device, surface, &fmt_count, NULL);
			vkGetPhysicalDeviceSurfacePresentModesKHR(device, surface, &present_count, NULL);

			*discrete = properties.deviceType == VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU;

			success = fmt_count && present_count;
		}
	}

	return success;
}

static b32 vDeviceCheckFeatureSupport(VkPhysicalDevice device) 
{
	VkPhysicalDeviceFeatures2 features2 = { .sType = STYPE(PHYSICAL_DEVICE_FEATURES_2) };

	VkPhysicalDeviceVulkan12Features features_12 = { .sType = STYPE(PHYSICAL_DEVICE_VULKAN_1_2_FEATURES) };
	VkPhysicalDeviceVulkan13Features features_13 = { .sType = STYPE(PHYSICAL_DEVICE_VULKAN_1_3_FEATURES) };

	features2.pNext = &features_12;
	vkGetPhysicalDeviceFeatures2(device, &features2);
	features2.pNext = &features_13;
	vkGetPhysicalDeviceFeatures2(device, &features2);

	VkPhysicalDeviceFeatures features = features2.features;
	b32 result = true;

	result &= (b32)features.shaderUniformBufferArrayDynamicIndexing;
	result &= (b32)features.shaderSampledImageArrayDynamicIndexing;
	result &= (b32)features.shaderStorageBufferArrayDynamicIndexing;
	result &= (b32)features.shaderStorageImageArrayDynamicIndexing;
	result &= (b32)features.samplerAnisotropy;

	result &= (b32)features_12.descriptorIndexing;
	result &= (b32)features_12.bufferDeviceAddress;
	
	result &= (b32)features_13.synchronization2;
	result &= (b32)features_13.dynamicRendering;
	
	return result;
}

static b32 vDeviceInit() 
{
	VkInstance inst = v_Renderer.handles.inst;
	VkSurfaceKHR surface = v_Renderer.handles.surface;
	Arena *arena = vFrameArena();

	u32 device_count;
	vkEnumeratePhysicalDevices(inst, &device_count, NULL);
	VkPhysicalDevice *devices = ArenaAlloc(arena, sizeof(VkPhysicalDevice) * device_count);
	vkEnumeratePhysicalDevices(inst, &device_count, devices);
	
	b32 discrete_device = false;
	vDeviceQueues queues = {0};
	VkPhysicalDevice phys_device = NULL;
	for (u32 i = 0; i < device_count; i++) {
		vDeviceQueues current_queues = vQueueCheckSupport(devices[i], surface);
		b32 discrete = false;

		if (current_queues.graphics < 0) 
			continue;
		if (!vDeviceCheckPropertiesSupport(devices[i], surface, &discrete)) 
			continue;
		if (discrete_device && !discrete) 
			continue;
		if (!vDeviceCheckFeatureSupport(devices[i])) 
			continue;
			
		discrete_device = discrete;
		queues = current_queues;
		phys_device = devices[i];

		if (discrete_device && queues.graphics != queues.transfer) 
			break;
	}

	b32 success = false;
	if (phys_device != NULL) 
	{
		VkDeviceQueueCreateInfo queue_info[2] = {0};
		f32 priority = 1.0f;
		u32 count = 1;
		u32 transfer_queue_index = 0;

		queue_info[0].sType = STYPE(DEVICE_QUEUE_CREATE_INFO);
		queue_info[0].queueFamilyIndex = queues.graphics;
		queue_info[0].queueCount = 1;
		queue_info[0].pQueuePriorities = &priority;
		queue_info[0].flags = 0;

		if (!queues.single_queue) {
			queue_info[1].sType = STYPE(DEVICE_QUEUE_CREATE_INFO);
			queue_info[1].queueFamilyIndex = queues.transfer;
			queue_info[1].queueCount = 1;
			queue_info[1].pQueuePriorities = &priority;
			queue_info[1].flags = 0;

			if (queues.transfer == queues.graphics)
				transfer_queue_index = 1;

			count++;
		}

		device_info.queueCreateInfoCount = count;
		device_info.pQueueCreateInfos = &queue_info[0];

		VkResult result = vkCreateDevice(phys_device, &device_info, NULL, &v_Renderer.handles.device);
		if (result != VK_SUCCESS) {
			Printf("vkCreateDevice failure: %d", result);
		}
		else 
		{
			Assert(vDeviceFunctionsInit(), "Failed to initialize device functions");
			
			vkGetDeviceQueue(
				v_Renderer.handles.device, 
				queues.graphics, 
				0, 
				&queues.graphics_queue);

			vkGetDeviceQueue(
				v_Renderer.handles.device, 
				queues.transfer, 
				transfer_queue_index, 
				&queues.transfer_queue);

			v_Renderer.handles.phys_device = phys_device;

			v_Renderer.handles.gfx_queue = queues.graphics_queue;
			v_Renderer.handles.tfer_queue = queues.transfer_queue;

			v_Renderer.state.vk.gfx_queue_idx = queues.graphics;
			v_Renderer.state.vk.tfer_queue_idx = queues.transfer;

			success = true;
		}
	}

	return success;
}

static b32 vGlobalFunctionsInit() 
{
	b32 result = vLibraryLoad();
	if (result) 
	{
		INIT_FN(vkGetInstanceProcAddr);
		INIT_FN(vkEnumerateInstanceLayerProperties);
		INIT_FN(vkCreateInstance);
	}

	return result;
}

static b32 vInstanceFunctionsInit() 
{
	VkInstance instance = v_Renderer.handles.inst;

	#ifdef __linux__
	{
		INIT_INST_FN(vkCreateXcbSurfaceKHR);
	}
	#elif _WIN32
	{
		INIT_INST_FN(vkCreateWin32SurfaceKHR);
	}
	#elif __APPLE__ || __MACH__
	#error Not yet implemented
	#elif __unix__ && !__linux__
	#error Not yet implemented
	#endif

	#ifdef BUILD_DEBUG
	{
		INIT_INST_FN(vkCreateDebugUtilsMessengerEXT);
		INIT_INST_FN(vkDestroyDebugUtilsMessengerEXT);
	}
	#endif

	INIT_INST_FN(vkEnumeratePhysicalDevices);
	INIT_INST_FN(vkGetPhysicalDeviceQueueFamilyProperties);
	INIT_INST_FN(vkGetPhysicalDeviceSurfaceSupportKHR);
	INIT_INST_FN(vkCreateDevice);
	INIT_INST_FN(vkGetPhysicalDeviceProperties);
	INIT_INST_FN(vkGetPhysicalDeviceFeatures2);
	INIT_INST_FN(vkGetPhysicalDeviceSurfaceFormatsKHR);
	INIT_INST_FN(vkGetPhysicalDeviceSurfacePresentModesKHR);
	INIT_INST_FN(vkEnumerateDeviceExtensionProperties);
	INIT_INST_FN(vkGetDeviceProcAddr);
	INIT_INST_FN(vkDestroyInstance);
	INIT_INST_FN(vkDestroySurfaceKHR);
	INIT_INST_FN(vkGetPhysicalDeviceSurfaceCapabilitiesKHR);
	INIT_INST_FN(vkGetPhysicalDeviceImageFormatProperties);

	return true;
}

static b32 vDeviceFunctionsInit() {
	VkDevice device = v_Renderer.handles.device;

	INIT_DEV_FN(vkCreateSwapchainKHR);
	INIT_DEV_FN(vkCreateImage);
	INIT_DEV_FN(vkCreateImageView);
	INIT_DEV_FN(vkGetSwapchainImagesKHR);
	INIT_DEV_FN(vkGetDeviceQueue);
	INIT_DEV_FN(vkCreateSemaphore);
	INIT_DEV_FN(vkAllocateCommandBuffers);
	INIT_DEV_FN(vkCreateCommandPool);
	INIT_DEV_FN(vkCreateFence);
	INIT_DEV_FN(vkCreateDescriptorPool);
	INIT_DEV_FN(vkCreateDescriptorSetLayout);
	INIT_DEV_FN(vkAllocateDescriptorSets);
	INIT_DEV_FN(vkCreatePipelineLayout);
	INIT_DEV_FN(vkResetDescriptorPool);
	INIT_DEV_FN(vkCreateShaderModule);
	INIT_DEV_FN(vkCreateGraphicsPipelines);
	INIT_DEV_FN(vkCreateComputePipelines);
	INIT_DEV_FN(vkUpdateDescriptorSets);
	INIT_DEV_FN(vkDestroyDevice);
	INIT_DEV_FN(vkDestroyDescriptorPool);
	INIT_DEV_FN(vkDestroySwapchainKHR);
	INIT_DEV_FN(vkDestroyImage);
	INIT_DEV_FN(vkDestroyImageView);
	INIT_DEV_FN(vkDestroyCommandPool);
	INIT_DEV_FN(vkDestroySemaphore);
	INIT_DEV_FN(vkDestroyFence);
	INIT_DEV_FN(vkDestroyPipelineLayout);
	INIT_DEV_FN(vkDestroyPipeline);
	INIT_DEV_FN(vkWaitForFences);
	INIT_DEV_FN(vkBeginCommandBuffer);
	INIT_DEV_FN(vkEndCommandBuffer);
	INIT_DEV_FN(vkAcquireNextImageKHR);
	INIT_DEV_FN(vkCmdBindPipeline);
	INIT_DEV_FN(vkCmdBindDescriptorSets);
	INIT_DEV_FN(vkCmdDispatch);
	INIT_DEV_FN(vkCmdBeginRendering);
	INIT_DEV_FN(vkCmdEndRendering);
	INIT_DEV_FN(vkCmdSetViewport);
	INIT_DEV_FN(vkCmdSetScissor);
	INIT_DEV_FN(vkCmdPushConstants);
	INIT_DEV_FN(vkCmdBindIndexBuffer);
	INIT_DEV_FN(vkCmdBindVertexBuffers);
	INIT_DEV_FN(vkCmdDrawIndexed);
	INIT_DEV_FN(vkCmdBlitImage2);
	INIT_DEV_FN(vkCmdPipelineBarrier2);
	INIT_DEV_FN(vkCmdCopyBufferToImage);
	INIT_DEV_FN(vkCmdCopyBuffer);
	INIT_DEV_FN(vkQueueSubmit2);
	INIT_DEV_FN(vkResetFences);
	INIT_DEV_FN(vkResetCommandBuffer);
	INIT_DEV_FN(vkFreeCommandBuffers);
	INIT_DEV_FN(vkDestroyDescriptorSetLayout);
	INIT_DEV_FN(vkDestroyShaderModule);
	INIT_DEV_FN(vkQueuePresentKHR);
	INIT_DEV_FN(vkCmdDraw);
	INIT_DEV_FN(vkDeviceWaitIdle);
	INIT_DEV_FN(vkCmdClearColorImage);
	INIT_DEV_FN(vkCreateSampler);

	return true;
}

// TODO(MA): implement other platforms
#ifdef __linux__
static b32 vSurfaceInit() 
{
	pPlatformWindow *window = pWindowGet();
	VkXcbSurfaceCreateInfoKHR surface_info = {
		.sType = STYPE(XCB_SURFACE_CREATE_INFO_KHR),
		.connection = window->connection,
		.window = window->window
	};

	VkResult result = vkCreateXcbSurfaceKHR(v_Renderer.handles.inst, &surface_info, NULL, &v_Renderer.handles.surface);
	if (result != VK_SUCCESS) {
		Printf("Unable to create surface: %d", result);
	}

	return result == VK_SUCCESS;
}
#elif _WIN32
static b32 vSurfaceInit()
{
	b32 success = true;

	pPlatformWindow *window = pWindowGet();
	VkWin32SurfaceCreateInfoKHR surface_info = {
		.sType = STYPE(WIN32_SURFACE_CREATE_INFO_KHR),
		.hinstance = window->instance,
		.hwnd = window->handle,
	};

	VkResult result = vkCreateWin32SurfaceKHR(v_Renderer.handles.inst, &surface_info, NULL, &v_Renderer.handles.surface);
	if (result != VK_SUCCESS)
	{
		Printfln("Unable to create surface: %s", vVkResultStr(result));
		success = false;
	}

	return success;
}
#endif

static b32 vLibraryLoad() 
{
	pLibrary *lib = &v_Renderer.handles.lib;
	b32 lib_found; pFunction fn;
	
	for (i32 i = 0; i < Len(vulkan_libs); i++) {
		lib_found = pLibraryLoad(vulkan_libs[i], lib);
		if (lib_found) {
			lib_found = pFunctionLoad("vkGetInstanceProcAddr", lib, &fn);
			vkGetInstanceProcAddr = (PFN_vkGetInstanceProcAddr)fn.fn;
			break;
		}
	}

	return lib_found;
}

static b32 vFrameStructuresInit()
{
	b32 success           = true;
	u32 img_count         = v_Renderer.images.sc.length;

	pool_create_info.queueFamilyIndex = v_Renderer.state.vk.gfx_queue_idx;

	for (u32 i = 0; i < FRAME_OVERLAP; i++)
	{
		VkResult result;
		VkDevice device = v_Renderer.handles.device;
		vFrameHandles *handles = &v_Renderer.frame_handles[i];

		result = vkCreateCommandPool(device, &pool_create_info, NULL, &handles->pool);
		if (result != VK_SUCCESS)
			success = false;

		cmd_buf_info.commandPool = handles->pool;
		
		result = vkAllocateCommandBuffers(device, &cmd_buf_info, &handles->buffer);
		if (result != VK_SUCCESS)
			success = false;

		result = vkCreateFence(device, &fence_create_info, NULL, &handles->r_fence);
		if (result != VK_SUCCESS)
			success = false;

		result = vkCreateSemaphore(device, &semaphore_create_info, NULL, &handles->r_sem);
		if (result != VK_SUCCESS)
			success = false;

		result = vkCreateSemaphore(device, &semaphore_create_info, NULL, &handles->sc_sem);
		if (result != VK_SUCCESS)
			success = false;

		//renderer.vk.frame.buffer_destroy_queues[i] = ArenaAlloc(v_Renderer.mem.perm_arena, sizeof(rRenderBuffer) * 64);
	}

	return success;
}

static b32 vImmediateStructuresInit()
{
	b32 success                       = true;
	VkResult result;
	VkDevice device                   = v_Renderer.handles.device;
	vImmHandlesArray *imm          = &v_Renderer.imm_handles;
	pool_create_info.queueFamilyIndex = v_Renderer.state.vk.tfer_queue_idx;
	
	if (v_Renderer.async.count >= 4 && !v_Renderer.state.vk.single_queue)
		v_Renderer.async.count = 1;
	else
		v_Renderer.async.count = 0;


	imm->data = MakeArray(v_Renderer.mem.perm_arena, vImmHandles, v_Renderer.async.count);
	imm->length = v_Renderer.async.count;
	imm->cap = v_Renderer.async.count;
	
	for (u32 i = 0; i < v_Renderer.async.count && success; i++)
	{
		result = vkCreateCommandPool(device, &pool_create_info, NULL, &imm->data[i].pool);
		if (result != VK_SUCCESS)
			success = false;

		cmd_buf_info.commandPool = imm->data[i].pool;

		result = vkAllocateCommandBuffers(device, &cmd_buf_info, &imm->data[i].buffer);
		if (result != VK_SUCCESS)
			success = false;

		result = vkCreateFence(device, &fence_create_info, NULL, &imm->data[i].fence);
		if (result != VK_SUCCESS)
			success = false;
	}

	return success;
}

static void vUploadQueuesInit()
{
	v_Renderer.upload.transfers = MakeArray(v_Renderer.mem.perm_arena, vTransfer *, 256);
}

static b32 vSwapchainInit()
{
	b32 success = true;
	VkPhysicalDevice phys_device = v_Renderer.handles.phys_device;
	VkDevice device = v_Renderer.handles.device;
	VkSurfaceKHR surface = v_Renderer.handles.surface;
	VkPresentModeKHR present_mode = v_Renderer.state.swapchain.present_mode;
	VkFormat format = v_Renderer.state.swapchain.format;
	VkColorSpaceKHR color_space = v_Renderer.state.swapchain.color_space;
	Arena *arena = vFrameArena();

	VkSurfaceCapabilitiesKHR capabilities;
	vkGetPhysicalDeviceSurfaceCapabilitiesKHR(phys_device, surface, &capabilities);

	// Maybe reconsider handling window sizing within here and only handle it from events themselves
	// causes issues when the window size is out of sync with the current swapchain
	VkExtent2D extent;
	u32 width = v_Renderer.state.swapchain.extent.width;
	u32 height = v_Renderer.state.swapchain.extent.height;

	extent.width = Clampu32((u32)width, capabilities.minImageExtent.width, capabilities.maxImageExtent.width);
	extent.height = Clampu32((u32)height, capabilities.minImageExtent.height, capabilities.maxImageExtent.height);

	if (present_mode == INT_MAX || format == INT_MAX || color_space == INT_MAX)
	{
		u32 format_count;
		vkGetPhysicalDeviceSurfaceFormatsKHR(phys_device, surface, &format_count, NULL);
		VkSurfaceFormatKHR *formats = ArenaAlloc(arena, sizeof(VkSurfaceFormatKHR) * format_count);
		vkGetPhysicalDeviceSurfaceFormatsKHR(phys_device, surface, &format_count, formats);

		format = formats[0].format;
		color_space = formats[0].colorSpace;

		u32 present_count;
		vkGetPhysicalDeviceSurfacePresentModesKHR(phys_device, surface, &present_count, NULL);
		VkPresentModeKHR *present_modes = ArenaAlloc(arena, sizeof(VkSurfaceFormatKHR) * present_count);
		vkGetPhysicalDeviceSurfacePresentModesKHR(phys_device, surface, &present_count, present_modes);

		for (u32 i = 0; i < present_count; i++)
		{
			if (present_modes[i] == VK_PRESENT_MODE_MAILBOX_KHR)
			{
				present_mode = VK_PRESENT_MODE_MAILBOX_KHR;
				break;
			}
		}

		if (present_mode != VK_PRESENT_MODE_MAILBOX_KHR)
			present_mode = VK_PRESENT_MODE_FIFO_KHR;
	}

	swapchain_create_info.minImageCount = capabilities.minImageCount + 1;
	swapchain_create_info.surface = surface;
	swapchain_create_info.imageFormat = format;
	swapchain_create_info.imageColorSpace = color_space;
	swapchain_create_info.imageExtent = extent;
	swapchain_create_info.preTransform = capabilities.currentTransform;
	swapchain_create_info.presentMode = present_mode;

	VkResult result;
	result = vkCreateSwapchainKHR(device, &swapchain_create_info, NULL, &v_Renderer.handles.swapchain);
	if (result != VK_SUCCESS)
		success = false;

	u32 image_count;
	vkGetSwapchainImagesKHR(device, v_Renderer.handles.swapchain, &image_count, NULL);
	VkImage *sc_images = ArenaAlloc(v_Renderer.mem.perm_arena, sizeof(VkImage) * image_count);
	VkImageView *sc_views = ArenaAlloc(v_Renderer.mem.perm_arena, sizeof(VkImageView) * image_count);
	vkGetSwapchainImagesKHR(device, v_Renderer.handles.swapchain, &image_count, sc_images);

	InitArrayType(v_Renderer.images.sc, v_Renderer.mem.perm_arena, vImageView, image_count);

	for (u32 i = 0; i < image_count; i++)
	{
		v_Renderer.images.sc.data[i].image.image = sc_images[i];
		sc_image_view_create_info.image = sc_images[i];
		sc_image_view_create_info.format = format;

		result = vkCreateImageView(device, &sc_image_view_create_info, NULL, &v_Renderer.images.sc.data[i].view);
		if (result != VK_SUCCESS)
			success = false;
	}

	v_Renderer.images.sc.length = image_count;

	v_Renderer.state.swapchain.format = format;
	v_Renderer.state.swapchain.color_space = color_space;
	v_Renderer.state.swapchain.present_mode = present_mode;
	v_Renderer.state.swapchain.extent.width = extent.width;
	v_Renderer.state.swapchain.extent.height = extent.height;
	v_Renderer.state.swapchain.extent.depth = 1;

	return success;
}

static b32 vDrawImagesInit()
{
	b32 success = true;
	VkResult result;

	VkFormat image_format = vImageFormatGet();
	VkExtent3D extent = v_Renderer.state.swapchain.extent;
	VkDevice device = v_Renderer.handles.device;

	VmaAllocationCreateInfo alloc_create_info = {
		.usage = VMA_MEMORY_USAGE_GPU_ONLY,
		.requiredFlags = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT,
	};

	// Draw vImage
	draw_image_create_info.format = image_format;
	draw_image_create_info.extent = extent;

	result = vmaCreateImage(v_Renderer.handles.vma_alloc, &draw_image_create_info, 
												 &alloc_create_info, &v_Renderer.images.draw.image.image, &v_Renderer.images.draw.image.alloc, NULL);
	if (result != VK_SUCCESS)
		success = false;

	// Draw vImage View
	draw_image_view_create_info.image = v_Renderer.images.draw.image.image;
	draw_image_view_create_info.format = image_format;

	result = vkCreateImageView(device, &draw_image_view_create_info, NULL, &v_Renderer.images.draw.view);
	if (result != VK_SUCCESS)
		success = false;

	// Depth vImage
	depth_image_create_info.extent = extent;

	result = vmaCreateImage(v_Renderer.handles.vma_alloc, &depth_image_create_info, 
												 &alloc_create_info, &v_Renderer.images.depth.image.image, &v_Renderer.images.depth.image.alloc, NULL);
	if (result != VK_SUCCESS)
		success = false;

	// Depth vImage View
	depth_image_view_create_info.image = v_Renderer.images.depth.image.image;
	result = vkCreateImageView(device, &depth_image_view_create_info, NULL, &v_Renderer.images.depth.view);
	if (result != VK_SUCCESS)
		success = false;
	
	// Setting values
	v_Renderer.state.swapchain.extent = extent;
	v_Renderer.images.depth.image.format = depth_image_create_info.format;
	v_Renderer.images.depth.image.layout = VK_IMAGE_LAYOUT_UNDEFINED;
	v_Renderer.images.draw.image.format = draw_image_create_info.format;
	v_Renderer.images.draw.image.layout = VK_IMAGE_LAYOUT_UNDEFINED;

	return success;
}

static VkFormat vImageFormatGet()
{
	VkPhysicalDevice phys_device = v_Renderer.handles.phys_device;
	VkImageType image_type = VK_IMAGE_TYPE_2D;
	VkImageTiling tiling = VK_IMAGE_TILING_OPTIMAL;
	VkImageUsageFlags usage_flags = VK_IMAGE_USAGE_TRANSFER_SRC_BIT |
																	VK_IMAGE_USAGE_TRANSFER_DST_BIT |
																	VK_IMAGE_USAGE_STORAGE_BIT			|
																	VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
	
	VkFormat format = 0;
	for (i32 i = 0; i < Len(VK_IMAGE_FORMATS); i++)
	{
		VkImageFormatProperties properties;
		VkResult result;
		result = vkGetPhysicalDeviceImageFormatProperties(phys_device, VK_IMAGE_FORMATS[i], image_type,
																												tiling, usage_flags, 0, &properties);
		if (result == VK_ERROR_FORMAT_NOT_SUPPORTED)
			continue;
		
		if (result == VK_SUCCESS)
		{
			format = VK_IMAGE_FORMATS[i];
			break;
		}
	}

	Assert(format != 0, "[Error] unable to find appropriate image format");

	return format;
}

static b32 vDescriptorsInit()
{
	b32 success = true;

	VkDevice device = v_Renderer.handles.device;
	VkResult result;
	vDescBindings *bindings = v_Renderer.desc_bindings;

	result = vkCreateDescriptorPool(device, &desc_pool_info, NULL, &v_Renderer.handles.desc_pool);
	if (result != VK_SUCCESS)
		success = false;

	result = vkCreateDescriptorSetLayout(device, &shared_layout_create_info, NULL, &v_Renderer.handles.desc_layouts[vDT_SHARED]);
	if (result != VK_SUCCESS)
		success = false;

	for (u32 i = vDT_SAMPLED_IMAGE; i < vDT_MAX; i++)
	{
		bindless_layout_binding.descriptorType = desc_type_map[i];
		result = vkCreateDescriptorSetLayout(device, &bindless_layout_create_info, NULL, &v_Renderer.handles.desc_layouts[i]);
		if (result != VK_SUCCESS)
			success = false;
	}

	set_allocate_info.descriptorPool = v_Renderer.handles.desc_pool;
	set_allocate_info.pSetLayouts = v_Renderer.handles.desc_layouts;

	result = vkAllocateDescriptorSets(device, &set_allocate_info, v_Renderer.handles.desc_sets);
	if (result != VK_SUCCESS)
		success = false;

	pipeline_layout_create_info.setLayoutCount = vDT_MAX;
	pipeline_layout_create_info.pSetLayouts = v_Renderer.handles.desc_layouts;

	result = vkCreatePipelineLayout(device, &pipeline_layout_create_info, NULL, &v_Renderer.handles.pipeline_layout);
	if (result != VK_SUCCESS)
		success = false;

	for (u32 i = 0; i < vDT_MAX; i++)
	{
		bindings[i].free = ArenaAlloc(v_Renderer.mem.perm_arena, sizeof(u32) * DESC_MAX_BINDINGS);

		HashTableInit(&bindings[i].lookup_table, 6);

		u32 free_count = 0;
		for (i32 j = DESC_MAX_BINDINGS-1; j >= 0; j--)
		{
			bindings[i].free[j] = free_count++;
		}
		
		bindings[i].free_count = free_count;
	}


	return success;
}

static b32 vPipelinesInit()
{
	b32 success = true;
	VkResult result;
	VkDevice device = v_Renderer.handles.device;

	Asset quad_vert_shader = apLoadShader(QUAD_VERT_SPIRV_SHADER);
	Asset quad_frag_shader = apLoadShader(QUAD_FRAG_SPIRV_SHADER);

	VkShaderModule cube_vert, cube_frag;
	success &= vShaderModuleInit(quad_vert_shader.bytes, quad_vert_shader.len, &cube_vert);
	success &= vShaderModuleInit(quad_frag_shader.bytes, quad_frag_shader.len, &cube_frag);

	VkPipelineRenderingCreateInfo pipeline_render_info = {
		.sType = STYPE(PIPELINE_RENDERING_CREATE_INFO),
		.colorAttachmentCount = 1,
		.pColorAttachmentFormats = &v_Renderer.images.draw.image.format,
		.depthAttachmentFormat = v_Renderer.images.depth.image.format,
	};

	VkPipelineShaderStageCreateInfo cube_shader_stages[] = {
		{
			.sType = STYPE(PIPELINE_SHADER_STAGE_CREATE_INFO),
			.stage = VK_SHADER_STAGE_VERTEX_BIT,
			.module = cube_vert,
			.pName = "main",
		},
		{
			.sType = STYPE(PIPELINE_SHADER_STAGE_CREATE_INFO),
			.stage = VK_SHADER_STAGE_FRAGMENT_BIT,
			.module = cube_frag,
			.pName = "main",
		},
	};

	cube_create_info.pStages = cube_shader_stages;
	cube_create_info.stageCount = Len(cube_shader_stages);
	cube_create_info.layout = v_Renderer.handles.pipeline_layout;
	cube_create_info.pNext = &pipeline_render_info;

	result = vkCreateGraphicsPipelines(device, 0, 1, &cube_create_info, NULL, &v_Renderer.handles.pipelines[R_PIPELINE_CUBE]);
	if (result != VK_SUCCESS)
	{
		Printf("vkCreateGraphicsPipelines failure: %s", vVkResultStr(result));
		success = false;
	}

	vkDestroyShaderModule(device, cube_vert, NULL);
	vkDestroyShaderModule(device, cube_frag, NULL);

	apUnloadShader(quad_vert_shader);
	apUnloadShader(quad_frag_shader);

	Asset gui_vert_shader = apLoadShader(GUI_VERT_SPIRV_SHADER);
	Asset gui_frag_shader = apLoadShader(GUI_FRAG_SPIRV_SHADER);

	VkShaderModule gui_vert, gui_frag;
	success &= vShaderModuleInit(gui_vert_shader.bytes, gui_vert_shader.len, &gui_vert);
	success &= vShaderModuleInit(gui_frag_shader.bytes, gui_frag_shader.len, &gui_frag);

	VkPipelineShaderStageCreateInfo gui_shader_stages[] = {
		{
			.sType = STYPE(PIPELINE_SHADER_STAGE_CREATE_INFO),
			.stage = VK_SHADER_STAGE_VERTEX_BIT,
			.module = gui_vert,
			.pName = "main",
		},
		{
			.sType = STYPE(PIPELINE_SHADER_STAGE_CREATE_INFO),
			.stage = VK_SHADER_STAGE_FRAGMENT_BIT,
			.module = gui_frag,
			.pName = "main",
		},
	};

	gui_create_info.pStages = gui_shader_stages;
	gui_create_info.stageCount = Len(gui_shader_stages);
	gui_create_info.layout = v_Renderer.handles.pipeline_layout;
	gui_create_info.pNext = &pipeline_render_info;

	result = vkCreateGraphicsPipelines(device, 0, 1, &gui_create_info, NULL, &v_Renderer.handles.pipelines[R_PIPELINE_GUI]);
	if (result != VK_SUCCESS)
	{
		Printfln("vkCreateGraphicsPipelines failure: %s", vVkResultStr(result));
		success = false;
	}

	vkDestroyShaderModule(device, gui_vert, NULL);
	vkDestroyShaderModule(device, gui_frag, NULL);

	apUnloadShader(gui_vert_shader);
	apUnloadShader(gui_frag_shader);

	return success;
}

static b32 vShaderModuleInit(u8 *bytes, u32 len, VkShaderModule *module)
{
	VkResult result;
	b32 success = true;

	VkShaderModuleCreateInfo module_info = {
		.sType = STYPE(SHADER_MODULE_CREATE_INFO),
		.codeSize = len,
		.pCode = (u32 *)bytes,
	};

	result = vkCreateShaderModule(v_Renderer.handles.device, &module_info, NULL, module);
	if (result != VK_SUCCESS)
	{
		Printf("vkCreateShaderModule failure: %s", vVkResultStr(result));
		success = false;
	}

	return success;
}

static b32 vInitBuffers()
{
	vRBuffers *buf = &v_Renderer.buffers;
	Arena *arena = v_Renderer.mem.perm_arena;

	buf->perm.data = MakeArray(arena, vBufferAlloc *, 1024);
	buf->perm.cap = 1024;
	buf->perm.length = 0;

	for (u32 i = 0; i < FRAME_OVERLAP; i++)
	{
		buf->frame[i].data = MakeArray(arena, vBufferAlloc *, 512);
		buf->frame[i].cap = 512;
		buf->frame[i].length = 0;
	}

	b32 success = true;
	VkResult result;

	if (success)
	{
		result = vBufferCreate(&buf->gui_vert.alloc, rRBT_VERTEX | rRBT_HOST, MB(32));
		if (result != VK_SUCCESS)
			success = false;
	}

	if (success)
	{
		result = vBufferCreate(&buf->gui_idx.alloc, rRBT_INDEX | rRBT_HOST, MB(8)); // TODO: figure out ratio of memory alloc from vertex -> index
		if (result != VK_SUCCESS)
			success = false;
	}

	if (success)
	{
		result = vBufferCreate(&buf->transfer.alloc, rRBT_STAGING, MB(64));
		if (result != VK_SUCCESS)
			success = false;
	}

	buf->gui_vert.ptr = vMapBuffer(buf->gui_vert.alloc.alloc);
	buf->gui_idx.ptr = vMapBuffer(buf->gui_idx.alloc.alloc);
	buf->transfer.ptr = vMapBuffer(buf->transfer.alloc.alloc);

	return success;
}

#if __linux__

static void vLoaderStartThreads()
{
	if (v_Renderer.async.count == 0)
		return;

	u32 count = v_Renderer.async.count;
	pthread_t *threads = ArenaAlloc(v_Renderer.mem.perm_arena, sizeof(pthread_t) * count);

	for (u32 i = 0; i < count; i++)
	{
		v_Renderer.async.thread_idx[i] = i;
		pthread_create(&threads[i], NULL, vLoaderStart, &v_Renderer.async.thread_idx[i]);
	}
}

#elif _WIN32

# error Threading not yet implemented

#endif

// ::Vulkan::Init::Functions::End::



// ::Vulkan::Async::Functions::Start::

static u32 vLoaderProcessBuffers(u32 thread_index)
{
	/*
	JobQueue *job_queue = &renderer.upload_queues[vDT_MATERIAL].job_queue;
	TicketMut *ticket_mut = &renderer.upload_queues[vDT_MATERIAL].ticket_mut;
	rRenderBuffer **render_buffers = renderer.upload_queues[vDT_MATERIAL].queued_buffers;
	rawptr *buffer_data = renderer.upload_queues[vDT_MATERIAL].data;
	u32 buffer_count = JobQueueGetCount(job_queue);

	u32 count = 0;
	if (buffer_count > 0)
	{
		TicketMutLock(ticket_mut);

		rRenderBuffer *buffers[16];
		rawptr data[16];
		for (i32 i = i32(buffer_count - 1); i >= 0 && count < 16; i--)
		{
			buffers[count] = render_buffers[i];
			data[count] = buffer_data[i];
			count += 1;
		}

		JobQueueMarkUnqueued(job_queue, count);

		TicketMutUnlock(ticket_mut);

		// TODO: FIX
		//for (u32 i = 0; i < count; i++)
			//Assert(rBufferCreate(buffers[i]), "vLoaderProcessBuffers failure: rBufferCreate failed");

		Assert(rBufferUpload(buffers, data, count, thread_index), "vLoaderProcessBuffers failure: rBufferUpload failed");

		JobQueueMarkCompleted(job_queue, count);
	}

	return count;

	*/

	return 0;
}

static u32 vLoaderProcessSamplers(u32 thread_index)
{
	/*
	JobQueue *job_queue = &renderer.upload_queues[vDT_SAMPLED_IMAGE].job_queue;
	TicketMut *ticket_mut = &renderer.upload_queues[vDT_SAMPLED_IMAGE].ticket_mut;
	rTextureBuffer **texture_buffers = renderer.upload_queues[vDT_SAMPLED_IMAGE].queued_textures;
	rawptr *texture_data = renderer.upload_queues[vDT_SAMPLED_IMAGE].data;
	u32 buffer_count = JobQueueGetCount(job_queue);

	u32 count = 0;
	if (buffer_count > 0)
	{
		TicketMutLock(ticket_mut);

		rTextureBuffer *buffers[16];
		rawptr data[16];
		for (i32 i = i32(buffer_count - 1); i >= 0 && count < 16; i--)
		{
			buffers[count] = texture_buffers[i];
			data[count] = texture_data[i];
			count += 1;
		}

		JobQueueMarkUnqueued(job_queue, count);

		TicketMutUnlock(ticket_mut);

		for (u32 i = 0; i < count; i++)
		{
			Assert(vSamplerCreate(buffers[i]), "Unable to create VkSampler");
			vImageUpload(buffers[i], data[i], thread_index);
		}

		JobQueueMarkCompleted(job_queue, count);

		for (u32 i = 0; i < count; i++)
		{
			FLMemFree(buffers[i]);
		}
	}

	return count;

	*/

	return 0;
}


#ifdef __linux__

void *vLoaderStart(void *i)
{
	u32 index = *(u32 *)i;
	pthread_t self = pthread_self();
	pthread_mutex_t mut;
	pthread_mutex_init(&mut, NULL);

	u32 processed_count = 0;
	u32 iter_count = 0;
	/*
	for (;;)
	{	
		for (u32 i = 0; i < vDT_MAX; i++)
		{
			Mut *mut = &renderer.upload_queues[i].mut;
			if (MutTryLock(mut))
			{
				switch (i)
				{
					case vDT_MATERIAL:
					{
						processed_count += vLoaderProcessBuffers(index);
					} break;
					case vDT_SAMPLED_IMAGE:
					{
						processed_count += vLoaderProcessSamplers(index);
					} break;
					default:
						break;
				}

				MutUnlock(mut);
			}
		}

		iter_count += 1;

		if (processed_count < 0)
			pthread_exit(NULL);
		else if (processed_count == 0 && iter_count >= 3)
		{
			iter_count = 0;
			pu8AtomicIncr(&v_Renderer.async.sleeping);
			pthread_mutex_lock(&mut);
			pthread_cond_wait(&v_Renderer.async.cond, &mut);
			pthread_mutex_unlock(&mut);
			pu8AtomicFetchSub(&v_Renderer.async.sleeping, 1);
		}
	}
	*/

	pthread_exit(NULL);
}

void vLoaderWake()
{
	for (u32 i = 0; i < v_Renderer.async.count; i++)
		pthread_cond_signal(&v_Renderer.async.cond);
}

#elif _WIN32

#error not yet implemented

#endif

// ::Vulkan::Async::Functions::End::



// ::Vulkan::CleanUp::Functions::Start::

static void vSwapchainDestroy()
{
	vImageViewArray images = v_Renderer.images.sc;
	VkDevice device = v_Renderer.handles.device;
	VkSwapchainKHR swapchain = v_Renderer.handles.swapchain;

	for (u32 i = 0; i < images.length; i++) 
	{
		vkDestroyImageView(device, images.data[i].view, NULL);
	}

	vkDestroySwapchainKHR(device, swapchain, NULL);
}

static void vDrawImagesDestroy()
{
	vRImages *images = &v_Renderer.images;
	VkDevice device = v_Renderer.handles.device;
	VmaAllocator vma_alloc = v_Renderer.handles.vma_alloc;

	vkDestroyImageView(device, images->draw.view, NULL);
	vmaDestroyImage(vma_alloc, images->draw.image.image, images->draw.image.alloc);

	vkDestroyImageView(device, images->depth.view, NULL);
	vmaDestroyImage(vma_alloc, images->depth.image.image, images->depth.image.alloc);
}

// ::Vulkan::CleanUp::Functions::End::



// ::Vulkan::Logging::Functions::Start::

void vInfo(const char *str)
{
	Printfln("[INFO] %s", str);
}

void vWarn(const char *str)
{
	Printfln("[WARN] %s", str);
}

void vError(const char *str)
{
	Printfln("[ERROR] %s", str);
}

// ::Vulkan::Logging::Functions::End::



// ::Vulkan::Debug::Functions::Start::

const char *vVkResultStr(VkResult result) 
{ 
	switch (result) 
	{ 
		case VK_SUCCESS: 
			return "VK_SUCCESS"; 
		case VK_NOT_READY: 
			return "VK_NOT_READY"; 
		case VK_TIMEOUT: 
			return "VK_TIMEOUT"; 
		case VK_EVENT_SET: 
			return "VK_EVENT_SET"; 
		case VK_EVENT_RESET: 
			return "VK_EVENT_RESET"; 
		case VK_INCOMPLETE: 
			return "VK_INCOMPLETE"; 
		case VK_ERROR_OUT_OF_HOST_MEMORY: 
			return "VK_ERROR_OUT_OF_HOST_MEMORY"; 
		case VK_ERROR_OUT_OF_DEVICE_MEMORY: 
			return "VK_ERROR_OUT_OF_DEVICE_MEMORY"; 
		case VK_ERROR_INITIALIZATION_FAILED: 
			return "VK_ERROR_INITIALIZATION_FAILED"; 
		case VK_ERROR_DEVICE_LOST: 
			return "VK_ERROR_DEVICE_LOST"; 
		case VK_ERROR_MEMORY_MAP_FAILED: 
			return "VK_ERROR_MEMORY_MAP_FAILED"; 
		case VK_ERROR_LAYER_NOT_PRESENT: 
			return "VK_ERROR_LAYER_NOT_PRESENT"; 
		case VK_ERROR_EXTENSION_NOT_PRESENT: 
			return "VK_ERROR_EXTENSION_NOT_PRESENT"; 
		case VK_ERROR_FEATURE_NOT_PRESENT: 
			return "VK_ERROR_FEATURE_NOT_PRESENT"; 
		case VK_ERROR_INCOMPATIBLE_DRIVER: 
			return "VK_ERROR_INCOMPATIBLE_DRIVER"; 
		case VK_ERROR_TOO_MANY_OBJECTS: 
			return "VK_ERROR_TOO_MANY_OBJECTS"; 
		case VK_ERROR_FORMAT_NOT_SUPPORTED: 
			return "VK_ERROR_FORMAT_NOT_SUPPORTED"; 
		case VK_ERROR_FRAGMENTED_POOL: 
			return "VK_ERROR_FRAGMENTED_POOL"; 
		case VK_ERROR_UNKNOWN: 
			return "VK_ERROR_UNKNOWN"; 
		case VK_ERROR_OUT_OF_POOL_MEMORY: 
			return "VK_ERROR_OUT_OF_POOL_MEMORY"; 
		case VK_ERROR_INVALID_EXTERNAL_HANDLE: 
			return "VK_ERROR_INVALID_EXTERNAL_HANDLE"; 
		case VK_ERROR_FRAGMENTATION: 
			return "VK_ERROR_FRAGMENTATION"; 
		case VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS: 
			return "VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS"; 
		case VK_PIPELINE_COMPILE_REQUIRED: 
			return "VK_PIPELINE_COMPILE_REQUIRED"; 
		case VK_ERROR_SURFACE_LOST_KHR: 
			return "VK_ERROR_SURFACE_LOST_KHR"; 
		case VK_ERROR_NATIVE_WINDOW_IN_USE_KHR: 
			return "VK_ERROR_NATIVE_WINDOW_IN_USE_KHR"; 
		case VK_SUBOPTIMAL_KHR: 
			return "VK_SUBOPTIMAL_KHR"; 
		case VK_ERROR_OUT_OF_DATE_KHR: 
			return "VK_ERROR_OUT_OF_DATE_KHR"; 
		case VK_ERROR_INCOMPATIBLE_DISPLAY_KHR: 
			return "VK_ERROR_INCOMPATIBLE_DISPLAY_KHR"; 
		case VK_ERROR_VALIDATION_FAILED_EXT: 
			return "VK_ERROR_VALIDATION_FAILED_EXT"; 
		case VK_ERROR_INVALID_SHADER_NV: 
			return "VK_ERROR_INVALID_SHADER_NV"; 
#ifdef VK_ENABLE_BETA_EXTENSIONS 
		case VK_ERROR_IMAGE_USAGE_NOT_SUPPORTED_KHR: 
			return "VK_ERROR_IMAGE_USAGE_NOT_SUPPORTED_KHR"; 
#endif 
#ifdef VK_ENABLE_BETA_EXTENSIONS 
		case VK_ERROR_VIDEO_PICTURE_LAYOUT_NOT_SUPPORTED_KHR: 
			return "VK_ERROR_VIDEO_PICTURE_LAYOUT_NOT_SUPPORTED_KHR"; 
#endif 
#ifdef VK_ENABLE_BETA_EXTENSIONS 
		case VK_ERROR_VIDEO_PROFILE_OPERATION_NOT_SUPPORTED_KHR: 
			return "VK_ERROR_VIDEO_PROFILE_OPERATION_NOT_SUPPORTED_KHR"; 
#endif 
#ifdef VK_ENABLE_BETA_EXTENSIONS 
		case VK_ERROR_VIDEO_PROFILE_FORMAT_NOT_SUPPORTED_KHR: 
			return "VK_ERROR_VIDEO_PROFILE_FORMAT_NOT_SUPPORTED_KHR"; 
#endif 
#ifdef VK_ENABLE_BETA_EXTENSIONS 
		case VK_ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED_KHR: 
			return "VK_ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED_KHR"; 
#endif 
#ifdef VK_ENABLE_BETA_EXTENSIONS 
		case VK_ERROR_VIDEO_STD_VERSION_NOT_SUPPORTED_KHR: 
			return "VK_ERROR_VIDEO_STD_VERSION_NOT_SUPPORTED_KHR"; 
#endif 
		case VK_ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT: 
			return "VK_ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT"; 
		case VK_ERROR_NOT_PERMITTED_KHR: 
			return "VK_ERROR_NOT_PERMITTED_KHR"; 
		case VK_ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT: 
			return "VK_ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT"; 
		case VK_THREAD_IDLE_KHR: 
			return "VK_THREAD_IDLE_KHR"; 
		case VK_THREAD_DONE_KHR: 
			return "VK_THREAD_DONE_KHR"; 
		case VK_OPERATION_DEFERRED_KHR: 
			return "VK_OPERATION_DEFERRED_KHR"; 
		case VK_OPERATION_NOT_DEFERRED_KHR: 
			return "VK_OPERATION_NOT_DEFERRED_KHR"; 
		case VK_ERROR_COMPRESSION_EXHAUSTED_EXT: 
			return "VK_ERROR_COMPRESSION_EXHAUSTED_EXT"; 
		case VK_RESULT_MAX_ENUM: 
			return "VK_RESULT_MAX_ENUM"; 
		default: 
			return "??????"; 
	} 
}

static VKAPI_ATTR VkBool32 vDebugCallback(
	VkDebugUtilsMessageSeverityFlagBitsEXT			message_severity,
	VkDebugUtilsMessageTypeFlagsEXT							message_type,
	const VkDebugUtilsMessengerCallbackDataEXT	*pCallbackData,
	void																				*pUserData
) {
	char *ms, *mt;

	switch (message_severity) {
	case VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT:
		ms = (char *)"VERBOSE";
		break;
	case VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT:
		ms = (char *)"INFO";
		break;
	case VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT:
		ms = (char *)"WARNING";
		break;
	case VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT:
		ms = (char *)"ERROR";
		break;
	default: 
		ms = (char *)"UNKNOWN";
		break;
	}

	switch (message_type) {
	case VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT:
		mt = (char *)"General";
		break;
	case VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT:
		mt = (char *)"Validation";
		break;
	case VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT | VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT:
		mt = (char *)"Validation | General";
		break;
	case VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT:
		mt = (char *)"Performance";
		break;
	case VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT | VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT:
		mt = (char *)"General | Performance";
		break;
	case VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT | VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT:
		mt = (char *)"Validation | Performance";
		break;
	case VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT | VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT | VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT:
		mt = (char *)"General | Validation | Performance";
		break;
	default:
		mt = (char *)"Unknown";
		break;
	}
	
	Printf("[%s: %s]\n%s\n", ms, mt, pCallbackData->pMessage);

	return VK_FALSE;
}

static b32 vValidationSupported() 
{
	b32 success = false;
	Arena *arena = vFrameArena();

	u32 count;
	vkEnumerateInstanceLayerProperties(&count, NULL);
	Assert(count, "vValidationSupported(): vkEnumerateInstanceLayerProperties returned a count of 0");

	VkLayerProperties *layers = ArenaAlloc(arena, sizeof(VkLayerProperties) * count);
	vkEnumerateInstanceLayerProperties(&count, layers);

	for (u32 i = 0; i < count; i++) {
		if (StrEq(layers[i].layerName, _VK_VALIDATION)) {
			success = true;
			break;
		}
	}

	return success;
}

// ::Vulkan::Debug::Functions::End::