SDL  2.0
testvulkan.c File Reference
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <math.h>
#include "SDL_test_common.h"
#include "../src/video/khronos/vulkan/vulkan.h"
#include "SDL_vulkan.h"
+ Include dependency graph for testvulkan.c:

Go to the source code of this file.

Data Structures

struct  VulkanContext
 

Macros

#define VK_NO_PROTOTYPES
 
#define UINT64_MAX   18446744073709551615
 
#define VULKAN_FUNCTIONS()
 
#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;
 
#define VULKAN_DEVICE_FUNCTION(name)
 
#define VULKAN_GLOBAL_FUNCTION(name)
 
#define VULKAN_INSTANCE_FUNCTION(name)
 
#define VULKAN_DEVICE_FUNCTION(name)
 
#define VULKAN_GLOBAL_FUNCTION(name)
 
#define VULKAN_INSTANCE_FUNCTION(name)
 
#define VULKAN_DEVICE_FUNCTION(name)
 
#define VULKAN_GLOBAL_FUNCTION(name)
 
#define VULKAN_INSTANCE_FUNCTION(name)
 

Functions

static const char * getVulkanResultString (VkResult result)
 
static void shutdownVulkan (void)
 
static void quit (int rc)
 
static void loadGlobalFunctions (void)
 
static void createInstance (void)
 
static void loadInstanceFunctions (void)
 
static void createSurface (void)
 
static void findPhysicalDevice (void)
 
static void createDevice (void)
 
static void loadDeviceFunctions (void)
 
static void getQueues (void)
 
static void createSemaphore (VkSemaphore *semaphore)
 
static void createSemaphores (void)
 
static void getSurfaceCaps (void)
 
static void getSurfaceFormats (void)
 
static void getSwapchainImages (void)
 
static SDL_bool createSwapchain (void)
 
static void destroySwapchain (void)
 
static void destroyCommandBuffers (void)
 
static void destroyCommandPool (void)
 
static void createCommandPool (void)
 
static void createCommandBuffers (void)
 
static void createFences (void)
 
static void destroyFences (void)
 
static void recordPipelineImageBarrier (VkCommandBuffer commandBuffer, VkAccessFlags sourceAccessMask, VkAccessFlags destAccessMask, VkImageLayout sourceLayout, VkImageLayout destLayout, VkImage image)
 
static void rerecordCommandBuffer (uint32_t frameIndex, const VkClearColorValue *clearColor)
 
static void destroySwapchainAndSwapchainSpecificStuff (SDL_bool doDestroySwapchain)
 
static SDL_bool createNewSwapchainAndSwapchainSpecificStuff (void)
 
static void initVulkan (void)
 
static SDL_bool render (void)
 
int main (int argc, char *argv[])
 

Variables

static PFN_vkGetInstanceProcAddr vkGetInstanceProcAddr = NULL
 
static SDLTest_CommonStatestate
 
static VulkanContext vulkanContext = {0}
 

Macro Definition Documentation

◆ UINT64_MAX

#define UINT64_MAX   18446744073709551615

Definition at line 39 of file testvulkan.c.

◆ VK_NO_PROTOTYPES

#define VK_NO_PROTOTYPES

Definition at line 29 of file testvulkan.c.

◆ VULKAN_DEVICE_FUNCTION [1/4]

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

Definition at line 87 of file testvulkan.c.

◆ VULKAN_DEVICE_FUNCTION [2/4]

#define VULKAN_DEVICE_FUNCTION (   name)

Definition at line 87 of file testvulkan.c.

◆ VULKAN_DEVICE_FUNCTION [3/4]

#define VULKAN_DEVICE_FUNCTION (   name)

Definition at line 87 of file testvulkan.c.

◆ VULKAN_DEVICE_FUNCTION [4/4]

#define VULKAN_DEVICE_FUNCTION (   name)
Value:
if(!name) \
{ \
"vkGetDeviceProcAddr(device, \"" #name "\") failed\n"); \
quit(2); \
}

Definition at line 87 of file testvulkan.c.

◆ VULKAN_FUNCTIONS

#define VULKAN_FUNCTIONS ( )

Definition at line 42 of file testvulkan.c.

◆ VULKAN_GLOBAL_FUNCTION [1/4]

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

Definition at line 88 of file testvulkan.c.

◆ VULKAN_GLOBAL_FUNCTION [2/4]

#define VULKAN_GLOBAL_FUNCTION (   name)
Value:
if(!name) \
{ \
"vkGetInstanceProcAddr(VK_NULL_HANDLE, \"" #name "\") failed\n"); \
quit(2); \
}

Definition at line 88 of file testvulkan.c.

◆ VULKAN_GLOBAL_FUNCTION [3/4]

#define VULKAN_GLOBAL_FUNCTION (   name)

Definition at line 88 of file testvulkan.c.

◆ VULKAN_GLOBAL_FUNCTION [4/4]

#define VULKAN_GLOBAL_FUNCTION (   name)

Definition at line 88 of file testvulkan.c.

◆ VULKAN_INSTANCE_FUNCTION [1/4]

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

Definition at line 89 of file testvulkan.c.

◆ VULKAN_INSTANCE_FUNCTION [2/4]

#define VULKAN_INSTANCE_FUNCTION (   name)

Definition at line 89 of file testvulkan.c.

◆ VULKAN_INSTANCE_FUNCTION [3/4]

#define VULKAN_INSTANCE_FUNCTION (   name)
Value:
if(!name) \
{ \
"vkGetInstanceProcAddr(instance, \"" #name "\") failed\n"); \
quit(2); \
}

Definition at line 89 of file testvulkan.c.

◆ VULKAN_INSTANCE_FUNCTION [4/4]

#define VULKAN_INSTANCE_FUNCTION (   name)

Definition at line 89 of file testvulkan.c.

Function Documentation

◆ createCommandBuffers()

static void createCommandBuffers ( void  )
static

Definition at line 806 of file testvulkan.c.

807 {
809 
810  VkCommandBufferAllocateInfo allocateInfo = {0};
812  allocateInfo.commandPool = vulkanContext.commandPool;
813  allocateInfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
816  SDL_malloc(sizeof(VkCommandBuffer) * vulkanContext.swapchainImageCount);
817  result =
819  if(result != VK_SUCCESS)
820  {
824  "vkAllocateCommandBuffers(): %s\n",
826  quit(2);
827  }
828 }

References VkCommandBufferAllocateInfo::commandBufferCount, VulkanContext::commandBuffers, VkCommandBufferAllocateInfo::commandPool, VulkanContext::commandPool, VulkanContext::device, getVulkanResultString(), VkCommandBufferAllocateInfo::level, NULL, quit(), SDL_free, SDL_LOG_CATEGORY_APPLICATION, SDL_LogError, SDL_malloc, VkCommandBufferAllocateInfo::sType, VulkanContext::swapchainImageCount, VK_COMMAND_BUFFER_LEVEL_PRIMARY, VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO, VK_SUCCESS, vkAllocateCommandBuffers(), and vulkanContext.

Referenced by createNewSwapchainAndSwapchainSpecificStuff().

◆ createCommandPool()

◆ createDevice()

static void createDevice ( void  )
static

Definition at line 497 of file testvulkan.c.

498 {
499  VkDeviceQueueCreateInfo deviceQueueCreateInfo[1] = {0};
500  static const float queuePriority[] = {1.0f};
501  VkDeviceCreateInfo deviceCreateInfo = {0};
502  static const char *const deviceExtensionNames[] = {
504  };
506 
507  deviceQueueCreateInfo->sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
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;
519  vulkanContext.physicalDevice, &deviceCreateInfo, NULL, &vulkanContext.device);
520  if(result != VK_SUCCESS)
521  {
523  SDL_LogError(
524  SDL_LOG_CATEGORY_APPLICATION, "vkCreateDevice(): %s\n", getVulkanResultString(result));
525  quit(2);
526  }
527 }

References VulkanContext::device, VkDeviceCreateInfo::enabledExtensionCount, getVulkanResultString(), VulkanContext::graphicsQueueFamilyIndex, NULL, VkDeviceCreateInfo::pEnabledFeatures, VulkanContext::physicalDevice, VkDeviceCreateInfo::ppEnabledExtensionNames, VkDeviceCreateInfo::pQueueCreateInfos, VkDeviceQueueCreateInfo::pQueuePriorities, VkDeviceQueueCreateInfo::queueCount, VkDeviceCreateInfo::queueCreateInfoCount, VkDeviceQueueCreateInfo::queueFamilyIndex, quit(), SDL_arraysize, SDL_LOG_CATEGORY_APPLICATION, SDL_LogError, VkDeviceQueueCreateInfo::sType, VkDeviceCreateInfo::sType, VK_KHR_SWAPCHAIN_EXTENSION_NAME, VK_NULL_HANDLE, VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO, VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO, VK_SUCCESS, vkCreateDevice(), and vulkanContext.

Referenced by initVulkan().

◆ createFences()

static void createFences ( void  )
static

◆ createInstance()

static void createInstance ( void  )
static

Definition at line 245 of file testvulkan.c.

