From 79c7a1713fef4dde119fba998edfaafa2fbbaac9 Mon Sep 17 00:00:00 2001
From: "Ryan C. Gordon" <[EMAIL REDACTED]>
Date: Tue, 24 Aug 2021 12:41:41 -0400
Subject: [PATCH] testvulkan: reformatted to more-closely match SDL coding
conventions.
---
test/testvulkan.c | 492 +++++++++++++++++++---------------------------
1 file changed, 207 insertions(+), 285 deletions(-)
diff --git a/test/testvulkan.c b/test/testvulkan.c
index 9b3bb39ffd..ee6bde8d5f 100644
--- a/test/testvulkan.c
+++ b/test/testvulkan.c
@@ -110,66 +110,39 @@ enum {
static const char *getVulkanResultString(VkResult result)
{
- switch((int)result)
+ switch((int) 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_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_OUT_OF_POOL_MEMORY_KHR:
- return "VK_ERROR_OUT_OF_POOL_MEMORY_KHR";
- case VK_ERROR_INVALID_SHADER_NV:
- return "VK_ERROR_INVALID_SHADER_NV";
- default:
- break;
+ #define RESULT_CASE(x) case x: return #x
+ RESULT_CASE(VK_SUCCESS);
+ RESULT_CASE(VK_NOT_READY);
+ RESULT_CASE(VK_TIMEOUT);
+ RESULT_CASE(VK_EVENT_SET);
+ RESULT_CASE(VK_EVENT_RESET);
+ RESULT_CASE(VK_INCOMPLETE);
+ RESULT_CASE(VK_ERROR_OUT_OF_HOST_MEMORY);
+ RESULT_CASE(VK_ERROR_OUT_OF_DEVICE_MEMORY);
+ RESULT_CASE(VK_ERROR_INITIALIZATION_FAILED);
+ RESULT_CASE(VK_ERROR_DEVICE_LOST);
+ RESULT_CASE(VK_ERROR_MEMORY_MAP_FAILED);
+ RESULT_CASE(VK_ERROR_LAYER_NOT_PRESENT);
+ RESULT_CASE(VK_ERROR_EXTENSION_NOT_PRESENT);
+ RESULT_CASE(VK_ERROR_FEATURE_NOT_PRESENT);
+ RESULT_CASE(VK_ERROR_INCOMPATIBLE_DRIVER);
+ RESULT_CASE(VK_ERROR_TOO_MANY_OBJECTS);
+ RESULT_CASE(VK_ERROR_FORMAT_NOT_SUPPORTED);
+ RESULT_CASE(VK_ERROR_FRAGMENTED_POOL);
+ RESULT_CASE(VK_ERROR_SURFACE_LOST_KHR);
+ RESULT_CASE(VK_ERROR_NATIVE_WINDOW_IN_USE_KHR);
+ RESULT_CASE(VK_SUBOPTIMAL_KHR);
+ RESULT_CASE(VK_ERROR_OUT_OF_DATE_KHR);
+ RESULT_CASE(VK_ERROR_INCOMPATIBLE_DISPLAY_KHR);
+ RESULT_CASE(VK_ERROR_VALIDATION_FAILED_EXT);
+ RESULT_CASE(VK_ERROR_OUT_OF_POOL_MEMORY_KHR);
+ RESULT_CASE(VK_ERROR_INVALID_SHADER_NV);
+ #undef RESULT_CASE
+ default: break;
}
- if(result < 0)
- return "VK_ERROR_<Unknown>";
- return "VK_<Unknown>";
+ return (result < 0) ? "VK_ERROR_<Unknown>" : "VK_<Unknown>";
}
typedef struct VulkanContext
@@ -219,8 +192,7 @@ static void quit(int rc)
static void loadGlobalFunctions(void)
{
vkGetInstanceProcAddr = SDL_Vulkan_GetVkGetInstanceProcAddr();
- if(!vkGetInstanceProcAddr)
- {
+ if (!vkGetInstanceProcAddr) {
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
"SDL_Vulkan_GetVkGetInstanceProcAddr(): %s\n",
SDL_GetError());
@@ -230,8 +202,7 @@ static void loadGlobalFunctions(void)
#define VULKAN_DEVICE_FUNCTION(name)
#define VULKAN_GLOBAL_FUNCTION(name) \
name = (PFN_##name)vkGetInstanceProcAddr(VK_NULL_HANDLE, #name); \
- if(!name) \
- { \
+ if (!name) { \
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, \
"vkGetInstanceProcAddr(VK_NULL_HANDLE, \"" #name "\") failed\n"); \
quit(2); \
@@ -251,26 +222,22 @@ static void createInstance(void)
unsigned extensionCount = 0;
VkResult result;
-
appInfo.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
appInfo.apiVersion = VK_API_VERSION_1_0;
instanceCreateInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
instanceCreateInfo.pApplicationInfo = &appInfo;
- if(!SDL_Vulkan_GetInstanceExtensions(NULL, &extensionCount, NULL))
- {
+ if (!SDL_Vulkan_GetInstanceExtensions(NULL, &extensionCount, NULL)) {
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
"SDL_Vulkan_GetInstanceExtensions(): %s\n",
SDL_GetError());
quit(2);
}
- extensions = SDL_malloc(sizeof(const char *) * extensionCount);
- if(!extensions)
- {
+ extensions = (const char **) SDL_malloc(sizeof(const char *) * extensionCount);
+ if (!extensions) {
SDL_OutOfMemory();
quit(2);
}
- if(!SDL_Vulkan_GetInstanceExtensions(NULL, &extensionCount, extensions))
- {
+ if (!SDL_Vulkan_GetInstanceExtensions(NULL, &extensionCount, extensions)) {
SDL_free((void*)extensions);
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
"SDL_Vulkan_GetInstanceExtensions(): %s\n",
@@ -281,8 +248,7 @@ static void createInstance(void)
instanceCreateInfo.ppEnabledExtensionNames = extensions;
result = vkCreateInstance(&instanceCreateInfo, NULL, &vulkanContext->instance);
SDL_free((void*)extensions);
- if(result != VK_SUCCESS)
- {
+ if (result != VK_SUCCESS) {
vulkanContext->instance = VK_NULL_HANDLE;
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
"vkCreateInstance(): %s\n",
@@ -296,9 +262,8 @@ static void loadInstanceFunctions(void)
#define VULKAN_DEVICE_FUNCTION(name)
#define VULKAN_GLOBAL_FUNCTION(name)
#define VULKAN_INSTANCE_FUNCTION(name) \
- name = (PFN_##name)vkGetInstanceProcAddr(vulkanContext->instance, #name); \
- if(!name) \
- { \
+ name = (PFN_##name)vkGetInstanceProcAddr(vulkanContext->instance, #name); \
+ if (!name) { \
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, \
"vkGetInstanceProcAddr(instance, \"" #name "\") failed\n"); \
quit(2); \
@@ -311,13 +276,11 @@ static void loadInstanceFunctions(void)
static void createSurface(void)
{
- if(!SDL_Vulkan_CreateSurface(vulkanContext->window,
+ if (!SDL_Vulkan_CreateSurface(vulkanContext->window,
vulkanContext->instance,
- &vulkanContext->surface))
- {
+ &vulkanContext->surface)) {
vulkanContext->surface = VK_NULL_HANDLE;
- SDL_LogError(
- SDL_LOG_CATEGORY_APPLICATION, "SDL_Vulkan_CreateSurface(): %s\n", SDL_GetError());
+ SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "SDL_Vulkan_CreateSurface(): %s\n", SDL_GetError());
quit(2);
}
}
@@ -331,32 +294,27 @@ static void findPhysicalDevice(void)
VkExtensionProperties *deviceExtensions = NULL;
uint32_t deviceExtensionsAllocatedSize = 0;
uint32_t physicalDeviceIndex;
+ VkResult result;
- VkResult result =
- vkEnumeratePhysicalDevices(vulkanContext->instance, &physicalDeviceCount, NULL);
- if(result != VK_SUCCESS)
- {
+ result = vkEnumeratePhysicalDevices(vulkanContext->instance, &physicalDeviceCount, NULL);
+ if (result != VK_SUCCESS) {
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
"vkEnumeratePhysicalDevices(): %s\n",
getVulkanResultString(result));
quit(2);
}
- if(physicalDeviceCount == 0)
- {
+ if (physicalDeviceCount == 0) {
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
"vkEnumeratePhysicalDevices(): no physical devices\n");
quit(2);
}
- physicalDevices = SDL_malloc(sizeof(VkPhysicalDevice) * physicalDeviceCount);
- if(!physicalDevices)
- {
+ physicalDevices = (VkPhysicalDevice *) SDL_malloc(sizeof(VkPhysicalDevice) * physicalDeviceCount);
+ if (!physicalDevices) {
SDL_OutOfMemory();
quit(2);
}
- result =
- vkEnumeratePhysicalDevices(vulkanContext->instance, &physicalDeviceCount, physicalDevices);
- if(result != VK_SUCCESS)
- {
+ result = vkEnumeratePhysicalDevices(vulkanContext->instance, &physicalDeviceCount, physicalDevices);
+ if (result != VK_SUCCESS) {
SDL_free(physicalDevices);
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
"vkEnumeratePhysicalDevices(): %s\n",
@@ -364,55 +322,50 @@ static void findPhysicalDevice(void)
quit(2);
}
vulkanContext->physicalDevice = NULL;
- for(physicalDeviceIndex = 0; physicalDeviceIndex < physicalDeviceCount;
- physicalDeviceIndex++)
- {
+ for (physicalDeviceIndex = 0; physicalDeviceIndex < physicalDeviceCount; physicalDeviceIndex++) {
uint32_t queueFamiliesCount = 0;
uint32_t queueFamilyIndex;
uint32_t deviceExtensionCount = 0;
SDL_bool hasSwapchainExtension = SDL_FALSE;
uint32_t i;
-
VkPhysicalDevice physicalDevice = physicalDevices[physicalDeviceIndex];
vkGetPhysicalDeviceProperties(physicalDevice, &vulkanContext->physicalDeviceProperties);
- if(VK_VERSION_MAJOR(vulkanContext->physicalDeviceProperties.apiVersion) < 1)
+ if(VK_VERSION_MAJOR(vulkanContext->physicalDeviceProperties.apiVersion) < 1) {
continue;
+ }
vkGetPhysicalDeviceFeatures(physicalDevice, &vulkanContext->physicalDeviceFeatures);
vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice, &queueFamiliesCount, NULL);
- if(queueFamiliesCount == 0)
+ if (queueFamiliesCount == 0) {
continue;
- if(queueFamiliesPropertiesAllocatedSize < queueFamiliesCount)
- {
+ }
+ if (queueFamiliesPropertiesAllocatedSize < queueFamiliesCount) {
SDL_free(queueFamiliesProperties);
queueFamiliesPropertiesAllocatedSize = queueFamiliesCount;
- queueFamiliesProperties =
- SDL_malloc(sizeof(VkQueueFamilyProperties) * queueFamiliesPropertiesAllocatedSize);
- if(!queueFamiliesProperties)
- {
+ queueFamiliesProperties = (VkQueueFamilyProperties *) SDL_malloc(sizeof(VkQueueFamilyProperties) * queueFamiliesPropertiesAllocatedSize);
+ if (!queueFamiliesProperties) {
SDL_free(physicalDevices);
SDL_free(deviceExtensions);
SDL_OutOfMemory();
quit(2);
}
}
- vkGetPhysicalDeviceQueueFamilyProperties(
- physicalDevice, &queueFamiliesCount, queueFamiliesProperties);
+ vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice, &queueFamiliesCount, queueFamiliesProperties);
vulkanContext->graphicsQueueFamilyIndex = queueFamiliesCount;
vulkanContext->presentQueueFamilyIndex = queueFamiliesCount;
- for(queueFamilyIndex = 0; queueFamilyIndex < queueFamiliesCount;
- queueFamilyIndex++)
- {
+ for (queueFamilyIndex = 0; queueFamilyIndex < queueFamiliesCount; queueFamilyIndex++) {
VkBool32 supported = 0;
- if(queueFamiliesProperties[queueFamilyIndex].queueCount == 0)
+ if (queueFamiliesProperties[queueFamilyIndex].queueCount == 0) {
continue;
- if(queueFamiliesProperties[queueFamilyIndex].queueFlags & VK_QUEUE_GRAPHICS_BIT)
+ }
+
+ if (queueFamiliesProperties[queueFamilyIndex].queueFlags & VK_QUEUE_GRAPHICS_BIT) {
vulkanContext->graphicsQueueFamilyIndex = queueFamilyIndex;
- result = vkGetPhysicalDeviceSurfaceSupportKHR(
- physicalDevice, queueFamilyIndex, vulkanContext->surface, &supported);
- if(result != VK_SUCCESS)
- {
+ }
+
+ result = vkGetPhysicalDeviceSurfaceSupportKHR(physicalDevice, queueFamilyIndex, vulkanContext->surface, &supported);
+ if (result != VK_SUCCESS) {
SDL_free(physicalDevices);
SDL_free(queueFamiliesProperties);
SDL_free(deviceExtensions);
@@ -421,20 +374,22 @@ static void findPhysicalDevice(void)
getVulkanResultString(result));
quit(2);
}
- if(supported)
- {
+ if (supported) {
vulkanContext->presentQueueFamilyIndex = queueFamilyIndex;
- if(queueFamiliesProperties[queueFamilyIndex].queueFlags & VK_QUEUE_GRAPHICS_BIT)
+ if (queueFamiliesProperties[queueFamilyIndex].queueFlags & VK_QUEUE_GRAPHICS_BIT) {
break; // use this queue because it can present and do graphics
+ }
}
}
- if(vulkanContext->graphicsQueueFamilyIndex == queueFamiliesCount) // no good queues found
+
+ if (vulkanContext->graphicsQueueFamilyIndex == queueFamiliesCount) { // no good queues found
continue;
- if(vulkanContext->presentQueueFamilyIndex == queueFamiliesCount) // no good queues found
+ }
+ if (vulkanContext->presentQueueFamilyIndex == queueFamiliesCount) { // no good queues found
continue;
- result =
- vkEnumerateDeviceExtensionProperties(physicalDevice, NULL, &deviceExtensionCount, NULL);
- if(result != VK_SUCCESS)
+ }
+ result = vkEnumerateDeviceExtensionProperties(physicalDevice, NULL, &deviceExtensionCount, NULL);
+ if (result != VK_SUCCESS)
{
SDL_free(physicalDevices);
SDL_free(queueFamiliesProperties);
@@ -444,26 +399,22 @@ static void findPhysicalDevice(void)
getVulkanResultString(result));
quit(2);
}
- if(deviceExtensionCount == 0)
+ if (deviceExtensionCount == 0) {
continue;
- if(deviceExtensionsAllocatedSize < deviceExtensionCount)
- {
+ }
+ if (deviceExtensionsAllocatedSize < deviceExtensionCount) {
SDL_free(deviceExtensions);
deviceExtensionsAllocatedSize = deviceExtensionCount;
- deviceExtensions =
- SDL_malloc(sizeof(VkExtensionProperties) * deviceExtensionsAllocatedSize);
- if(!deviceExtensions)
- {
+ deviceExtensions = SDL_malloc(sizeof(VkExtensionProperties) * deviceExtensionsAllocatedSize);
+ if (!deviceExtensions) {
SDL_free(physicalDevices);
SDL_free(queueFamiliesProperties);
SDL_OutOfMemory();
quit(2);
}
}
- result = vkEnumerateDeviceExtensionProperties(
- physicalDevice, NULL, &deviceExtensionCount, deviceExtensions);
- if(result != VK_SUCCESS)
- {
+ result = vkEnumerateDeviceExtensionProperties(physicalDevice, NULL, &deviceExtensionCount, deviceExtensions);
+ if (result != VK_SUCCESS) {
SDL_free(physicalDevices);
SDL_free(queueFamiliesProperties);
SDL_free(deviceExtensions);
@@ -472,24 +423,22 @@ static void findPhysicalDevice(void)
getVulkanResultString(result));
quit(2);
}
- for(i = 0; i < deviceExtensionCount; i++)
- {
- if(0 == SDL_strcmp(deviceExtensions[i].extensionName, VK_KHR_SWAPCHAIN_EXTENSION_NAME))
- {
+ for (i = 0; i < deviceExtensionCount; i++) {
+ if(SDL_strcmp(deviceExtensions[i].extensionName, VK_KHR_SWAPCHAIN_EXTENSION_NAME) == 0) {
hasSwapchainExtension = SDL_TRUE;
break;
}
}
- if(!hasSwapchainExtension)
+ if (!hasSwapchainExtension) {
continue;
+ }
vulkanContext->physicalDevice = physicalDevice;
break;
}
SDL_free(physicalDevices);
SDL_free(queueFamiliesProperties);
SDL_free(deviceExtensions);
- if(!vulkanContext->physicalDevice)
- {
+ if (!vulkanContext->physicalDevice) {
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Vulkan: no viable physical devices found");
quit(2);
}
@@ -516,13 +465,10 @@ static void createDevice(void)
deviceCreateInfo.pEnabledFeatures = NULL;
deviceCreateInfo.enabledExtensionCount = SDL_arraysize(deviceExtensionNames);
deviceCreateInfo.ppEnabledExtensionNames = deviceExtensionNames;
- result = vkCreateDevice(
- vulkanContext->physicalDevice, &deviceCreateInfo, NULL, &vulkanContext->device);
- if(result != VK_SUCCESS)
- {
+ result = vkCreateDevice(vulkanContext->physicalDevice, &deviceCreateInfo, NULL, &vulkanContext->device);
+ if (result != VK_SUCCESS) {
vulkanContext->device = VK_NULL_HANDLE;
- SDL_LogError(
- SDL_LOG_CATEGORY_APPLICATION, "vkCreateDevice(): %s\n", getVulkanResultString(result));
+ SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "vkCreateDevice(): %s\n", getVulkanResultString(result));
quit(2);
}
}
@@ -530,9 +476,8 @@ static void createDevice(void)
static void loadDeviceFunctions(void)
{
#define VULKAN_DEVICE_FUNCTION(name) \
- name = (PFN_##name)vkGetDeviceProcAddr(vulkanContext->device, #name); \
- if(!name) \
- { \
+ name = (PFN_##name)vkGetDeviceProcAddr(vulkanContext->device, #name); \
+ if (!name) { \
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, \
"vkGetDeviceProcAddr(device, \"" #name "\") failed\n"); \
quit(2); \
@@ -553,13 +498,14 @@ static void getQueues(void)
vulkanContext->graphicsQueueFamilyIndex,
0,
&vulkanContext->graphicsQueue);
- if(vulkanContext->graphicsQueueFamilyIndex != vulkanContext->presentQueueFamilyIndex)
+ if (vulkanContext->graphicsQueueFamilyIndex != vulkanContext->presentQueueFamilyIndex) {
vkGetDeviceQueue(vulkanContext->device,
vulkanContext->presentQueueFamilyIndex,
0,
&vulkanContext->presentQueue);
- else
+ } else {
vulkanContext->presentQueue = vulkanContext->graphicsQueue;
+ }
}
static void createSemaphore(VkSemaphore *semaphore)
@@ -569,8 +515,7 @@ static void createSemaphore(VkSemaphore *semaphore)
VkSemaphoreCreateInfo createInfo = {0};
createInfo.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO;
result = vkCreateSemaphore(vulkanContext->device, &createInfo, NULL, semaphore);
- if(result != VK_SUCCESS)
- {
+ if (result != VK_SUCCESS) {
*semaphore = VK_NULL_HANDLE;
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
"vkCreateSemaphore(): %s\n",
@@ -587,10 +532,8 @@ static void createSemaphores(void)
static void getSurfaceCaps(void)
{
- VkResult result = vkGetPhysicalDeviceSurfaceCapabilitiesKHR(
- vulkanContext->physicalDevice, vulkanContext->surface, &vulkanContext->surfaceCapabilities);
- if(result != VK_SUCCESS)
- {
+ VkResult result = vkGetPhysicalDeviceSurfaceCapabilitiesKHR(vulkanContext->physicalDevice, vulkanContext->surface, &vulkanContext->surfaceCapabilities);
+ if (result != VK_SUCCESS) {
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
"vkGetPhysicalDeviceSurfaceCapabilitiesKHR(): %s\n",
getVulkanResultString(result));
@@ -598,8 +541,7 @@ static void getSurfaceCaps(void)
}
// check surface usage
- if(!(vulkanContext->surfaceCapabilities.supportedUsageFlags & VK_IMAGE_USAGE_TRANSFER_DST_BIT))
- {
+ if (!(vulkanContext->surfaceCapabilities.supportedUsageFlags & VK_IMAGE_USAGE_TRANSFER_DST_BIT)) {
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
"Vulkan surface doesn't support VK_IMAGE_USAGE_TRANSFER_DST_BIT\n");
quit(2);
@@ -612,22 +554,18 @@ static void getSurfaceFormats(void)
vulkanContext->surface,
&vulkanContext->surfaceFormatsCount,
NULL);
- if(result != VK_SUCCESS)
- {
+ if (result != VK_SUCCESS) {
vulkanContext->surfaceFormatsCount = 0;
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
"vkGetPhysicalDeviceSurfaceFormatsKHR(): %s\n",
getVulkanResultString(result));
quit(2);
}
- if(vulkanContext->surfaceFormatsCount > vulkanContext->surfaceFormatsAllocatedCount)
- {
+ if (vulkanContext->surfaceFormatsCount > vulkanContext->surfaceFormatsAllocatedCount) {
vulkanContext->surfaceFormatsAllocatedCount = vulkanContext->surfaceFormatsCount;
SDL_free(vulkanContext->surfaceFormats);
- vulkanContext->surfaceFormats =
- SDL_malloc(sizeof(VkSurfaceFormatKHR) * vulkanContext->surfaceFormatsAllocatedCount);
- if(!vulkanContext->surfaceFormats)
- {
+ vulkanContext->surfaceFormats = (VkSurfaceFormatKHR *) SDL_malloc(sizeof(VkSurfaceFormatKHR) * vulkanContext->surfaceFormatsAllocatedCount);
+ if (!vulkanContext->surfaceFormats) {
vulkanContext->surfaceFormatsCount = 0;
SDL_OutOfMemory();
quit(2);
@@ -637,8 +575,7 @@ static void getSurfaceFormats(void)
vulkanContext->surface,
&vulkanContext->surfaceFormatsCount,
vulkanContext->surfaceFormats);
- if(result != VK_SUCCESS)
- {
+ if (result != VK_SUCCESS) {
vulkanContext->surfaceFormatsCount = 0;
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
"vkGetPhysicalDeviceSurfaceFormatsKHR(): %s\n",
@@ -653,10 +590,8 @@ static void getSwapchainImages(void)
SDL_free(vulkanContext->swapchainImages);
vulkanContext->swapchainImages = NULL;
- result = vkGetSwapchainImagesKHR(
- vulkanContext->device, vulkanContext->swapchain, &vulkanContext->swapchainImageCount, NULL);
- if(result != VK_SUCCESS)
- {
+ result = vkGetSwapchainImagesKHR(vulkanContext->device, vulkanContext->swapchain, &vulkanContext->swapchainImageCount, NULL);
+ if (result != VK_SUCCESS) {
vulkanContext->swapchainImageCount = 0;
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
"vkGetSwapchainImagesKHR(): %s\n",
@@ -664,8 +599,7 @@ static void getSwapchainImages(void)
quit(2);
}
vulkanContext->swapchainImages = SDL_malloc(sizeof(VkImage) * vulkanContext->swapchainImageCount);
- if(!vulkanContext->swapchainImages)
- {
+ if (!vulkanContext->swapchainImages) {
SDL_OutOfMemory();
quit(2);
}
@@ -673,8 +607,7 @@ static void getSwapchainImages(void)
vulkanContext->swapchain,
&vulkanContext->swapchainImageCount,
vulkanContext->swapchainImages);
- if(result != VK_SUCCESS)
- {
+ if (result != VK_SUCCESS) {
SDL_free(vulkanContext->swapchainImages);
vulkanContext->swapchainImages = NULL;
vulkanContext->swapchainImageCount = 0;
@@ -694,25 +627,21 @@ static SDL_bool createSwapchain(void)
// pick an image count
vulkanContext->swapchainDesiredImageCount = vulkanContext->surfaceCapabilities.minImageCount + 1;
- if(vulkanContext->swapchainDesiredImageCount > vulkanContext->surfaceCapabilities.maxImageCount
- && vulkanContext->surfaceCapabilities.maxImageCount > 0)
+ if ( (vulkanContext->swapchainDesiredImageCount > vulkanContext->surfaceCapabilities.maxImageCount) &&
+ (vulkanContext->surfaceCapabilities.maxImageCount > 0) ) {
vulkanContext->swapchainDesiredImageCount = vulkanContext->surfaceCapabilities.maxImageCount;
+ }
// pick a format
- if(vulkanContext->surfaceFormatsCount == 1
- && vulkanContext->surfaceFormats[0].format == VK_FORMAT_UNDEFINED)
- {
+ if ( (vulkanContext->surfaceFormatsCount == 1) &&
+ (vulkanContext->surfaceFormats[0].format == VK_FORMAT_UNDEFINED) ) {
// aren't any preferred formats, so we pick
vulkanContext->surfaceFormat.colorSpace = VK_COLORSPACE_SRGB_NONLINEAR_KHR;
vulkanContext->surfaceFormat.format = VK_FORMAT_R8G8B8A8_UNORM;
- }
- else
- {
+ } else {
vulkanContext->surfaceFormat = vulkanContext->surfaceFormats[0];
- for(i = 0; i < vulkanContext->surfaceFormatsCount; i++)
- {
- if(vulkanContext->surfaceFormats[i].format == VK_FORMAT_R8G8B8A8_UNORM)
- {
+ for (i = 0; i < vulkanContext->surfaceFormatsCount; i++) {
+ if(vulkanContext->surfaceFormats[i].format == VK_FORMAT_R8G8B8A8_UNORM) {
vulkanContext->surfaceFormat = vulkanContext->surfaceFormats[i];
break;
}
@@ -732,8 +661,9 @@ static SDL_bool createSwapchain(void)
vulkanContext->surfaceCapabilities.minImageExtent.height,
vulkanContext->surfaceCapabilities.maxImageExtent.height);
- if(w == 0 || h == 0)
+ if (w == 0 || h == 0) {
return SDL_FALSE;
+ }
getSurfaceCaps();
@@ -751,62 +681,63 @@ static SDL_bool createSwapchain(void)
createInfo.presentMode = VK_PRESENT_MODE_FIFO_KHR;
createInfo.clipped = VK_TRUE;
createInfo.oldSwapchain = vulkanContext->swapchain;
- result =
- vkCreateSwapchainKHR(vulkanContext->device, &createInfo, NULL, &vulkanContext->swapchain);
- if(createInfo.oldSwapchain)
+ result = vkCreateSwapchainKHR(vulkanContext->device, &createInfo, NULL, &vulkanContext->swapchain);
+
+ if (createInfo.oldSwapchain) {
vkDestroySwapchainKHR(vulkanContext->device, createInfo.oldSwapchain, NULL);
- if(result != VK_SUCCESS)
- {
+ }
+
+ if(result != VK_SUCCESS) {
vulkanContext->swapchain = VK_NULL_HANDLE;
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
"vkCreateSwapchainKHR(): %s\n",
getVulkanResultString(result));
quit(2);
}
+
getSwapchainImages();
return SDL_TRUE;
}
static void destroySwapchain(void)
{
- if(vulkanContext->swapchain)
+ if (vulkanContext->swapchain) {
vkDestroySwapchainKHR(vulkanContext->device, vulkanContext->swapchain, NULL);
- vulkanContext->swapchain = VK_NULL_HANDLE;
+ vulkanContext->swapchain = VK_NULL_HANDLE;
+ }
SDL_free(vulkanContext->swapchainImages);
vulkanContext->swapchainImages = NULL;
}
static void destroyCommandBuffers(void)
{
- if(vulkanContext->commandBuffers)
+ if (vulkanContext->commandBuffers) {
vkFreeCommandBuffers(vulkanContext->device,
vulkanContext->commandPool,
vulkanContext->swapchainImageCount,
vulkanContext->commandBuffers);
- SDL_free(vulkanContext->commandBuffers);
- vulkanContext->commandBuffers = NULL;
+ SDL_free(vulkanContext->commandBuffers);
+ vulkanContext->commandBuffers = NULL;
+ }
}
static void destroyCommandPool(void)
{
- if(vulkanContext->commandPool)
+ if (vulkanContext->commandPool) {
vkDestroyCommandPool(vulkanContext->device, vulkanContext->commandPool, NULL);
+ }
vulkanContext->commandPool = VK_NULL_HANDLE;
}
static void createCommandPool(void)
{
VkResult result;
-
VkCommandPoolCreateInfo createInfo = {0};
createInfo.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
- createInfo.flags =
- VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT | VK_COMMAND_POOL_CREATE_TRANSIENT_BIT;
+ createInfo.flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT | VK_COMMAND_POOL_CREATE_TRANSIENT_BIT;
createInfo.queueFamilyIndex = vulkanContext->graphicsQueueFamilyIndex;
- result =
- vkCreateCommandPool(vulkanContext->device, &createInfo, NULL, &vulkanContext->commandPool);
- if(result != VK_SUCCESS)
- {
+ result = vkCreateCommandPool(vulkanContext->device, &createInfo, NULL, &vulkanContext->commandPool);
+ if (result != VK_SUCCESS) {
vulkanContext->commandPool = VK_NULL_HANDLE;
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
"vkCreateCommandPool(): %s\n",
@@ -818,18 +749,14 @@ static void createCommandPool(void)
static void createCommandBuffers(void)
{
VkResult result;
-
VkCommandBufferAllocateInfo allocateInfo = {0};
allocateInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
allocateInfo.commandPool = vulkanContext->commandPool;
allocateInfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
allocateInfo.commandBufferCount = vulkanContext->swapchainImageCount;
- vulkanContext->commandBuffers =
- SDL_malloc(sizeof(VkCommandBuffer) * vulkanContext->swapchainImageCount);
- result =
- vkAllocateCommandBuffers(vulkanContext->device, &allocateInfo, vulkanContext->commandBuffers);
- if(result != VK_SUCCESS)
- {
+ vulkanContext->commandBuffers = (VkCommandBuf
(Patch may be truncated, please check the link at the top of this post.)