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, VulkanContext::commandPool, VkCommandBufferAllocateInfo::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, VulkanContext::surface, VkSwapchainCreateInfoKHR::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 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 
1142  /* Set Vulkan parameters */
1144  state->num_windows = 1;
1145  state->skip_renderer = 1;
1146 
1147  if (!SDLTest_CommonDefaultArgs(state, argc, argv) || !SDLTest_CommonInit(state)) {
1149  return 1;
1150  }
1151 
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  {
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 }

References done, frames, 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_CommonCreateState(), SDLTest_CommonDefaultArgs(), SDLTest_CommonEvent(), SDLTest_CommonInit(), SDLTest_CommonQuit(), 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

vkResetFences
VKAPI_ATTR VkResult VKAPI_CALL vkResetFences(VkDevice device, uint32_t fenceCount, const VkFence *pFences)
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
vkDeviceWaitIdle
VKAPI_ATTR VkResult VKAPI_CALL vkDeviceWaitIdle(VkDevice device)
vkResetCommandBuffer
VKAPI_ATTR VkResult VKAPI_CALL vkResetCommandBuffer(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags)
createSemaphores
static void createSemaphores(void)
Definition: testvulkan.c:581
SDL_memset
#define SDL_memset
Definition: SDL_dynapi_overrides.h:386
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
VkSwapchainCreateInfoKHR
Definition: vulkan_core.h:4810
VkPhysicalDeviceProperties::apiVersion
uint32_t apiVersion
Definition: vulkan_core.h:1989
VK_STRUCTURE_TYPE_FENCE_CREATE_INFO
Definition: vulkan_core.h:168
VulkanContext::commandPool
VkCommandPool commandPool
Definition: testvulkan.c:198
VkApplicationInfo::apiVersion
uint32_t apiVersion
Definition: vulkan_core.h:1741
VkSwapchainCreateInfoKHR::imageUsage
VkImageUsageFlags imageUsage
Definition: vulkan_core.h:4820
VkSwapchainCreateInfoKHR::sType
VkStructureType sType
Definition: vulkan_core.h:4811
vkDestroyCommandPool
VKAPI_ATTR void VKAPI_CALL vkDestroyCommandPool(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks *pAllocator)
VkSwapchainCreateInfoKHR::clipped
VkBool32 clipped
Definition: vulkan_core.h:4827
SDL_Vulkan_GetDrawableSize
#define SDL_Vulkan_GetDrawableSize
Definition: SDL_dynapi_overrides.h:637
VK_IMAGE_USAGE_TRANSFER_DST_BIT
Definition: vulkan_core.h:1342
vkCmdClearColorImage
VKAPI_ATTR void VKAPI_CALL vkCmdClearColorImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue *pColor, uint32_t rangeCount, const VkImageSubresourceRange *pRanges)
VkSurfaceFormatKHR::format
VkFormat format
Definition: vulkan_core.h:4746
VkDeviceCreateInfo::queueCreateInfoCount
uint32_t queueCreateInfoCount
Definition: vulkan_core.h:2038
VkInstanceCreateInfo::enabledExtensionCount
uint32_t enabledExtensionCount
Definition: vulkan_core.h:1751
VkPresentInfoKHR::swapchainCount
uint32_t swapchainCount
Definition: vulkan_core.h:4836
SDL_PollEvent
#define SDL_PollEvent
Definition: SDL_dynapi_overrides.h:122
vkDestroyDevice
VKAPI_ATTR void VKAPI_CALL vkDestroyDevice(VkDevice device, const VkAllocationCallbacks *pAllocator)
VK_KHR_SWAPCHAIN_EXTENSION_NAME
#define VK_KHR_SWAPCHAIN_EXTENSION_NAME
Definition: vulkan_core.h:4791
VK_ERROR_MEMORY_MAP_FAILED
Definition: vulkan_core.h:131
vkEnumeratePhysicalDevices
VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDevices(VkInstance instance, uint32_t *pPhysicalDeviceCount, VkPhysicalDevice *pPhysicalDevices)
SDL_LOG_CATEGORY_APPLICATION
Definition: SDL_log.h:66
VK_FENCE_CREATE_SIGNALED_BIT
Definition: vulkan_core.h:1492
VkDeviceQueueCreateInfo::queueFamilyIndex
uint32_t queueFamilyIndex
Definition: vulkan_core.h:2029
VulkanContext::presentQueueFamilyIndex
uint32_t presentQueueFamilyIndex
Definition: testvulkan.c:185
vkDestroyInstance
VKAPI_ATTR void VKAPI_CALL vkDestroyInstance(VkInstance instance, const VkAllocationCallbacks *pAllocator)
VK_ERROR_INCOMPATIBLE_DISPLAY_KHR
Definition: vulkan_core.h:145
vkGetPhysicalDeviceSurfaceSupportKHR
VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32 *pSupported)
VulkanContext
Definition: testvulkan.c:176
VK_RESULT_MAX_ENUM
Definition: vulkan_core.h:156
NULL
#define NULL
Definition: begin_code.h:167
VK_NOT_READY
Definition: vulkan_core.h:122
VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT
Definition: vulkan_core.h:1709
VulkanContext::physicalDevice
VkPhysicalDevice physicalDevice
Definition: testvulkan.c:186
VkImageMemoryBarrier::dstAccessMask
VkAccessFlags dstAccessMask
Definition: vulkan_core.h:2799
VkSubmitInfo::pWaitDstStageMask
const VkPipelineStageFlags * pWaitDstStageMask
Definition: vulkan_core.h:2064
VkPresentInfoKHR::pImageIndices
const uint32_t * pImageIndices
Definition: vulkan_core.h:4838
SDL_GetPerformanceFrequency
Uint64 SDL_GetPerformanceFrequency(void)
Get the count per second of the high resolution counter.
VkSurfaceFormatKHR
Definition: vulkan_core.h:4745
VK_STRUCTURE_TYPE_SUBMIT_INFO
Definition: vulkan_core.h:164
VkImageMemoryBarrier
Definition: vulkan_core.h:2795
vkGetDeviceProcAddr
VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetDeviceProcAddr(VkDevice device, const char *pName)
VulkanContext::surfaceFormats
VkSurfaceFormatKHR * surfaceFormats
Definition: testvulkan.c:192
mode
GLenum mode
Definition: SDL_opengl_glext.h:1122
VkCommandPoolCreateInfo::flags
VkCommandPoolCreateFlags flags
Definition: vulkan_core.h:2673
VK_STRUCTURE_TYPE_PRESENT_INFO_KHR
Definition: vulkan_core.h:275
VK_EVENT_SET
Definition: vulkan_core.h:124
VK_ACCESS_TRANSFER_WRITE_BIT
Definition: vulkan_core.h:1663
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_core.h:2035
VulkanContext::instance
VkInstance instance
Definition: testvulkan.c:178
VkClearColorValue::float32
float float32[4]
Definition: vulkan_core.h:2741
VK_PRESENT_MODE_FIFO_KHR
Definition: vulkan_core.h:4698
VkSurfaceCapabilitiesKHR::maxImageCount
uint32_t maxImageCount
Definition: vulkan_core.h:4734
SDLTest_CommonState::skip_renderer
SDL_bool skip_renderer
Definition: SDL_test_common.h:83
VkImageSubresourceRange::baseArrayLayer
uint32_t baseArrayLayer
Definition: vulkan_core.h:2253
VkSubmitInfo::pCommandBuffers
const VkCommandBuffer * pCommandBuffers
Definition: vulkan_core.h:2066
VK_TIMEOUT
Definition: vulkan_core.h:123
VK_ACCESS_MEMORY_READ_BIT
Definition: vulkan_core.h:1666
vkWaitForFences
VKAPI_ATTR VkResult VKAPI_CALL vkWaitForFences(VkDevice device, uint32_t fenceCount, const VkFence *pFences, VkBool32 waitAll, uint64_t timeout)
VkQueueFamilyProperties
Definition: vulkan_core.h:2000
VK_RESULT_RANGE_SIZE
Definition: vulkan_core.h:155
VkImageSubresourceRange
Definition: vulkan_core.h:2249
VK_COMMAND_BUFFER_LEVEL_PRIMARY
Definition: vulkan_core.h:1216
VK_ERROR_FRAGMENTED_POOL
Definition: vulkan_core.h:138
VkSurfaceCapabilitiesKHR::supportedUsageFlags
VkImageUsageFlags supportedUsageFlags
Definition: vulkan_core.h:4742
VkSwapchainCreateInfoKHR::imageArrayLayers
uint32_t imageArrayLayers
Definition: vulkan_core.h:4819
VkImageMemoryBarrier::srcQueueFamilyIndex
uint32_t srcQueueFamilyIndex
Definition: vulkan_core.h:2802
VkImageSubresourceRange::aspectMask
VkImageAspectFlags aspectMask
Definition: vulkan_core.h:2250
VulkanContext::swapchainImages
VkImage * swapchainImages
Definition: testvulkan.c:200
VkExtent2D::height
uint32_t height
Definition: vulkan_core.h:2361
VkSubmitInfo::sType
VkStructureType sType
Definition: vulkan_core.h:2060
VkSwapchainCreateInfoKHR::minImageCount
uint32_t minImageCount
Definition: vulkan_core.h:4815
VulkanContext::swapchain
VkSwapchainKHR swapchain
Definition: testvulkan.c:181
VulkanContext::graphicsQueueFamilyIndex
uint32_t graphicsQueueFamilyIndex
Definition: testvulkan.c:184
VulkanContext::surfaceFormatsAllocatedCount
uint32_t surfaceFormatsAllocatedCount
Definition: testvulkan.c:193
VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT
Definition: vulkan_core.h:1345
VulkanContext::imageAvailableSemaphore
VkSemaphore imageAvailableSemaphore
Definition: testvulkan.c:189
VkImageMemoryBarrier::srcAccessMask
VkAccessFlags srcAccessMask
Definition: vulkan_core.h:2798
createNewSwapchainAndSwapchainSpecificStuff
static SDL_bool createNewSwapchainAndSwapchainSpecificStuff(void)
Definition: testvulkan.c:975
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL
Definition: vulkan_core.h:873
VK_ERROR_OUT_OF_POOL_MEMORY_KHR
Definition: vulkan_core.h:151
VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO
Definition: vulkan_core.h:202
vkCreateSemaphore
VKAPI_ATTR VkResult VKAPI_CALL vkCreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSemaphore *pSemaphore)
h
GLfloat GLfloat GLfloat GLfloat h
Definition: SDL_opengl_glext.h:1946
VkBool32
uint32_t VkBool32
Definition: vulkan_core.h:65
quit
static void quit(int rc)
Definition: testvulkan.c:211
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
VK_ERROR_LAYER_NOT_PRESENT
Definition: vulkan_core.h:132
vkEnumerateDeviceExtensionProperties
VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, const char *pLayerName, uint32_t *pPropertyCount, VkExtensionProperties *pProperties)
vkGetInstanceProcAddr
static PFN_vkGetInstanceProcAddr vkGetInstanceProcAddr
Definition: testvulkan.c:94
VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO
Definition: vulkan_core.h:163
VkImageSubresourceRange::levelCount
uint32_t levelCount
Definition: vulkan_core.h:2252
VkSurfaceFormatKHR::colorSpace
VkColorSpaceKHR colorSpace
Definition: vulkan_core.h:4747
VkSubmitInfo::signalSemaphoreCount
uint32_t signalSemaphoreCount
Definition: vulkan_core.h:2067
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:59
SDL_DisplayMode
The structure that defines a display mode.
Definition: SDL_video.h:53
VkInstanceCreateInfo
Definition: vulkan_core.h:1744
VK_PIPELINE_STAGE_TRANSFER_BIT
Definition: vulkan_core.h:1440
VkFenceCreateInfo::sType
VkStructureType sType
Definition: vulkan_core.h:2169
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:1832
SDL_GetWindowSize
#define SDL_GetWindowSize
Definition: SDL_dynapi_overrides.h:527
VkSubmitInfo::waitSemaphoreCount
uint32_t waitSemaphoreCount
Definition: vulkan_core.h:2062
SDL_Vulkan_CreateSurface
#define SDL_Vulkan_CreateSurface
Definition: SDL_dynapi_overrides.h:636
VK_ERROR_INITIALIZATION_FAILED
Definition: vulkan_core.h:129
vkQueuePresentKHR
VKAPI_ATTR VkResult VKAPI_CALL vkQueuePresentKHR(VkQueue queue, const VkPresentInfoKHR *pPresentInfo)
VkSwapchainCreateInfoKHR::imageColorSpace
VkColorSpaceKHR imageColorSpace
Definition: vulkan_core.h:4817
VK_SHARING_MODE_EXCLUSIVE
Definition: vulkan_core.h:857
VK_SUCCESS
Definition: vulkan_core.h:121
VK_TRUE
#define VK_TRUE
Definition: vulkan_core.h:100
SDLTest_CommonState::num_windows
int num_windows
Definition: SDL_test_common.h:77
VK_EVENT_RESET
Definition: vulkan_core.h:125
VkDeviceCreateInfo::pEnabledFeatures
const VkPhysicalDeviceFeatures * pEnabledFeatures
Definition: vulkan_core.h:2044
event
struct _cl_event * event
Definition: SDL_opengl_glext.h:2649
done
int done
Definition: checkkeys.c:28
VK_NULL_HANDLE
#define VK_NULL_HANDLE
Definition: vulkan_core.h:49
SDLTest_CommonDefaultArgs
SDL_bool SDLTest_CommonDefaultArgs(SDLTest_CommonState *state, const int argc, char **argv)
Easy argument handling when test app doesn't need any custom args.
Definition: SDL_test_common.c:516
VkPresentInfoKHR::sType
VkStructureType sType
Definition: vulkan_core.h:4832
VkClearColorValue
Definition: vulkan_core.h:2740
vkCreateInstance
VKAPI_ATTR VkResult VKAPI_CALL vkCreateInstance(const VkInstanceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkInstance *pInstance)
VulkanContext::surface
VkSurfaceKHR surface
Definition: testvulkan.c:180
VulkanContext::physicalDeviceFeatures
VkPhysicalDeviceFeatures physicalDeviceFeatures
Definition: testvulkan.c:183
vkAllocateCommandBuffers
VKAPI_ATTR VkResult VKAPI_CALL vkAllocateCommandBuffers(VkDevice device, const VkCommandBufferAllocateInfo *pAllocateInfo, VkCommandBuffer *pCommandBuffers)
retval
SDL_bool retval
Definition: testgamecontroller.c:65
VK_INCOMPLETE
Definition: vulkan_core.h:126
VkImageMemoryBarrier::oldLayout
VkImageLayout oldLayout
Definition: vulkan_core.h:2800
SDL_Log
#define SDL_Log
Definition: SDL_dynapi_overrides.h:31
VkResult
VkResult
Definition: vulkan_core.h:120
VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER
Definition: vulkan_core.h:205
VK_FORMAT_UNDEFINED
Definition: vulkan_core.h:545
createCommandBuffers
static void createCommandBuffers(void)
Definition: testvulkan.c:806
createInstance
static void createInstance(void)
Definition: testvulkan.c:245
SDL_free
#define SDL_free
Definition: SDL_dynapi_overrides.h:377
VkCommandPoolCreateInfo::sType
VkStructureType sType
Definition: vulkan_core.h:2671
VK_ERROR_OUT_OF_HOST_MEMORY
Definition: vulkan_core.h:127
vkGetSwapchainImagesKHR
VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain, uint32_t *pSwapchainImageCount, VkImage *pSwapchainImages)
SDL_FALSE
Definition: SDL_stdinc.h:163
name
GLuint const GLchar * name
Definition: SDL_opengl_glext.h:660
VkCommandBufferAllocateInfo::commandPool
VkCommandPool commandPool
Definition: vulkan_core.h:2680
VkExtent2D::width
uint32_t width
Definition: vulkan_core.h:2360
VK_SUBOPTIMAL_KHR
Definition: vulkan_core.h:143
SDL_Vulkan_LoadLibrary
#define SDL_Vulkan_LoadLibrary
Definition: SDL_dynapi_overrides.h:632
VkSwapchainCreateInfoKHR::imageFormat
VkFormat imageFormat
Definition: vulkan_core.h:4816
VulkanContext::swapchainSize
VkExtent2D swapchainSize
Definition: testvulkan.c:197
VkImageSubresourceRange::layerCount
uint32_t layerCount
Definition: vulkan_core.h:2254
VK_QUEUE_FAMILY_IGNORED
#define VK_QUEUE_FAMILY_IGNORED
Definition: vulkan_core.h:102
VkPipelineStageFlags
VkFlags VkPipelineStageFlags
Definition: vulkan_core.h:1455
SDL_GetTicks
Uint32 SDL_GetTicks(void)
Get the number of milliseconds since the SDL library initialization.
vkEndCommandBuffer
VKAPI_ATTR VkResult VKAPI_CALL vkEndCommandBuffer(VkCommandBuffer commandBuffer)
VkPresentInfoKHR
Definition: vulkan_core.h:4831
getVulkanResultString
static const char * getVulkanResultString(VkResult result)
Definition: testvulkan.c:111
VkInstanceCreateInfo::sType
VkStructureType sType
Definition: vulkan_core.h:1745
UINT64_MAX
#define UINT64_MAX
Definition: testvulkan.c:39
VkSubmitInfo
Definition: vulkan_core.h:2059
VkImageMemoryBarrier::image
VkImage image
Definition: vulkan_core.h:2804
SDL_Delay
#define SDL_Delay
Definition: SDL_dynapi_overrides.h:486
VK_IMAGE_LAYOUT_PRESENT_SRC_KHR
Definition: vulkan_core.h:877
VK_ERROR_FEATURE_NOT_PRESENT
Definition: vulkan_core.h:134
VkImageMemoryBarrier::newLayout
VkImageLayout newLayout
Definition: vulkan_core.h:2801
SDL_GetPerformanceCounter
#define SDL_GetPerformanceCounter
Definition: SDL_dynapi_overrides.h:484
VkCommandPoolCreateInfo::queueFamilyIndex
uint32_t queueFamilyIndex
Definition: vulkan_core.h:2674
VK_ERROR_TOO_MANY_OBJECTS
Definition: vulkan_core.h:136
vulkanContext
static VulkanContext vulkanContext
Definition: testvulkan.c:206
VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO
Definition: vulkan_core.h:200
VK_VERSION_MAJOR
#define VK_VERSION_MAJOR(version)
Definition: vulkan_core.h:42
vkGetDeviceQueue
VKAPI_ATTR void VKAPI_CALL vkGetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue *pQueue)
VkSubmitInfo::commandBufferCount
uint32_t commandBufferCount
Definition: vulkan_core.h:2065
createDevice
static void createDevice(void)
Definition: testvulkan.c:497
VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR
Definition: vulkan_core.h:274
VkCommandPoolCreateInfo
Definition: vulkan_core.h:2670
VK_ERROR_INVALID_SHADER_NV
Definition: vulkan_core.h:147
createCommandPool
static void createCommandPool(void)
Definition: testvulkan.c:785
getSurfaceFormats
static void getSurfaceFormats(void)
Definition: testvulkan.c:608
VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO
Definition: vulkan_core.h:161
VkCommandBufferAllocateInfo
Definition: vulkan_core.h:2677
VkDeviceQueueCreateInfo
Definition: vulkan_core.h:2025
SDL_OutOfMemory
#define SDL_OutOfMemory()
Definition: SDL_error.h:52
VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR
Definition: vulkan_core.h:4724
vkDestroySwapchainKHR
VKAPI_ATTR void VKAPI_CALL vkDestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks *pAllocator)
VULKAN_FUNCTIONS
#define VULKAN_FUNCTIONS()
Definition: testvulkan.c:42
vkDestroyFence
VKAPI_ATTR void VKAPI_CALL vkDestroyFence(VkDevice device, VkFence fence, const VkAllocationCallbacks *pAllocator)
vkDestroySemaphore
VKAPI_ATTR void VKAPI_CALL vkDestroySemaphore(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks *pAllocator)
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
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:764
VkSwapchainCreateInfoKHR::imageSharingMode
VkSharingMode imageSharingMode
Definition: vulkan_core.h:4821
VkApplicationInfo::sType
VkStructureType sType
Definition: vulkan_core.h:1735
SDL_INIT_VIDEO
#define SDL_INIT_VIDEO
Definition: SDL.h:79
SDL_bool
SDL_bool
Definition: SDL_stdinc.h:161
vkGetPhysicalDeviceSurfaceFormatsKHR
VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t *pSurfaceFormatCount, VkSurfaceFormatKHR *pSurfaceFormats)
SDL_LOG_PRIORITY_INFO
Definition: SDL_log.h:106
VkInstanceCreateInfo::ppEnabledExtensionNames
const char *const * ppEnabledExtensionNames
Definition: vulkan_core.h:1752
VkCommandBufferBeginInfo
Definition: vulkan_core.h:2696
SDLTest_CommonState::window_flags
Uint32 window_flags
Definition: SDL_test_common.h:63
uint32_t
unsigned int uint32_t
Definition: SDL_config_windows.h:63
frames
static Uint32 frames
Definition: testsprite2.c:40
getSwapchainImages
static void getSwapchainImages(void)
Definition: testvulkan.c:649
VK_ERROR_DEVICE_LOST
Definition: vulkan_core.h:130
VulkanContext::fences
VkFence * fences
Definition: testvulkan.c:202
VK_FALSE
#define VK_FALSE
Definition: vulkan_core.h:101
VK_IMAGE_LAYOUT_UNDEFINED
Definition: vulkan_core.h:866
SDL_LogSetPriority
#define SDL_LogSetPriority
Definition: SDL_dynapi_overrides.h:236
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)
VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO
Definition: vulkan_core.h:162
VK_ERROR_INCOMPATIBLE_DRIVER
Definition: vulkan_core.h:135
VK_ERROR_NATIVE_WINDOW_IN_USE_KHR
Definition: vulkan_core.h:142
VkSubmitInfo::pSignalSemaphores
const VkSemaphore * pSignalSemaphores
Definition: vulkan_core.h:2068
VulkanContext::physicalDeviceProperties
VkPhysicalDeviceProperties physicalDeviceProperties
Definition: testvulkan.c:182
VK_ERROR_SURFACE_LOST_KHR
Definition: vulkan_core.h:141
VkSemaphoreCreateInfo
Definition: vulkan_core.h:2174
VulkanContext::surfaceFormatsCount
uint32_t surfaceFormatsCount
Definition: testvulkan.c:194
VkFenceCreateInfo::flags
VkFenceCreateFlags flags
Definition: vulkan_core.h:2171
VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT
Definition: vulkan_core.h:1694
VkSwapchainCreateInfoKHR::presentMode
VkPresentModeKHR presentMode
Definition: vulkan_core.h:4826
getQueues
static void getQueues(void)
Definition: testvulkan.c:549
VkDeviceCreateInfo::ppEnabledExtensionNames
const char *const * ppEnabledExtensionNames
Definition: vulkan_core.h:2043
SDL_TRUE
Definition: SDL_stdinc.h:164
VkApplicationInfo
Definition: vulkan_core.h:1734
vkGetPhysicalDeviceFeatures
VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures *pFeatures)
initVulkan
static void initVulkan(void)
Definition: testvulkan.c:988
VulkanContext::commandBuffers
VkCommandBuffer * commandBuffers
Definition: testvulkan.c:201
VkDeviceCreateInfo::pQueueCreateInfos
const VkDeviceQueueCreateInfo * pQueueCreateInfos
Definition: vulkan_core.h:2039
vkQueueSubmit
VKAPI_ATTR VkResult VKAPI_CALL vkQueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo *pSubmits, VkFence fence)
VK_API_VERSION_1_0
#define VK_API_VERSION_1_0
Definition: vulkan_core.h:40
VkSwapchainCreateInfoKHR::preTransform
VkSurfaceTransformFlagBitsKHR preTransform
Definition: vulkan_core.h:4824
VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO
Definition: vulkan_core.h:199
VkDeviceQueueCreateInfo::sType
VkStructureType sType
Definition: vulkan_core.h:2026
vkCreateCommandPool
VKAPI_ATTR VkResult VKAPI_CALL vkCreateCommandPool(VkDevice device, const VkCommandPoolCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkCommandPool *pCommandPool)
VulkanContext::device
VkDevice device
Definition: testvulkan.c:179
vkGetPhysicalDeviceQueueFamilyProperties
VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice, uint32_t *pQueueFamilyPropertyCount, VkQueueFamilyProperties *pQueueFamilyProperties)
VkFenceCreateInfo
Definition: vulkan_core.h:2168
VK_COMMAND_POOL_CREATE_TRANSIENT_BIT
Definition: vulkan_core.h:1693
VkCommandBufferBeginInfo::flags
VkCommandBufferUsageFlags flags
Definition: vulkan_core.h:2699
shutdownVulkan
static void shutdownVulkan(void)
Definition: testvulkan.c:1004
VkDeviceQueueCreateInfo::queueCount
uint32_t queueCount
Definition: vulkan_core.h:2030
vkBeginCommandBuffer
VKAPI_ATTR VkResult VKAPI_CALL vkBeginCommandBuffer(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo *pBeginInfo)
VkSurfaceCapabilitiesKHR::minImageCount
uint32_t minImageCount
Definition: vulkan_core.h:4733
Uint32
uint32_t Uint32
Definition: SDL_stdinc.h:203
SDL_Vulkan_GetVkGetInstanceProcAddr
#define SDL_Vulkan_GetVkGetInstanceProcAddr
Definition: SDL_dynapi_overrides.h:633
VkCommandBufferAllocateInfo::sType
VkStructureType sType
Definition: vulkan_core.h:2678
VulkanContext::renderingFinishedSemaphore
VkSemaphore renderingFinishedSemaphore
Definition: testvulkan.c:190
VulkanContext::presentQueue
VkQueue presentQueue
Definition: testvulkan.c:188
SDL_GetCurrentDisplayMode
#define SDL_GetCurrentDisplayMode
Definition: SDL_dynapi_overrides.h:508
VkSwapchainCreateInfoKHR::imageExtent
VkExtent2D imageExtent
Definition: vulkan_core.h:4818
SDL_Event
General event structure.
Definition: SDL_events.h:557
VkDeviceCreateInfo
Definition: vulkan_core.h:2034
vkFreeCommandBuffers
VKAPI_ATTR void VKAPI_CALL vkFreeCommandBuffers(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer *pCommandBuffers)
VulkanContext::swapchainDesiredImageCount
uint32_t swapchainDesiredImageCount
Definition: testvulkan.c:195
createSwapchain
static SDL_bool createSwapchain(void)
Definition: testvulkan.c:687
vkAcquireNextImageKHR
VKAPI_ATTR VkResult VKAPI_CALL vkAcquireNextImageKHR(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t *pImageIndex)
VkImageSubresourceRange::baseMipLevel
uint32_t baseMipLevel
Definition: vulkan_core.h:2251
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:1501
VkExtensionProperties
Definition: vulkan_core.h:2047
SDL_malloc
#define SDL_malloc
Definition: SDL_dynapi_overrides.h:374
VK_ERROR_FORMAT_NOT_SUPPORTED
Definition: vulkan_core.h:137
VK_ERROR_OUT_OF_DEVICE_MEMORY
Definition: vulkan_core.h:128
VkImageMemoryBarrier::sType
VkStructureType sType
Definition: vulkan_core.h:2796
SDL_strcmp
#define SDL_strcmp
Definition: SDL_dynapi_overrides.h:417
VkCommandBufferBeginInfo::sType
VkStructureType sType
Definition: vulkan_core.h:2697
vkCreateFence
VKAPI_ATTR VkResult VKAPI_CALL vkCreateFence(VkDevice device, const VkFenceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkFence *pFence)
VkPresentInfoKHR::waitSemaphoreCount
uint32_t waitSemaphoreCount
Definition: vulkan_core.h:4834
findPhysicalDevice
static void findPhysicalDevice(void)
Definition: testvulkan.c:324
vkDestroySurfaceKHR
VKAPI_ATTR void VKAPI_CALL vkDestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks *pAllocator)
VkCommandBufferAllocateInfo::level
VkCommandBufferLevel level
Definition: vulkan_core.h:2681
VK_ERROR_VALIDATION_FAILED_EXT
Definition: vulkan_core.h:146
VkImageMemoryBarrier::subresourceRange
VkImageSubresourceRange subresourceRange
Definition: vulkan_core.h:2805
VkDeviceCreateInfo::enabledExtensionCount
uint32_t enabledExtensionCount
Definition: vulkan_core.h:2042
VkSwapchainCreateInfoKHR::surface
VkSurfaceKHR surface
Definition: vulkan_core.h:4814
VK_ERROR_OUT_OF_DATE_KHR
Definition: vulkan_core.h:144
VK_FORMAT_R8G8B8A8_UNORM
Definition: vulkan_core.h:582
VkSurfaceCapabilitiesKHR::currentTransform
VkSurfaceTransformFlagBitsKHR currentTransform
Definition: vulkan_core.h:4740
VkSwapchainCreateInfoKHR::compositeAlpha
VkCompositeAlphaFlagBitsKHR compositeAlpha
Definition: vulkan_core.h:4825
SDL_sin
#define SDL_sin
Definition: SDL_dynapi_overrides.h:435
createSurface
static void createSurface(void)
Definition: testvulkan.c:311
VK_ERROR_EXTENSION_NOT_PRESENT
Definition: vulkan_core.h:133
VulkanContext::swapchainImageCount
uint32_t swapchainImageCount
Definition: testvulkan.c:199
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
VkPresentInfoKHR::pWaitSemaphores
const VkSemaphore * pWaitSemaphores
Definition: vulkan_core.h:4835
VK_STRUCTURE_TYPE_APPLICATION_INFO
Definition: vulkan_core.h:160
VK_IMAGE_ASPECT_COLOR_BIT
Definition: vulkan_core.h:1459
VulkanContext::surfaceFormat
VkSurfaceFormatKHR surfaceFormat
Definition: testvulkan.c:196
vkCreateSwapchainKHR
VKAPI_ATTR VkResult VKAPI_CALL vkCreateSwapchainKHR(VkDevice device, const VkSwapchainCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSwapchainKHR *pSwapchain)
VkSemaphoreCreateInfo::sType
VkStructureType sType
Definition: vulkan_core.h:2175
VkSubmitInfo::pWaitSemaphores
const VkSemaphore * pWaitSemaphores
Definition: vulkan_core.h:2063
vkCreateDevice
VKAPI_ATTR VkResult VKAPI_CALL vkCreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDevice *pDevice)
VkCommandBufferAllocateInfo::commandBufferCount
uint32_t commandBufferCount
Definition: vulkan_core.h:2682
VkInstanceCreateInfo::pApplicationInfo
const VkApplicationInfo * pApplicationInfo
Definition: vulkan_core.h:1748
VkSwapchainCreateInfoKHR::oldSwapchain
VkSwapchainKHR oldSwapchain
Definition: vulkan_core.h:4828
vkGetPhysicalDeviceSurfaceCapabilitiesKHR
VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR *pSurfaceCapabilities)
getSurfaceCaps
static void getSurfaceCaps(void)
Definition: testvulkan.c:587
VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO
Definition: vulkan_core.h:169
VkImageMemoryBarrier::dstQueueFamilyIndex
uint32_t dstQueueFamilyIndex
Definition: vulkan_core.h:2803
vkGetPhysicalDeviceProperties
VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties *pProperties)
VK_COLORSPACE_SRGB_NONLINEAR_KHR
Definition: vulkan_core.h:4688
loadGlobalFunctions
static void loadGlobalFunctions(void)
Definition: testvulkan.c:218
VK_QUEUE_GRAPHICS_BIT
Definition: vulkan_core.h:1392
render
static SDL_bool render(void)
Definition: testvulkan.c:1023
VkPresentInfoKHR::pSwapchains
const VkSwapchainKHR * pSwapchains
Definition: vulkan_core.h:4837
w
GLubyte GLubyte GLubyte GLubyte w
Definition: SDL_opengl_glext.h:731
VkDeviceQueueCreateInfo::pQueuePriorities
const float * pQueuePriorities
Definition: vulkan_core.h:2031
createSemaphore
static void createSemaphore(VkSemaphore *semaphore)
Definition: testvulkan.c:564
SDL_WINDOW_VULKAN
Definition: SDL_video.h:122
VulkanContext::graphicsQueue
VkQueue graphicsQueue
Definition: testvulkan.c:187