246 {
247  VkApplicationInfo appInfo = {0};
248  VkInstanceCreateInfo instanceCreateInfo = {0};
249  const char **extensions = NULL;
250  unsigned extensionCount = 0;
252 
253 
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  {
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);
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  {
287  "vkCreateInstance(): %s\n",
289  quit(2);
290  }
291 }

References VkApplicationInfo::apiVersion, VkInstanceCreateInfo::enabledExtensionCount, getVulkanResultString(), VulkanContext::instance, NULL, VkInstanceCreateInfo::pApplicationInfo, VkInstanceCreateInfo::ppEnabledExtensionNames, quit(), SDL_free, SDL_GetError, SDL_LOG_CATEGORY_APPLICATION, SDL_LogError, SDL_malloc, SDL_OutOfMemory, SDL_Vulkan_GetInstanceExtensions, VkApplicationInfo::sType, VkInstanceCreateInfo::sType, VK_API_VERSION_1_0, VK_NULL_HANDLE, VK_STRUCTURE_TYPE_APPLICATION_INFO, VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO, VK_SUCCESS, vkCreateInstance(), and vulkanContext.

Referenced by initVulkan().

◆ createNewSwapchainAndSwapchainSpecificStuff()

static SDL_bool createNewSwapchainAndSwapchainSpecificStuff ( void  )
static

◆ createSemaphore()

static void createSemaphore ( VkSemaphore *  semaphore)
static

Definition at line 564 of file testvulkan.c.

565 {
567 
568  VkSemaphoreCreateInfo createInfo = {0};
570  result = vkCreateSemaphore(vulkanContext.device, &createInfo, NULL, semaphore);
571  if(result != VK_SUCCESS)
572  {
573  *semaphore = VK_NULL_HANDLE;
575  "vkCreateSemaphore(): %s\n",
577  quit(2);
578  }
579 }

References VulkanContext::device, getVulkanResultString(), NULL, quit(), SDL_LOG_CATEGORY_APPLICATION, SDL_LogError, VkSemaphoreCreateInfo::sType, VK_NULL_HANDLE, VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO, VK_SUCCESS, vkCreateSemaphore(), and vulkanContext.

Referenced by createSemaphores().

◆ createSemaphores()

◆ createSurface()

static void createSurface ( void  )
static

◆ createSwapchain()

static SDL_bool createSwapchain ( void  )
static

Definition at line 687 of file testvulkan.c.

688 {
689  uint32_t i;
690  int w, h;
691  VkSwapchainCreateInfoKHR createInfo = {0};
693 
694  // pick an image count
699 
700  // pick a format
703  {
704  // aren't any preferred formats, so we pick
707  }
708  else
709  {
711  for(i = 0; i < vulkanContext.surfaceFormatsCount; i++)
712  {
714  {
716  break;
717  }
718  }
719  }
720 
721  // get size
725  if(w == 0 || h == 0)
726  return SDL_FALSE;
727 
729  createInfo.surface = vulkanContext.surface;
734  createInfo.imageArrayLayers = 1;
740  createInfo.clipped = VK_TRUE;
741  createInfo.oldSwapchain = vulkanContext.swapchain;
742  result =
744  if(createInfo.oldSwapchain)
746  if(result != VK_SUCCESS)
747  {
750  "vkCreateSwapchainKHR(): %s\n",
752  quit(2);
753  }
755  return SDL_TRUE;
756 }

References VkSwapchainCreateInfoKHR::clipped, VkSurfaceFormatKHR::colorSpace, VkSwapchainCreateInfoKHR::compositeAlpha, VkSurfaceCapabilitiesKHR::currentTransform, VulkanContext::device, VkSurfaceFormatKHR::format, getSwapchainImages(), getVulkanResultString(), VkExtent2D::height, i, VkSwapchainCreateInfoKHR::imageArrayLayers, VkSwapchainCreateInfoKHR::imageColorSpace, VkSwapchainCreateInfoKHR::imageExtent, VkSwapchainCreateInfoKHR::imageFormat, VkSwapchainCreateInfoKHR::imageSharingMode, VkSwapchainCreateInfoKHR::imageUsage, VkSurfaceCapabilitiesKHR::maxImageCount, VkSurfaceCapabilitiesKHR::minImageCount, VkSwapchainCreateInfoKHR::minImageCount, NULL, VkSwapchainCreateInfoKHR::oldSwapchain, VkSwapchainCreateInfoKHR::presentMode, VkSwapchainCreateInfoKHR::preTransform, quit(), SDL_FALSE, SDL_LOG_CATEGORY_APPLICATION, SDL_LogError, SDL_TRUE, SDL_Vulkan_GetDrawableSize, state, VkSwapchainCreateInfoKHR::sType, VkSwapchainCreateInfoKHR::surface, VulkanContext::surface, VulkanContext::surfaceCapabilities, VulkanContext::surfaceFormat, VulkanContext::surfaceFormats, VulkanContext::surfaceFormatsCount, VulkanContext::swapchain, VulkanContext::swapchainDesiredImageCount, VulkanContext::swapchainSize, VK_COLORSPACE_SRGB_NONLINEAR_KHR, VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR, VK_FORMAT_R8G8B8A8_UNORM, VK_FORMAT_UNDEFINED, VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, VK_IMAGE_USAGE_TRANSFER_DST_BIT, VK_NULL_HANDLE, VK_PRESENT_MODE_FIFO_KHR, VK_SHARING_MODE_EXCLUSIVE, VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR, VK_SUCCESS, VK_TRUE, vkCreateSwapchainKHR(), vkDestroySwapchainKHR(), vulkanContext, VkExtent2D::width, and SDLTest_CommonState::windows.

Referenced by createNewSwapchainAndSwapchainSpecificStuff().

◆ destroyCommandBuffers()

◆ destroyCommandPool()

◆ destroyFences()

static void destroyFences ( void  )
static

◆ destroySwapchain()

◆ destroySwapchainAndSwapchainSpecificStuff()

static void destroySwapchainAndSwapchainSpecificStuff ( SDL_bool  doDestroySwapchain)
static

Definition at line 966 of file testvulkan.c.

967 {
968  destroyFences();
971  if(doDestroySwapchain)
973 }

References destroyCommandBuffers(), destroyCommandPool(), destroyFences(), and destroySwapchain().

Referenced by createNewSwapchainAndSwapchainSpecificStuff(), and shutdownVulkan().

◆ findPhysicalDevice()

static void findPhysicalDevice ( void  )
static

Definition at line 324 of file testvulkan.c.

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  {
339  "vkEnumeratePhysicalDevices(): %s\n",
341  quit(2);
342  }
343  if(physicalDeviceCount == 0)
344  {
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);
361  "vkEnumeratePhysicalDevices(): %s\n",
363  quit(2);
364  }
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];
379  continue;
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  }
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;
412  physicalDevice, queueFamilyIndex, vulkanContext.surface, &supported);
413  if(result != VK_SUCCESS)
414  {
415  SDL_free(physicalDevices);
416  SDL_free(queueFamiliesProperties);
417  SDL_free(deviceExtensions);
419  "vkGetPhysicalDeviceSurfaceSupportKHR(): %s\n",
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);
442  "vkEnumerateDeviceExtensionProperties(): %s\n",
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  }
463  physicalDevice, NULL, &deviceExtensionCount, deviceExtensions);
464  if(result != VK_SUCCESS)
465  {
466  SDL_free(physicalDevices);
467  SDL_free(queueFamiliesProperties);
468  SDL_free(deviceExtensions);
470  "vkEnumerateDeviceExtensionProperties(): %s\n",
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);
491  {
492  SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Vulkan: no viable physical devices found");
493  quit(2);
494  }
495 }

References VkPhysicalDeviceProperties::apiVersion, getVulkanResultString(), VulkanContext::graphicsQueueFamilyIndex, i, VulkanContext::instance, NULL, VulkanContext::physicalDevice, VulkanContext::physicalDeviceFeatures, VulkanContext::physicalDeviceProperties, VulkanContext::presentQueueFamilyIndex, quit(), SDL_FALSE, SDL_free, SDL_LOG_CATEGORY_APPLICATION, SDL_LogError, SDL_malloc, SDL_OutOfMemory, SDL_strcmp, SDL_TRUE, VulkanContext::surface, VK_KHR_SWAPCHAIN_EXTENSION_NAME, VK_QUEUE_GRAPHICS_BIT, VK_SUCCESS, VK_VERSION_MAJOR, vkEnumerateDeviceExtensionProperties(), vkEnumeratePhysicalDevices(), vkGetPhysicalDeviceFeatures(), vkGetPhysicalDeviceProperties(), vkGetPhysicalDeviceQueueFamilyProperties(), vkGetPhysicalDeviceSurfaceSupportKHR(), and vulkanContext.

Referenced by initVulkan().

◆ getQueues()

◆ getSurfaceCaps()

◆ getSurfaceFormats()

static void getSurfaceFormats ( void  )
static

Definition at line 608 of file testvulkan.c.

References getVulkanResultString(), NULL, VulkanContext::physicalDevice, quit(), SDL_free, SDL_LOG_CATEGORY_APPLICATION, SDL_LogError, SDL_malloc, SDL_OutOfMemory, VulkanContext::surface, VulkanContext::surfaceFormats, VulkanContext::surfaceFormatsAllocatedCount, VulkanContext::surfaceFormatsCount, VK_SUCCESS, vkGetPhysicalDeviceSurfaceFormatsKHR(), and vulkanContext.

