testvulkan.c
Go to the documentation of this file.
/*
Copyright (C) 1997-2018 Sam Lantinga <slouken@libsdl.org>
This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any damages
arising from the use of this software.
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it
freely.
*/
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <math.h>
#include "SDL_test_common.h"
#if defined(__ANDROID__) && defined(__ARM_EABI__) && !defined(__ARM_ARCH_7A__)
int main(int argc, char *argv[])
{
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "No Vulkan support on this system\n");
return 1;
}
#else
#define VK_NO_PROTOTYPES
#ifdef HAVE_VULKAN_H
#include <vulkan/vulkan.h>
#else
/* SDL includes a copy for building on systems without the Vulkan SDK */
#include "../src/video/khronos/vulkan/vulkan.h"
#endif
#include "SDL_vulkan.h"
#ifndef UINT64_MAX /* VS2008 */
#define UINT64_MAX 18446744073709551615
#endif
#define VULKAN_FUNCTIONS() \
VULKAN_DEVICE_FUNCTION(vkAcquireNextImageKHR) \
VULKAN_DEVICE_FUNCTION(vkAllocateCommandBuffers) \
VULKAN_DEVICE_FUNCTION(vkBeginCommandBuffer) \
VULKAN_DEVICE_FUNCTION(vkCmdClearColorImage) \
VULKAN_DEVICE_FUNCTION(vkCmdPipelineBarrier) \
VULKAN_DEVICE_FUNCTION(vkCreateCommandPool) \
VULKAN_DEVICE_FUNCTION(vkCreateFence) \
VULKAN_DEVICE_FUNCTION(vkCreateImageView) \
VULKAN_DEVICE_FUNCTION(vkCreateSemaphore) \
VULKAN_DEVICE_FUNCTION(vkCreateSwapchainKHR) \
VULKAN_DEVICE_FUNCTION(vkDestroyCommandPool) \
VULKAN_DEVICE_FUNCTION(vkDestroyDevice) \
VULKAN_DEVICE_FUNCTION(vkDestroyFence) \
VULKAN_DEVICE_FUNCTION(vkDestroyImageView) \
VULKAN_DEVICE_FUNCTION(vkDestroySemaphore) \
VULKAN_DEVICE_FUNCTION(vkDestroySwapchainKHR) \
VULKAN_DEVICE_FUNCTION(vkDeviceWaitIdle) \
VULKAN_DEVICE_FUNCTION(vkEndCommandBuffer) \
VULKAN_DEVICE_FUNCTION(vkFreeCommandBuffers) \
VULKAN_DEVICE_FUNCTION(vkGetDeviceQueue) \
VULKAN_DEVICE_FUNCTION(vkGetFenceStatus) \
VULKAN_DEVICE_FUNCTION(vkGetSwapchainImagesKHR) \
VULKAN_DEVICE_FUNCTION(vkQueuePresentKHR) \
VULKAN_DEVICE_FUNCTION(vkQueueSubmit) \
VULKAN_DEVICE_FUNCTION(vkResetCommandBuffer) \
VULKAN_DEVICE_FUNCTION(vkResetFences) \
VULKAN_DEVICE_FUNCTION(vkWaitForFences) \
VULKAN_GLOBAL_FUNCTION(vkCreateInstance) \
VULKAN_GLOBAL_FUNCTION(vkEnumerateInstanceExtensionProperties) \
VULKAN_GLOBAL_FUNCTION(vkEnumerateInstanceLayerProperties) \
VULKAN_INSTANCE_FUNCTION(vkCreateDevice) \
VULKAN_INSTANCE_FUNCTION(vkDestroyInstance) \
VULKAN_INSTANCE_FUNCTION(vkDestroySurfaceKHR) \
VULKAN_INSTANCE_FUNCTION(vkEnumerateDeviceExtensionProperties) \
VULKAN_INSTANCE_FUNCTION(vkEnumeratePhysicalDevices) \
VULKAN_INSTANCE_FUNCTION(vkGetDeviceProcAddr) \
VULKAN_INSTANCE_FUNCTION(vkGetPhysicalDeviceFeatures) \
VULKAN_INSTANCE_FUNCTION(vkGetPhysicalDeviceProperties) \
VULKAN_INSTANCE_FUNCTION(vkGetPhysicalDeviceQueueFamilyProperties) \
VULKAN_INSTANCE_FUNCTION(vkGetPhysicalDeviceSurfaceCapabilitiesKHR) \
VULKAN_INSTANCE_FUNCTION(vkGetPhysicalDeviceSurfaceFormatsKHR) \
VULKAN_INSTANCE_FUNCTION(vkGetPhysicalDeviceSurfacePresentModesKHR) \
VULKAN_INSTANCE_FUNCTION(vkGetPhysicalDeviceSurfaceSupportKHR)
#define VULKAN_DEVICE_FUNCTION(name) static PFN_##name name = NULL;
#define VULKAN_GLOBAL_FUNCTION(name) static PFN_##name name = NULL;
#define VULKAN_INSTANCE_FUNCTION(name) static PFN_##name name = NULL;
VULKAN_FUNCTIONS()
#undef VULKAN_DEVICE_FUNCTION
#undef VULKAN_GLOBAL_FUNCTION
#undef VULKAN_INSTANCE_FUNCTION
static PFN_vkGetInstanceProcAddr vkGetInstanceProcAddr = NULL;
/* Based on the headers found in
* https://github.com/KhronosGroup/Vulkan-LoaderAndValidationLayers
*/
#if VK_HEADER_VERSION < 22
enum
{
VK_ERROR_FRAGMENTED_POOL = -12,
};
#endif
#if VK_HEADER_VERSION < 38
enum {
VK_ERROR_OUT_OF_POOL_MEMORY_KHR = -1000069000
};
#endif
static const char *getVulkanResultString(VkResult 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";
case VK_RESULT_MAX_ENUM:
case VK_RESULT_RANGE_SIZE:
break;
}
if(result < 0)
return "VK_ERROR_<Unknown>";
return "VK_<Unknown>";
}
typedef struct VulkanContext
{
VkInstance instance;
VkDevice device;
VkSurfaceKHR surface;
VkSwapchainKHR swapchain;
VkPhysicalDeviceProperties physicalDeviceProperties;
VkPhysicalDeviceFeatures physicalDeviceFeatures;
uint32_t graphicsQueueFamilyIndex;
uint32_t presentQueueFamilyIndex;
VkPhysicalDevice physicalDevice;
VkQueue graphicsQueue;
VkQueue presentQueue;
VkSemaphore imageAvailableSemaphore;
VkSemaphore renderingFinishedSemaphore;
VkSurfaceCapabilitiesKHR surfaceCapabilities;
VkSurfaceFormatKHR *surfaceFormats;
uint32_t surfaceFormatsAllocatedCount;
uint32_t surfaceFormatsCount;
uint32_t swapchainDesiredImageCount;
VkSurfaceFormatKHR surfaceFormat;
VkExtent2D swapchainSize;
VkCommandPool commandPool;
uint32_t swapchainImageCount;
VkImage *swapchainImages;
VkCommandBuffer *commandBuffers;
VkFence *fences;
} VulkanContext;
static SDLTest_CommonState *state;
static VulkanContext vulkanContext = {0};
static void shutdownVulkan(void);
/* Call this instead of exit(), so we can clean up SDL: atexit() is evil. */
static void quit(int rc)
{
shutdownVulkan();
SDLTest_CommonQuit(state);
exit(rc);
}
static void loadGlobalFunctions(void)
{
vkGetInstanceProcAddr = SDL_Vulkan_GetVkGetInstanceProcAddr();
if(!vkGetInstanceProcAddr)
{
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
"SDL_Vulkan_GetVkGetInstanceProcAddr(): %s\n",
SDL_GetError());
quit(2);
}
#define VULKAN_DEVICE_FUNCTION(name)
#define VULKAN_GLOBAL_FUNCTION(name) \
name = (PFN_##name)vkGetInstanceProcAddr(VK_NULL_HANDLE, #name); \
if(!name) \
{ \
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, \
"vkGetInstanceProcAddr(VK_NULL_HANDLE, \"" #name "\") failed\n"); \
quit(2); \
}
#define VULKAN_INSTANCE_FUNCTION(name)
VULKAN_FUNCTIONS()
#undef VULKAN_DEVICE_FUNCTION
#undef VULKAN_GLOBAL_FUNCTION
#undef VULKAN_INSTANCE_FUNCTION
}
static void createInstance(void)
{
VkApplicationInfo appInfo = {0};
VkInstanceCreateInfo instanceCreateInfo = {0};
const char **extensions = NULL;
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(state->windows[0], &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)
{
SDL_OutOfMemory();
quit(2);
}
if(!SDL_Vulkan_GetInstanceExtensions(state->windows[0], &extensionCount, extensions))
{
SDL_free((void*)extensions);
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
"SDL_Vulkan_GetInstanceExtensions(): %s\n",
SDL_GetError());
quit(2);
}
instanceCreateInfo.enabledExtensionCount = extensionCount;
instanceCreateInfo.ppEnabledExtensionNames = extensions;
result = vkCreateInstance(&instanceCreateInfo, NULL, &vulkanContext.instance);
SDL_free((void*)extensions);
if(result != VK_SUCCESS)
{
vulkanContext.instance = VK_NULL_HANDLE;
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
"vkCreateInstance(): %s\n",
getVulkanResultString(result));
quit(2);
}
}
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) \
{ \
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, \
"vkGetInstanceProcAddr(instance, \"" #name "\") failed\n"); \
quit(2); \
}
VULKAN_FUNCTIONS()
#undef VULKAN_DEVICE_FUNCTION
#undef VULKAN_GLOBAL_FUNCTION
#undef VULKAN_INSTANCE_FUNCTION
}
static void createSurface(void)
{
if(!SDL_Vulkan_CreateSurface(state->windows[0],
vulkanContext.instance,
&vulkanContext.surface))
{
vulkanContext.surface = VK_NULL_HANDLE;
SDL_LogError(
SDL_LOG_CATEGORY_APPLICATION, "SDL_Vulkan_CreateSurface(): %s\n", SDL_GetError());
quit(2);
}
}
static void findPhysicalDevice(void)
{
uint32_t physicalDeviceCount = 0;
VkPhysicalDevice *physicalDevices;
VkQueueFamilyProperties *queueFamiliesProperties = NULL;
uint32_t queueFamiliesPropertiesAllocatedSize = 0;
VkExtensionProperties *deviceExtensions = NULL;
uint32_t deviceExtensionsAllocatedSize = 0;
uint32_t physicalDeviceIndex;
VkResult 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)
{
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
"vkEnumeratePhysicalDevices(): no physical devices\n");
quit(2);
}
physicalDevices = SDL_malloc(sizeof(VkPhysicalDevice) * physicalDeviceCount);
if(!physicalDevices)
{
SDL_OutOfMemory();
quit(2);
}
result =
vkEnumeratePhysicalDevices(vulkanContext.instance, &physicalDeviceCount, physicalDevices);
if(result != VK_SUCCESS)
{
SDL_free(physicalDevices);
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
"vkEnumeratePhysicalDevices(): %s\n",
getVulkanResultString(result));
quit(2);
}
vulkanContext.physicalDevice = NULL;
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)
continue;
vkGetPhysicalDeviceFeatures(physicalDevice, &vulkanContext.physicalDeviceFeatures);
vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice, &queueFamiliesCount, NULL);
if(queueFamiliesCount == 0)
continue;
if(queueFamiliesPropertiesAllocatedSize < queueFamiliesCount)
{
SDL_free(queueFamiliesProperties);
queueFamiliesPropertiesAllocatedSize = queueFamiliesCount;
queueFamiliesProperties =
SDL_malloc(sizeof(VkQueueFamilyProperties) * queueFamiliesPropertiesAllocatedSize);
if(!queueFamiliesProperties)
{
SDL_free(physicalDevices);
SDL_free(deviceExtensions);
SDL_OutOfMemory();
quit(2);
}
}
vkGetPhysicalDeviceQueueFamilyProperties(
physicalDevice, &queueFamiliesCount, queueFamiliesProperties);
vulkanContext.graphicsQueueFamilyIndex = queueFamiliesCount;
vulkanContext.presentQueueFamilyIndex = queueFamiliesCount;
for(queueFamilyIndex = 0; queueFamilyIndex < queueFamiliesCount;
queueFamilyIndex++)
{
VkBool32 supported = 0;
if(queueFamiliesProperties[queueFamilyIndex].queueCount == 0)
continue;
if(queueFamiliesProperties[queueFamilyIndex].queueFlags & VK_QUEUE_GRAPHICS_BIT)
vulkanContext.graphicsQueueFamilyIndex = queueFamilyIndex;
result = vkGetPhysicalDeviceSurfaceSupportKHR(
physicalDevice, queueFamilyIndex, vulkanContext.surface, &supported);
if(result != VK_SUCCESS)
{
SDL_free(physicalDevices);
SDL_free(queueFamiliesProperties);
SDL_free(deviceExtensions);
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
"vkGetPhysicalDeviceSurfaceSupportKHR(): %s\n",
getVulkanResultString(result));
quit(2);
}
if(supported)
{
vulkanContext.presentQueueFamilyIndex = queueFamilyIndex;
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
continue;
if(vulkanContext.presentQueueFamilyIndex == queueFamiliesCount) // no good queues found
continue;
result =
vkEnumerateDeviceExtensionProperties(physicalDevice, NULL, &deviceExtensionCount, NULL);
if(result != VK_SUCCESS)
{
SDL_free(physicalDevices);
SDL_free(queueFamiliesProperties);
SDL_free(deviceExtensions);
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
"vkEnumerateDeviceExtensionProperties(): %s\n",
getVulkanResultString(result));
quit(2);
}
if(deviceExtensionCount == 0)
continue;
if(deviceExtensionsAllocatedSize < deviceExtensionCount)
{
SDL_free(deviceExtensions);
deviceExtensionsAllocatedSize = deviceExtensionCount;
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)
{
SDL_free(physicalDevices);
SDL_free(queueFamiliesProperties);
SDL_free(deviceExtensions);
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
"vkEnumerateDeviceExtensionProperties(): %s\n",
getVulkanResultString(result));
quit(2);
}
for(i = 0; i < deviceExtensionCount; i++)
{
if(0 == SDL_strcmp(deviceExtensions[i].extensionName, VK_KHR_SWAPCHAIN_EXTENSION_NAME))
{
hasSwapchainExtension = SDL_TRUE;
break;
}
}
if(!hasSwapchainExtension)
continue;
vulkanContext.physicalDevice = physicalDevice;
break;
}
SDL_free(physicalDevices);
SDL_free(queueFamiliesProperties);
SDL_free(deviceExtensions);
if(!vulkanContext.physicalDevice)
{
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Vulkan: no viable physical devices found");
quit(2);
}
}
static void createDevice(void)
{
VkDeviceQueueCreateInfo deviceQueueCreateInfo[1] = {0};
static const float queuePriority[] = {1.0f};
VkDeviceCreateInfo deviceCreateInfo = {0};
static const char *const deviceExtensionNames[] = {
VK_KHR_SWAPCHAIN_EXTENSION_NAME,
};
VkResult result;
deviceQueueCreateInfo->sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
deviceQueueCreateInfo->queueFamilyIndex = vulkanContext.graphicsQueueFamilyIndex;
deviceQueueCreateInfo->queueCount = 1;
deviceQueueCreateInfo->pQueuePriorities = &queuePriority[0];
deviceCreateInfo.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
deviceCreateInfo.queueCreateInfoCount = 1;
deviceCreateInfo.pQueueCreateInfos = deviceQueueCreateInfo;
deviceCreateInfo.pEnabledFeatures = NULL;
deviceCreateInfo.enabledExtensionCount = SDL_arraysize(deviceExtensionNames);
deviceCreateInfo.ppEnabledExtensionNames = deviceExtensionNames;
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));
quit(2);
}
}
static void loadDeviceFunctions(void)
{
#define VULKAN_DEVICE_FUNCTION(name) \
name = (PFN_##name)vkGetDeviceProcAddr(vulkanContext.device, #name); \
if(!name) \
{ \
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, \
"vkGetDeviceProcAddr(device, \"" #name "\") failed\n"); \
quit(2); \
}
#define VULKAN_GLOBAL_FUNCTION(name)
#define VULKAN_INSTANCE_FUNCTION(name)
VULKAN_FUNCTIONS()
#undef VULKAN_DEVICE_FUNCTION
#undef VULKAN_GLOBAL_FUNCTION
#undef VULKAN_INSTANCE_FUNCTION
}
#undef VULKAN_FUNCTIONS
static void getQueues(void)
{
vkGetDeviceQueue(vulkanContext.device,
vulkanContext.graphicsQueueFamilyIndex,
0,
&vulkanContext.graphicsQueue);
if(vulkanContext.graphicsQueueFamilyIndex != vulkanContext.presentQueueFamilyIndex)
vkGetDeviceQueue(vulkanContext.device,
vulkanContext.presentQueueFamilyIndex,
0,
&vulkanContext.presentQueue);
else
vulkanContext.presentQueue = vulkanContext.graphicsQueue;
}
static void createSemaphore(VkSemaphore *semaphore)
{
VkResult result;
VkSemaphoreCreateInfo createInfo = {0};
createInfo.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO;
result = vkCreateSemaphore(vulkanContext.device, &createInfo, NULL, semaphore);
if(result != VK_SUCCESS)
{
*semaphore = VK_NULL_HANDLE;
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
"vkCreateSemaphore(): %s\n",
getVulkanResultString(result));
quit(2);
}
}
static void createSemaphores(void)
{
createSemaphore(&vulkanContext.imageAvailableSemaphore);
createSemaphore(&vulkanContext.renderingFinishedSemaphore);
}
static void getSurfaceCaps(void)
{
VkResult result = vkGetPhysicalDeviceSurfaceCapabilitiesKHR(
vulkanContext.physicalDevice, vulkanContext.surface, &vulkanContext.surfaceCapabilities);
if(result != VK_SUCCESS)
{
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
"vkGetPhysicalDeviceSurfaceCapabilitiesKHR(): %s\n",
getVulkanResultString(result));
quit(2);
}
// check surface usage
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);
}
}
static void getSurfaceFormats(void)
{
VkResult result = vkGetPhysicalDeviceSurfaceFormatsKHR(vulkanContext.physicalDevice,
vulkanContext.surface,
&vulkanContext.surfaceFormatsCount,
NULL);
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)
{
vulkanContext.surfaceFormatsAllocatedCount = vulkanContext.surfaceFormatsCount;
SDL_free(vulkanContext.surfaceFormats);
vulkanContext.surfaceFormats =
SDL_malloc(sizeof(VkSurfaceFormatKHR) * vulkanContext.surfaceFormatsAllocatedCount);
if(!vulkanContext.surfaceFormats)
{
vulkanContext.surfaceFormatsCount = 0;
SDL_OutOfMemory();
quit(2);
}
}
result = vkGetPhysicalDeviceSurfaceFormatsKHR(vulkanContext.physicalDevice,
vulkanContext.surface,
&vulkanContext.surfaceFormatsCount,
vulkanContext.surfaceFormats);
if(result != VK_SUCCESS)
{
vulkanContext.surfaceFormatsCount = 0;
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
"vkGetPhysicalDeviceSurfaceFormatsKHR(): %s\n",
getVulkanResultString(result));
quit(2);
}
}
static void getSwapchainImages(void)
{
VkResult result;
SDL_free(vulkanContext.swapchainImages);
vulkanContext.swapchainImages = NULL;
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",
getVulkanResultString(result));
quit(2);
}
vulkanContext.swapchainImages = SDL_malloc(sizeof(VkImage) * vulkanContext.swapchainImageCount);
if(!vulkanContext.swapchainImages)
{
SDL_OutOfMemory();
quit(2);
}
result = vkGetSwapchainImagesKHR(vulkanContext.device,
vulkanContext.swapchain,
&vulkanContext.swapchainImageCount,
vulkanContext.swapchainImages);
if(result != VK_SUCCESS)
{
SDL_free(vulkanContext.swapchainImages);
vulkanContext.swapchainImages = NULL;
vulkanContext.swapchainImageCount = 0;
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
"vkGetSwapchainImagesKHR(): %s\n",
getVulkanResultString(result));
quit(2);
}
}
static SDL_bool createSwapchain(void)
{
uint32_t i;
int w, h;
VkSwapchainCreateInfoKHR createInfo = {0};
VkResult result;
// pick an image count
vulkanContext.swapchainDesiredImageCount = vulkanContext.surfaceCapabilities.minImageCount + 1;
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)
{
// aren't any preferred formats, so we pick
vulkanContext.surfaceFormat.colorSpace = VK_COLORSPACE_SRGB_NONLINEAR_KHR;
vulkanContext.surfaceFormat.format = VK_FORMAT_R8G8B8A8_UNORM;
}
else
{
vulkanContext.surfaceFormat = vulkanContext.surfaceFormats[0];
for(i = 0; i < vulkanContext.surfaceFormatsCount; i++)
{
if(vulkanContext.surfaceFormats[i].format == VK_FORMAT_R8G8B8A8_UNORM)
{
vulkanContext.surfaceFormat = vulkanContext.surfaceFormats[i];
break;
}
}
}
// get size
SDL_Vulkan_GetDrawableSize(state->windows[0], &w, &h);
vulkanContext.swapchainSize.width = w;
vulkanContext.swapchainSize.height = h;
if(w == 0 || h == 0)
return SDL_FALSE;
createInfo.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR;
createInfo.surface = vulkanContext.surface;
createInfo.minImageCount = vulkanContext.swapchainDesiredImageCount;
createInfo.imageFormat = vulkanContext.surfaceFormat.format;
createInfo.imageColorSpace = vulkanContext.surfaceFormat.colorSpace;
createInfo.imageExtent = vulkanContext.swapchainSize;
createInfo.imageArrayLayers = 1;
createInfo.imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
createInfo.imageSharingMode = VK_SHARING_MODE_EXCLUSIVE;
createInfo.preTransform = vulkanContext.surfaceCapabilities.currentTransform;
createInfo.compositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR;
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)
vkDestroySwapchainKHR(vulkanContext.device, createInfo.oldSwapchain, NULL);
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)
vkDestroySwapchainKHR(vulkanContext.device, vulkanContext.swapchain, NULL);
vulkanContext.swapchain = VK_NULL_HANDLE;
SDL_free(vulkanContext.swapchainImages);
vulkanContext.swapchainImages = NULL;
}
static void destroyCommandBuffers(void)
{
if(vulkanContext.commandBuffers)
vkFreeCommandBuffers(vulkanContext.device,
vulkanContext.commandPool,
vulkanContext.swapchainImageCount,
vulkanContext.commandBuffers);
SDL_free(vulkanContext.commandBuffers);
vulkanContext.commandBuffers = NULL;
}
static void destroyCommandPool(void)
{
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.queueFamilyIndex = vulkanContext.graphicsQueueFamilyIndex;
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",
getVulkanResultString(result));
quit(2);
}
}
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)
{
SDL_free(vulkanContext.commandBuffers);
vulkanContext.commandBuffers = NULL;
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
"vkAllocateCommandBuffers(): %s\n",
getVulkanResultString(result));
quit(2);
}
}
static void createFences(void)
{
uint32_t i;
vulkanContext.fences = SDL_malloc(sizeof(VkFence) * vulkanContext.swapchainImageCount);
if(!vulkanContext.fences)
{
SDL_OutOfMemory();
quit(2);
}
for(i = 0; i < vulkanContext.swapchainImageCount; i++)
{
VkResult result;
VkFenceCreateInfo createInfo = {0};
createInfo.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
createInfo.flags = VK_FENCE_CREATE_SIGNALED_BIT;
result =
vkCreateFence(vulkanContext.device, &createInfo, NULL, &vulkanContext.fences[i]);
if(result != VK_SUCCESS)
{
for(; i > 0; i--)
{
vkDestroyFence(vulkanContext.device, vulkanContext.fences[i - 1], NULL);
}
SDL_free(vulkanContext.fences);
vulkanContext.fences = NULL;
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
"vkCreateFence(): %s\n",
getVulkanResultString(result));
quit(2);
}
}
}
static void destroyFences(void)
{
uint32_t i;
if(!vulkanContext.fences)
return;
for(i = 0; i < vulkanContext.swapchainImageCount; i++)
{
vkDestroyFence(vulkanContext.device, vulkanContext.fences[i], NULL);
}
SDL_free(vulkanContext.fences);
vulkanContext.fences = NULL;
}
static void recordPipelineImageBarrier(VkCommandBuffer commandBuffer,
VkAccessFlags sourceAccessMask,
VkAccessFlags destAccessMask,
VkImageLayout sourceLayout,
VkImageLayout destLayout,
VkImage image)
{
VkImageMemoryBarrier barrier = {0};
barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
barrier.srcAccessMask = sourceAccessMask;
barrier.dstAccessMask = destAccessMask;
barrier.oldLayout = sourceLayout;
barrier.newLayout = destLayout;
barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
barrier.image = image;
barrier.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
barrier.subresourceRange.baseMipLevel = 0;
barrier.subresourceRange.levelCount = 1;
barrier.subresourceRange.baseArrayLayer = 0;
barrier.subresourceRange.layerCount = 1;
vkCmdPipelineBarrier(commandBuffer,
VK_PIPELINE_STAGE_TRANSFER_BIT,
VK_PIPELINE_STAGE_TRANSFER_BIT,
0,
0,
NULL,
0,
NULL,
1,
&barrier);
}
static void rerecordCommandBuffer(uint32_t frameIndex, const VkClearColorValue *clearColor)
{
VkCommandBuffer commandBuffer = vulkanContext.commandBuffers[frameIndex];
VkImage image = vulkanContext.swapchainImages[frameIndex];
VkCommandBufferBeginInfo beginInfo = {0};
VkImageSubresourceRange clearRange = {0};
VkResult result = vkResetCommandBuffer(commandBuffer, 0);
if(result != VK_SUCCESS)
{
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
"vkResetCommandBuffer(): %s\n",
getVulkanResultString(result));
quit(2);
}
beginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
beginInfo.flags = VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT;
result = vkBeginCommandBuffer(commandBuffer, &beginInfo);
if(result != VK_SUCCESS)
{
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
"vkBeginCommandBuffer(): %s\n",
getVulkanResultString(result));
quit(2);
}
recordPipelineImageBarrier(commandBuffer,
0,
VK_ACCESS_TRANSFER_WRITE_BIT,
VK_IMAGE_LAYOUT_UNDEFINED,
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
image);
clearRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
clearRange.baseMipLevel = 0;
clearRange.levelCount = 1;
clearRange.baseArrayLayer = 0;
clearRange.layerCount = 1;
vkCmdClearColorImage(
commandBuffer, image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, clearColor, 1, &clearRange);
recordPipelineImageBarrier(commandBuffer,
VK_ACCESS_TRANSFER_WRITE_BIT,
VK_ACCESS_MEMORY_READ_BIT,
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
VK_IMAGE_LAYOUT_PRESENT_SRC_KHR,
image);
result = vkEndCommandBuffer(commandBuffer);
if(result != VK_SUCCESS)
{
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
"vkEndCommandBuffer(): %s\n",
getVulkanResultString(result));
quit(2);
}
}
static void destroySwapchainAndSwapchainSpecificStuff(SDL_bool doDestroySwapchain)
{
destroyFences();
destroyCommandBuffers();
destroyCommandPool();
if(doDestroySwapchain)
destroySwapchain();
}
static SDL_bool createNewSwapchainAndSwapchainSpecificStuff(void)
{
destroySwapchainAndSwapchainSpecificStuff(SDL_FALSE);
getSurfaceCaps();
getSurfaceFormats();
if(!createSwapchain())
return SDL_FALSE;
createCommandPool();
createCommandBuffers();
createFences();
return SDL_TRUE;
}
static void initVulkan(void)
{
SDL_Vulkan_LoadLibrary(NULL);
SDL_memset(&vulkanContext, 0, sizeof(VulkanContext));
loadGlobalFunctions();
createInstance();
loadInstanceFunctions();
createSurface();
findPhysicalDevice();
createDevice();
loadDeviceFunctions();
getQueues();
createSemaphores();
createNewSwapchainAndSwapchainSpecificStuff();
}
static void shutdownVulkan(void)
{
if(vulkanContext.device && vkDeviceWaitIdle)
vkDeviceWaitIdle(vulkanContext.device);
destroySwapchainAndSwapchainSpecificStuff(SDL_TRUE);
if(vulkanContext.imageAvailableSemaphore && vkDestroySemaphore)
vkDestroySemaphore(vulkanContext.device, vulkanContext.imageAvailableSemaphore, NULL);
if(vulkanContext.renderingFinishedSemaphore && vkDestroySemaphore)
vkDestroySemaphore(vulkanContext.device, vulkanContext.renderingFinishedSemaphore, NULL);
if(vulkanContext.device && vkDestroyDevice)
vkDestroyDevice(vulkanContext.device, NULL);
if(vulkanContext.surface && vkDestroySurfaceKHR)
vkDestroySurfaceKHR(vulkanContext.instance, vulkanContext.surface, NULL);
if(vulkanContext.instance && vkDestroyInstance)
vkDestroyInstance(vulkanContext.instance, NULL);
SDL_free(vulkanContext.surfaceFormats);
SDL_Vulkan_UnloadLibrary();
}
static SDL_bool render(void)
{
uint32_t frameIndex;
VkResult result;
double currentTime;
VkClearColorValue clearColor = {0};
VkPipelineStageFlags waitDestStageMask = VK_PIPELINE_STAGE_TRANSFER_BIT;
VkSubmitInfo submitInfo = {0};
VkPresentInfoKHR presentInfo = {0};
int w, h;
if(!vulkanContext.swapchain)
{
SDL_bool retval = createNewSwapchainAndSwapchainSpecificStuff();
if(!retval)
SDL_Delay(100);
return retval;
}
result = vkAcquireNextImageKHR(vulkanContext.device,
vulkanContext.swapchain,
UINT64_MAX,
vulkanContext.imageAvailableSemaphore,
VK_NULL_HANDLE,
&frameIndex);
if(result == VK_ERROR_OUT_OF_DATE_KHR)
return createNewSwapchainAndSwapchainSpecificStuff();
if(result != VK_SUBOPTIMAL_KHR && result != VK_SUCCESS)
{
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
"vkAcquireNextImageKHR(): %s\n",
getVulkanResultString(result));
quit(2);
}
result = vkWaitForFences(
vulkanContext.device, 1, &vulkanContext.fences[frameIndex], VK_FALSE, UINT64_MAX);
if(result != VK_SUCCESS)
{
SDL_LogError(
SDL_LOG_CATEGORY_APPLICATION, "vkWaitForFences(): %s\n", getVulkanResultString(result));
quit(2);
}
result = vkResetFences(vulkanContext.device, 1, &vulkanContext.fences[frameIndex]);
if(result != VK_SUCCESS)
{
SDL_LogError(
SDL_LOG_CATEGORY_APPLICATION, "vkResetFences(): %s\n", getVulkanResultString(result));
quit(2);
}
currentTime = (double)SDL_GetPerformanceCounter() / SDL_GetPerformanceFrequency();
clearColor.float32[0] = (float)(0.5 + 0.5 * SDL_sin(currentTime));
clearColor.float32[1] = (float)(0.5 + 0.5 * SDL_sin(currentTime + M_PI * 2 / 3));
clearColor.float32[2] = (float)(0.5 + 0.5 * SDL_sin(currentTime + M_PI * 4 / 3));
clearColor.float32[3] = 1;
rerecordCommandBuffer(frameIndex, &clearColor);
submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
submitInfo.waitSemaphoreCount = 1;
submitInfo.pWaitSemaphores = &vulkanContext.imageAvailableSemaphore;
submitInfo.pWaitDstStageMask = &waitDestStageMask;
submitInfo.commandBufferCount = 1;
submitInfo.pCommandBuffers = &vulkanContext.commandBuffers[frameIndex];
submitInfo.signalSemaphoreCount = 1;
submitInfo.pSignalSemaphores = &vulkanContext.renderingFinishedSemaphore;
result = vkQueueSubmit(
vulkanContext.graphicsQueue, 1, &submitInfo, vulkanContext.fences[frameIndex]);
if(result != VK_SUCCESS)
{
SDL_LogError(
SDL_LOG_CATEGORY_APPLICATION, "vkQueueSubmit(): %s\n", getVulkanResultString(result));
quit(2);
}
presentInfo.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR;
presentInfo.waitSemaphoreCount = 1;
presentInfo.pWaitSemaphores = &vulkanContext.renderingFinishedSemaphore;
presentInfo.swapchainCount = 1;
presentInfo.pSwapchains = &vulkanContext.swapchain;
presentInfo.pImageIndices = &frameIndex;
result = vkQueuePresentKHR(vulkanContext.presentQueue, &presentInfo);
if(result == VK_ERROR_OUT_OF_DATE_KHR || result == VK_SUBOPTIMAL_KHR)
{
return createNewSwapchainAndSwapchainSpecificStuff();
}
if(result != VK_SUCCESS)
{
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
"vkQueuePresentKHR(): %s\n",
getVulkanResultString(result));
quit(2);
}
SDL_Vulkan_GetDrawableSize(state->windows[0], &w, &h);
if(w != (int)vulkanContext.swapchainSize.width || h != (int)vulkanContext.swapchainSize.height)
{
return createNewSwapchainAndSwapchainSpecificStuff();
}
return SDL_TRUE;
}
int main(int argc, char *argv[])
{
int fsaa, accel;
int i, done;
SDL_DisplayMode mode;
SDL_Event event;
Uint32 then, now, frames;
int dw, dh;
/* Enable standard application logging */
SDL_LogSetPriority(SDL_LOG_CATEGORY_APPLICATION, SDL_LOG_PRIORITY_INFO);
/* Initialize parameters */
fsaa = 0;
accel = -1;
/* Initialize test framework */
state = SDLTest_CommonCreateState(argv, SDL_INIT_VIDEO);
if(!state)
{
return 1;
}
for(i = 1; i < argc;)
{
int consumed;
consumed = SDLTest_CommonArg(state, i);
if(consumed < 0)
{
SDL_Log("Usage: %s %s\n", argv[0], SDLTest_CommonUsage(state));
quit(1);
}
i += consumed;
}
/* Set Vulkan parameters */
state->window_flags |= SDL_WINDOW_VULKAN;
state->num_windows = 1;
state->skip_renderer = 1;
if(!SDLTest_CommonInit(state))
{
quit(2);
}
SDL_GetCurrentDisplayMode(0, &mode);
SDL_Log("Screen BPP : %d\n", SDL_BITSPERPIXEL(mode.format));
SDL_GetWindowSize(state->windows[0], &dw, &dh);
SDL_Log("Window Size : %d,%d\n", dw, dh);
SDL_Vulkan_GetDrawableSize(state->windows[0], &dw, &dh);
SDL_Log("Draw Size : %d,%d\n", dw, dh);
SDL_Log("\n");
initVulkan();
/* Main render loop */
frames = 0;
then = SDL_GetTicks();
done = 0;
while(!done)
{
/* Check for events */
++frames;
while(SDL_PollEvent(&event))
{
SDLTest_CommonEvent(state, &event, &done);
}
if(!done)
render();
}
/* Print out some timing information */
now = SDL_GetTicks();
if(now > then)
{
SDL_Log("%2.2f frames per second\n", ((double)frames * 1000) / (now - then));
}
quit(0);
return 0;
}
#endif
VkPresentInfoKHR::pSwapchains
const VkSwapchainKHR * pSwapchains
Definition: vulkan.h:3574
VkSurfaceFormatKHR::format
VkFormat format
Definition: vulkan.h:3493
SDL_Vulkan_GetDrawableSize
#define SDL_Vulkan_GetDrawableSize
Definition: SDL_dynapi_overrides.h:637
VkCommandBufferAllocateInfo::commandPool
VkCommandPool commandPool
Definition: vulkan.h:2315
VkPresentInfoKHR::pWaitSemaphores
const VkSemaphore * pWaitSemaphores
Definition: vulkan.h:3572
VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO
Definition: vulkan.h:159
VkPhysicalDeviceFeatures
Definition: vulkan.h:1428
vkBeginCommandBuffer
VKAPI_ATTR VkResult VKAPI_CALL vkBeginCommandBuffer(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo *pBeginInfo)
VkSubmitInfo::pCommandBuffers
const VkCommandBuffer * pCommandBuffers
Definition: vulkan.h:1701
recordPipelineImageBarrier
static void recordPipelineImageBarrier(VkCommandBuffer commandBuffer, VkAccessFlags sourceAccessMask, VkAccessFlags destAccessMask, VkImageLayout sourceLayout, VkImageLayout destLayout, VkImage image)
Definition: testvulkan.c:879
VK_ERROR_NATIVE_WINDOW_IN_USE_KHR
Definition: vulkan.h:142
SDL_PollEvent
#define SDL_PollEvent
Definition: SDL_dynapi_overrides.h:122
createCommandPool
static void createCommandPool(void)
Definition: testvulkan.c:785
SDL_GetError
#define SDL_GetError
Definition: SDL_dynapi_overrides.h:113
VkPresentInfoKHR::pImageIndices
const uint32_t * pImageIndices
Definition: vulkan.h:3575
destroyCommandPool
static void destroyCommandPool(void)
Definition: testvulkan.c:778
VkPresentInfoKHR::swapchainCount
uint32_t swapchainCount
Definition: vulkan.h:3573
VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR
Definition: vulkan.h:3471
VK_COMMAND_BUFFER_LEVEL_PRIMARY
Definition: vulkan.h:951
VK_PRESENT_MODE_FIFO_KHR
Definition: vulkan.h:3445
VulkanContext::surface
VkSurfaceKHR surface
Definition: testvulkan.c:180
SDL_TRUE
Definition: SDL_stdinc.h:142
result
GLuint64EXT * result
Definition: SDL_opengl_glext.h:9432
VK_ERROR_EXTENSION_NOT_PRESENT
Definition: vulkan.h:135
VkSubmitInfo::sType
VkStructureType sType
Definition: vulkan.h:1695
VulkanContext::presentQueue
VkQueue presentQueue
Definition: testvulkan.c:188
VkInstanceCreateInfo::pApplicationInfo
const VkApplicationInfo * pApplicationInfo
Definition: vulkan.h:1383
vkDestroyDevice
VKAPI_ATTR void VKAPI_CALL vkDestroyDevice(VkDevice device, const VkAllocationCallbacks *pAllocator)
image
GLeglImageOES image
Definition: SDL_opengl.h:2148
vkCmdPipelineBarrier
VKAPI_ATTR void VKAPI_CALL vkCmdPipelineBarrier(VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const VkMemoryBarrier *pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier *pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier *pImageMemoryBarriers)
SDLTest_CommonState::skip_renderer
SDL_bool skip_renderer
Definition: SDL_test_common.h:83
VkSwapchainCreateInfoKHR::sType
VkStructureType sType
Definition: vulkan.h:3548
VkSubmitInfo::pWaitSemaphores
const VkSemaphore * pWaitSemaphores
Definition: vulkan.h:1698
vkGetPhysicalDeviceQueueFamilyProperties
VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice, uint32_t *pQueueFamilyPropertyCount, VkQueueFamilyProperties *pQueueFamilyProperties)
VkInstanceCreateInfo::enabledExtensionCount
uint32_t enabledExtensionCount
Definition: vulkan.h:1386
VK_EVENT_SET
Definition: vulkan.h:126
vkQueuePresentKHR
VKAPI_ATTR VkResult VKAPI_CALL vkQueuePresentKHR(VkQueue queue, const VkPresentInfoKHR *pPresentInfo)
main
int main(int argc, char *argv[])
Definition: testvulkan.c:1119
VkFenceCreateInfo::sType
VkStructureType sType
Definition: vulkan.h:1804
vkGetPhysicalDeviceProperties
VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties *pProperties)
createSemaphores
static void createSemaphores(void)
Definition: testvulkan.c:581
VK_INCOMPLETE
Definition: vulkan.h:128
VkApplicationInfo::apiVersion
uint32_t apiVersion
Definition: vulkan.h:1376
UINT64_MAX
#define UINT64_MAX
Definition: testvulkan.c:39
vkDestroyCommandPool
VKAPI_ATTR void VKAPI_CALL vkDestroyCommandPool(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks *pAllocator)
VkSwapchainCreateInfoKHR
Definition: vulkan.h:3547
SDLTest_CommonCreateState
SDLTest_CommonState * SDLTest_CommonCreateState(char **argv, Uint32 flags)
Parse command line parameters and create common state.
Definition: SDL_test_common.c:48
VK_SHARING_MODE_EXCLUSIVE
Definition: vulkan.h:604
VK_STRUCTURE_TYPE_SUBMIT_INFO
Definition: vulkan.h:161
vkGetPhysicalDeviceSurfaceSupportKHR
VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32 *pSupported)
VK_ERROR_OUT_OF_POOL_MEMORY_KHR
Definition: vulkan.h:148
VK_FENCE_CREATE_SIGNALED_BIT
Definition: vulkan.h:1155
VulkanContext::swapchainSize
VkExtent2D swapchainSize
Definition: testvulkan.c:197
shutdownVulkan
static void shutdownVulkan(void)
Definition: testvulkan.c:1004
VkImageMemoryBarrier::newLayout
VkImageLayout newLayout
Definition: vulkan.h:2436
SDL_FALSE
Definition: SDL_stdinc.h:141
h
GLfloat GLfloat GLfloat GLfloat h
Definition: SDL_opengl_glext.h:1946
VkDeviceQueueCreateInfo::queueFamilyIndex
uint32_t queueFamilyIndex
Definition: vulkan.h:1664
VULKAN_FUNCTIONS
#define VULKAN_FUNCTIONS()
Definition: testvulkan.c:42
SDLTest_CommonArg
int SDLTest_CommonArg(SDLTest_CommonState *state, int index)
Process one common argument.
Definition: SDL_test_common.c:106
VkDeviceCreateInfo::ppEnabledExtensionNames
const char *const * ppEnabledExtensionNames
Definition: vulkan.h:1678
VkImageMemoryBarrier::srcAccessMask
VkAccessFlags srcAccessMask
Definition: vulkan.h:2433
SDL_Vulkan_GetInstanceExtensions
#define SDL_Vulkan_GetInstanceExtensions
Definition: SDL_dynapi_overrides.h:635
SDL_GetPerformanceFrequency
Uint64 SDL_GetPerformanceFrequency(void)
Get the count per second of the high resolution counter.
VulkanContext::surfaceFormat
VkSurfaceFormatKHR surfaceFormat
Definition: testvulkan.c:196
VK_EVENT_RESET
Definition: vulkan.h:127
VkExtensionProperties
Definition: vulkan.h:1682
vkCreateSwapchainKHR
VKAPI_ATTR VkResult VKAPI_CALL vkCreateSwapchainKHR(VkDevice device, const VkSwapchainCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSwapchainKHR *pSwapchain)
VkSwapchainCreateInfoKHR::preTransform
VkSurfaceTransformFlagBitsKHR preTransform
Definition: vulkan.h:3561
VulkanContext::swapchainDesiredImageCount
uint32_t swapchainDesiredImageCount
Definition: testvulkan.c:195
VkSwapchainCreateInfoKHR::imageFormat
VkFormat imageFormat
Definition: vulkan.h:3553
VkSwapchainCreateInfoKHR::surface
VkSurfaceKHR surface
Definition: vulkan.h:3551
VkDeviceQueueCreateInfo::sType
VkStructureType sType
Definition: vulkan.h:1661
SDL_DisplayMode
The structure that defines a display mode.
Definition: SDL_video.h:53
VkInstanceCreateInfo
Definition: vulkan.h:1379
vkCreateInstance
VKAPI_ATTR VkResult VKAPI_CALL vkCreateInstance(const VkInstanceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkInstance *pInstance)
VkSwapchainCreateInfoKHR::clipped
VkBool32 clipped
Definition: vulkan.h:3564
loadInstanceFunctions
static void loadInstanceFunctions(void)
Definition: testvulkan.c:293
VkBool32
uint32_t VkBool32
Definition: vulkan.h:67
VK_IMAGE_LAYOUT_UNDEFINED
Definition: vulkan.h:613
VK_ACCESS_TRANSFER_WRITE_BIT
Definition: vulkan.h:1308
loadGlobalFunctions
static void loadGlobalFunctions(void)
Definition: testvulkan.c:218
VK_KHR_SWAPCHAIN_EXTENSION_NAME
#define VK_KHR_SWAPCHAIN_EXTENSION_NAME
Definition: vulkan.h:3538
VkSwapchainCreateInfoKHR::oldSwapchain
VkSwapchainKHR oldSwapchain
Definition: vulkan.h:3565
VkImageMemoryBarrier::srcQueueFamilyIndex
uint32_t srcQueueFamilyIndex
Definition: vulkan.h:2437
Uint32
uint32_t Uint32
Definition: SDL_stdinc.h:181
VkDeviceQueueCreateInfo::queueCount
uint32_t queueCount
Definition: vulkan.h:1665
VK_ERROR_FORMAT_NOT_SUPPORTED
Definition: vulkan.h:139
SDL_test_common.h
VK_COLORSPACE_SRGB_NONLINEAR_KHR
#define VK_COLORSPACE_SRGB_NONLINEAR_KHR
Definition: vulkan.h:3417
VkSubmitInfo::pWaitDstStageMask
const VkPipelineStageFlags * pWaitDstStageMask
Definition: vulkan.h:1699
SDLTest_CommonInit
SDL_bool SDLTest_CommonInit(SDLTest_CommonState *state)
Open test window.
Definition: SDL_test_common.c:726
VkAccessFlags
VkFlags VkAccessFlags
Definition: vulkan.h:1318
VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO
Definition: vulkan.h:196
VkSwapchainCreateInfoKHR::imageArrayLayers
uint32_t imageArrayLayers
Definition: vulkan.h:3556
VK_IMAGE_USAGE_TRANSFER_DST_BIT
Definition: vulkan.h:1044
VK_ERROR_INCOMPATIBLE_DISPLAY_KHR
Definition: vulkan.h:145
VkSubmitInfo::waitSemaphoreCount
uint32_t waitSemaphoreCount
Definition: vulkan.h:1697
vkDestroyFence
VKAPI_ATTR void VKAPI_CALL vkDestroyFence(VkDevice device, VkFence fence, const VkAllocationCallbacks *pAllocator)
PFN_vkGetInstanceProcAddr
PFN_vkVoidFunction(VKAPI_PTR * PFN_vkGetInstanceProcAddr)(VkInstance instance, const char *pName)
Definition: vulkan.h:2484
VkSwapchainCreateInfoKHR::compositeAlpha
VkCompositeAlphaFlagBitsKHR compositeAlpha
Definition: vulkan.h:3562
createSwapchain
static SDL_bool createSwapchain(void)
Definition: testvulkan.c:687
createDevice
static void createDevice(void)
Definition: testvulkan.c:497
VK_FORMAT_R8G8B8A8_UNORM
Definition: vulkan.h:400
SDL_Vulkan_CreateSurface
#define SDL_Vulkan_CreateSurface
Definition: SDL_dynapi_overrides.h:636
VkImageSubresourceRange::baseMipLevel
uint32_t baseMipLevel
Definition: vulkan.h:1886
VK_NULL_HANDLE
#define VK_NULL_HANDLE
Definition: vulkan.h:49
vkEndCommandBuffer
VKAPI_ATTR VkResult VKAPI_CALL vkEndCommandBuffer(VkCommandBuffer commandBuffer)
findPhysicalDevice
static void findPhysicalDevice(void)
Definition: testvulkan.c:324
vkGetPhysicalDeviceFeatures
VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures *pFeatures)
getVulkanResultString
static const char * getVulkanResultString(VkResult result)
Definition: testvulkan.c:111
VkSemaphoreCreateInfo::sType
VkStructureType sType
Definition: vulkan.h:1810
vulkan.h
VkResult
VkResult
Definition: vulkan.h:122
VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO
Definition: vulkan.h:199
VkDeviceCreateInfo::queueCreateInfoCount
uint32_t queueCreateInfoCount
Definition: vulkan.h:1673
SDLTest_CommonState::windows
SDL_Window ** windows
Definition: SDL_test_common.h:78
VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO
Definition: vulkan.h:158
VK_STRUCTURE_TYPE_APPLICATION_INFO
Definition: vulkan.h:157
VK_IMAGE_ASPECT_COLOR_BIT
Definition: vulkan.h:1132
VK_IMAGE_LAYOUT_PRESENT_SRC_KHR
Definition: vulkan.h:622
VK_ERROR_SURFACE_LOST_KHR
Definition: vulkan.h:141
SDL_LogError
#define SDL_LogError
Definition: SDL_dynapi_overrides.h:36
VkSemaphoreCreateInfo
Definition: vulkan.h:1809
state
static SDLTest_CommonState * state
Definition: testvulkan.c:205
destroySwapchain
static void destroySwapchain(void)
Definition: testvulkan.c:758
VkImageSubresourceRange
Definition: vulkan.h:1884
vkDestroySurfaceKHR
VKAPI_ATTR void VKAPI_CALL vkDestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks *pAllocator)
VulkanContext::physicalDeviceProperties
VkPhysicalDeviceProperties physicalDeviceProperties
Definition: testvulkan.c:182
VkDeviceQueueCreateInfo
Definition: vulkan.h:1660
getSurfaceFormats
static void getSurfaceFormats(void)
Definition: testvulkan.c:608
SDLTest_CommonState::num_windows
int num_windows
Definition: SDL_test_common.h:77
vkEnumeratePhysicalDevices
VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDevices(VkInstance instance, uint32_t *pPhysicalDeviceCount, VkPhysicalDevice *pPhysicalDevices)
VkFenceCreateInfo
Definition: vulkan.h:1803
VkImageMemoryBarrier
Definition: vulkan.h:2430
VkCommandBufferAllocateInfo::level
VkCommandBufferLevel level
Definition: vulkan.h:2316
SDL_GetWindowSize
#define SDL_GetWindowSize
Definition: SDL_dynapi_overrides.h:527
VkSurfaceFormatKHR::colorSpace
VkColorSpaceKHR colorSpace
Definition: vulkan.h:3494
VulkanContext::surfaceFormats
VkSurfaceFormatKHR * surfaceFormats
Definition: testvulkan.c:192
VK_PIPELINE_STAGE_TRANSFER_BIT
Definition: vulkan.h:1120
retval
SDL_bool retval
Definition: testgamecontroller.c:65
VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT
Definition: vulkan.h:1330
SDLTest_CommonState::window_flags
Uint32 window_flags
Definition: SDL_test_common.h:63
vkGetDeviceQueue
VKAPI_ATTR void VKAPI_CALL vkGetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue *pQueue)
getSwapchainImages
static void getSwapchainImages(void)
Definition: testvulkan.c:649
VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT
Definition: vulkan.h:1047
SDL_Log
#define SDL_Log
Definition: SDL_dynapi_overrides.h:31
VulkanContext::commandBuffers
VkCommandBuffer * commandBuffers
Definition: testvulkan.c:201
VK_COMMAND_POOL_CREATE_TRANSIENT_BIT
Definition: vulkan.h:1329
vkQueueSubmit
VKAPI_ATTR VkResult VKAPI_CALL vkQueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo *pSubmits, VkFence fence)
vkGetSwapchainImagesKHR
VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain, uint32_t *pSwapchainImageCount, VkImage *pSwapchainImages)
VulkanContext::instance
VkInstance instance
Definition: testvulkan.c:178
VkInstanceCreateInfo::sType
VkStructureType sType
Definition: vulkan.h:1380
VkClearColorValue::float32
float float32[4]
Definition: vulkan.h:2376
VkSurfaceCapabilitiesKHR::currentTransform
VkSurfaceTransformFlagBitsKHR currentTransform
Definition: vulkan.h:3487
VulkanContext::fences
VkFence * fences
Definition: testvulkan.c:202
createSemaphore
static void createSemaphore(VkSemaphore *semaphore)
Definition: testvulkan.c:564
vkCreateSemaphore
VKAPI_ATTR VkResult VKAPI_CALL vkCreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSemaphore *pSemaphore)
VulkanContext::device
VkDevice device
Definition: testvulkan.c:179
SDLTest_CommonEvent
void SDLTest_CommonEvent(SDLTest_CommonState *state, SDL_Event *event, int *done)
Common event handler for test windows.
Definition: SDL_test_common.c:1425
VkImageLayout
VkImageLayout
Definition: vulkan.h:612
vkGetInstanceProcAddr
static PFN_vkGetInstanceProcAddr vkGetInstanceProcAddr
Definition: testvulkan.c:94
VkPhysicalDeviceProperties
Definition: vulkan.h:1623
initVulkan
static void initVulkan(void)
Definition: testvulkan.c:988
VkDeviceCreateInfo::sType
VkStructureType sType
Definition: vulkan.h:1670
VkClearColorValue
Definition: vulkan.h:2375
VulkanContext::renderingFinishedSemaphore
VkSemaphore renderingFinishedSemaphore
Definition: testvulkan.c:190
VK_NOT_READY
Definition: vulkan.h:124
SDL_Vulkan_LoadLibrary
#define SDL_Vulkan_LoadLibrary
Definition: SDL_dynapi_overrides.h:632
SDL_GetTicks
Uint32 SDL_GetTicks(void)
Get the number of milliseconds since the SDL library initialization.
VkSwapchainCreateInfoKHR::imageUsage
VkImageUsageFlags imageUsage
Definition: vulkan.h:3557
VkPresentInfoKHR::sType
VkStructureType sType
Definition: vulkan.h:3569
vkDeviceWaitIdle
VKAPI_ATTR VkResult VKAPI_CALL vkDeviceWaitIdle(VkDevice device)
VK_ERROR_VALIDATION_FAILED_EXT
Definition: vulkan.h:146
vkCreateFence
VKAPI_ATTR VkResult VKAPI_CALL vkCreateFence(VkDevice device, const VkFenceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkFence *pFence)
VkSubmitInfo::signalSemaphoreCount
uint32_t signalSemaphoreCount
Definition: vulkan.h:1702
SDL_free
#define SDL_free
Definition: SDL_dynapi_overrides.h:377
SDL_WINDOW_VULKAN
Definition: SDL_video.h:122
event
struct _cl_event * event
Definition: SDL_opengl_glext.h:2649
vkGetPhysicalDeviceSurfaceFormatsKHR
VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t *pSurfaceFormatCount, VkSurfaceFormatKHR *pSurfaceFormats)
VK_ERROR_FRAGMENTED_POOL
Definition: vulkan.h:140
VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER
Definition: vulkan.h:202
VkCommandBufferBeginInfo::sType
VkStructureType sType
Definition: vulkan.h:2332
VK_FORMAT_UNDEFINED
Definition: vulkan.h:363
VkImageMemoryBarrier::dstAccessMask
VkAccessFlags dstAccessMask
Definition: vulkan.h:2434
VkDeviceCreateInfo::pEnabledFeatures
const VkPhysicalDeviceFeatures * pEnabledFeatures
Definition: vulkan.h:1679
VulkanContext::surfaceCapabilities
VkSurfaceCapabilitiesKHR surfaceCapabilities
Definition: testvulkan.c:191
VulkanContext::swapchain
VkSwapchainKHR swapchain
Definition: testvulkan.c:181
done
int done
Definition: checkkeys.c:28
VkExtent2D::width
uint32_t width
Definition: vulkan.h:1995
VkCommandBufferBeginInfo::flags
VkCommandBufferUsageFlags flags
Definition: vulkan.h:2334
VkCommandPoolCreateInfo
Definition: vulkan.h:2305
vkDestroySemaphore
VKAPI_ATTR void VKAPI_CALL vkDestroySemaphore(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks *pAllocator)
SDL_vulkan.h
VkDeviceCreateInfo
Definition: vulkan.h:1669
VkFenceCreateInfo::flags
VkFenceCreateFlags flags
Definition: vulkan.h:1806
VK_QUEUE_FAMILY_IGNORED
#define VK_QUEUE_FAMILY_IGNORED
Definition: vulkan.h:104
VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO
Definition: vulkan.h:197
VkQueueFamilyProperties
Definition: vulkan.h:1635
VkSurfaceCapabilitiesKHR::supportedUsageFlags
VkImageUsageFlags supportedUsageFlags
Definition: vulkan.h:3489
mode
GLenum mode
Definition: SDL_opengl_glext.h:1122
w
GLubyte GLubyte GLubyte GLubyte w
Definition: SDL_opengl_glext.h:731
VkSwapchainCreateInfoKHR::presentMode
VkPresentModeKHR presentMode
Definition: vulkan.h:3563
vulkanContext
static VulkanContext vulkanContext
Definition: testvulkan.c:206
VkImageMemoryBarrier::dstQueueFamilyIndex
uint32_t dstQueueFamilyIndex
Definition: vulkan.h:2438
VK_TRUE
#define VK_TRUE
Definition: vulkan.h:102
VK_STRUCTURE_TYPE_PRESENT_INFO_KHR
Definition: vulkan.h:207
VK_SUCCESS
Definition: vulkan.h:123
VkCommandBufferAllocateInfo::sType
VkStructureType sType
Definition: vulkan.h:2313
VK_API_VERSION_1_0
#define VK_API_VERSION_1_0
Definition: vulkan.h:40
rerecordCommandBuffer
static void rerecordCommandBuffer(uint32_t frameIndex, const VkClearColorValue *clearColor)
Definition: testvulkan.c:912
VkDeviceCreateInfo::enabledExtensionCount
uint32_t enabledExtensionCount
Definition: vulkan.h:1677
VulkanContext::swapchainImageCount
uint32_t swapchainImageCount
Definition: testvulkan.c:199
VkSubmitInfo
Definition: vulkan.h:1694
SDL_LOG_PRIORITY_INFO
Definition: SDL_log.h:106
VkSwapchainCreateInfoKHR::imageSharingMode
VkSharingMode imageSharingMode
Definition: vulkan.h:3558
vkAllocateCommandBuffers
VKAPI_ATTR VkResult VKAPI_CALL vkAllocateCommandBuffers(VkDevice device, const VkCommandBufferAllocateInfo *pAllocateInfo, VkCommandBuffer *pCommandBuffers)
createInstance
static void createInstance(void)
Definition: testvulkan.c:245
VK_TIMEOUT
Definition: vulkan.h:125
destroyCommandBuffers
static void destroyCommandBuffers(void)
Definition: testvulkan.c:767
VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO
Definition: vulkan.h:160
VkCommandBufferAllocateInfo
Definition: vulkan.h:2312
SDLTest_CommonUsage
const char * SDLTest_CommonUsage(SDLTest_CommonState *state)
Returns common usage information.
Definition: SDL_test_common.c:478
VkDeviceCreateInfo::pQueueCreateInfos
const VkDeviceQueueCreateInfo * pQueueCreateInfos
Definition: vulkan.h:1674
quit
static void quit(int rc)
Definition: testvulkan.c:211
VkImageMemoryBarrier::sType
VkStructureType sType
Definition: vulkan.h:2431
VK_ERROR_INITIALIZATION_FAILED
Definition: vulkan.h:131
VulkanContext::imageAvailableSemaphore
VkSemaphore imageAvailableSemaphore
Definition: testvulkan.c:189
getSurfaceCaps
static void getSurfaceCaps(void)
Definition: testvulkan.c:587
SDLTest_CommonState
Definition: SDL_test_common.h:51
destroyFences
static void destroyFences(void)
Definition: testvulkan.c:865
SDL_GetPerformanceCounter
#define SDL_GetPerformanceCounter
Definition: SDL_dynapi_overrides.h:484
SDL_Delay
#define SDL_Delay
Definition: SDL_dynapi_overrides.h:486
VkImageMemoryBarrier::subresourceRange
VkImageSubresourceRange subresourceRange
Definition: vulkan.h:2440
i
return Display return Display Bool Bool int int int return Display XEvent Bool(*) XPointer return Display return Display Drawable _Xconst char unsigned int unsigned int return Display Pixmap Pixmap XColor XColor unsigned int unsigned int return Display _Xconst char char int char return Display Visual unsigned int int int char unsigned int unsigned int in i)
Definition: SDL_x11sym.h:50
VkSubmitInfo::commandBufferCount
uint32_t commandBufferCount
Definition: vulkan.h:1700
SDL_LogSetPriority
#define SDL_LogSetPriority
Definition: SDL_dynapi_overrides.h:236
NULL
#define NULL
Definition: begin_code.h:164
VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO
Definition: vulkan.h:166
VK_ERROR_OUT_OF_DATE_KHR
Definition: vulkan.h:144
VkPresentInfoKHR
Definition: vulkan.h:3568
SDL_OutOfMemory
#define SDL_OutOfMemory()
Definition: SDL_error.h:52
SDL_bool
SDL_bool
Definition: SDL_stdinc.h:139
vkFreeCommandBuffers
VKAPI_ATTR void VKAPI_CALL vkFreeCommandBuffers(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer *pCommandBuffers)
VkImageSubresourceRange::aspectMask
VkImageAspectFlags aspectMask
Definition: vulkan.h:1885
uint32_t
unsigned int uint32_t
Definition: SDL_config_windows.h:63
vkCreateDevice
VKAPI_ATTR VkResult VKAPI_CALL vkCreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDevice *pDevice)
VkDeviceQueueCreateInfo::pQueuePriorities
const float * pQueuePriorities
Definition: vulkan.h:1666
VulkanContext::commandPool
VkCommandPool commandPool
Definition: testvulkan.c:198
getQueues
static void getQueues(void)
Definition: testvulkan.c:549
VkPhysicalDeviceProperties::apiVersion
uint32_t apiVersion
Definition: vulkan.h:1624
VK_QUEUE_GRAPHICS_BIT
Definition: vulkan.h:1080
VkApplicationInfo
Definition: vulkan.h:1369
createFences
static void createFences(void)
Definition: testvulkan.c:830
VK_ERROR_INVALID_SHADER_NV
Definition: vulkan.h:147
VulkanContext::graphicsQueue
VkQueue graphicsQueue
Definition: testvulkan.c:187
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL
Definition: vulkan.h:620
VK_SUBOPTIMAL_KHR
Definition: vulkan.h:143
vkAcquireNextImageKHR
VKAPI_ATTR VkResult VKAPI_CALL vkAcquireNextImageKHR(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t *pImageIndex)
VulkanContext
Definition: testvulkan.c:176
VkInstanceCreateInfo::ppEnabledExtensionNames
const char *const * ppEnabledExtensionNames
Definition: vulkan.h:1387
vkResetFences
VKAPI_ATTR VkResult VKAPI_CALL vkResetFences(VkDevice device, uint32_t fenceCount, const VkFence *pFences)
VkCommandPoolCreateInfo::flags
VkCommandPoolCreateFlags flags
Definition: vulkan.h:2308
VkImageSubresourceRange::baseArrayLayer
uint32_t baseArrayLayer
Definition: vulkan.h:1888
VK_ERROR_TOO_MANY_OBJECTS
Definition: vulkan.h:138
VK_RESULT_MAX_ENUM
Definition: vulkan.h:153
VK_ERROR_LAYER_NOT_PRESENT
Definition: vulkan.h:134
VK_ERROR_OUT_OF_DEVICE_MEMORY
Definition: vulkan.h:130
vkGetPhysicalDeviceSurfaceCapabilitiesKHR
VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR *pSurfaceCapabilities)
SDL_Vulkan_GetVkGetInstanceProcAddr
#define SDL_Vulkan_GetVkGetInstanceProcAddr
Definition: SDL_dynapi_overrides.h:633
vkEnumerateDeviceExtensionProperties
VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, const char *pLayerName, uint32_t *pPropertyCount, VkExtensionProperties *pProperties)
VkCommandPoolCreateInfo::sType
VkStructureType sType
Definition: vulkan.h:2306
VkSurfaceCapabilitiesKHR::maxImageCount
uint32_t maxImageCount
Definition: vulkan.h:3481
vkCmdClearColorImage
VKAPI_ATTR void VKAPI_CALL vkCmdClearColorImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue *pColor, uint32_t rangeCount, const VkImageSubresourceRange *pRanges)
VulkanContext::physicalDeviceFeatures
VkPhysicalDeviceFeatures physicalDeviceFeatures
Definition: testvulkan.c:183
VkSwapchainCreateInfoKHR::imageColorSpace
VkColorSpaceKHR imageColorSpace
Definition: vulkan.h:3554
VK_FALSE
#define VK_FALSE
Definition: vulkan.h:103
VkSubmitInfo::pSignalSemaphores
const VkSemaphore * pSignalSemaphores
Definition: vulkan.h:1703
loadDeviceFunctions
static void loadDeviceFunctions(void)
Definition: testvulkan.c:529
VkPresentInfoKHR::waitSemaphoreCount
uint32_t waitSemaphoreCount
Definition: vulkan.h:3571
createNewSwapchainAndSwapchainSpecificStuff
static SDL_bool createNewSwapchainAndSwapchainSpecificStuff(void)
Definition: testvulkan.c:975
VK_VERSION_MAJOR
#define VK_VERSION_MAJOR(version)
Definition: vulkan.h:42
SDL_arraysize
#define SDL_arraysize(array)
Definition: SDL_stdinc.h:93
SDL_Event
General event structure.
Definition: SDL_events.h:525
SDL_Vulkan_UnloadLibrary
#define SDL_Vulkan_UnloadLibrary
Definition: SDL_dynapi_overrides.h:634
SDL_malloc
#define SDL_malloc
Definition: SDL_dynapi_overrides.h:374
vkWaitForFences
VKAPI_ATTR VkResult VKAPI_CALL vkWaitForFences(VkDevice device, uint32_t fenceCount, const VkFence *pFences, VkBool32 waitAll, uint64_t timeout)
SDL_strcmp
#define SDL_strcmp
Definition: SDL_dynapi_overrides.h:417
VulkanContext::physicalDevice
VkPhysicalDevice physicalDevice
Definition: testvulkan.c:186
VulkanContext::presentQueueFamilyIndex
uint32_t presentQueueFamilyIndex
Definition: testvulkan.c:185
vkDestroySwapchainKHR
VKAPI_ATTR void VKAPI_CALL vkDestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks *pAllocator)
VK_STRUCTURE_TYPE_FENCE_CREATE_INFO
Definition: vulkan.h:165
VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR
Definition: vulkan.h:206
VkImageMemoryBarrier::oldLayout
VkImageLayout oldLayout
Definition: vulkan.h:2435
VkApplicationInfo::sType
VkStructureType sType
Definition: vulkan.h:1370
SDL_DisplayMode::format
Uint32 format
Definition: SDL_video.h:55
VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT
Definition: vulkan.h:1344
VK_ACCESS_MEMORY_READ_BIT
Definition: vulkan.h:1311
VkImageSubresourceRange::levelCount
uint32_t levelCount
Definition: vulkan.h:1887
VkCommandBufferAllocateInfo::commandBufferCount
uint32_t commandBufferCount
Definition: vulkan.h:2317
vkDestroyInstance
VKAPI_ATTR void VKAPI_CALL vkDestroyInstance(VkInstance instance, const VkAllocationCallbacks *pAllocator)
vkCreateCommandPool
VKAPI_ATTR VkResult VKAPI_CALL vkCreateCommandPool(VkDevice device, const VkCommandPoolCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkCommandPool *pCommandPool)
VkSurfaceCapabilitiesKHR::minImageCount
uint32_t minImageCount
Definition: vulkan.h:3480
VkSwapchainCreateInfoKHR::imageExtent
VkExtent2D imageExtent
Definition: vulkan.h:3555
VkCommandPoolCreateInfo::queueFamilyIndex
uint32_t queueFamilyIndex
Definition: vulkan.h:2309
VulkanContext::surfaceFormatsAllocatedCount
uint32_t surfaceFormatsAllocatedCount
Definition: testvulkan.c:193
SDL_GetCurrentDisplayMode
#define SDL_GetCurrentDisplayMode
Definition: SDL_dynapi_overrides.h:508
VK_ERROR_DEVICE_LOST
Definition: vulkan.h:132
VulkanContext::graphicsQueueFamilyIndex
uint32_t graphicsQueueFamilyIndex
Definition: testvulkan.c:184
VkSurfaceCapabilitiesKHR
Definition: vulkan.h:3479
VkImageMemoryBarrier::image
VkImage image
Definition: vulkan.h:2439
SDL_LOG_CATEGORY_APPLICATION
Definition: SDL_log.h:66
VK_ERROR_MEMORY_MAP_FAILED
Definition: vulkan.h:133
VK_ERROR_OUT_OF_HOST_MEMORY
Definition: vulkan.h:129
VK_ERROR_INCOMPATIBLE_DRIVER
Definition: vulkan.h:137
SDL_BITSPERPIXEL
#define SDL_BITSPERPIXEL(X)
Definition: SDL_pixels.h:127
vkResetCommandBuffer
VKAPI_ATTR VkResult VKAPI_CALL vkResetCommandBuffer(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags)
VkExtent2D
Definition: vulkan.h:1994
VkSurfaceFormatKHR
Definition: vulkan.h:3492
VK_RESULT_RANGE_SIZE
Definition: vulkan.h:152
SDLTest_CommonQuit
void SDLTest_CommonQuit(SDLTest_CommonState *state)
Close test window.
Definition: SDL_test_common.c:1751
VkExtent2D::height
uint32_t height
Definition: vulkan.h:1996
VK_ERROR_FEATURE_NOT_PRESENT
Definition: vulkan.h:136
SDL_INIT_VIDEO
#define SDL_INIT_VIDEO
Definition: SDL.h:78
SDL_memset
#define SDL_memset
Definition: SDL_dynapi_overrides.h:386
VkCommandBufferBeginInfo
Definition: vulkan.h:2331
VkSwapchainCreateInfoKHR::minImageCount
uint32_t minImageCount
Definition: vulkan.h:3552
render
static SDL_bool render(void)
Definition: testvulkan.c:1023
createCommandBuffers
static void createCommandBuffers(void)
Definition: testvulkan.c:806
SDL_sin
#define SDL_sin
Definition: SDL_dynapi_overrides.h:435
VkImageSubresourceRange::layerCount
uint32_t layerCount
Definition: vulkan.h:1889
VulkanContext::swapchainImages
VkImage * swapchainImages
Definition: testvulkan.c:200
VkPipelineStageFlags
VkFlags VkPipelineStageFlags
Definition: vulkan.h:1128
createSurface
static void createSurface(void)
Definition: testvulkan.c:311
destroySwapchainAndSwapchainSpecificStuff
static void destroySwapchainAndSwapchainSpecificStuff(SDL_bool doDestroySwapchain)
Definition: testvulkan.c:966
VulkanContext::surfaceFormatsCount
uint32_t surfaceFormatsCount
Definition: testvulkan.c:194