yes

runtime/Sources/Renderer/RenderCore.cpp

@@ -42,6 +42,9 @@ namespace mlx
 
 		Window window(1, 1, "", true);
 		std::vector<const char*> instance_extentions = window.GetRequiredVulkanInstanceExtentions();
+		#ifdef MLX_PLAT_MACOS
+			instance_extentions.push_back(VK_KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME);
+		#endif
 
 		m_instance = kvfCreateInstance(instance_extensions.data(), instance_extensions.size());
 		DebugLog("Vulkan : instance created");

third_party/kvf.h

@@ -43,6 +43,8 @@
  * or VK_NO_PROTOTYPES before including this file to avoid conflicts with Vulkan prototypes.
  *
  * You can also #define KVF_ENABLE_VALIDATION_LAYERS to enable validation layers.
+ *
+ * Use #define KVF_NO_KHR to remove all functions that use KHR calls.
  */
 
 #ifndef KBZ_8_VULKAN_FRAMEWORK_H
@@ -89,20 +91,30 @@ void kvfSetValidationWarningCallback(KvfErrorCallback callback);
 
 void kvfAddLayer(const char* layer);
 
-VkInstance kvfCreateInstance(const char** extensionsEnabled, uint32_t extensionsCount);
+VkInstance kvfCreateInstance(const char** extensions_enabled, uint32_t extensions_count);
 void kvfDestroyInstance(VkInstance instance);
 
 // If surfaces given to theses functions are VK_NULL_HANDLE no present queues will be searched and thus kvfQueuePresentKHR will not work
 VkPhysicalDevice kvfPickFirstPhysicalDevice(VkInstance instance, VkSurfaceKHR surface);
 VkPhysicalDevice kvfPickGoodDefaultPhysicalDevice(VkInstance instance, VkSurfaceKHR surface);
-VkPhysicalDevice kvfPickGoodPhysicalDevice(VkInstance instance, VkSurfaceKHR surface, const char** deviceExtensions, uint32_t deviceExtensionsCount);
+VkPhysicalDevice kvfPickGoodPhysicalDevice(VkInstance instance, VkSurfaceKHR surface, const char** device_extensions, uint32_t device_extensions_count);
 
 VkQueue kvfGetDeviceQueue(VkDevice device, KvfQueueType queue);
 uint32_t kvfGetDeviceQueueFamily(VkDevice device, KvfQueueType queue);
+#ifndef KVF_NO_KHR
 	bool kvfQueuePresentKHR(VkDevice device, VkSemaphore wait, VkSwapchainKHR swapchain, uint32_t image_index); // return false when the swapchain must be recreated
+#endif
+
+// Meant to be used when creating a VkDevice with a custom VkPhysicalDevice
+int32_t kvfFindDeviceQueueFamily(VkPhysicalDevice physical, KvfQueueType type); // This function cannot find present queue
+#ifndef KVF_NO_KHR
+	int32_t kvfFindDeviceQueueFamilyKHR(VkPhysicalDevice physical, VkSurfaceKHR surface, KvfQueueType type); // This one can find present queue
+#endif
 
 VkDevice kvfCreateDefaultDevice(VkPhysicalDevice physical);
 VkDevice kvfCreateDevice(VkPhysicalDevice physical, const char** extensions, uint32_t extensions_count, VkPhysicalDeviceFeatures* features);
+VkDevice kvfCreateDefaultDevicePhysicalDeviceAndCustomQueues(VkPhysicalDevice physical, int32_t graphics_queue, int32_t present_queue, int32_t compute_queue);
+VkDevice kvfCreateDeviceCustomPhysicalDeviceAndQueues(VkPhysicalDevice physical, const char** extensions, uint32_t extensions_count, VkPhysicalDeviceFeatures* features, int32_t graphics_queue, int32_t present_queue, int32_t compute_queue);
 void kvfDestroyDevice(VkDevice device);
 
 VkFence kvfCreateFence(VkDevice device);
@@ -112,15 +124,17 @@ void kvfDestroyFence(VkDevice device, VkFence fence);
 VkSemaphore kvfCreateSemaphore(VkDevice device);
 void kvfDestroySemaphore(VkDevice device, VkSemaphore semaphore);
 
-VkSwapchainKHR kvfCreateSwapchainKHR(VkDevice device, VkPhysicalDevice physical, VkSurfaceKHR surface, VkExtent2D extent, bool tryVsync);
+#ifndef KVF_NO_KHR
+	VkSwapchainKHR kvfCreateSwapchainKHR(VkDevice device, VkPhysicalDevice physical, VkSurfaceKHR surface, VkExtent2D extent, bool try_vsync);
 	VkFormat kvfGetSwapchainImagesFormat(VkSwapchainKHR swapchain);
 	uint32_t kvfGetSwapchainImagesCount(VkSwapchainKHR swapchain);
 	uint32_t kvfGetSwapchainMinImagesCount(VkSwapchainKHR swapchain);
 	VkExtent2D kvfGetSwapchainImagesSize(VkSwapchainKHR swapchain);
 	void kvfDestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain);
+#endif
 
 VkImage kvfCreateImage(VkDevice device, uint32_t width, uint32_t height, VkFormat format, VkImageTiling tiling, VkImageUsageFlags usage, KvfImageType type);