Referenced by createNewSwapchainAndSwapchainSpecificStuff().

◆ getSwapchainImages()

static void getSwapchainImages ( void  )
static

Definition at line 649 of file testvulkan.c.

References VulkanContext::device, getVulkanResultString(), NULL, quit(), SDL_free, SDL_LOG_CATEGORY_APPLICATION, SDL_LogError, SDL_malloc, SDL_OutOfMemory, VulkanContext::swapchain, VulkanContext::swapchainImageCount, VulkanContext::swapchainImages, VK_SUCCESS, vkGetSwapchainImagesKHR(), and vulkanContext.

Referenced by createSwapchain().

◆ getVulkanResultString()

static const char* getVulkanResultString ( VkResult  result)
static

Definition at line 111 of file testvulkan.c.

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";
128  return "VK_ERROR_OUT_OF_HOST_MEMORY";
130  return "VK_ERROR_OUT_OF_DEVICE_MEMORY";
132  return "VK_ERROR_INITIALIZATION_FAILED";
134  return "VK_ERROR_DEVICE_LOST";
136  return "VK_ERROR_MEMORY_MAP_FAILED";
138  return "VK_ERROR_LAYER_NOT_PRESENT";
140  return "VK_ERROR_EXTENSION_NOT_PRESENT";
142  return "VK_ERROR_FEATURE_NOT_PRESENT";
144  return "VK_ERROR_INCOMPATIBLE_DRIVER";
146  return "VK_ERROR_TOO_MANY_OBJECTS";
148  return "VK_ERROR_FORMAT_NOT_SUPPORTED";
150  return "VK_ERROR_FRAGMENTED_POOL";
152  return "VK_ERROR_SURFACE_LOST_KHR";
154  return "VK_ERROR_NATIVE_WINDOW_IN_USE_KHR";
155  case VK_SUBOPTIMAL_KHR:
156  return "VK_SUBOPTIMAL_KHR";
158  return "VK_ERROR_OUT_OF_DATE_KHR";
160  return "VK_ERROR_INCOMPATIBLE_DISPLAY_KHR";
162  return "VK_ERROR_VALIDATION_FAILED_EXT";
164  return "VK_ERROR_OUT_OF_POOL_MEMORY_KHR";
166  return "VK_ERROR_INVALID_SHADER_NV";
167  case VK_RESULT_MAX_ENUM:
169  break;
170  }
171  if(result < 0)
172  return "VK_ERROR_<Unknown>";
173  return "VK_<Unknown>";
174 }

References VK_ERROR_DEVICE_LOST, VK_ERROR_EXTENSION_NOT_PRESENT, VK_ERROR_FEATURE_NOT_PRESENT, VK_ERROR_FORMAT_NOT_SUPPORTED, VK_ERROR_FRAGMENTED_POOL, VK_ERROR_INCOMPATIBLE_DISPLAY_KHR, VK_ERROR_INCOMPATIBLE_DRIVER, VK_ERROR_INITIALIZATION_FAILED, VK_ERROR_INVALID_SHADER_NV, VK_ERROR_LAYER_NOT_PRESENT, VK_ERROR_MEMORY_MAP_FAILED, VK_ERROR_NATIVE_WINDOW_IN_USE_KHR, VK_ERROR_OUT_OF_DATE_KHR, VK_ERROR_OUT_OF_DEVICE_MEMORY, VK_ERROR_OUT_OF_HOST_MEMORY, VK_ERROR_OUT_OF_POOL_MEMORY_KHR, VK_ERROR_SURFACE_LOST_KHR, VK_ERROR_TOO_MANY_OBJECTS, VK_ERROR_VALIDATION_FAILED_EXT, VK_EVENT_RESET, VK_EVENT_SET, VK_INCOMPLETE, VK_NOT_READY, VK_RESULT_MAX_ENUM, VK_RESULT_RANGE_SIZE, VK_SUBOPTIMAL_KHR, VK_SUCCESS, and VK_TIMEOUT.

Referenced by createCommandBuffers(), createCommandPool(), createDevice(), createFences(), createInstance(), createSemaphore(), createSwapchain(), findPhysicalDevice(), getSurfaceCaps(), getSurfaceFormats(), getSwapchainImages(), render(), and rerecordCommandBuffer().

◆ initVulkan()

◆ loadDeviceFunctions()

static void loadDeviceFunctions ( void  )
static

Definition at line 529 of file testvulkan.c.

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)
542 #undef VULKAN_DEVICE_FUNCTION
543 #undef VULKAN_GLOBAL_FUNCTION
544 #undef VULKAN_INSTANCE_FUNCTION
545 }

References VULKAN_FUNCTIONS.

Referenced by initVulkan().

◆ loadGlobalFunctions()

static void loadGlobalFunctions ( void  )
static

Definition at line 218 of file testvulkan.c.

219 {
222  {
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)
240 #undef VULKAN_DEVICE_FUNCTION
241 #undef VULKAN_GLOBAL_FUNCTION
242 #undef VULKAN_INSTANCE_FUNCTION
243 }

References quit(), SDL_GetError, SDL_LOG_CATEGORY_APPLICATION, SDL_LogError, SDL_Vulkan_GetVkGetInstanceProcAddr, vkGetInstanceProcAddr, and VULKAN_FUNCTIONS.

Referenced by initVulkan().

◆ loadInstanceFunctions()

static void loadInstanceFunctions ( void  )
static

Definition at line 293 of file testvulkan.c.

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  }
306 #undef VULKAN_DEVICE_FUNCTION
307 #undef VULKAN_GLOBAL_FUNCTION
308 #undef VULKAN_INSTANCE_FUNCTION
309 }

References VULKAN_FUNCTIONS.

Referenced by initVulkan().

◆ main()

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

Definition at line 1119 of file testvulkan.c.

1120 {
1121  int fsaa, accel;
1122  int i, done;
1124  SDL_Event event;
1125  Uint32 then, now, frames;
1126  int dw, dh;
1127 
1128  /* Enable standard application logging */
1130 
1131  /* Initialize parameters */
1132  fsaa = 0;
1133  accel = -1;
1134 
1135  /* Initialize test framework */
1137  if(!state)
1138  {
1139  return 1;
1140  }
1141  for(i = 1; i < argc;)
1142  {
1143  int consumed;
1144 
1145  consumed = SDLTest_CommonArg(state, i);
1146  if(consumed < 0)
1147  {
1148  SDL_Log("Usage: %s %s\n", argv[0], SDLTest_CommonUsage(state));
1149  quit(1);
1150  }
1151  i += consumed;
1152  }
1153 
1154  /* Set Vulkan parameters */
1156  state->num_windows = 1;
1157  state->skip_renderer = 1;
1158 
1160  {
1161  quit(2);
1162  }
1163 
1165  SDL_Log("Screen BPP : %d\n", SDL_BITSPERPIXEL(mode.format));
1166  SDL_GetWindowSize(state->windows[0], &dw, &dh);
1167  SDL_Log("Window Size : %d,%d\n", dw, dh);
1168  SDL_Vulkan_GetDrawableSize(state->windows[0], &dw, &dh);
1169  SDL_Log("Draw Size : %d,%d\n", dw, dh);
1170  SDL_Log("\n");
1171 
1172  initVulkan();
1173 
1174  /* Main render loop */
1175  frames = 0;
1176  then = SDL_GetTicks();
1177  done = 0;
1178  while(!done)
1179  {
1180  /* Check for events */
1181  ++frames;
1182  while(SDL_PollEvent(&event))
1183  {
1185  }
1186 
1187  if(!done)
1188  render();
1189  }
1190 
1191  /* Print out some timing information */
1192  now = SDL_GetTicks();
1193  if(now > then)
1194  {
1195  SDL_Log("%2.2f frames per second\n", ((double)frames * 1000) / (now - then));
1196  }
1197  quit(0);
1198  return 0;
1199 }

References done, i, initVulkan(), SDLTest_CommonState::num_windows, quit(), render(), SDL_BITSPERPIXEL, SDL_GetCurrentDisplayMode, SDL_GetTicks(), SDL_GetWindowSize, SDL_INIT_VIDEO, SDL_Log, SDL_LOG_CATEGORY_APPLICATION, SDL_LOG_PRIORITY_INFO, SDL_LogSetPriority, SDL_PollEvent, SDL_Vulkan_GetDrawableSize, SDL_WINDOW_VULKAN, SDLTest_CommonArg(), SDLTest_CommonCreateState(), SDLTest_CommonEvent(), SDLTest_CommonInit(), SDLTest_CommonUsage(), SDLTest_CommonState::skip_renderer, state, SDLTest_CommonState::window_flags, and SDLTest_CommonState::windows.

◆ quit()

◆ recordPipelineImageBarrier()

static void recordPipelineImageBarrier ( VkCommandBuffer  commandBuffer,
VkAccessFlags  sourceAccessMask,
VkAccessFlags  destAccessMask,
VkImageLayout  sourceLayout,
VkImageLayout  destLayout,
VkImage  image 
)
static

