Mercurial Mercurial > SDL / file revision
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
test/testvulkan.c
author Sylvain Becker <sylvain.becker@gmail.com>
Sat, 24 Aug 2019 20:40:37 +0200
changeset 13034 7693573f862d
parent 12732 0280fd2d02ca
permissions -rw-r--r--
Fixed bug 1663 - SDL_EventState(SDL_DOLLARGESTURE,SDL_IGNORE) etc. has no effect 
     1 /*

     2   Copyright (C) 1997-2019 Sam Lantinga <slouken@libsdl.org>

     3 

     4   This software is provided 'as-is', without any express or implied

     5   warranty.  In no event will the authors be held liable for any damages

     6   arising from the use of this software.

     7 

     8   Permission is granted to anyone to use this software for any purpose,

     9   including commercial applications, and to alter it and redistribute it

    10   freely.

    11 */

    12 #include <stdlib.h>

    13 #include <stdio.h>

    14 #include <string.h>

    15 #include <math.h>

    16 

    17 #include "SDL_test_common.h"

    18 

    19 #if defined(__ANDROID__) && defined(__ARM_EABI__) && !defined(__ARM_ARCH_7A__)

    20 

    21 int main(int argc, char *argv[])

    22 {

    23     SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "No Vulkan support on this system\n");

    24     return 1;

    25 }

    26 

    27 #else

    28 

    29 #define VK_NO_PROTOTYPES

    30 #ifdef HAVE_VULKAN_H

    31 #include <vulkan/vulkan.h>

    32 #else

    33 /* SDL includes a copy for building on systems without the Vulkan SDK */

    34 #include "../src/video/khronos/vulkan/vulkan.h"

    35 #endif

    36 #include "SDL_vulkan.h"

    37 

    38 #ifndef UINT64_MAX /* VS2008 */

    39 #define UINT64_MAX 18446744073709551615

    40 #endif

    41 

    42 #define VULKAN_FUNCTIONS()                                              \

    43     VULKAN_DEVICE_FUNCTION(vkAcquireNextImageKHR)                       \

    44     VULKAN_DEVICE_FUNCTION(vkAllocateCommandBuffers)                    \

    45     VULKAN_DEVICE_FUNCTION(vkBeginCommandBuffer)                        \

    46     VULKAN_DEVICE_FUNCTION(vkCmdClearColorImage)                        \

    47     VULKAN_DEVICE_FUNCTION(vkCmdPipelineBarrier)                        \

    48     VULKAN_DEVICE_FUNCTION(vkCreateCommandPool)                         \

    49     VULKAN_DEVICE_FUNCTION(vkCreateFence)                               \

    50     VULKAN_DEVICE_FUNCTION(vkCreateImageView)                           \

    51     VULKAN_DEVICE_FUNCTION(vkCreateSemaphore)                           \

    52     VULKAN_DEVICE_FUNCTION(vkCreateSwapchainKHR)                        \

    53     VULKAN_DEVICE_FUNCTION(vkDestroyCommandPool)                        \

    54     VULKAN_DEVICE_FUNCTION(vkDestroyDevice)                             \

    55     VULKAN_DEVICE_FUNCTION(vkDestroyFence)                              \

    56     VULKAN_DEVICE_FUNCTION(vkDestroyImageView)                          \

    57     VULKAN_DEVICE_FUNCTION(vkDestroySemaphore)                          \

    58     VULKAN_DEVICE_FUNCTION(vkDestroySwapchainKHR)                       \

    59     VULKAN_DEVICE_FUNCTION(vkDeviceWaitIdle)                            \

    60     VULKAN_DEVICE_FUNCTION(vkEndCommandBuffer)                          \

    61     VULKAN_DEVICE_FUNCTION(vkFreeCommandBuffers)                        \

    62     VULKAN_DEVICE_FUNCTION(vkGetDeviceQueue)                            \

    63     VULKAN_DEVICE_FUNCTION(vkGetFenceStatus)                            \

    64     VULKAN_DEVICE_FUNCTION(vkGetSwapchainImagesKHR)                     \

    65     VULKAN_DEVICE_FUNCTION(vkQueuePresentKHR)                           \

    66     VULKAN_DEVICE_FUNCTION(vkQueueSubmit)                               \

    67     VULKAN_DEVICE_FUNCTION(vkResetCommandBuffer)                        \

    68     VULKAN_DEVICE_FUNCTION(vkResetFences)                               \

    69     VULKAN_DEVICE_FUNCTION(vkWaitForFences)                             \

    70     VULKAN_GLOBAL_FUNCTION(vkCreateInstance)                            \

    71     VULKAN_GLOBAL_FUNCTION(vkEnumerateInstanceExtensionProperties)      \

    72     VULKAN_GLOBAL_FUNCTION(vkEnumerateInstanceLayerProperties)          \

    73     VULKAN_INSTANCE_FUNCTION(vkCreateDevice)                            \

    74     VULKAN_INSTANCE_FUNCTION(vkDestroyInstance)                         \

    75     VULKAN_INSTANCE_FUNCTION(vkDestroySurfaceKHR)                       \

    76     VULKAN_INSTANCE_FUNCTION(vkEnumerateDeviceExtensionProperties)      \

    77     VULKAN_INSTANCE_FUNCTION(vkEnumeratePhysicalDevices)                \

    78     VULKAN_INSTANCE_FUNCTION(vkGetDeviceProcAddr)                       \

    79     VULKAN_INSTANCE_FUNCTION(vkGetPhysicalDeviceFeatures)               \

    80     VULKAN_INSTANCE_FUNCTION(vkGetPhysicalDeviceProperties)             \

    81     VULKAN_INSTANCE_FUNCTION(vkGetPhysicalDeviceQueueFamilyProperties)  \

    82     VULKAN_INSTANCE_FUNCTION(vkGetPhysicalDeviceSurfaceCapabilitiesKHR) \

    83     VULKAN_INSTANCE_FUNCTION(vkGetPhysicalDeviceSurfaceFormatsKHR)      \

    84     VULKAN_INSTANCE_FUNCTION(vkGetPhysicalDeviceSurfacePresentModesKHR) \

    85     VULKAN_INSTANCE_FUNCTION(vkGetPhysicalDeviceSurfaceSupportKHR)

    86 

    87 #define VULKAN_DEVICE_FUNCTION(name) static PFN_##name name = NULL;

    88 #define VULKAN_GLOBAL_FUNCTION(name) static PFN_##name name = NULL;

    89 #define VULKAN_INSTANCE_FUNCTION(name) static PFN_##name name = NULL;

    90 VULKAN_FUNCTIONS()

    91 #undef VULKAN_DEVICE_FUNCTION

    92 #undef VULKAN_GLOBAL_FUNCTION

    93 #undef VULKAN_INSTANCE_FUNCTION

    94 static PFN_vkGetInstanceProcAddr vkGetInstanceProcAddr = NULL;

    95 

    96 /* Based on the headers found in

    97  * https://github.com/KhronosGroup/Vulkan-LoaderAndValidationLayers

    98  */

    99 #if VK_HEADER_VERSION < 22

   100 enum

   101 {

   102     VK_ERROR_FRAGMENTED_POOL = -12,

   103 };

   104 #endif

   105 #if VK_HEADER_VERSION < 38

   106 enum {

   107     VK_ERROR_OUT_OF_POOL_MEMORY_KHR = -1000069000

   108 };

   109 #endif

   110 

   111 static const char *getVulkanResultString(VkResult result)

   112 {

   113     switch((int)result)

   114     {

   115     case VK_SUCCESS:

   116         return "VK_SUCCESS";

   117     case VK_NOT_READY:

   118         return "VK_NOT_READY";

   119     case VK_TIMEOUT:

   120         return "VK_TIMEOUT";

   121     case VK_EVENT_SET:

   122         return "VK_EVENT_SET";

   123     case VK_EVENT_RESET:

   124         return "VK_EVENT_RESET";

   125     case VK_INCOMPLETE:

   126         return "VK_INCOMPLETE";

   127     case VK_ERROR_OUT_OF_HOST_MEMORY:

   128         return "VK_ERROR_OUT_OF_HOST_MEMORY";

   129     case VK_ERROR_OUT_OF_DEVICE_MEMORY:

   130         return "VK_ERROR_OUT_OF_DEVICE_MEMORY";

   131     case VK_ERROR_INITIALIZATION_FAILED:

   132         return "VK_ERROR_INITIALIZATION_FAILED";

   133     case VK_ERROR_DEVICE_LOST:

   134         return "VK_ERROR_DEVICE_LOST";

   135     case VK_ERROR_MEMORY_MAP_FAILED:

   136         return "VK_ERROR_MEMORY_MAP_FAILED";

   137     case VK_ERROR_LAYER_NOT_PRESENT:

   138         return "VK_ERROR_LAYER_NOT_PRESENT";

   139     case VK_ERROR_EXTENSION_NOT_PRESENT:

   140         return "VK_ERROR_EXTENSION_NOT_PRESENT";

   141     case VK_ERROR_FEATURE_NOT_PRESENT:

   142         return "VK_ERROR_FEATURE_NOT_PRESENT";

   143     case VK_ERROR_INCOMPATIBLE_DRIVER:

   144         return "VK_ERROR_INCOMPATIBLE_DRIVER";

   145     case VK_ERROR_TOO_MANY_OBJECTS:

   146         return "VK_ERROR_TOO_MANY_OBJECTS";

   147     case VK_ERROR_FORMAT_NOT_SUPPORTED:

   148         return "VK_ERROR_FORMAT_NOT_SUPPORTED";

   149     case VK_ERROR_FRAGMENTED_POOL:

   150         return "VK_ERROR_FRAGMENTED_POOL";

   151     case VK_ERROR_SURFACE_LOST_KHR:

   152         return "VK_ERROR_SURFACE_LOST_KHR";

   153     case VK_ERROR_NATIVE_WINDOW_IN_USE_KHR:

   154         return "VK_ERROR_NATIVE_WINDOW_IN_USE_KHR";

   155     case VK_SUBOPTIMAL_KHR:

   156         return "VK_SUBOPTIMAL_KHR";

   157     case VK_ERROR_OUT_OF_DATE_KHR:

   158         return "VK_ERROR_OUT_OF_DATE_KHR";

   159     case VK_ERROR_INCOMPATIBLE_DISPLAY_KHR:

   160         return "VK_ERROR_INCOMPATIBLE_DISPLAY_KHR";

   161     case VK_ERROR_VALIDATION_FAILED_EXT:

   162         return "VK_ERROR_VALIDATION_FAILED_EXT";

   163     case VK_ERROR_OUT_OF_POOL_MEMORY_KHR:

   164         return "VK_ERROR_OUT_OF_POOL_MEMORY_KHR";

   165     case VK_ERROR_INVALID_SHADER_NV:

   166         return "VK_ERROR_INVALID_SHADER_NV";

   167     case VK_RESULT_MAX_ENUM:

   168     case VK_RESULT_RANGE_SIZE:

   169         break;

   170     }

   171     if(result < 0)

   172         return "VK_ERROR_<Unknown>";

   173     return "VK_<Unknown>";

   174 }

   175 

   176 typedef struct VulkanContext

   177 {

   178     VkInstance instance;

   179     VkDevice device;

   180     VkSurfaceKHR surface;

   181     VkSwapchainKHR swapchain;

   182     VkPhysicalDeviceProperties physicalDeviceProperties;

   183     VkPhysicalDeviceFeatures physicalDeviceFeatures;

   184     uint32_t graphicsQueueFamilyIndex;

   185     uint32_t presentQueueFamilyIndex;

   186     VkPhysicalDevice physicalDevice;

   187     VkQueue graphicsQueue;

   188     VkQueue presentQueue;

   189     VkSemaphore imageAvailableSemaphore;

   190     VkSemaphore renderingFinishedSemaphore;

   191     VkSurfaceCapabilitiesKHR surfaceCapabilities;

   192     VkSurfaceFormatKHR *surfaceFormats;

   193     uint32_t surfaceFormatsAllocatedCount;

   194     uint32_t surfaceFormatsCount;

   195     uint32_t swapchainDesiredImageCount;

   196     VkSurfaceFormatKHR surfaceFormat;

   197     VkExtent2D swapchainSize;

   198     VkCommandPool commandPool;

   199     uint32_t swapchainImageCount;

   200     VkImage *swapchainImages;

   201     VkCommandBuffer *commandBuffers;

   202     VkFence *fences;

   203 } VulkanContext;

   204 

   205 static SDLTest_CommonState *state;

   206 static VulkanContext vulkanContext = {0};

   207 

   208 static void shutdownVulkan(void);

   209 

   210 /* Call this instead of exit(), so we can clean up SDL: atexit() is evil. */

   211 static void quit(int rc)

   212 {

   213     shutdownVulkan();

   214     SDLTest_CommonQuit(state);

   215     exit(rc);

   216 }

   217 

   218 static void loadGlobalFunctions(void)

   219 {

   220     vkGetInstanceProcAddr = SDL_Vulkan_GetVkGetInstanceProcAddr();

   221     if(!vkGetInstanceProcAddr)

   222     {

   223         SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,

   224                      "SDL_Vulkan_GetVkGetInstanceProcAddr(): %s\n",

   225                      SDL_GetError());

   226         quit(2);

   227     }

   228 

   229 #define VULKAN_DEVICE_FUNCTION(name)

   230 #define VULKAN_GLOBAL_FUNCTION(name)                                                   \

   231     name = (PFN_##name)vkGetInstanceProcAddr(VK_NULL_HANDLE, #name);                   \

   232     if(!name)                                                                          \

   233     {                                                                                  \

   234         SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,                                     \

   235                      "vkGetInstanceProcAddr(VK_NULL_HANDLE, \"" #name "\") failed\n"); \

   236         quit(2);                                                                       \

   237     }

   238 #define VULKAN_INSTANCE_FUNCTION(name)

   239     VULKAN_FUNCTIONS()

   240 #undef VULKAN_DEVICE_FUNCTION

   241 #undef VULKAN_GLOBAL_FUNCTION

   242 #undef VULKAN_INSTANCE_FUNCTION

   243 }

   244 

   245 static void createInstance(void)

   246 {

   247     VkApplicationInfo appInfo = {0};

   248     VkInstanceCreateInfo instanceCreateInfo = {0};

   249     const char **extensions = NULL;

   250     unsigned extensionCount = 0;

   251 	VkResult result;

   252 

   253 

   254 	appInfo.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;

   255     appInfo.apiVersion = VK_API_VERSION_1_0;

   256     instanceCreateInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;

   257     instanceCreateInfo.pApplicationInfo = &appInfo;

   258     if(!SDL_Vulkan_GetInstanceExtensions(NULL, &extensionCount, NULL))

   259     {

   260         SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,

   261                      "SDL_Vulkan_GetInstanceExtensions(): %s\n",

   262                      SDL_GetError());

   263         quit(2);

   264     }

   265     extensions = SDL_malloc(sizeof(const char *) * extensionCount);

   266     if(!extensions)

   267     {

   268         SDL_OutOfMemory();

   269         quit(2);

   270     }

   271     if(!SDL_Vulkan_GetInstanceExtensions(NULL, &extensionCount, extensions))

   272     {

   273         SDL_free((void*)extensions);

   274         SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,

   275                      "SDL_Vulkan_GetInstanceExtensions(): %s\n",

   276                      SDL_GetError());

   277         quit(2);

   278     }

   279     instanceCreateInfo.enabledExtensionCount = extensionCount;

   280     instanceCreateInfo.ppEnabledExtensionNames = extensions;

   281     result = vkCreateInstance(&instanceCreateInfo, NULL, &vulkanContext.instance);

   282     SDL_free((void*)extensions);

   283     if(result != VK_SUCCESS)

   284     {

   285         vulkanContext.instance = VK_NULL_HANDLE;

   286         SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,

   287                      "vkCreateInstance(): %s\n",

   288                      getVulkanResultString(result));

   289         quit(2);

   290     }

   291 }

   292 

   293 static void loadInstanceFunctions(void)

   294 {

   295 #define VULKAN_DEVICE_FUNCTION(name)

   296 #define VULKAN_GLOBAL_FUNCTION(name)

   297 #define VULKAN_INSTANCE_FUNCTION(name)                                           \

   298     name = (PFN_##name)vkGetInstanceProcAddr(vulkanContext.instance, #name);     \

   299     if(!name)                                                                    \

   300     {                                                                            \

   301         SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,                               \

   302                      "vkGetInstanceProcAddr(instance, \"" #name "\") failed\n"); \

   303         quit(2);                                                                 \

   304     }

   305     VULKAN_FUNCTIONS()

   306 #undef VULKAN_DEVICE_FUNCTION

   307 #undef VULKAN_GLOBAL_FUNCTION

   308 #undef VULKAN_INSTANCE_FUNCTION

   309 }

   310 

   311 static void createSurface(void)

   312 {

   313     if(!SDL_Vulkan_CreateSurface(state->windows[0],

   314                                  vulkanContext.instance,

   315                                  &vulkanContext.surface))

   316     {

   317         vulkanContext.surface = VK_NULL_HANDLE;

   318         SDL_LogError(

   319             SDL_LOG_CATEGORY_APPLICATION, "SDL_Vulkan_CreateSurface(): %s\n", SDL_GetError());

   320         quit(2);

   321     }

   322 }

   323 

   324 static void findPhysicalDevice(void)

   325 {

   326     uint32_t physicalDeviceCount = 0;

   327 	VkPhysicalDevice *physicalDevices;

   328 	VkQueueFamilyProperties *queueFamiliesProperties = NULL;

   329     uint32_t queueFamiliesPropertiesAllocatedSize = 0;

   330     VkExtensionProperties *deviceExtensions = NULL;

   331     uint32_t deviceExtensionsAllocatedSize = 0;

   332 	uint32_t physicalDeviceIndex;

   333 

   334     VkResult result =

   335         vkEnumeratePhysicalDevices(vulkanContext.instance, &physicalDeviceCount, NULL);

   336     if(result != VK_SUCCESS)

   337     {

   338         SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,

   339                      "vkEnumeratePhysicalDevices(): %s\n",

   340                      getVulkanResultString(result));

   341         quit(2);

   342     }

   343     if(physicalDeviceCount == 0)

   344     {

   345         SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,

   346                      "vkEnumeratePhysicalDevices(): no physical devices\n");

   347         quit(2);

   348     }

   349     physicalDevices = SDL_malloc(sizeof(VkPhysicalDevice) * physicalDeviceCount);

   350     if(!physicalDevices)

   351     {

   352         SDL_OutOfMemory();

   353         quit(2);

   354     }

   355     result =

   356         vkEnumeratePhysicalDevices(vulkanContext.instance, &physicalDeviceCount, physicalDevices);

   357     if(result != VK_SUCCESS)

   358     {

   359         SDL_free(physicalDevices);

   360         SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,

   361                      "vkEnumeratePhysicalDevices(): %s\n",

   362                      getVulkanResultString(result));

   363         quit(2);

   364     }

   365     vulkanContext.physicalDevice = NULL;

   366     for(physicalDeviceIndex = 0; physicalDeviceIndex < physicalDeviceCount;

   367         physicalDeviceIndex++)

   368     {

   369         uint32_t queueFamiliesCount = 0;

   370 		uint32_t queueFamilyIndex;

   371         uint32_t deviceExtensionCount = 0;

   372 		SDL_bool hasSwapchainExtension = SDL_FALSE;

   373 		uint32_t i;

   374 

   375 

   376 		VkPhysicalDevice physicalDevice = physicalDevices[physicalDeviceIndex];

   377         vkGetPhysicalDeviceProperties(physicalDevice, &vulkanContext.physicalDeviceProperties);

   378         if(VK_VERSION_MAJOR(vulkanContext.physicalDeviceProperties.apiVersion) < 1)

   379             continue;

   380         vkGetPhysicalDeviceFeatures(physicalDevice, &vulkanContext.physicalDeviceFeatures);

   381         vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice, &queueFamiliesCount, NULL);

   382         if(queueFamiliesCount == 0)

   383             continue;

   384         if(queueFamiliesPropertiesAllocatedSize < queueFamiliesCount)

   385         {

   386             SDL_free(queueFamiliesProperties);

   387             queueFamiliesPropertiesAllocatedSize = queueFamiliesCount;

   388             queueFamiliesProperties =

   389                 SDL_malloc(sizeof(VkQueueFamilyProperties) * queueFamiliesPropertiesAllocatedSize);

   390             if(!queueFamiliesProperties)

   391             {

   392                 SDL_free(physicalDevices);

   393                 SDL_free(deviceExtensions);

   394                 SDL_OutOfMemory();

   395                 quit(2);

   396             }

   397         }

   398         vkGetPhysicalDeviceQueueFamilyProperties(

   399             physicalDevice, &queueFamiliesCount, queueFamiliesProperties);

   400         vulkanContext.graphicsQueueFamilyIndex = queueFamiliesCount;

   401         vulkanContext.presentQueueFamilyIndex = queueFamiliesCount;

   402         for(queueFamilyIndex = 0; queueFamilyIndex < queueFamiliesCount;

   403             queueFamilyIndex++)

   404         {

   405             VkBool32 supported = 0;

   406 

   407 			if(queueFamiliesProperties[queueFamilyIndex].queueCount == 0)

   408                 continue;

   409             if(queueFamiliesProperties[queueFamilyIndex].queueFlags & VK_QUEUE_GRAPHICS_BIT)

   410                 vulkanContext.graphicsQueueFamilyIndex = queueFamilyIndex;

   411             result = vkGetPhysicalDeviceSurfaceSupportKHR(

   412                 physicalDevice, queueFamilyIndex, vulkanContext.surface, &supported);

   413             if(result != VK_SUCCESS)

   414             {

   415                 SDL_free(physicalDevices);

   416                 SDL_free(queueFamiliesProperties);

   417                 SDL_free(deviceExtensions);

   418                 SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,

   419                              "vkGetPhysicalDeviceSurfaceSupportKHR(): %s\n",

   420                              getVulkanResultString(result));

   421                 quit(2);

   422             }

   423             if(supported)

   424             {

   425                 vulkanContext.presentQueueFamilyIndex = queueFamilyIndex;

   426                 if(queueFamiliesProperties[queueFamilyIndex].queueFlags & VK_QUEUE_GRAPHICS_BIT)

   427                     break; // use this queue because it can present and do graphics

   428             }

   429         }

   430         if(vulkanContext.graphicsQueueFamilyIndex == queueFamiliesCount) // no good queues found

   431             continue;

   432         if(vulkanContext.presentQueueFamilyIndex == queueFamiliesCount) // no good queues found

   433             continue;

   434         result =

   435             vkEnumerateDeviceExtensionProperties(physicalDevice, NULL, &deviceExtensionCount, NULL);

   436         if(result != VK_SUCCESS)

   437         {

   438             SDL_free(physicalDevices);

   439             SDL_free(queueFamiliesProperties);

   440             SDL_free(deviceExtensions);

   441             SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,

   442                          "vkEnumerateDeviceExtensionProperties(): %s\n",

   443                          getVulkanResultString(result));

   444             quit(2);

   445         }

   446         if(deviceExtensionCount == 0)

   447             continue;

   448         if(deviceExtensionsAllocatedSize < deviceExtensionCount)

   449         {

   450             SDL_free(deviceExtensions);

   451             deviceExtensionsAllocatedSize = deviceExtensionCount;

   452             deviceExtensions =

   453                 SDL_malloc(sizeof(VkExtensionProperties) * deviceExtensionsAllocatedSize);

   454             if(!deviceExtensions)

   455             {

   456                 SDL_free(physicalDevices);

   457                 SDL_free(queueFamiliesProperties);

   458                 SDL_OutOfMemory();

   459                 quit(2);

   460             }

   461         }

   462         result = vkEnumerateDeviceExtensionProperties(

   463             physicalDevice, NULL, &deviceExtensionCount, deviceExtensions);

   464         if(result != VK_SUCCESS)

   465         {

   466             SDL_free(physicalDevices);

   467             SDL_free(queueFamiliesProperties);

   468             SDL_free(deviceExtensions);

   469             SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,

   470                          "vkEnumerateDeviceExtensionProperties(): %s\n",

   471                          getVulkanResultString(result));

   472             quit(2);

   473         }

   474         for(i = 0; i < deviceExtensionCount; i++)

   475         {

   476             if(0 == SDL_strcmp(deviceExtensions[i].extensionName, VK_KHR_SWAPCHAIN_EXTENSION_NAME))

   477             {

   478                 hasSwapchainExtension = SDL_TRUE;

   479                 break;

   480             }

   481         }

   482         if(!hasSwapchainExtension)

   483             continue;

   484         vulkanContext.physicalDevice = physicalDevice;

   485         break;

   486     }

   487     SDL_free(physicalDevices);

   488     SDL_free(queueFamiliesProperties);

   489     SDL_free(deviceExtensions);

   490     if(!vulkanContext.physicalDevice)

   491     {

   492         SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Vulkan: no viable physical devices found");

   493         quit(2);

   494     }

   495 }

   496 

   497 static void createDevice(void)

   498 {

   499     VkDeviceQueueCreateInfo deviceQueueCreateInfo[1] = {0};

   500     static const float queuePriority[] = {1.0f};

   501     VkDeviceCreateInfo deviceCreateInfo = {0};

   502     static const char *const deviceExtensionNames[] = {

   503         VK_KHR_SWAPCHAIN_EXTENSION_NAME,

   504     };

   505 	VkResult result;

   506 

   507 	deviceQueueCreateInfo->sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;

   508     deviceQueueCreateInfo->queueFamilyIndex = vulkanContext.graphicsQueueFamilyIndex;

   509     deviceQueueCreateInfo->queueCount = 1;

   510     deviceQueueCreateInfo->pQueuePriorities = &queuePriority[0];

   511 

   512     deviceCreateInfo.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;

   513     deviceCreateInfo.queueCreateInfoCount = 1;

   514     deviceCreateInfo.pQueueCreateInfos = deviceQueueCreateInfo;

   515     deviceCreateInfo.pEnabledFeatures = NULL;

   516     deviceCreateInfo.enabledExtensionCount = SDL_arraysize(deviceExtensionNames);

   517     deviceCreateInfo.ppEnabledExtensionNames = deviceExtensionNames;

   518     result = vkCreateDevice(

   519         vulkanContext.physicalDevice, &deviceCreateInfo, NULL, &vulkanContext.device);

   520     if(result != VK_SUCCESS)

   521     {

   522         vulkanContext.device = VK_NULL_HANDLE;

   523         SDL_LogError(

   524             SDL_LOG_CATEGORY_APPLICATION, "vkCreateDevice(): %s\n", getVulkanResultString(result));

   525         quit(2);

   526     }

   527 }

   528 

   529 static void loadDeviceFunctions(void)

   530 {

   531 #define VULKAN_DEVICE_FUNCTION(name)                                         \

   532     name = (PFN_##name)vkGetDeviceProcAddr(vulkanContext.device, #name);     \

   533     if(!name)                                                                \

   534     {                                                                        \

   535         SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,                           \

   536                      "vkGetDeviceProcAddr(device, \"" #name "\") failed\n"); \

   537         quit(2);                                                             \

   538     }

   539 #define VULKAN_GLOBAL_FUNCTION(name)

   540 #define VULKAN_INSTANCE_FUNCTION(name)

   541     VULKAN_FUNCTIONS()

   542 #undef VULKAN_DEVICE_FUNCTION

   543 #undef VULKAN_GLOBAL_FUNCTION

   544 #undef VULKAN_INSTANCE_FUNCTION

   545 }

   546 

   547 #undef VULKAN_FUNCTIONS

   548 

   549 static void getQueues(void)

   550 {

   551     vkGetDeviceQueue(vulkanContext.device,

   552                      vulkanContext.graphicsQueueFamilyIndex,

   553                      0,

   554                      &vulkanContext.graphicsQueue);

   555     if(vulkanContext.graphicsQueueFamilyIndex != vulkanContext.presentQueueFamilyIndex)

   556         vkGetDeviceQueue(vulkanContext.device,

   557                          vulkanContext.presentQueueFamilyIndex,

   558                          0,

   559                          &vulkanContext.presentQueue);

   560     else

   561         vulkanContext.presentQueue = vulkanContext.graphicsQueue;

   562 }

   563 

   564 static void createSemaphore(VkSemaphore *semaphore)

   565 {

   566 	VkResult result;

   567 

   568     VkSemaphoreCreateInfo createInfo = {0};

   569     createInfo.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO;

   570     result = vkCreateSemaphore(vulkanContext.device, &createInfo, NULL, semaphore);

   571     if(result != VK_SUCCESS)

   572     {

   573         *semaphore = VK_NULL_HANDLE;

   574         SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,

   575                      "vkCreateSemaphore(): %s\n",

   576                      getVulkanResultString(result));

   577         quit(2);

   578     }

   579 }

   580 

   581 static void createSemaphores(void)

   582 {

   583     createSemaphore(&vulkanContext.imageAvailableSemaphore);

   584     createSemaphore(&vulkanContext.renderingFinishedSemaphore);

   585 }

   586 

   587 static void getSurfaceCaps(void)

   588 {

   589     VkResult result = vkGetPhysicalDeviceSurfaceCapabilitiesKHR(

   590         vulkanContext.physicalDevice, vulkanContext.surface, &vulkanContext.surfaceCapabilities);

   591     if(result != VK_SUCCESS)

   592     {

   593         SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,

   594                      "vkGetPhysicalDeviceSurfaceCapabilitiesKHR(): %s\n",

   595                      getVulkanResultString(result));

   596         quit(2);

   597     }

   598 

   599     // check surface usage

   600     if(!(vulkanContext.surfaceCapabilities.supportedUsageFlags & VK_IMAGE_USAGE_TRANSFER_DST_BIT))

   601     {

   602         SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,

   603                      "Vulkan surface doesn't support VK_IMAGE_USAGE_TRANSFER_DST_BIT\n");

   604         quit(2);

   605     }

   606 }

   607 

   608 static void getSurfaceFormats(void)

   609 {

   610     VkResult result = vkGetPhysicalDeviceSurfaceFormatsKHR(vulkanContext.physicalDevice,

   611                                                            vulkanContext.surface,

   612                                                            &vulkanContext.surfaceFormatsCount,

   613                                                            NULL);

   614     if(result != VK_SUCCESS)

   615     {

   616         vulkanContext.surfaceFormatsCount = 0;

   617         SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,

   618                      "vkGetPhysicalDeviceSurfaceFormatsKHR(): %s\n",

   619                      getVulkanResultString(result));

   620         quit(2);

   621     }

   622     if(vulkanContext.surfaceFormatsCount > vulkanContext.surfaceFormatsAllocatedCount)

   623     {

   624         vulkanContext.surfaceFormatsAllocatedCount = vulkanContext.surfaceFormatsCount;

   625         SDL_free(vulkanContext.surfaceFormats);

   626         vulkanContext.surfaceFormats =

   627             SDL_malloc(sizeof(VkSurfaceFormatKHR) * vulkanContext.surfaceFormatsAllocatedCount);

   628         if(!vulkanContext.surfaceFormats)

   629         {

   630             vulkanContext.surfaceFormatsCount = 0;

   631             SDL_OutOfMemory();

   632             quit(2);

   633         }

   634     }

   635     result = vkGetPhysicalDeviceSurfaceFormatsKHR(vulkanContext.physicalDevice,

   636                                                   vulkanContext.surface,

   637                                                   &vulkanContext.surfaceFormatsCount,

   638                                                   vulkanContext.surfaceFormats);

   639     if(result != VK_SUCCESS)

   640     {

   641         vulkanContext.surfaceFormatsCount = 0;

   642         SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,

   643                      "vkGetPhysicalDeviceSurfaceFormatsKHR(): %s\n",

   644                      getVulkanResultString(result));

   645         quit(2);

   646     }

   647 }

   648 

   649 static void getSwapchainImages(void)

   650 {

   651 	VkResult result;

   652 

   653     SDL_free(vulkanContext.swapchainImages);

   654     vulkanContext.swapchainImages = NULL;

   655     result = vkGetSwapchainImagesKHR(

   656         vulkanContext.device, vulkanContext.swapchain, &vulkanContext.swapchainImageCount, NULL);

   657     if(result != VK_SUCCESS)

   658     {

   659         vulkanContext.swapchainImageCount = 0;

   660         SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,

   661                      "vkGetSwapchainImagesKHR(): %s\n",

   662                      getVulkanResultString(result));

   663         quit(2);

   664     }

   665     vulkanContext.swapchainImages = SDL_malloc(sizeof(VkImage) * vulkanContext.swapchainImageCount);

   666     if(!vulkanContext.swapchainImages)

   667     {

   668         SDL_OutOfMemory();

   669         quit(2);

   670     }

   671     result = vkGetSwapchainImagesKHR(vulkanContext.device,

   672                                      vulkanContext.swapchain,

   673                                      &vulkanContext.swapchainImageCount,

   674                                      vulkanContext.swapchainImages);

   675     if(result != VK_SUCCESS)

   676     {

   677         SDL_free(vulkanContext.swapchainImages);

   678         vulkanContext.swapchainImages = NULL;

   679         vulkanContext.swapchainImageCount = 0;

   680         SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,

   681                      "vkGetSwapchainImagesKHR(): %s\n",

   682                      getVulkanResultString(result));

   683         quit(2);

   684     }

   685 }

   686 

   687 static SDL_bool createSwapchain(void)

   688 {

   689 	uint32_t i;

   690 	int w, h;

   691 	VkSwapchainCreateInfoKHR createInfo = {0};

   692 	VkResult result;

   693 

   694     // pick an image count

   695     vulkanContext.swapchainDesiredImageCount = vulkanContext.surfaceCapabilities.minImageCount + 1;

   696     if(vulkanContext.swapchainDesiredImageCount > vulkanContext.surfaceCapabilities.maxImageCount

   697        && vulkanContext.surfaceCapabilities.maxImageCount > 0)

   698         vulkanContext.swapchainDesiredImageCount = vulkanContext.surfaceCapabilities.maxImageCount;

   699 

   700     // pick a format

   701     if(vulkanContext.surfaceFormatsCount == 1

   702        && vulkanContext.surfaceFormats[0].format == VK_FORMAT_UNDEFINED)

   703     {

   704         // aren't any preferred formats, so we pick

   705         vulkanContext.surfaceFormat.colorSpace = VK_COLORSPACE_SRGB_NONLINEAR_KHR;

   706         vulkanContext.surfaceFormat.format = VK_FORMAT_R8G8B8A8_UNORM;

   707     }

   708     else

   709     {

   710         vulkanContext.surfaceFormat = vulkanContext.surfaceFormats[0];

   711         for(i = 0; i < vulkanContext.surfaceFormatsCount; i++)

   712         {

   713             if(vulkanContext.surfaceFormats[i].format == VK_FORMAT_R8G8B8A8_UNORM)

   714             {

   715                 vulkanContext.surfaceFormat = vulkanContext.surfaceFormats[i];

   716                 break;

   717             }

   718         }

   719     }

   720 

   721     // get size

   722     SDL_Vulkan_GetDrawableSize(state->windows[0], &w, &h);

   723     vulkanContext.swapchainSize.width = w;

   724     vulkanContext.swapchainSize.height = h;

   725     if(w == 0 || h == 0)

   726         return SDL_FALSE;

   727 

   728     createInfo.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR;

   729     createInfo.surface = vulkanContext.surface;

   730     createInfo.minImageCount = vulkanContext.swapchainDesiredImageCount;

   731     createInfo.imageFormat = vulkanContext.surfaceFormat.format;

   732     createInfo.imageColorSpace = vulkanContext.surfaceFormat.colorSpace;

   733     createInfo.imageExtent = vulkanContext.swapchainSize;

   734     createInfo.imageArrayLayers = 1;

   735     createInfo.imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;

   736     createInfo.imageSharingMode = VK_SHARING_MODE_EXCLUSIVE;

   737     createInfo.preTransform = vulkanContext.surfaceCapabilities.currentTransform;

   738     createInfo.compositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR;

   739     createInfo.presentMode = VK_PRESENT_MODE_FIFO_KHR;

   740     createInfo.clipped = VK_TRUE;

   741     createInfo.oldSwapchain = vulkanContext.swapchain;

   742     result =

   743         vkCreateSwapchainKHR(vulkanContext.device, &createInfo, NULL, &vulkanContext.swapchain);

   744     if(createInfo.oldSwapchain)

   745         vkDestroySwapchainKHR(vulkanContext.device, createInfo.oldSwapchain, NULL);

   746     if(result != VK_SUCCESS)

   747     {

   748         vulkanContext.swapchain = VK_NULL_HANDLE;

   749         SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,

   750                      "vkCreateSwapchainKHR(): %s\n",

   751                      getVulkanResultString(result));

   752         quit(2);

   753     }

   754     getSwapchainImages();

   755     return SDL_TRUE;

   756 }

   757 

   758 static void destroySwapchain(void)

   759 {

   760     if(vulkanContext.swapchain)

   761         vkDestroySwapchainKHR(vulkanContext.device, vulkanContext.swapchain, NULL);

   762     vulkanContext.swapchain = VK_NULL_HANDLE;

   763     SDL_free(vulkanContext.swapchainImages);

   764     vulkanContext.swapchainImages = NULL;

   765 }

   766 

   767 static void destroyCommandBuffers(void)

   768 {

   769     if(vulkanContext.commandBuffers)

   770         vkFreeCommandBuffers(vulkanContext.device,

   771                              vulkanContext.commandPool,

   772                              vulkanContext.swapchainImageCount,

   773                              vulkanContext.commandBuffers);

   774     SDL_free(vulkanContext.commandBuffers);

   775     vulkanContext.commandBuffers = NULL;

   776 }

   777 

   778 static void destroyCommandPool(void)

   779 {

   780     if(vulkanContext.commandPool)

   781         vkDestroyCommandPool(vulkanContext.device, vulkanContext.commandPool, NULL);

   782     vulkanContext.commandPool = VK_NULL_HANDLE;

   783 }

   784 

   785 static void createCommandPool(void)

   786 {

   787 	VkResult result;

   788 

   789     VkCommandPoolCreateInfo createInfo = {0};

   790     createInfo.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;

   791     createInfo.flags =

   792         VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT | VK_COMMAND_POOL_CREATE_TRANSIENT_BIT;

   793     createInfo.queueFamilyIndex = vulkanContext.graphicsQueueFamilyIndex;

   794     result =

   795         vkCreateCommandPool(vulkanContext.device, &createInfo, NULL, &vulkanContext.commandPool);

   796     if(result != VK_SUCCESS)

   797     {

   798         vulkanContext.commandPool = VK_NULL_HANDLE;

   799         SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,

   800                      "vkCreateCommandPool(): %s\n",

   801                      getVulkanResultString(result));

   802         quit(2);

   803     }

   804 }

   805 

   806 static void createCommandBuffers(void)

   807 {

   808 	VkResult result;

   809 

   810     VkCommandBufferAllocateInfo allocateInfo = {0};

   811     allocateInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;

   812     allocateInfo.commandPool = vulkanContext.commandPool;

   813     allocateInfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;

   814     allocateInfo.commandBufferCount = vulkanContext.swapchainImageCount;

   815     vulkanContext.commandBuffers =

   816         SDL_malloc(sizeof(VkCommandBuffer) * vulkanContext.swapchainImageCount);

   817     result =

   818         vkAllocateCommandBuffers(vulkanContext.device, &allocateInfo, vulkanContext.commandBuffers);

   819     if(result != VK_SUCCESS)

   820     {

   821         SDL_free(vulkanContext.commandBuffers);

   822         vulkanContext.commandBuffers = NULL;

   823         SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,

   824                      "vkAllocateCommandBuffers(): %s\n",

   825                      getVulkanResultString(result));

   826         quit(2);

   827     }

   828 }

   829 

   830 static void createFences(void)

   831 {

   832 	uint32_t i;

   833 

   834     vulkanContext.fences = SDL_malloc(sizeof(VkFence) * vulkanContext.swapchainImageCount);

   835     if(!vulkanContext.fences)

   836     {

   837         SDL_OutOfMemory();

   838         quit(2);

   839     }

   840     for(i = 0; i < vulkanContext.swapchainImageCount; i++)

   841     {

   842 		VkResult result;

   843 

   844         VkFenceCreateInfo createInfo = {0};

   845         createInfo.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;

   846         createInfo.flags = VK_FENCE_CREATE_SIGNALED_BIT;

   847         result =

   848             vkCreateFence(vulkanContext.device, &createInfo, NULL, &vulkanContext.fences[i]);

   849         if(result != VK_SUCCESS)

   850         {

   851             for(; i > 0; i--)

   852             {

   853                 vkDestroyFence(vulkanContext.device, vulkanContext.fences[i - 1], NULL);

   854             }

   855             SDL_free(vulkanContext.fences);

   856             vulkanContext.fences = NULL;

   857             SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,

   858                          "vkCreateFence(): %s\n",

   859                          getVulkanResultString(result));

   860             quit(2);

   861         }

   862     }

   863 }

   864 

   865 static void destroyFences(void)

   866 {

   867 	uint32_t i;

   868 

   869     if(!vulkanContext.fences)

   870         return;

   871     for(i = 0; i < vulkanContext.swapchainImageCount; i++)

   872     {

   873         vkDestroyFence(vulkanContext.device, vulkanContext.fences[i], NULL);

   874     }

   875     SDL_free(vulkanContext.fences);

   876     vulkanContext.fences = NULL;

   877 }

   878 

   879 static void recordPipelineImageBarrier(VkCommandBuffer commandBuffer,

   880                                        VkAccessFlags sourceAccessMask,

   881                                        VkAccessFlags destAccessMask,

   882                                        VkImageLayout sourceLayout,

   883                                        VkImageLayout destLayout,

   884                                        VkImage image)

   885 {

   886     VkImageMemoryBarrier barrier = {0};

   887     barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;

   888     barrier.srcAccessMask = sourceAccessMask;

   889     barrier.dstAccessMask = destAccessMask;

   890     barrier.oldLayout = sourceLayout;

   891     barrier.newLayout = destLayout;

   892     barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;

   893     barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;

   894     barrier.image = image;

   895     barrier.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;

   896     barrier.subresourceRange.baseMipLevel = 0;

   897     barrier.subresourceRange.levelCount = 1;

   898     barrier.subresourceRange.baseArrayLayer = 0;

   899     barrier.subresourceRange.layerCount = 1;

   900     vkCmdPipelineBarrier(commandBuffer,

   901                          VK_PIPELINE_STAGE_TRANSFER_BIT,

   902                          VK_PIPELINE_STAGE_TRANSFER_BIT,

   903                          0,

   904                          0,

   905                          NULL,

   906                          0,

   907                          NULL,

   908                          1,

   909                          &barrier);

   910 }

   911 

   912 static void rerecordCommandBuffer(uint32_t frameIndex, const VkClearColorValue *clearColor)

   913 {

   914     VkCommandBuffer commandBuffer = vulkanContext.commandBuffers[frameIndex];

   915     VkImage image = vulkanContext.swapchainImages[frameIndex];

   916 	VkCommandBufferBeginInfo beginInfo = {0};

   917     VkImageSubresourceRange clearRange = {0};

   918 

   919     VkResult result = vkResetCommandBuffer(commandBuffer, 0);

   920     if(result != VK_SUCCESS)

   921     {

   922         SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,

   923                      "vkResetCommandBuffer(): %s\n",

   924                      getVulkanResultString(result));

   925         quit(2);

   926     }

   927     beginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;

   928     beginInfo.flags = VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT;

   929     result = vkBeginCommandBuffer(commandBuffer, &beginInfo);

   930     if(result != VK_SUCCESS)

   931     {

   932         SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,

   933                      "vkBeginCommandBuffer(): %s\n",

   934                      getVulkanResultString(result));

   935         quit(2);

   936     }

   937     recordPipelineImageBarrier(commandBuffer,

   938                                0,

   939                                VK_ACCESS_TRANSFER_WRITE_BIT,

   940                                VK_IMAGE_LAYOUT_UNDEFINED,

   941                                VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,

   942                                image);

   943     clearRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;

   944     clearRange.baseMipLevel = 0;

   945     clearRange.levelCount = 1;

   946     clearRange.baseArrayLayer = 0;

   947     clearRange.layerCount = 1;

   948     vkCmdClearColorImage(

   949         commandBuffer, image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, clearColor, 1, &clearRange);

   950     recordPipelineImageBarrier(commandBuffer,

   951                                VK_ACCESS_TRANSFER_WRITE_BIT,

   952                                VK_ACCESS_MEMORY_READ_BIT,

   953                                VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,

   954                                VK_IMAGE_LAYOUT_PRESENT_SRC_KHR,

   955                                image);

   956     result = vkEndCommandBuffer(commandBuffer);

   957     if(result != VK_SUCCESS)

   958     {

   959         SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,

   960                      "vkEndCommandBuffer(): %s\n",

   961                      getVulkanResultString(result));

   962         quit(2);

   963     }

   964 }

   965 

   966 static void destroySwapchainAndSwapchainSpecificStuff(SDL_bool doDestroySwapchain)

   967 {

   968     destroyFences();

   969     destroyCommandBuffers();

   970     destroyCommandPool();

   971     if(doDestroySwapchain)

   972         destroySwapchain();

   973 }

   974 

   975 static SDL_bool createNewSwapchainAndSwapchainSpecificStuff(void)

   976 {

   977     destroySwapchainAndSwapchainSpecificStuff(SDL_FALSE);

   978     getSurfaceCaps();

   979     getSurfaceFormats();

   980     if(!createSwapchain())

   981         return SDL_FALSE;

   982     createCommandPool();

   983     createCommandBuffers();

   984     createFences();

   985     return SDL_TRUE;

   986 }

   987 

   988 static void initVulkan(void)

   989 {

   990     SDL_Vulkan_LoadLibrary(NULL);

   991     SDL_memset(&vulkanContext, 0, sizeof(VulkanContext));

   992     loadGlobalFunctions();

   993     createInstance();

   994     loadInstanceFunctions();

   995     createSurface();

   996     findPhysicalDevice();

   997     createDevice();

   998     loadDeviceFunctions();

   999     getQueues();

  1000     createSemaphores();

  1001     createNewSwapchainAndSwapchainSpecificStuff();

  1002 }

  1003 

  1004 static void shutdownVulkan(void)

  1005 {

  1006     if(vulkanContext.device && vkDeviceWaitIdle)

  1007         vkDeviceWaitIdle(vulkanContext.device);

  1008     destroySwapchainAndSwapchainSpecificStuff(SDL_TRUE);

  1009     if(vulkanContext.imageAvailableSemaphore && vkDestroySemaphore)

  1010         vkDestroySemaphore(vulkanContext.device, vulkanContext.imageAvailableSemaphore, NULL);

  1011     if(vulkanContext.renderingFinishedSemaphore && vkDestroySemaphore)

  1012         vkDestroySemaphore(vulkanContext.device, vulkanContext.renderingFinishedSemaphore, NULL);

  1013     if(vulkanContext.device && vkDestroyDevice)

  1014         vkDestroyDevice(vulkanContext.device, NULL);

  1015     if(vulkanContext.surface && vkDestroySurfaceKHR)

  1016         vkDestroySurfaceKHR(vulkanContext.instance, vulkanContext.surface, NULL);

  1017     if(vulkanContext.instance && vkDestroyInstance)

  1018         vkDestroyInstance(vulkanContext.instance, NULL);

  1019     SDL_free(vulkanContext.surfaceFormats);

  1020     SDL_Vulkan_UnloadLibrary();

  1021 }

  1022 

  1023 static SDL_bool render(void)

  1024 {

  1025     uint32_t frameIndex;

  1026     VkResult result;

  1027     double currentTime;

  1028     VkClearColorValue clearColor = {0};

  1029     VkPipelineStageFlags waitDestStageMask = VK_PIPELINE_STAGE_TRANSFER_BIT;

  1030     VkSubmitInfo submitInfo = {0};

  1031     VkPresentInfoKHR presentInfo = {0};

  1032     int w, h;

  1033 

  1034     if(!vulkanContext.swapchain)

  1035     {

  1036         SDL_bool retval = createNewSwapchainAndSwapchainSpecificStuff();

  1037         if(!retval)

  1038             SDL_Delay(100);

  1039         return retval;

  1040     }

  1041     result = vkAcquireNextImageKHR(vulkanContext.device,

  1042                                             vulkanContext.swapchain,

  1043                                             UINT64_MAX,

  1044                                             vulkanContext.imageAvailableSemaphore,

  1045                                             VK_NULL_HANDLE,

  1046                                             &frameIndex);

  1047     if(result == VK_ERROR_OUT_OF_DATE_KHR)

  1048         return createNewSwapchainAndSwapchainSpecificStuff();

  1049     if(result != VK_SUBOPTIMAL_KHR && result != VK_SUCCESS)

  1050     {

  1051         SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,

  1052                      "vkAcquireNextImageKHR(): %s\n",

  1053                      getVulkanResultString(result));

  1054         quit(2);

  1055     }

  1056     result = vkWaitForFences(

  1057         vulkanContext.device, 1, &vulkanContext.fences[frameIndex], VK_FALSE, UINT64_MAX);

  1058     if(result != VK_SUCCESS)

  1059     {

  1060         SDL_LogError(

  1061             SDL_LOG_CATEGORY_APPLICATION, "vkWaitForFences(): %s\n", getVulkanResultString(result));

  1062         quit(2);

  1063     }

  1064     result = vkResetFences(vulkanContext.device, 1, &vulkanContext.fences[frameIndex]);

  1065     if(result != VK_SUCCESS)

  1066     {

  1067         SDL_LogError(

  1068             SDL_LOG_CATEGORY_APPLICATION, "vkResetFences(): %s\n", getVulkanResultString(result));

  1069         quit(2);

  1070     }

  1071     currentTime = (double)SDL_GetPerformanceCounter() / SDL_GetPerformanceFrequency();

  1072     clearColor.float32[0] = (float)(0.5 + 0.5 * SDL_sin(currentTime));

  1073     clearColor.float32[1] = (float)(0.5 + 0.5 * SDL_sin(currentTime + M_PI * 2 / 3));

  1074     clearColor.float32[2] = (float)(0.5 + 0.5 * SDL_sin(currentTime + M_PI * 4 / 3));

  1075     clearColor.float32[3] = 1;

  1076     rerecordCommandBuffer(frameIndex, &clearColor);

  1077     submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;

  1078     submitInfo.waitSemaphoreCount = 1;

  1079     submitInfo.pWaitSemaphores = &vulkanContext.imageAvailableSemaphore;

  1080     submitInfo.pWaitDstStageMask = &waitDestStageMask;

  1081     submitInfo.commandBufferCount = 1;

  1082     submitInfo.pCommandBuffers = &vulkanContext.commandBuffers[frameIndex];

  1083     submitInfo.signalSemaphoreCount = 1;

  1084     submitInfo.pSignalSemaphores = &vulkanContext.renderingFinishedSemaphore;

  1085     result = vkQueueSubmit(

  1086         vulkanContext.graphicsQueue, 1, &submitInfo, vulkanContext.fences[frameIndex]);

  1087     if(result != VK_SUCCESS)

  1088     {

  1089         SDL_LogError(

  1090             SDL_LOG_CATEGORY_APPLICATION, "vkQueueSubmit(): %s\n", getVulkanResultString(result));

  1091         quit(2);

  1092     }

  1093     presentInfo.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR;

  1094     presentInfo.waitSemaphoreCount = 1;

  1095     presentInfo.pWaitSemaphores = &vulkanContext.renderingFinishedSemaphore;

  1096     presentInfo.swapchainCount = 1;

  1097     presentInfo.pSwapchains = &vulkanContext.swapchain;

  1098     presentInfo.pImageIndices = &frameIndex;

  1099     result = vkQueuePresentKHR(vulkanContext.presentQueue, &presentInfo);

  1100     if(result == VK_ERROR_OUT_OF_DATE_KHR || result == VK_SUBOPTIMAL_KHR)

  1101     {

  1102         return createNewSwapchainAndSwapchainSpecificStuff();

  1103     }

  1104     if(result != VK_SUCCESS)

  1105     {

  1106         SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,

  1107                      "vkQueuePresentKHR(): %s\n",

  1108                      getVulkanResultString(result));

  1109         quit(2);

  1110     }

  1111     SDL_Vulkan_GetDrawableSize(state->windows[0], &w, &h);

  1112     if(w != (int)vulkanContext.swapchainSize.width || h != (int)vulkanContext.swapchainSize.height)

  1113     {

  1114         return createNewSwapchainAndSwapchainSpecificStuff();

  1115     }

  1116     return SDL_TRUE;

  1117 }

  1118 

  1119 int main(int argc, char *argv[])

  1120 {

  1121     int fsaa, accel;

  1122     int done;

  1123     SDL_DisplayMode mode;

  1124     SDL_Event event;

  1125     Uint32 then, now, frames;

  1126     int dw, dh;

  1127 

  1128     /* Enable standard application logging */

  1129     SDL_LogSetPriority(SDL_LOG_CATEGORY_APPLICATION, SDL_LOG_PRIORITY_INFO);

  1130 

  1131     /* Initialize parameters */

  1132     fsaa = 0;

  1133     accel = -1;

  1134 

  1135     /* Initialize test framework */

  1136     state = SDLTest_CommonCreateState(argv, SDL_INIT_VIDEO);

  1137     if(!state)

  1138     {

  1139         return 1;

  1140     }

  1141 

  1142     /* Set Vulkan parameters */

  1143     state->window_flags |= SDL_WINDOW_VULKAN;

  1144     state->num_windows = 1;

  1145     state->skip_renderer = 1;

  1146 

  1147     if (!SDLTest_CommonDefaultArgs(state, argc, argv) || !SDLTest_CommonInit(state)) {

  1148         SDLTest_CommonQuit(state);

  1149         return 1;

  1150     }

  1151 

  1152     SDL_GetCurrentDisplayMode(0, &mode);

  1153     SDL_Log("Screen BPP    : %d\n", SDL_BITSPERPIXEL(mode.format));

  1154     SDL_GetWindowSize(state->windows[0], &dw, &dh);

  1155     SDL_Log("Window Size   : %d,%d\n", dw, dh);

  1156     SDL_Vulkan_GetDrawableSize(state->windows[0], &dw, &dh);

  1157     SDL_Log("Draw Size     : %d,%d\n", dw, dh);

  1158     SDL_Log("\n");

  1159 

  1160     initVulkan();

  1161 

  1162     /* Main render loop */

  1163     frames = 0;

  1164     then = SDL_GetTicks();

  1165     done = 0;

  1166     while(!done)

  1167     {

  1168         /* Check for events */

  1169         ++frames;

  1170         while(SDL_PollEvent(&event))

  1171         {

  1172             SDLTest_CommonEvent(state, &event, &done);

  1173         }

  1174 

  1175         if(!done)

  1176             render();

  1177     }

  1178 

  1179     /* Print out some timing information */

  1180     now = SDL_GetTicks();

  1181     if(now > then)

  1182     {

  1183         SDL_Log("%2.2f frames per second\n", ((double)frames * 1000) / (now - then));

  1184     }

  1185     quit(0);

  1186     return 0;

  1187 }

  1188 

  1189 #endif
SDL