-void kvfImageToBuffer(VkCommandBuffer cmd, VkBuffer dst, VkImage src, size_t size);
+void kvfImageToBuffer(VkCommandBuffer cmd, VkBuffer dst, VkImage src, size_t buffer_offset, VkImageAspectFlagBits aspect, VkExtent3D extent);
 void kvfDestroyImage(VkDevice device, VkImage image);
 VkImageView kvfCreateImageView(VkDevice device, VkImage image, VkFormat format, VkImageViewType type, VkImageAspectFlags aspect, int layer_count);
 void kvfDestroyImageView(VkDevice device, VkImageView image_view);
@@ -145,7 +159,9 @@ void kvfSubmitCommandBuffer(VkDevice device, VkCommandBuffer buffer, KvfQueueTyp
 void kvfSubmitSingleTimeCommandBuffer(VkDevice device, VkCommandBuffer buffer, KvfQueueType queue, VkFence fence);
 
 VkAttachmentDescription kvfBuildAttachmentDescription(KvfImageType type, VkFormat format, VkImageLayout initial, VkImageLayout final, bool clear, VkSampleCountFlagBits samples);
+#ifndef KVF_NO_KHR
 	VkAttachmentDescription kvfBuildSwapchainAttachmentDescription(VkSwapchainKHR swapchain, bool clear);
+#endif
 
 VkRenderPass kvfCreateRenderPass(VkDevice device, VkAttachmentDescription* attachments, size_t attachments_count, VkPipelineBindPoint bind_point);
 VkRenderPass kvfCreateRenderPassWithSubpassDependencies(VkDevice device, VkAttachmentDescription* attachments, size_t attachments_count, VkPipelineBindPoint bind_point, VkSubpassDependency* dependencies, size_t dependencies_count);
@@ -260,13 +276,14 @@ typedef struct
 	size_t sets_pools_size;
 } __KvfDevice;
 
+#ifndef KVF_NO_KHR
 	typedef struct
 	{
 		VkSurfaceCapabilitiesKHR capabilities;
 		VkSurfaceFormatKHR* formats;
 		VkPresentModeKHR* presentModes;
-	uint32_t formatsCount;
+		uint32_t formats_count;
-	uint32_t presentModesCount;
+		uint32_t presentModes_count;
 	} __KvfSwapchainSupportInternal;
 
 	typedef struct
@@ -277,6 +294,7 @@ typedef struct
 		VkFormat images_format;
 		uint32_t images_count;
 	} __KvfSwapchain;
+#endif
 
 typedef struct
 {
@@ -302,9 +320,11 @@ __KvfDevice* __kvf_internal_devices = NULL;
 size_t __kvf_internal_devices_size = 0;
 size_t __kvf_internal_devices_capacity = 0;
 
+#ifndef KVF_NO_KHR
 	__KvfSwapchain* __kvf_internal_swapchains = NULL;
 	size_t __kvf_internal_swapchains_size = 0;
 	size_t __kvf_internal_swapchains_capacity = 0;
+#endif
 
 __KvfFramebuffer* __kvf_internal_framebuffers = NULL;
 size_t __kvf_internal_framebuffers_size = 0;
@@ -346,7 +366,7 @@ void kvfCheckVk(VkResult result)
 	__kvfCheckVk(result);
 }
 
-void __kvfAddDeviceToArray(VkPhysicalDevice device, int32_t graphics_queue, int32_t present_queue)
+void __kvfAddDeviceToArray(VkPhysicalDevice device, int32_t graphics_queue, int32_t present_queue, int32_t compute_queue)
 {
 	KVF_ASSERT(device != VK_NULL_HANDLE);
 	if(__kvf_internal_devices_size == __kvf_internal_devices_capacity)
@@ -358,6 +378,7 @@ void __kvfAddDeviceToArray(VkPhysicalDevice device, int32_t graphics_queue, int3
 
 	__kvf_internal_devices[__kvf_internal_devices_size].physical = device;
 	__kvf_internal_devices[__kvf_internal_devices_size].queues.graphics = graphics_queue;
+	__kvf_internal_devices[__kvf_internal_devices_size].queues.compute = compute_queue;
 	__kvf_internal_devices[__kvf_internal_devices_size].queues.present = present_queue;
 	__kvf_internal_devices_size++;
 }
@@ -390,6 +411,36 @@ void __kvfCompleteDevice(VkPhysicalDevice physical, VkDevice device)
 	kvf_device->sets_pools_size = 0;
 }
 
+void __kvfCompleteDeviceCustomPhysicalDeviceAndQueues(VkPhysicalDevice physical, VkDevice device, int32_t graphics_queue, int32_t present_queue, int32_t compute_queue)
+{
+	KVF_ASSERT(device != VK_NULL_HANDLE);
+	KVF_ASSERT(physical != VK_NULL_HANDLE);
+
+	__kvfAddDeviceToArray(physical, graphics_queue, present_queue, compute_queue);
+
+	__KvfDevice* kvf_device = NULL;
+
+	for(size_t i = 0; i < __kvf_internal_devices_size; i++)
+	{
+		if(__kvf_internal_devices[i].physical == physical)
+			kvf_device = &__kvf_internal_devices[i];
+	}
+
+	KVF_ASSERT(kvf_device != NULL);
+
+	VkCommandPool pool;
+	VkCommandPoolCreateInfo pool_info = {};
+	pool_info.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
+	pool_info.flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT;
+	pool_info.queueFamilyIndex = kvf_device->queues.graphics;
+	__kvfCheckVk(vkCreateCommandPool(device, &pool_info, NULL, &pool));
+
+	kvf_device->device = device;
+	kvf_device->cmd_pool = pool;
+	kvf_device->sets_pools = NULL;
+	kvf_device->sets_pools_size = 0;
+}
+
 void __kvfDestroyDescriptorPools(VkDevice device);
 
 void __kvfDestroyDevice(VkDevice device)