Definition at line 879 of file testvulkan.c.

885 {
886  VkImageMemoryBarrier barrier = {0};
888  barrier.srcAccessMask = sourceAccessMask;
889  barrier.dstAccessMask = destAccessMask;
890  barrier.oldLayout = sourceLayout;
891  barrier.newLayout = destLayout;
894  barrier.image = image;
896  barrier.subresourceRange.baseMipLevel = 0;
897  barrier.subresourceRange.levelCount = 1;
898  barrier.subresourceRange.baseArrayLayer = 0;
899  barrier.subresourceRange.layerCount = 1;
900  vkCmdPipelineBarrier(commandBuffer,
903  0,
904  0,
905  NULL,
906  0,
907  NULL,
908  1,
909  &barrier);
910 }

References VkImageSubresourceRange::aspectMask, VkImageSubresourceRange::baseArrayLayer, VkImageSubresourceRange::baseMipLevel, VkImageMemoryBarrier::dstAccessMask, VkImageMemoryBarrier::dstQueueFamilyIndex, VkImageMemoryBarrier::image, VkImageSubresourceRange::layerCount, VkImageSubresourceRange::levelCount, VkImageMemoryBarrier::newLayout, NULL, VkImageMemoryBarrier::oldLayout, VkImageMemoryBarrier::srcAccessMask, VkImageMemoryBarrier::srcQueueFamilyIndex, VkImageMemoryBarrier::sType, VkImageMemoryBarrier::subresourceRange, VK_IMAGE_ASPECT_COLOR_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_QUEUE_FAMILY_IGNORED, VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, and vkCmdPipelineBarrier().

Referenced by rerecordCommandBuffer().

◆ render()

static SDL_bool render ( void  )
static

Definition at line 1023 of file testvulkan.c.

1024 {
1025  uint32_t frameIndex;
1026  VkResult result;
1027  double currentTime;
1028  VkClearColorValue clearColor = {0};
1030  VkSubmitInfo submitInfo = {0};
1031  VkPresentInfoKHR presentInfo = {0};
1032  int w, h;
1033 
1035  {
1037  if(!retval)
1038  SDL_Delay(100);
1039  return retval;
1040  }
1043  UINT64_MAX,
1046  &frameIndex);
1050  {
1052  "vkAcquireNextImageKHR(): %s\n",
1054  quit(2);
1055  }
1058  if(result != VK_SUCCESS)
1059  {
1060  SDL_LogError(
1061  SDL_LOG_CATEGORY_APPLICATION, "vkWaitForFences(): %s\n", getVulkanResultString(result));
1062  quit(2);
1063  }
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;
1080  submitInfo.pWaitDstStageMask = &waitDestStageMask;
1081  submitInfo.commandBufferCount = 1;
1082  submitInfo.pCommandBuffers = &vulkanContext.commandBuffers[frameIndex];
1083  submitInfo.signalSemaphoreCount = 1;
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  }
1094  presentInfo.waitSemaphoreCount = 1;
1096  presentInfo.swapchainCount = 1;
1097  presentInfo.pSwapchains = &vulkanContext.swapchain;
1098  presentInfo.pImageIndices = &frameIndex;
1101  {
1103  }
1104  if(result != VK_SUCCESS)
1105  {
1107  "vkQueuePresentKHR(): %s\n",
1109  quit(2);
1110  }
1113  {
1115  }
1116  return SDL_TRUE;
1117 }

References VkSubmitInfo::commandBufferCount, VulkanContext::commandBuffers, createNewSwapchainAndSwapchainSpecificStuff(), VulkanContext::device, VulkanContext::fences, VkClearColorValue::float32, getVulkanResultString(), VulkanContext::graphicsQueue, VkExtent2D::height, VulkanContext::imageAvailableSemaphore, VkSubmitInfo::pCommandBuffers, VkPresentInfoKHR::pImageIndices, VulkanContext::presentQueue, VkSubmitInfo::pSignalSemaphores, VkPresentInfoKHR::pSwapchains, VkSubmitInfo::pWaitDstStageMask, VkSubmitInfo::pWaitSemaphores, VkPresentInfoKHR::pWaitSemaphores, quit(), VulkanContext::renderingFinishedSemaphore, rerecordCommandBuffer(), retval, SDL_Delay, SDL_GetPerformanceCounter, SDL_GetPerformanceFrequency(), SDL_LOG_CATEGORY_APPLICATION, SDL_LogError, SDL_sin, SDL_TRUE, SDL_Vulkan_GetDrawableSize, VkSubmitInfo::signalSemaphoreCount, state, VkSubmitInfo::sType, VkPresentInfoKHR::sType, VulkanContext::swapchain, VkPresentInfoKHR::swapchainCount, VulkanContext::swapchainSize, UINT64_MAX, VK_ERROR_OUT_OF_DATE_KHR, VK_FALSE, VK_NULL_HANDLE, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_STRUCTURE_TYPE_PRESENT_INFO_KHR, VK_STRUCTURE_TYPE_SUBMIT_INFO, VK_SUBOPTIMAL_KHR, VK_SUCCESS, vkAcquireNextImageKHR(), vkQueuePresentKHR(), vkQueueSubmit(), vkResetFences(), vkWaitForFences(), vulkanContext, VkSubmitInfo::waitSemaphoreCount, VkPresentInfoKHR::waitSemaphoreCount, VkExtent2D::width, and SDLTest_CommonState::windows.

Referenced by main().

◆ rerecordCommandBuffer()

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

Definition at line 912 of file testvulkan.c.

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  {
923  "vkResetCommandBuffer(): %s\n",
925  quit(2);
926  }
929  result = vkBeginCommandBuffer(commandBuffer, &beginInfo);
930  if(result != VK_SUCCESS)
931  {
933  "vkBeginCommandBuffer(): %s\n",
935  quit(2);
936  }
937  recordPipelineImageBarrier(commandBuffer,
938  0,
942  image);
944  clearRange.baseMipLevel = 0;
945  clearRange.levelCount = 1;
946  clearRange.baseArrayLayer = 0;
947  clearRange.layerCount = 1;
949  commandBuffer, image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, clearColor, 1, &clearRange);
950  recordPipelineImageBarrier(commandBuffer,
955  image);
956  result = vkEndCommandBuffer(commandBuffer);
957  if(result != VK_SUCCESS)
958  {
960  "vkEndCommandBuffer(): %s\n",
962  quit(2);
963  }
964 }

References VkImageSubresourceRange::aspectMask, VkImageSubresourceRange::baseArrayLayer, VkImageSubresourceRange::baseMipLevel, VulkanContext::commandBuffers, VkCommandBufferBeginInfo::flags, getVulkanResultString(), VkImageSubresourceRange::layerCount, VkImageSubresourceRange::levelCount, quit(), recordPipelineImageBarrier(), SDL_LOG_CATEGORY_APPLICATION, SDL_LogError, VkCommandBufferBeginInfo::sType, VulkanContext::swapchainImages, VK_ACCESS_MEMORY_READ_BIT, VK_ACCESS_TRANSFER_WRITE_BIT, VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT, VK_IMAGE_ASPECT_COLOR_BIT, VK_IMAGE_LAYOUT_PRESENT_SRC_KHR, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, VK_IMAGE_LAYOUT_UNDEFINED, VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, VK_SUCCESS, vkBeginCommandBuffer(), vkCmdClearColorImage(), vkEndCommandBuffer(), vkResetCommandBuffer(), and vulkanContext.

Referenced by render().

◆ shutdownVulkan()

Variable Documentation

◆ state

SDLTest_CommonState* state
static

Definition at line 205 of file testvulkan.c.

Referenced by createSurface(), createSwapchain(), main(), quit(), and render().

◆ vkGetInstanceProcAddr

PFN_vkGetInstanceProcAddr vkGetInstanceProcAddr = NULL
static

Definition at line 94 of file testvulkan.c.

Referenced by loadGlobalFunctions().

◆ vulkanContext

recordPipelineImageBarrier
static void recordPipelineImageBarrier(VkCommandBuffer commandBuffer, VkAccessFlags sourceAccessMask, VkAccessFlags destAccessMask, VkImageLayout sourceLayout, VkImageLayout destLayout, VkImage image)
Definition: testvulkan.c:879
destroySwapchain
static void destroySwapchain(void)
Definition: testvulkan.c:758
vkAcquireNextImageKHR
VKAPI_ATTR VkResult VKAPI_CALL vkAcquireNextImageKHR(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t *pImageIndex)
createSemaphores
static void createSemaphores(void)
Definition: testvulkan.c:581
SDL_memset
#define SDL_memset
Definition: SDL_dynapi_overrides.h:386
VK_TRUE
#define VK_TRUE
Definition: vulkan.h:102
state
static SDLTest_CommonState * state
Definition: testvulkan.c:205
SDLTest_CommonState::windows
SDL_Window ** windows
Definition: SDL_test_common.h:78
SDL_BITSPERPIXEL
#define SDL_BITSPERPIXEL(X)
Definition: SDL_pixels.h:127
SDL_GetError
#define SDL_GetError
Definition: SDL_dynapi_overrides.h:113
image
GLeglImageOES image
Definition: SDL_opengl.h:2148
vkEnumeratePhysicalDevices
VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDevices(VkInstance instance, uint32_t *pPhysicalDeviceCount, VkPhysicalDevice *pPhysicalDevices)
VK_ERROR_INVALID_SHADER_NV
@ VK_ERROR_INVALID_SHADER_NV
Definition: vulkan.h:147
VkSwapchainCreateInfoKHR
Definition: vulkan.h:3547
vkDestroySurfaceKHR
VKAPI_ATTR void VKAPI_CALL vkDestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks *pAllocator)
VkPhysicalDeviceProperties::apiVersion
uint32_t apiVersion
Definition: vulkan.h:1624
vkEnumerateDeviceExtensionProperties
VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, const char *pLayerName, uint32_t *pPropertyCount, VkExtensionProperties *pProperties)
VulkanContext::commandPool
VkCommandPool commandPool
Definition: testvulkan.c:198
VkApplicationInfo::apiVersion
uint32_t apiVersion
Definition: vulkan.h:1376
VkSwapchainCreateInfoKHR::imageUsage
VkImageUsageFlags imageUsage
Definition: vulkan.h:3557
VkSwapchainCreateInfoKHR::sType
VkStructureType sType
Definition: vulkan.h:3548
VkSwapchainCreateInfoKHR::clipped
VkBool32 clipped
Definition: vulkan.h:3564
SDL_Vulkan_GetDrawableSize
#define SDL_Vulkan_GetDrawableSize
Definition: SDL_dynapi_overrides.h:637
VK_ERROR_OUT_OF_DEVICE_MEMORY
@ VK_ERROR_OUT_OF_DEVICE_MEMORY
Definition: vulkan.h:130
VK_EVENT_SET
@ VK_EVENT_SET
Definition: vulkan.h:126
VK_NOT_READY
@ VK_NOT_READY
Definition: vulkan.h:124
vkEndCommandBuffer
VKAPI_ATTR VkResult VKAPI_CALL vkEndCommandBuffer(VkCommandBuffer commandBuffer)
VkSurfaceFormatKHR::format
VkFormat format
Definition: vulkan.h:3493
VkDeviceCreateInfo::queueCreateInfoCount
uint32_t queueCreateInfoCount
Definition: vulkan.h:1673
VkInstanceCreateInfo::enabledExtensionCount
uint32_t enabledExtensionCount
Definition: vulkan.h:1386
vkDestroySemaphore
VKAPI_ATTR void VKAPI_CALL vkDestroySemaphore(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks *pAllocator)
VkPresentInfoKHR::swapchainCount
uint32_t swapchainCount
Definition: vulkan.h:3573
SDL_PollEvent
#define SDL_PollEvent
Definition: SDL_dynapi_overrides.h:122
VK_VERSION_MAJOR
#define VK_VERSION_MAJOR(version)
Definition: vulkan.h:42
VK_FORMAT_UNDEFINED
@ VK_FORMAT_UNDEFINED
Definition: vulkan.h:363
vkResetCommandBuffer
VKAPI_ATTR VkResult VKAPI_CALL vkResetCommandBuffer(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags)
SDL_LOG_CATEGORY_APPLICATION
@ SDL_LOG_CATEGORY_APPLICATION
Definition: SDL_log.h:66
vkCreateSemaphore
VKAPI_ATTR VkResult VKAPI_CALL vkCreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSemaphore *pSemaphore)
VkDeviceQueueCreateInfo::queueFamilyIndex
uint32_t queueFamilyIndex
Definition: vulkan.h:1664
VulkanContext::presentQueueFamilyIndex
uint32_t presentQueueFamilyIndex
Definition: testvulkan.c:185
VulkanContext
Definition: testvulkan.c:177
NULL
#define NULL
Definition: begin_code.h:164
VulkanContext::physicalDevice
VkPhysicalDevice physicalDevice
Definition: testvulkan.c:186
VkImageMemoryBarrier::dstAccessMask
VkAccessFlags dstAccessMask
Definition: vulkan.h:2434
VkSubmitInfo::pWaitDstStageMask
const VkPipelineStageFlags * pWaitDstStageMask
Definition: vulkan.h:1699
VkPresentInfoKHR::pImageIndices
const uint32_t * pImageIndices
Definition: vulkan.h:3575
SDL_GetPerformanceFrequency
Uint64 SDL_GetPerformanceFrequency(void)
Get the count per second of the high resolution counter.
VkSurfaceFormatKHR
Definition: vulkan.h:3492
VkImageMemoryBarrier
Definition: vulkan.h:2430
VulkanContext::surfaceFormats
VkSurfaceFormatKHR * surfaceFormats
Definition: testvulkan.c:192
mode
GLenum mode
Definition: SDL_opengl_glext.h:1122
VkCommandPoolCreateInfo::flags
VkCommandPoolCreateFlags flags
Definition: vulkan.h:2308
vkGetDeviceQueue
VKAPI_ATTR void VKAPI_CALL vkGetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue *pQueue)
loadDeviceFunctions
static void loadDeviceFunctions(void)
Definition: testvulkan.c:529
VulkanContext::surfaceCapabilities
VkSurfaceCapabilitiesKHR surfaceCapabilities
Definition: testvulkan.c:191
SDL_Vulkan_GetInstanceExtensions
#define SDL_Vulkan_GetInstanceExtensions
Definition: SDL_dynapi_overrides.h:635
VkDeviceCreateInfo::sType
VkStructureType sType
Definition: vulkan.h:1670
vkGetPhysicalDeviceFeatures
VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures *pFeatures)
VulkanContext::instance
VkInstance instance
Definition: testvulkan.c:178
VK_QUEUE_FAMILY_IGNORED
#define VK_QUEUE_FAMILY_IGNORED
Definition: vulkan.h:104
VkClearColorValue::float32
float float32[4]
Definition: vulkan.h:2376
VkSurfaceCapabilitiesKHR::maxImageCount
uint32_t maxImageCount
Definition: vulkan.h:3481
SDLTest_CommonState::skip_renderer
SDL_bool skip_renderer
Definition: SDL_test_common.h:83
VkImageSubresourceRange::baseArrayLayer
uint32_t baseArrayLayer
Definition: vulkan.h:1888
VkSubmitInfo::pCommandBuffers
const VkCommandBuffer * pCommandBuffers
Definition: vulkan.h:1701
VkQueueFamilyProperties
Definition: vulkan.h:1635
VkImageSubresourceRange
Definition: vulkan.h:1884
VkSurfaceCapabilitiesKHR::supportedUsageFlags
VkImageUsageFlags supportedUsageFlags
Definition: vulkan.h:3489
VkSwapchainCreateInfoKHR::imageArrayLayers
uint32_t imageArrayLayers
Definition: vulkan.h:3556
VK_STRUCTURE_TYPE_PRESENT_INFO_KHR
@ VK_STRUCTURE_TYPE_PRESENT_INFO_KHR
Definition: vulkan.h:207
VkImageMemoryBarrier::srcQueueFamilyIndex
uint32_t srcQueueFamilyIndex
Definition: vulkan.h:2437
VkImageSubresourceRange::aspectMask
VkImageAspectFlags aspectMask
Definition: vulkan.h:1885
vkCreateDevice
VKAPI_ATTR VkResult VKAPI_CALL vkCreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDevice *pDevice)
VkPipelineStageFlags
VkFlags VkPipelineStageFlags
Definition: vulkan.h:1128
vkCreateFence
VKAPI_ATTR VkResult VKAPI_CALL vkCreateFence(VkDevice device, const VkFenceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkFence *pFence)
VulkanContext::swapchainImages
VkImage * swapchainImages
Definition: testvulkan.c:200
VK_ERROR_EXTENSION_NOT_PRESENT
@ VK_ERROR_EXTENSION_NOT_PRESENT
Definition: vulkan.h:135
VkExtent2D::height
uint32_t height
Definition: vulkan.h:1996
VkSubmitInfo::sType
VkStructureType sType
Definition: vulkan.h:1695
VkSwapchainCreateInfoKHR::minImageCount
uint32_t minImageCount
Definition: vulkan.h:3552
Uint32
uint32_t Uint32
Definition: SDL_stdinc.h:203
VulkanContext::swapchain
VkSwapchainKHR swapchain
Definition: testvulkan.c:181
VK_STRUCTURE_TYPE_FENCE_CREATE_INFO
@ VK_STRUCTURE_TYPE_FENCE_CREATE_INFO
Definition: vulkan.h:165
VulkanContext::graphicsQueueFamilyIndex
uint32_t graphicsQueueFamilyIndex
Definition: testvulkan.c:184
VulkanContext::surfaceFormatsAllocatedCount
uint32_t surfaceFormatsAllocatedCount
Definition: testvulkan.c:193
VK_INCOMPLETE
@ VK_INCOMPLETE
Definition: vulkan.h:128
VulkanContext::imageAvailableSemaphore
VkSemaphore imageAvailableSemaphore
Definition: testvulkan.c:189
VkImageMemoryBarrier::srcAccessMask
VkAccessFlags srcAccessMask
Definition: vulkan.h:2433
createNewSwapchainAndSwapchainSpecificStuff
static SDL_bool createNewSwapchainAndSwapchainSpecificStuff(void)
Definition: testvulkan.c:975
VK_FENCE_CREATE_SIGNALED_BIT
@ VK_FENCE_CREATE_SIGNALED_BIT
Definition: vulkan.h:1155
vkBeginCommandBuffer
VKAPI_ATTR VkResult VKAPI_CALL vkBeginCommandBuffer(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo *pBeginInfo)
h
GLfloat GLfloat GLfloat GLfloat h
Definition: SDL_opengl_glext.h:1946
VK_ERROR_DEVICE_LOST
@ VK_ERROR_DEVICE_LOST
Definition: vulkan.h:132
quit
static void quit(int rc)
Definition: testvulkan.c:211
VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO
@ VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO
Definition: vulkan.h:158
VK_API_VERSION_1_0
#define VK_API_VERSION_1_0
Definition: vulkan.h:40
destroyCommandPool
static void destroyCommandPool(void)
Definition: testvulkan.c:778
result
GLuint64EXT * result
Definition: SDL_opengl_glext.h:9432
SDL_LogError
#define SDL_LogError
Definition: SDL_dynapi_overrides.h:36
vkGetInstanceProcAddr
static PFN_vkGetInstanceProcAddr vkGetInstanceProcAddr
Definition: testvulkan.c:94
vkCmdClearColorImage
VKAPI_ATTR void VKAPI_CALL vkCmdClearColorImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue *pColor, uint32_t rangeCount, const VkImageSubresourceRange *pRanges)
VkImageSubresourceRange::levelCount
uint32_t levelCount
Definition: vulkan.h:1887
vkGetPhysicalDeviceSurfaceFormatsKHR
VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t *pSurfaceFormatCount, VkSurfaceFormatKHR *pSurfaceFormats)
VkSurfaceFormatKHR::colorSpace
VkColorSpaceKHR colorSpace
Definition: vulkan.h:3494
VkSubmitInfo::signalSemaphoreCount
uint32_t signalSemaphoreCount
Definition: vulkan.h:1702
VK_FALSE
#define VK_FALSE
Definition: vulkan.h:103
loadInstanceFunctions
static void loadInstanceFunctions(void)
Definition: testvulkan.c:293
SDLTest_CommonCreateState
SDLTest_CommonState * SDLTest_CommonCreateState(char **argv, Uint32 flags)
Parse command line parameters and create common state.
Definition: SDL_test_common.c:48
SDL_DisplayMode
The structure that defines a display mode.
Definition: SDL_video.h:54
vkDestroyInstance
VKAPI_ATTR void VKAPI_CALL vkDestroyInstance(VkInstance instance, const VkAllocationCallbacks *pAllocator)
VkInstanceCreateInfo
Definition: vulkan.h:1379
VK_ACCESS_TRANSFER_WRITE_BIT
@ VK_ACCESS_TRANSFER_WRITE_BIT
Definition: vulkan.h:1308
VkFenceCreateInfo::sType
VkStructureType sType
Definition: vulkan.h:1804
destroyCommandBuffers
static void destroyCommandBuffers(void)
Definition: testvulkan.c:767
SDLTest_CommonQuit
void SDLTest_CommonQuit(SDLTest_CommonState *state)
Close test window.
Definition: SDL_test_common.c:1794
SDL_GetWindowSize
#define SDL_GetWindowSize
Definition: SDL_dynapi_overrides.h:527
VkSubmitInfo::waitSemaphoreCount
uint32_t waitSemaphoreCount
Definition: vulkan.h:1697
SDL_Vulkan_CreateSurface
#define SDL_Vulkan_CreateSurface
Definition: SDL_dynapi_overrides.h:636
VK_PRESENT_MODE_FIFO_KHR
@ VK_PRESENT_MODE_FIFO_KHR
Definition: vulkan.h:3445
VkSwapchainCreateInfoKHR::imageColorSpace
VkColorSpaceKHR imageColorSpace
Definition: vulkan.h:3554
vkCreateInstance
VKAPI_ATTR VkResult VKAPI_CALL vkCreateInstance(const VkInstanceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkInstance *pInstance)
vkResetFences
VKAPI_ATTR VkResult VKAPI_CALL vkResetFences(VkDevice device, uint32_t fenceCount, const VkFence *pFences)
SDLTest_CommonState::num_windows
int num_windows
Definition: SDL_test_common.h:77
VkDeviceCreateInfo::pEnabledFeatures
const VkPhysicalDeviceFeatures * pEnabledFeatures
Definition: vulkan.h:1679
VK_QUEUE_GRAPHICS_BIT
@ VK_QUEUE_GRAPHICS_BIT
Definition: vulkan.h:1080
VK_IMAGE_LAYOUT_PRESENT_SRC_KHR
@ VK_IMAGE_LAYOUT_PRESENT_SRC_KHR
Definition: vulkan.h:622
event
struct _cl_event * event
Definition: SDL_opengl_glext.h:2649
done
int done
Definition: checkkeys.c:28
vkWaitForFences
VKAPI_ATTR VkResult VKAPI_CALL vkWaitForFences(VkDevice device, uint32_t fenceCount, const VkFence *pFences, VkBool32 waitAll, uint64_t timeout)
VkPresentInfoKHR::sType
VkStructureType sType
Definition: vulkan.h:3569
VkClearColorValue
Definition: vulkan.h:2375
VK_ERROR_MEMORY_MAP_FAILED
@ VK_ERROR_MEMORY_MAP_FAILED
Definition: vulkan.h:133
vkGetPhysicalDeviceSurfaceCapabilitiesKHR
VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR *pSurfaceCapabilities)
vkAllocateCommandBuffers
VKAPI_ATTR VkResult VKAPI_CALL vkAllocateCommandBuffers(VkDevice device, const VkCommandBufferAllocateInfo *pAllocateInfo, VkCommandBuffer *pCommandBuffers)
VK_KHR_SWAPCHAIN_EXTENSION_NAME
#define VK_KHR_SWAPCHAIN_EXTENSION_NAME
Definition: vulkan.h:3538
VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO
@ VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO
Definition: vulkan.h:159
VulkanContext::surface
VkSurfaceKHR surface
Definition: testvulkan.c:180
VulkanContext::physicalDeviceFeatures
VkPhysicalDeviceFeatures physicalDeviceFeatures
Definition: testvulkan.c:183
VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO
@ VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO
Definition: vulkan.h:196
VK_IMAGE_USAGE_TRANSFER_DST_BIT
@ VK_IMAGE_USAGE_TRANSFER_DST_BIT
Definition: vulkan.h:1044
VK_PIPELINE_STAGE_TRANSFER_BIT
@ VK_PIPELINE_STAGE_TRANSFER_BIT
Definition: vulkan.h:1120
retval
SDL_bool retval
Definition: testgamecontroller.c:65
VK_ERROR_FEATURE_NOT_PRESENT
@ VK_ERROR_FEATURE_NOT_PRESENT
Definition: vulkan.h:136
VK_SUCCESS
@ VK_SUCCESS
Definition: vulkan.h:123
VkImageMemoryBarrier::oldLayout
VkImageLayout oldLayout
Definition: vulkan.h:2435
SDL_Log
#define SDL_Log
Definition: SDL_dynapi_overrides.h:31
createCommandBuffers
static void createCommandBuffers(void)
Definition: testvulkan.c:806
createInstance
static void createInstance(void)
Definition: testvulkan.c:245
VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO
@ VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO
Definition: vulkan.h:166
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)
SDL_free
#define SDL_free
Definition: SDL_dynapi_overrides.h:377
VkCommandPoolCreateInfo::sType
VkStructureType sType
Definition: vulkan.h:2306
VK_ERROR_OUT_OF_DATE_KHR
@ VK_ERROR_OUT_OF_DATE_KHR
Definition: vulkan.h:144
VK_NULL_HANDLE
#define VK_NULL_HANDLE
Definition: vulkan.h:49
name
GLuint const GLchar * name
Definition: SDL_opengl_glext.h:660
VkCommandBufferAllocateInfo::commandPool
VkCommandPool commandPool
Definition: vulkan.h:2315
SDLTest_CommonArg
int SDLTest_CommonArg(SDLTest_CommonState *state, int index)
Process one common argument.
Definition: SDL_test_common.c:106
VkExtent2D::width
uint32_t width
Definition: vulkan.h:1995
vkGetPhysicalDeviceSurfaceSupportKHR
VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32 *pSupported)
SDL_Vulkan_LoadLibrary
#define SDL_Vulkan_LoadLibrary
Definition: SDL_dynapi_overrides.h:632
VkSwapchainCreateInfoKHR::imageFormat
VkFormat imageFormat
Definition: vulkan.h:3553
VulkanContext::swapchainSize
VkExtent2D swapchainSize
Definition: testvulkan.c:197
VkImageSubresourceRange::layerCount
uint32_t layerCount
Definition: vulkan.h:1889
VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER
@ VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER
Definition: vulkan.h:202
SDL_GetTicks
Uint32 SDL_GetTicks(void)
Get the number of milliseconds since the SDL library initialization.
VK_STRUCTURE_TYPE_SUBMIT_INFO
@ VK_STRUCTURE_TYPE_SUBMIT_INFO
Definition: vulkan.h:161
VkPresentInfoKHR
Definition: vulkan.h:3568
VK_FORMAT_R8G8B8A8_UNORM
@ VK_FORMAT_R8G8B8A8_UNORM
Definition: vulkan.h:400
vkCreateSwapchainKHR
VKAPI_ATTR VkResult VKAPI_CALL vkCreateSwapchainKHR(VkDevice device, const VkSwapchainCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSwapchainKHR *pSwapchain)
vkQueuePresentKHR
VKAPI_ATTR VkResult VKAPI_CALL vkQueuePresentKHR(VkQueue queue, const VkPresentInfoKHR *pPresentInfo)
getVulkanResultString
static const char * getVulkanResultString(VkResult result)
Definition: testvulkan.c:111
VK_ACCESS_MEMORY_READ_BIT
@ VK_ACCESS_MEMORY_READ_BIT
Definition: vulkan.h:1311
VkInstanceCreateInfo::sType
VkStructureType sType
Definition: vulkan.h:1380
vkDestroyFence
VKAPI_ATTR void VKAPI_CALL vkDestroyFence(VkDevice device, VkFence fence, const VkAllocationCallbacks *pAllocator)
UINT64_MAX
#define UINT64_MAX
Definition: testvulkan.c:39
VkSubmitInfo
Definition: vulkan.h:1694
SDL_TRUE
@ SDL_TRUE
Definition: SDL_stdinc.h:164
VkImageMemoryBarrier::image
VkImage image
Definition: vulkan.h:2439
VK_IMAGE_ASPECT_COLOR_BIT
@ VK_IMAGE_ASPECT_COLOR_BIT
Definition: vulkan.h:1132
SDL_Delay
#define SDL_Delay
Definition: SDL_dynapi_overrides.h:486
VkImageMemoryBarrier::newLayout
VkImageLayout newLayout
Definition: vulkan.h:2436
VK_ERROR_INITIALIZATION_FAILED
@ VK_ERROR_INITIALIZATION_FAILED
Definition: vulkan.h:131
SDL_GetPerformanceCounter
#define SDL_GetPerformanceCounter
Definition: SDL_dynapi_overrides.h:484
VkCommandPoolCreateInfo::queueFamilyIndex
uint32_t queueFamilyIndex
Definition: vulkan.h:2309
vulkanContext
static VulkanContext vulkanContext
Definition: testvulkan.c:206
VK_ERROR_INCOMPATIBLE_DISPLAY_KHR
@ VK_ERROR_INCOMPATIBLE_DISPLAY_KHR
Definition: vulkan.h:145
VkSubmitInfo::commandBufferCount
uint32_t commandBufferCount
Definition: vulkan.h:1700
createDevice
static void createDevice(void)
Definition: testvulkan.c:497
VkCommandPoolCreateInfo
Definition: vulkan.h:2305
createCommandPool
static void createCommandPool(void)
Definition: testvulkan.c:785
VK_EVENT_RESET
@ VK_EVENT_RESET
Definition: vulkan.h:127
getSurfaceFormats
static void getSurfaceFormats(void)
Definition: testvulkan.c:608
VkCommandBufferAllocateInfo
Definition: vulkan.h:2312
VkDeviceQueueCreateInfo
Definition: vulkan.h:1660
VK_COMMAND_POOL_CREATE_TRANSIENT_BIT
@ VK_COMMAND_POOL_CREATE_TRANSIENT_BIT
Definition: vulkan.h:1329
SDL_OutOfMemory
#define SDL_OutOfMemory()
Definition: SDL_error.h:52
VK_RESULT_RANGE_SIZE
@ VK_RESULT_RANGE_SIZE
Definition: vulkan.h:152
VK_ERROR_OUT_OF_POOL_MEMORY_KHR
@ VK_ERROR_OUT_OF_POOL_MEMORY_KHR
Definition: vulkan.h:148
vkDestroyDevice
VKAPI_ATTR void VKAPI_CALL vkDestroyDevice(VkDevice device, const VkAllocationCallbacks *pAllocator)
VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR
@ VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR
Definition: vulkan.h:206
VULKAN_FUNCTIONS
#define VULKAN_FUNCTIONS()
Definition: testvulkan.c:42
vkGetPhysicalDeviceQueueFamilyProperties
VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice, uint32_t *pQueueFamilyPropertyCount, VkQueueFamilyProperties *pQueueFamilyProperties)
destroySwapchainAndSwapchainSpecificStuff
static void destroySwapchainAndSwapchainSpecificStuff(SDL_bool doDestroySwapchain)
Definition: testvulkan.c:966
SDL_arraysize
#define SDL_arraysize(array)
Definition: SDL_stdinc.h:115
createFences
static void createFences(void)
Definition: testvulkan.c:830
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL
@ VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL
Definition: vulkan.h:620
destroyFences
static void destroyFences(void)
Definition: testvulkan.c:865
SDLTest_CommonInit
SDL_bool SDLTest_CommonInit(SDLTest_CommonState *state)
Open test window.
Definition: SDL_test_common.c:726
vkGetPhysicalDeviceProperties
VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties *pProperties)
VkBool32
uint32_t VkBool32
Definition: vulkan.h:67
VkSwapchainCreateInfoKHR::imageSharingMode
VkSharingMode imageSharingMode
Definition: vulkan.h:3558
vkDestroySwapchainKHR
VKAPI_ATTR void VKAPI_CALL vkDestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks *pAllocator)
VkApplicationInfo::sType
VkStructureType sType
Definition: vulkan.h:1370
SDL_INIT_VIDEO
#define SDL_INIT_VIDEO
Definition: SDL.h:79
SDL_LOG_PRIORITY_INFO
@ SDL_LOG_PRIORITY_INFO
Definition: SDL_log.h:106
VkResult
VkResult
Definition: vulkan.h:122
VkInstanceCreateInfo::ppEnabledExtensionNames
const char *const * ppEnabledExtensionNames
Definition: vulkan.h:1387
VkCommandBufferBeginInfo
Definition: vulkan.h:2331
SDLTest_CommonState::window_flags
Uint32 window_flags
Definition: SDL_test_common.h:63
VK_STRUCTURE_TYPE_APPLICATION_INFO
@ VK_STRUCTURE_TYPE_APPLICATION_INFO
Definition: vulkan.h:157
uint32_t
unsigned int uint32_t
Definition: SDL_config_windows.h:63
getSwapchainImages
static void getSwapchainImages(void)
Definition: testvulkan.c:649
VulkanContext::fences
VkFence * fences
Definition: testvulkan.c:202
VK_ERROR_FRAGMENTED_POOL
@ VK_ERROR_FRAGMENTED_POOL
Definition: vulkan.h:140
VK_ERROR_VALIDATION_FAILED_EXT
@ VK_ERROR_VALIDATION_FAILED_EXT
Definition: vulkan.h:146
SDL_LogSetPriority
#define SDL_LogSetPriority
Definition: SDL_dynapi_overrides.h:236
vkCreateCommandPool
VKAPI_ATTR VkResult VKAPI_CALL vkCreateCommandPool(VkDevice device, const VkCommandPoolCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkCommandPool *pCommandPool)
VkSubmitInfo::pSignalSemaphores
const VkSemaphore * pSignalSemaphores
Definition: vulkan.h:1703
VK_SHARING_MODE_EXCLUSIVE
@ VK_SHARING_MODE_EXCLUSIVE
Definition: vulkan.h:604
VulkanContext::physicalDeviceProperties
VkPhysicalDeviceProperties physicalDeviceProperties
Definition: testvulkan.c:182
VkSemaphoreCreateInfo
Definition: vulkan.h:1809
VulkanContext::surfaceFormatsCount
uint32_t surfaceFormatsCount
Definition: testvulkan.c:194
VkFenceCreateInfo::flags
VkFenceCreateFlags flags
Definition: vulkan.h:1806
VkSwapchainCreateInfoKHR::presentMode
VkPresentModeKHR presentMode
Definition: vulkan.h:3563
getQueues
static void getQueues(void)
Definition: testvulkan.c:549
VkDeviceCreateInfo::ppEnabledExtensionNames
const char *const * ppEnabledExtensionNames
Definition: vulkan.h:1678
VkApplicationInfo
Definition: vulkan.h:1369
initVulkan
static void initVulkan(void)
Definition: testvulkan.c:988
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::commandBuffers
VkCommandBuffer * commandBuffers
Definition: testvulkan.c:201
VkDeviceCreateInfo::pQueueCreateInfos
const VkDeviceQueueCreateInfo * pQueueCreateInfos
Definition: vulkan.h:1674
VK_ERROR_SURFACE_LOST_KHR
@ VK_ERROR_SURFACE_LOST_KHR
Definition: vulkan.h:141
VkSwapchainCreateInfoKHR::preTransform
VkSurfaceTransformFlagBitsKHR preTransform
Definition: vulkan.h:3561
VkDeviceQueueCreateInfo::sType
VkStructureType sType
Definition: vulkan.h:1661
VulkanContext::device
VkDevice device
Definition: testvulkan.c:179
VK_ERROR_OUT_OF_HOST_MEMORY
@ VK_ERROR_OUT_OF_HOST_MEMORY
Definition: vulkan.h:129
VkFenceCreateInfo
Definition: vulkan.h:1803
VkCommandBufferBeginInfo::flags
VkCommandBufferUsageFlags flags
Definition: vulkan.h:2334
shutdownVulkan
static void shutdownVulkan(void)
Definition: testvulkan.c:1004
VkDeviceQueueCreateInfo::queueCount
uint32_t queueCount
Definition: vulkan.h:1665
VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO
@ VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO
Definition: vulkan.h:160
VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT
@ VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT
Definition: vulkan.h:1047
VkSurfaceCapabilitiesKHR::minImageCount
uint32_t minImageCount
Definition: vulkan.h:3480
SDL_Vulkan_GetVkGetInstanceProcAddr
#define SDL_Vulkan_GetVkGetInstanceProcAddr
Definition: SDL_dynapi_overrides.h:633
VkCommandBufferAllocateInfo::sType
VkStructureType sType
Definition: vulkan.h:2313
VulkanContext::renderingFinishedSemaphore
VkSemaphore renderingFinishedSemaphore
Definition: testvulkan.c:190
VulkanContext::presentQueue
VkQueue presentQueue
Definition: testvulkan.c:188
SDL_bool
SDL_bool
Definition: SDL_stdinc.h:162
SDL_GetCurrentDisplayMode
#define SDL_GetCurrentDisplayMode
Definition: SDL_dynapi_overrides.h:508
VK_COLORSPACE_SRGB_NONLINEAR_KHR
#define VK_COLORSPACE_SRGB_NONLINEAR_KHR
Definition: vulkan.h:3417
VkSwapchainCreateInfoKHR::imageExtent
VkExtent2D imageExtent
Definition: vulkan.h:3555
SDL_Event
General event structure.
Definition: SDL_events.h:558
VkDeviceCreateInfo
Definition: vulkan.h:1669
vkGetDeviceProcAddr
VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetDeviceProcAddr(VkDevice device, const char *pName)
VulkanContext::swapchainDesiredImageCount
uint32_t swapchainDesiredImageCount
Definition: testvulkan.c:195
VK_COMMAND_BUFFER_LEVEL_PRIMARY
@ VK_COMMAND_BUFFER_LEVEL_PRIMARY
Definition: vulkan.h:951
SDL_FALSE
@ SDL_FALSE
Definition: SDL_stdinc.h:163
VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO
@ VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO
Definition: vulkan.h:199
SDLTest_CommonUsage
const char * SDLTest_CommonUsage(SDLTest_CommonState *state)
Returns common usage information.
Definition: SDL_test_common.c:478
createSwapchain
static SDL_bool createSwapchain(void)
Definition: testvulkan.c:687
VkImageSubresourceRange::baseMipLevel
uint32_t baseMipLevel
Definition: vulkan.h:1886
SDL_Vulkan_UnloadLibrary
#define SDL_Vulkan_UnloadLibrary
Definition: SDL_dynapi_overrides.h:634
SDLTest_CommonEvent
void SDLTest_CommonEvent(SDLTest_CommonState *state, SDL_Event *event, int *done)
Common event handler for test windows.
Definition: SDL_test_common.c:1463
VK_ERROR_INCOMPATIBLE_DRIVER
@ VK_ERROR_INCOMPATIBLE_DRIVER
Definition: vulkan.h:137
VkExtensionProperties
Definition: vulkan.h:1682
SDL_malloc
#define SDL_malloc
Definition: SDL_dynapi_overrides.h:374
VkImageMemoryBarrier::sType
VkStructureType sType
Definition: vulkan.h:2431
SDL_strcmp
#define SDL_strcmp
Definition: SDL_dynapi_overrides.h:417
VK_ERROR_FORMAT_NOT_SUPPORTED
@ VK_ERROR_FORMAT_NOT_SUPPORTED
Definition: vulkan.h:139
VK_SUBOPTIMAL_KHR
@ VK_SUBOPTIMAL_KHR
Definition: vulkan.h:143
VkCommandBufferBeginInfo::sType
VkStructureType sType
Definition: vulkan.h:2332
VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT
@ VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT
Definition: vulkan.h:1330
VK_TIMEOUT
@ VK_TIMEOUT
Definition: vulkan.h:125
vkDestroyCommandPool
VKAPI_ATTR void VKAPI_CALL vkDestroyCommandPool(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks *pAllocator)
VkPresentInfoKHR::waitSemaphoreCount
uint32_t waitSemaphoreCount
Definition: vulkan.h:3571
findPhysicalDevice
static void findPhysicalDevice(void)
Definition: testvulkan.c:324
VkCommandBufferAllocateInfo::level
VkCommandBufferLevel level
Definition: vulkan.h:2316
VkImageMemoryBarrier::subresourceRange
VkImageSubresourceRange subresourceRange
Definition: vulkan.h:2440
VkDeviceCreateInfo::enabledExtensionCount
uint32_t enabledExtensionCount
Definition: vulkan.h:1677
VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR
@ VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR
Definition: vulkan.h:3471
VkSwapchainCreateInfoKHR::surface
VkSurfaceKHR surface
Definition: vulkan.h:3551
VK_ERROR_LAYER_NOT_PRESENT
@ VK_ERROR_LAYER_NOT_PRESENT
Definition: vulkan.h:134
VK_ERROR_NATIVE_WINDOW_IN_USE_KHR
@ VK_ERROR_NATIVE_WINDOW_IN_USE_KHR
Definition: vulkan.h:142
VkSurfaceCapabilitiesKHR::currentTransform
VkSurfaceTransformFlagBitsKHR currentTransform
Definition: vulkan.h:3487
VkSwapchainCreateInfoKHR::compositeAlpha
VkCompositeAlphaFlagBitsKHR compositeAlpha
Definition: vulkan.h:3562
SDL_sin
#define SDL_sin
Definition: SDL_dynapi_overrides.h:435
createSurface
static void createSurface(void)
Definition: testvulkan.c:311
VulkanContext::swapchainImageCount
uint32_t swapchainImageCount
Definition: testvulkan.c:199
vkDeviceWaitIdle
VKAPI_ATTR VkResult VKAPI_CALL vkDeviceWaitIdle(VkDevice device)
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
rerecordCommandBuffer
static void rerecordCommandBuffer(uint32_t frameIndex, const VkClearColorValue *clearColor)
Definition: testvulkan.c:912
VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT
@ VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT
Definition: vulkan.h:1344
VkPresentInfoKHR::pWaitSemaphores
const VkSemaphore * pWaitSemaphores
Definition: vulkan.h:3572
vkFreeCommandBuffers
VKAPI_ATTR void VKAPI_CALL vkFreeCommandBuffers(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer *pCommandBuffers)
VulkanContext::surfaceFormat
VkSurfaceFormatKHR surfaceFormat
Definition: testvulkan.c:196
VkSemaphoreCreateInfo::sType
VkStructureType sType
Definition: vulkan.h:1810
VkSubmitInfo::pWaitSemaphores
const VkSemaphore * pWaitSemaphores
Definition: vulkan.h:1698
VkCommandBufferAllocateInfo::commandBufferCount
uint32_t commandBufferCount
Definition: vulkan.h:2317
VkInstanceCreateInfo::pApplicationInfo
const VkApplicationInfo * pApplicationInfo
Definition: vulkan.h:1383
VkSwapchainCreateInfoKHR::oldSwapchain
VkSwapchainKHR oldSwapchain
Definition: vulkan.h:3565
getSurfaceCaps
static void getSurfaceCaps(void)
Definition: testvulkan.c:587
VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO
@ VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO
Definition: vulkan.h:197
VkImageMemoryBarrier::dstQueueFamilyIndex
uint32_t dstQueueFamilyIndex
Definition: vulkan.h:2438
VK_ERROR_TOO_MANY_OBJECTS
@ VK_ERROR_TOO_MANY_OBJECTS
Definition: vulkan.h:138
loadGlobalFunctions
static void loadGlobalFunctions(void)
Definition: testvulkan.c:218
VK_RESULT_MAX_ENUM
@ VK_RESULT_MAX_ENUM
Definition: vulkan.h:153
render
static SDL_bool render(void)
Definition: testvulkan.c:1023
VkPresentInfoKHR::pSwapchains
const VkSwapchainKHR * pSwapchains
Definition: vulkan.h:3574
w
GLubyte GLubyte GLubyte GLubyte w
Definition: SDL_opengl_glext.h:731
VkDeviceQueueCreateInfo::pQueuePriorities
const float * pQueuePriorities
Definition: vulkan.h:1666
createSemaphore
static void createSemaphore(VkSemaphore *semaphore)
Definition: testvulkan.c:564
SDL_WINDOW_VULKAN
@ SDL_WINDOW_VULKAN
Definition: SDL_video.h:122
VulkanContext::graphicsQueue
VkQueue graphicsQueue
Definition: testvulkan.c:187
VK_IMAGE_LAYOUT_UNDEFINED
@ VK_IMAGE_LAYOUT_UNDEFINED
Definition: vulkan.h:613