@@ -438,6 +489,7 @@ __KvfDevice* __kvfGetKvfDeviceFromVkDevice(VkDevice device)
 	return NULL;
 }
 
+#ifndef KVF_NO_KHR
 	void __kvfAddSwapchainToArray(VkSwapchainKHR swapchain, __KvfSwapchainSupportInternal support, VkFormat format, uint32_t images_count, VkExtent2D extent)
 	{
 		KVF_ASSERT(swapchain != VK_NULL_HANDLE);
@@ -490,6 +542,7 @@ __KvfSwapchain* __kvfGetKvfSwapchainFromVkSwapchainKHR(VkSwapchainKHR swapchain)
 		}
 		return NULL;
 	}
+#endif
 
 void __kvfAddFramebufferToArray(VkFramebuffer framebuffer, VkExtent2D extent)
 {
@@ -1025,19 +1078,23 @@ VkInstance kvfCreateInstance(const char** extensions_enabled, uint32_t extension
 	VkInstanceCreateInfo create_info = {};
 	create_info.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
 	create_info.pApplicationInfo = NULL;
-	create_info.flags = 0;
 	create_info.enabledExtensionCount = extensions_count;
 	create_info.ppEnabledExtensionNames = extensions_enabled;
 	create_info.enabledLayerCount = 0;
 	create_info.ppEnabledLayerNames = NULL;
 	create_info.pNext = NULL;
+	#if defined(VK_USE_PLATFORM_MACOS_MVK) || defined(VK_USE_PLATFORM_METAL_EXT)
+		create_info.flags = VK_INSTANCE_CREATE_ENUMERATE_PORTABILITY_BIT_KHR;
+	#else
+		create_info.flags = 0;
+	#endif
 
 #ifdef KVF_ENABLE_VALIDATION_LAYERS
 	kvfAddLayer("VK_LAYER_KHRONOS_validation");
 	const char** new_extension_set = NULL;
+	VkDebugUtilsMessengerCreateInfoEXT debug_create_info = {};
 	if(__kvfCheckValidationLayerSupport())
 	{
-		VkDebugUtilsMessengerCreateInfoEXT debug_create_info = {};
 		__kvfPopulateDebugMessengerCreateInfo(&debug_create_info);
 		new_extension_set = (const char**)KVF_MALLOC(sizeof(char*) * (extensions_count + 1));
 		memcpy(new_extension_set, extensions_enabled, sizeof(char*) * extensions_count);
@@ -1090,6 +1147,7 @@ __KvfQueueFamilies __kvfFindQueueFamilies(VkPhysicalDevice physical, VkSurfaceKH
 			queues.compute = i;
 		if(queue_families[i].queueFlags & VK_QUEUE_GRAPHICS_BIT)
 			queues.graphics = i;
+		#ifndef KVF_NO_KHR
 			VkBool32 present_support = false;
 			if(surface != VK_NULL_HANDLE)
 			{
@@ -1101,6 +1159,10 @@ __KvfQueueFamilies __kvfFindQueueFamilies(VkPhysicalDevice physical, VkSurfaceKH
 			}
 			else if(queues.graphics != -1 && queues.compute != -1)
 				break;
+		#else
+			if(queues.graphics != -1 && queues.compute != -1)
+				break;
+		#endif
 	}
 	KVF_FREE(queue_families);
 	return queues;
@@ -1120,7 +1182,7 @@ VkPhysicalDevice kvfPickFirstPhysicalDevice(VkInstance instance, VkSurfaceKHR su
 	chosen_one = devices[0];
 	KVF_FREE(devices);
 	__KvfQueueFamilies queues = __kvfFindQueueFamilies(chosen_one, surface);
-	__kvfAddDeviceToArray(chosen_one, queues.graphics, queues.present);
+	__kvfAddDeviceToArray(chosen_one, queues.graphics, queues.present, queues.present);
 	return chosen_one;
 }
 
@@ -1130,21 +1192,21 @@ VkPhysicalDevice kvfPickGoodDefaultPhysicalDevice(VkInstance instance, VkSurface
 	return kvfPickGoodPhysicalDevice(instance, surface, extensions, sizeof(extensions) / sizeof(extensions[0]));
 }
 
-int32_t __kvfScorePhysicalDevice(VkPhysicalDevice device, VkSurfaceKHR surface, const char** deviceExtensions, uint32_t deviceExtensionsCount)
+int32_t __kvfScorePhysicalDevice(VkPhysicalDevice device, VkSurfaceKHR surface, const char** device_extensions, uint32_t device_extensions_count)
 {
-	/* Check Extensions Support */
+	/* Check extensions support */
 	uint32_t extension_count;
 	vkEnumerateDeviceExtensionProperties(device, NULL, &extension_count, NULL);
 	VkExtensionProperties* props = (VkExtensionProperties*)KVF_MALLOC(sizeof(VkExtensionProperties) * extension_count + 1);
 	vkEnumerateDeviceExtensionProperties(device, NULL, &extension_count, props);
 
 	bool are_there_required_device_extensions = true;
-	for(int j = 0; j < deviceExtensionsCount; j++)
+	for(int j = 0; j < device_extensions_count; j++)
 	{
 		bool is_there_extension = false;
 		for(int k = 0; k < extension_count; k++)
 		{
-			if(strcmp(deviceExtensions[j], props[k].extensionName) == 0)
+			if(strcmp(device_extensions[j], props[k].extensionName) == 0)
 			{
 				is_there_extension = true;
 				break;
@@ -1162,14 +1224,19 @@ int32_t __kvfScorePhysicalDevice(VkPhysicalDevice device, VkSurfaceKHR surface,
 
 	/* Check Queue Families Support */
 	__KvfQueueFamilies queues = __kvfFindQueueFamilies(device, surface);
-	if(queues.graphics == -1 || queues.present == -1)
+	if(queues.graphics == -1 || (surface != VK_NULL_HANDLE && queues.present == -1))
 		return -1;
 
-	/* Check Surface Formats Counts */
+	#ifndef KVF_NO_KHR
+		if(surface != VK_NULL_HANDLE)
+		{
+			/* Check surface formats counts */
 			uint32_t format_count;
 			vkGetPhysicalDeviceSurfaceFormatsKHR(device, surface, &format_count, NULL);
 			if(format_count == 0)
 				return -1;
+		}
+	#endif
 
 	VkPhysicalDeviceProperties device_props;
 	vkGetPhysicalDeviceProperties(device, &device_props);
@@ -1190,7 +1257,7 @@ int32_t __kvfScorePhysicalDevice(VkPhysicalDevice device, VkSurfaceKHR surface,
 	return score;
 }
 
-VkPhysicalDevice kvfPickGoodPhysicalDevice(VkInstance instance, VkSurfaceKHR surface, const char** deviceExtensions, uint32_t deviceExtensionsCount)
+VkPhysicalDevice kvfPickGoodPhysicalDevice(VkInstance instance, VkSurfaceKHR surface, const char** device_extensions, uint32_t device_extensions_count)
 {
 	VkPhysicalDevice* devices = NULL;
 	VkPhysicalDevice chosen_one = VK_NULL_HANDLE;
@@ -1198,7 +1265,6 @@ VkPhysicalDevice kvfPickGoodPhysicalDevice(VkInstance instance, VkSurfaceKHR sur
 	int32_t best_device_score = -1;
 
 	KVF_ASSERT(instance != VK_NULL_HANDLE);
-	KVF_ASSERT(surface != VK_NULL_HANDLE);
 
 	vkEnumeratePhysicalDevices(instance, &device_count, NULL);
 	devices = (VkPhysicalDevice*)KVF_MALLOC(sizeof(VkPhysicalDevice) * device_count + 1);
@@ -1206,7 +1272,7 @@ VkPhysicalDevice kvfPickGoodPhysicalDevice(VkInstance instance, VkSurfaceKHR sur
 
 	for(int i = 0; i < device_count; i++)
 	{
-		int32_t current_device_score = __kvfScorePhysicalDevice(devices[i], surface, deviceExtensions, deviceExtensionsCount);
+		int32_t current_device_score = __kvfScorePhysicalDevice(devices[i], surface, device_extensions, device_extensions_count);
 		if(current_device_score > best_device_score)
 		{
 			best_device_score = current_device_score;
@@ -1217,7 +1283,7 @@ VkPhysicalDevice kvfPickGoodPhysicalDevice(VkInstance instance, VkSurfaceKHR sur
 	if(chosen_one != VK_NULL_HANDLE)
 	{
 		__KvfQueueFamilies queues = __kvfFindQueueFamilies(chosen_one, surface);
-		__kvfAddDeviceToArray(chosen_one, queues.graphics, queues.present);
+		__kvfAddDeviceToArray(chosen_one, queues.graphics, queues.present, queues.compute);
 		return chosen_one;
 	}
 	return VK_NULL_HANDLE;
@@ -1237,27 +1303,49 @@ VkDevice kvfCreateDevice(VkPhysicalDevice physical, const char** extensions, uin
 	__KvfDevice* kvfdevice = __kvfGetKvfDeviceFromVkPhysicalDevice(physical);
 
 	KVF_ASSERT(kvfdevice != NULL);
-	KVF_ASSERT(kvfdevice->queues.graphics != -1);
-	KVF_ASSERT(kvfdevice->queues.present != -1);
 
-	VkDeviceQueueCreateInfo queue_create_info[2];
+	uint32_t queue_count = 0;
-	queue_create_info[0].sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
+	queue_count += (kvfdevice->queues.graphics != -1);
-	queue_create_info[0].queueFamilyIndex = kvfdevice->queues.graphics;
+	queue_count += (kvfdevice->queues.present != -1);
-	queue_create_info[0].queueCount = 1;
+	queue_count += (kvfdevice->queues.compute != -1);
-	queue_create_info[0].pQueuePriorities = &queue_priority;
+
-	queue_create_info[0].flags = 0;
+	VkDeviceQueueCreateInfo* queue_create_infos = (VkDeviceQueueCreateInfo*)KVF_MALLOC(queue_count * sizeof(VkDeviceQueueCreateInfo));
-	queue_create_info[0].pNext = NULL;
+	size_t i = 0;
-	queue_create_info[1].sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
+	if(kvfdevice->queues.graphics != -1)
-	queue_create_info[1].queueFamilyIndex = kvfdevice->queues.present;
+	{
-	queue_create_info[1].queueCount = 1;
+		queue_create_infos[i].sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
-	queue_create_info[1].pQueuePriorities = &queue_priority;
+		queue_create_infos[i].queueFamilyIndex = kvfdevice->queues.graphics;
-	queue_create_info[1].flags = 0;
+		queue_create_infos[i].queueCount = 1;
-	queue_create_info[1].pNext = NULL;
+		queue_create_infos[i].pQueuePriorities = &queue_priority;
+		queue_create_infos[i].flags = 0;
+		queue_create_infos[i].pNext = NULL;
+		i++;
+	}
+	if(kvfdevice->queues.present != -1 && kvfdevice->queues.present != kvfdevice->queues.graphics)
+	{
+		queue_create_infos[i].sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
+		queue_create_infos[i].queueFamilyIndex = kvfdevice->queues.present;
+		queue_create_infos[i].queueCount = 1;
+		queue_create_infos[i].pQueuePriorities = &queue_priority;
+		queue_create_infos[i].flags = 0;
+		queue_create_infos[i].pNext = NULL;
+		i++;
+	}
+	if(kvfdevice->queues.compute != -1 && kvfdevice->queues.present != kvfdevice->queues.compute && kvfdevice->queues.graphics != kvfdevice->queues.compute)
+	{
+		queue_create_infos[i].sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
+		queue_create_infos[i].queueFamilyIndex = kvfdevice->queues.compute;
+		queue_create_infos[i].queueCount = 1;
+		queue_create_infos[i].pQueuePriorities = &queue_priority;
+		queue_create_infos[i].flags = 0;
+		queue_create_infos[i].pNext = NULL;
+		i++;
+	}
 
 	VkDeviceCreateInfo createInfo;
 	createInfo.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
-	createInfo.queueCreateInfoCount = (kvfdevice->queues.graphics == kvfdevice->queues.present ? 1 : 2);
+	createInfo.queueCreateInfoCount = i;
-	createInfo.pQueueCreateInfos = queue_create_info;
+	createInfo.pQueueCreateInfos = queue_create_infos;
 	createInfo.pEnabledFeatures = features;
 	createInfo.enabledExtensionCount = extensions_count;
 	createInfo.ppEnabledExtensionNames = extensions;
@@ -1273,6 +1361,74 @@ VkDevice kvfCreateDevice(VkPhysicalDevice physical, const char** extensions, uin
 	return device;
 }
 
+VkDevice kvfCreateDefaultDevicePhysicalDeviceAndCustomQueues(VkPhysicalDevice physical, int32_t graphics_queue, int32_t present_queue, int32_t compute_queue)
+{
+	const char* extensions[] = { VK_KHR_SWAPCHAIN_EXTENSION_NAME };
+	VkPhysicalDeviceFeatures device_features = { VK_FALSE };
+	return kvfCreateDeviceCustomPhysicalDeviceAndQueues(physical, extensions, sizeof(extensions) / sizeof(extensions[0]), &device_features, graphics_queue, present_queue, compute_queue);
+}
+
+VkDevice kvfCreateDeviceCustomPhysicalDeviceAndQueues(VkPhysicalDevice physical, const char** extensions, uint32_t extensions_count, VkPhysicalDeviceFeatures* features, int32_t graphics_queue, int32_t present_queue, int32_t compute_queue)
+{
+	const float queue_priority = 1.0f;
+
+	uint32_t queue_count = 0;
+	queue_count += (graphics_queue != -1);
+	queue_count += (present_queue != -1);
+	queue_count += (compute_queue != -1);
+
+	VkDeviceQueueCreateInfo* queue_create_infos = (VkDeviceQueueCreateInfo*)KVF_MALLOC(queue_count * sizeof(VkDeviceQueueCreateInfo));
+	size_t i = 0;
+	if(graphics_queue != -1)
+	{
+		queue_create_infos[i].sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
+		queue_create_infos[i].queueFamilyIndex = graphics_queue;
+		queue_create_infos[i].queueCount = 1;
+		queue_create_infos[i].pQueuePriorities = &queue_priority;
+		queue_create_infos[i].flags = 0;
+		queue_create_infos[i].pNext = NULL;
+		i++;
+	}
+	if(present_queue != -1 && present_queue != graphics_queue)
+	{
+		queue_create_infos[i].sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
+		queue_create_infos[i].queueFamilyIndex = present_queue;
+		queue_create_infos[i].queueCount = 1;
+		queue_create_infos[i].pQueuePriorities = &queue_priority;
+		queue_create_infos[i].flags = 0;
+		queue_create_infos[i].pNext = NULL;
+		i++;
+	}
+	if(compute_queue != -1 && present_queue != compute_queue && graphics_queue != compute_queue)
+	{
+		queue_create_infos[i].sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
+		queue_create_infos[i].queueFamilyIndex = compute_queue;
+		queue_create_infos[i].queueCount = 1;
+		queue_create_infos[i].pQueuePriorities = &queue_priority;
+		queue_create_infos[i].flags = 0;
+		queue_create_infos[i].pNext = NULL;
+		i++;
+	}
+
+	VkDeviceCreateInfo createInfo;
+	createInfo.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
+	createInfo.queueCreateInfoCount = queue_count;
+	createInfo.pQueueCreateInfos = queue_create_infos;
+	createInfo.pEnabledFeatures = features;
+	createInfo.enabledExtensionCount = extensions_count;
+	createInfo.ppEnabledExtensionNames = extensions;
+	createInfo.enabledLayerCount = 0;
+	createInfo.ppEnabledLayerNames = NULL;
+	createInfo.flags = 0;
+	createInfo.pNext = NULL;
+
+	VkDevice device;
+	__kvfCheckVk(vkCreateDevice(physical, &createInfo, NULL, &device));
+	__kvfCompleteDeviceCustomPhysicalDeviceAndQueues(physical, device, graphics_queue, present_queue, compute_queue);
+
+	return device;
+}
+
 void kvfDestroyDevice(VkDevice device)
 {
 	if(device == VK_NULL_HANDLE)
@@ -1287,11 +1443,20 @@ VkQueue kvfGetDeviceQueue(VkDevice device, KvfQueueType queue)
 	KVF_ASSERT(kvfdevice != NULL);
 	VkQueue vk_queue = VK_NULL_HANDLE;
 	if(queue == KVF_GRAPHICS_QUEUE)
+	{
+		KVF_ASSERT(kvfdevice->queues.graphics != -1);
 		vkGetDeviceQueue(device, kvfdevice->queues.graphics, 0, &vk_queue);
+	}
 	else if(queue == KVF_PRESENT_QUEUE)
+	{
+		KVF_ASSERT(kvfdevice->queues.present != -1);
 		vkGetDeviceQueue(device, kvfdevice->queues.present, 0, &vk_queue);
+	}
 	else if(queue == KVF_COMPUTE_QUEUE)
+	{
+		KVF_ASSERT(kvfdevice->queues.compute != -1);
 		vkGetDeviceQueue(device, kvfdevice->queues.compute, 0, &vk_queue);
+	}
 	return vk_queue;
 }
 
@@ -1311,6 +1476,7 @@ uint32_t kvfGetDeviceQueueFamily(VkDevice device, KvfQueueType queue)
 	return 0;
 }
 
+#ifndef KVF_NO_KHR
 	bool kvfQueuePresentKHR(VkDevice device, VkSemaphore wait, VkSwapchainKHR swapchain, uint32_t image_index)
 	{
 		KVF_ASSERT(device != VK_NULL_HANDLE);
@@ -1328,6 +1494,71 @@ bool kvfQueuePresentKHR(VkDevice device, VkSemaphore wait, VkSwapchainKHR swapch
 			__kvfCheckVk(result);
 		return true;
 	}
+#endif
+
+int32_t kvfFindDeviceQueueFamily(VkPhysicalDevice physical, KvfQueueType type)
+{
+	KVF_ASSERT(physical != VK_NULL_HANDLE);
+	KVF_ASSERT(type != KVF_PRESENT_QUEUE && "Use kvfFindDeviceQueueFamilyKHR to find present queue");
+
+	uint32_t queue_family_count;
+	vkGetPhysicalDeviceQueueFamilyProperties(physical, &queue_family_count, NULL);
+	VkQueueFamilyProperties* queue_families = (VkQueueFamilyProperties*)KVF_MALLOC(sizeof(VkQueueFamilyProperties) * queue_family_count);
+	vkGetPhysicalDeviceQueueFamilyProperties(physical, &queue_family_count, queue_families);
+
+	int32_t queue = -1;
+
+	for(int i = 0; i < queue_family_count; i++)
+	{
+		if(type == KVF_COMPUTE_QUEUE)
+		{
+			if(queue_families[i].queueFlags & VK_QUEUE_COMPUTE_BIT && (queue_families[i].queueFlags & VK_QUEUE_GRAPHICS_BIT) == 0)
+				queue = i;
+			else if(queue != -1 && queue_families[i].queueFlags & VK_QUEUE_COMPUTE_BIT) // else just find a compute queue
+				queue = i;
+		}
+		else if(type == KVF_GRAPHICS_QUEUE)
+		{
+			if(queue_families[i].queueFlags & VK_QUEUE_GRAPHICS_BIT)
+				queue = i;
+		}
+
+		if(queue != -1)
+			break;
+	}
+	KVF_FREE(queue_families);
+	return queue;
+}
+
+#ifndef KVF_NO_KHR
+	int32_t kvfFindDeviceQueueFamilyKHR(VkPhysicalDevice physical, VkSurfaceKHR surface, KvfQueueType type)
+	{
+		KVF_ASSERT(physical != VK_NULL_HANDLE);
+		KVF_ASSERT(surface != VK_NULL_HANDLE);
+
+		if(type != KVF_PRESENT_QUEUE)
+			return kvfFindDeviceQueueFamily(physical, type);
+
+		uint32_t queue_family_count;
+		vkGetPhysicalDeviceQueueFamilyProperties(physical, &queue_family_count, NULL);
+		VkQueueFamilyProperties* queue_families = (VkQueueFamilyProperties*)KVF_MALLOC(sizeof(VkQueueFamilyProperties) * queue_family_count);
+		vkGetPhysicalDeviceQueueFamilyProperties(physical, &queue_family_count, queue_families);
+
+		int32_t queue = -1;
+
+		for(int i = 0; i < queue_family_count; i++)
+		{
+			VkBool32 present_support = false;
+			vkGetPhysicalDeviceSurfaceSupportKHR(physical, i, surface, &present_support);
+			if(present_support)
+				queue = i;
+			if(queue != -1)
+				break;
+		}
+		KVF_FREE(queue_families);
+		return queue;
+	}
+#endif
 
 VkFence kvfCreateFence(VkDevice device)
 {
@@ -1373,31 +1604,32 @@ void kvfDestroySemaphore(VkDevice device, VkSemaphore semaphore)
 	vkDestroySemaphore(device, semaphore, NULL);
 }
 
+#ifndef KVF_NO_KHR
 	__KvfSwapchainSupportInternal __kvfQuerySwapchainSupport(VkPhysicalDevice physical, VkSurfaceKHR surface)
 	{
 		__KvfSwapchainSupportInternal support;
 
 		__kvfCheckVk(vkGetPhysicalDeviceSurfaceCapabilitiesKHR(physical, surface, &support.capabilities));
 
-	vkGetPhysicalDeviceSurfaceFormatsKHR(physical, surface, &support.formatsCount, NULL);
+		vkGetPhysicalDeviceSurfaceFormatsKHR(physical, surface, &support.formats_count, NULL);
-	if(support.formatsCount != 0)
+		if(support.formats_count != 0)
 		{
-		support.formats = (VkSurfaceFormatKHR*)KVF_MALLOC(sizeof(VkSurfaceFormatKHR) * support.formatsCount);
+			support.formats = (VkSurfaceFormatKHR*)KVF_MALLOC(sizeof(VkSurfaceFormatKHR) * support.formats_count);
-		vkGetPhysicalDeviceSurfaceFormatsKHR(physical, surface, &support.formatsCount, support.formats);
+			vkGetPhysicalDeviceSurfaceFormatsKHR(physical, surface, &support.formats_count, support.formats);
 		}
 
-	vkGetPhysicalDeviceSurfacePresentModesKHR(physical, surface, &support.presentModesCount, NULL);
+		vkGetPhysicalDeviceSurfacePresentModesKHR(physical, surface, &support.presentModes_count, NULL);
-	if(support.presentModesCount != 0)
+		if(support.presentModes_count != 0)
 		{
-		support.presentModes = (VkPresentModeKHR*)KVF_MALLOC(sizeof(VkPresentModeKHR) * support.presentModesCount);
+			support.presentModes = (VkPresentModeKHR*)KVF_MALLOC(sizeof(VkPresentModeKHR) * support.presentModes_count);
-		vkGetPhysicalDeviceSurfacePresentModesKHR(physical, surface, &support.presentModesCount, support.presentModes);
+			vkGetPhysicalDeviceSurfacePresentModesKHR(physical, surface, &support.presentModes_count, support.presentModes);
 		}
 		return support;
 	}
 
 	VkSurfaceFormatKHR __kvfChooseSwapSurfaceFormat(__KvfSwapchainSupportInternal* support)
 	{
-	for(int i = 0; i < support->formatsCount; i++)
+		for(int i = 0; i < support->formats_count; i++)
 		{
 			if(support->formats[i].format == VK_FORMAT_R8G8B8A8_SRGB && support->formats[i].colorSpace == VK_COLOR_SPACE_SRGB_NONLINEAR_KHR)
 				return support->formats[i];
@@ -1405,11 +1637,11 @@ VkSurfaceFormatKHR __kvfChooseSwapSurfaceFormat(__KvfSwapchainSupportInternal* s
 		return support->formats[0];
 	}
 
-VkPresentModeKHR __kvfChooseSwapPresentMode(__KvfSwapchainSupportInternal* support, bool tryVsync)
+	VkPresentModeKHR __kvfChooseSwapPresentMode(__KvfSwapchainSupportInternal* support, bool try_vsync)
 	{
-	if(tryVsync == false)
+		if(try_vsync == false)
 			return VK_PRESENT_MODE_IMMEDIATE_KHR;
-	for(int i = 0; i < support->presentModesCount; i++)
+		for(int i = 0; i < support->presentModes_count; i++)
 		{
 			if(support->presentModes[i] == VK_PRESENT_MODE_MAILBOX_KHR)
 				return support->presentModes[i];
@@ -1423,23 +1655,23 @@ uint32_t __kvfClamp(uint32_t i, uint32_t min, uint32_t max)
 		return t > max ? max : t;
 	}
 
-VkSwapchainKHR kvfCreateSwapchainKHR(VkDevice device, VkPhysicalDevice physical, VkSurfaceKHR surface, VkExtent2D extent, bool tryVsync)
+	VkSwapchainKHR kvfCreateSwapchainKHR(VkDevice device, VkPhysicalDevice physical, VkSurfaceKHR surface, VkExtent2D extent, bool try_vsync)
 	{
 		KVF_ASSERT(device != VK_NULL_HANDLE);
 		VkSwapchainKHR swapchain;
 		__KvfSwapchainSupportInternal support = __kvfQuerySwapchainSupport(physical, surface);
 
 		VkSurfaceFormatKHR surfaceFormat = __kvfChooseSwapSurfaceFormat(&support);
-	VkPresentModeKHR presentMode = __kvfChooseSwapPresentMode(&support, tryVsync);
+		VkPresentModeKHR presentMode = __kvfChooseSwapPresentMode(&support, try_vsync);
 
-	uint32_t imageCount = support.capabilities.minImageCount + 1;
+		uint32_t image_count = support.capabilities.minImageCount + 1;
-	if(support.capabilities.maxImageCount > 0 && imageCount > support.capabilities.maxImageCount)
+		if(support.capabilities.maxImageCount > 0 && image_count > support.capabilities.maxImageCount)
-		imageCount = support.capabilities.maxImageCount;
+			image_count = support.capabilities.maxImageCount;
 
 		__KvfDevice* kvfdevice = __kvfGetKvfDeviceFromVkDevice(device);
 		KVF_ASSERT(kvfdevice != NULL);
 
-	uint32_t queueFamilyIndices[] = { (uint32_t)kvfdevice->queues.graphics, (uint32_t)kvfdevice->queues.present };
+		uint32_t queue_family_indices[] = { (uint32_t)kvfdevice->queues.graphics, (uint32_t)kvfdevice->queues.present };
 
 		if(support.capabilities.currentExtent.width != UINT32_MAX)
 			extent = support.capabilities.currentExtent;
@@ -1452,7 +1684,7 @@ VkSwapchainKHR kvfCreateSwapchainKHR(VkDevice device, VkPhysicalDevice physical,
 		VkSwapchainCreateInfoKHR createInfo = {};
 		createInfo.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR;
 		createInfo.surface = surface;
-	createInfo.minImageCount = imageCount;
+		createInfo.minImageCount = image_count;
 		createInfo.imageFormat = surfaceFormat.format;
 		createInfo.imageColorSpace = surfaceFormat.colorSpace;
 		createInfo.imageExtent = extent;
@@ -1468,7 +1700,7 @@ VkSwapchainKHR kvfCreateSwapchainKHR(VkDevice device, VkPhysicalDevice physical,
 		{
 			createInfo.imageSharingMode = VK_SHARING_MODE_CONCURRENT;
 			createInfo.queueFamilyIndexCount = 2;
-		createInfo.pQueueFamilyIndices = queueFamilyIndices;
+			createInfo.pQueueFamilyIndices = queue_family_indices;
 		}
 		else
 			createInfo.imageSharingMode = VK_SHARING_MODE_EXCLUSIVE;
@@ -1518,6 +1750,7 @@ void kvfDestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain)
 		KVF_ASSERT(device != VK_NULL_HANDLE);
 		__kvfDestroySwapchain(device, swapchain);
 	}
+#endif
 
 VkImage kvfCreateImage(VkDevice device, uint32_t width, uint32_t height, VkFormat format, VkImageTiling tiling, VkImageUsageFlags usage, KvfImageType type)
 {
@@ -1564,7 +1797,7 @@ void kvfImageToBuffer(VkCommandBuffer cmd, VkBuffer dst, VkImage src, size_t buf
 	region.imageSubresource.layerCount = 1;
 	region.imageOffset = offset;
 	region.imageExtent = extent;
-	vkCmdCopyImageToBuffer(cmd, src, dst, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, 1, &region);
+	vkCmdCopyImageToBuffer(cmd, src, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, dst, 1, &region);
 }
 
 void kvfDestroyImage(VkDevice device, VkImage image)
@@ -1899,6 +2132,7 @@ VkAttachmentDescription kvfBuildAttachmentDescription(KvfImageType type, VkForma
 	return attachment;
 }
 
+#ifndef KVF_NO_KHR
 	VkAttachmentDescription kvfBuildSwapchainAttachmentDescription(VkSwapchainKHR swapchain, bool clear)
 	{
 		__KvfSwapchain* kvf_swapchain = __kvfGetKvfSwapchainFromVkSwapchainKHR(swapchain);
@@ -1906,6 +2140,7 @@ VkAttachmentDescription kvfBuildSwapchainAttachmentDescription(VkSwapchainKHR sw
 		KVF_ASSERT(kvf_swapchain->images_count != 0);
 		return kvfBuildAttachmentDescription(KVF_IMAGE_COLOR, kvf_swapchain->images_format, VK_IMAGE_LAYOUT_UNDEFINED,VK_IMAGE_LAYOUT_PRESENT_SRC_KHR, clear, VK_SAMPLE_COUNT_1_BIT);
 	}
+#endif
 
 VkRenderPass kvfCreateRenderPass(VkDevice device, VkAttachmentDescription* attachments, size_t attachments_count, VkPipelineBindPoint bind_point)
 {