SDL  2.0
testvulkan.c
Go to the documentation of this file.
1 /*
2  Copyright (C) 1997-2019 Sam Lantinga <slouken@libsdl.org>
3 
4  This software is provided 'as-is', without any express or implied
5  warranty. In no event will the authors be held liable for any damages
6  arising from the use of this software.
7 
8  Permission is granted to anyone to use this software for any purpose,
9  including commercial applications, and to alter it and redistribute it
10  freely.
11 */
12 #include <stdlib.h>
13 #include <stdio.h>
14 #include <string.h>
15 #include <math.h>
16 
17 #include "SDL_test_common.h"
18 
19 #if defined(__ANDROID__) && defined(__ARM_EABI__) && !defined(__ARM_ARCH_7A__)
20 
21 int main(int argc, char *argv[])
22 {
23  SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "No Vulkan support on this system\n");
24  return 1;
25 }
26 
27 #else
28 
29 #define VK_NO_PROTOTYPES
30 #ifdef HAVE_VULKAN_H
31 #include <vulkan/vulkan.h>
32 #else
33 /* SDL includes a copy for building on systems without the Vulkan SDK */
34 #include "../src/video/khronos/vulkan/vulkan.h"
35 #endif
36 #include "SDL_vulkan.h"
37 
38 #ifndef UINT64_MAX /* VS2008 */
39 #define UINT64_MAX 18446744073709551615
40 #endif
41 
42 #define VULKAN_FUNCTIONS() \
43  VULKAN_DEVICE_FUNCTION(vkAcquireNextImageKHR) \
44  VULKAN_DEVICE_FUNCTION(vkAllocateCommandBuffers) \
45  VULKAN_DEVICE_FUNCTION(vkBeginCommandBuffer) \
46  VULKAN_DEVICE_FUNCTION(vkCmdClearColorImage) \
47  VULKAN_DEVICE_FUNCTION(vkCmdPipelineBarrier) \
48  VULKAN_DEVICE_FUNCTION(vkCreateCommandPool) \
49  VULKAN_DEVICE_FUNCTION(vkCreateFence) \
50  VULKAN_DEVICE_FUNCTION(vkCreateImageView) \
51  VULKAN_DEVICE_FUNCTION(vkCreateSemaphore) \
52  VULKAN_DEVICE_FUNCTION(vkCreateSwapchainKHR) \
53  VULKAN_DEVICE_FUNCTION(vkDestroyCommandPool) \
54  VULKAN_DEVICE_FUNCTION(vkDestroyDevice) \
55  VULKAN_DEVICE_FUNCTION(vkDestroyFence) \
56  VULKAN_DEVICE_FUNCTION(vkDestroyImageView) \
57  VULKAN_DEVICE_FUNCTION(vkDestroySemaphore) \
58  VULKAN_DEVICE_FUNCTION(vkDestroySwapchainKHR) \
59  VULKAN_DEVICE_FUNCTION(vkDeviceWaitIdle) \
60  VULKAN_DEVICE_FUNCTION(vkEndCommandBuffer) \
61  VULKAN_DEVICE_FUNCTION(vkFreeCommandBuffers) \
62  VULKAN_DEVICE_FUNCTION(vkGetDeviceQueue) \
63  VULKAN_DEVICE_FUNCTION(vkGetFenceStatus) \
64  VULKAN_DEVICE_FUNCTION(vkGetSwapchainImagesKHR) \
65  VULKAN_DEVICE_FUNCTION(vkQueuePresentKHR) \
66  VULKAN_DEVICE_FUNCTION(vkQueueSubmit) \
67  VULKAN_DEVICE_FUNCTION(vkResetCommandBuffer) \
68  VULKAN_DEVICE_FUNCTION(vkResetFences) \
69  VULKAN_DEVICE_FUNCTION(vkWaitForFences) \
70  VULKAN_GLOBAL_FUNCTION(vkCreateInstance) \
71  VULKAN_GLOBAL_FUNCTION(vkEnumerateInstanceExtensionProperties) \
72  VULKAN_GLOBAL_FUNCTION(vkEnumerateInstanceLayerProperties) \
73  VULKAN_INSTANCE_FUNCTION(vkCreateDevice) \
74  VULKAN_INSTANCE_FUNCTION(vkDestroyInstance) \
75  VULKAN_INSTANCE_FUNCTION(vkDestroySurfaceKHR) \
76  VULKAN_INSTANCE_FUNCTION(vkEnumerateDeviceExtensionProperties) \
77  VULKAN_INSTANCE_FUNCTION(vkEnumeratePhysicalDevices) \
78  VULKAN_INSTANCE_FUNCTION(vkGetDeviceProcAddr) \
79  VULKAN_INSTANCE_FUNCTION(vkGetPhysicalDeviceFeatures) \
80  VULKAN_INSTANCE_FUNCTION(vkGetPhysicalDeviceProperties) \
81  VULKAN_INSTANCE_FUNCTION(vkGetPhysicalDeviceQueueFamilyProperties) \
82  VULKAN_INSTANCE_FUNCTION(vkGetPhysicalDeviceSurfaceCapabilitiesKHR) \
83  VULKAN_INSTANCE_FUNCTION(vkGetPhysicalDeviceSurfaceFormatsKHR) \
84  VULKAN_INSTANCE_FUNCTION(vkGetPhysicalDeviceSurfacePresentModesKHR) \
85  VULKAN_INSTANCE_FUNCTION(vkGetPhysicalDeviceSurfaceSupportKHR)
86 
87 #define VULKAN_DEVICE_FUNCTION(name) static PFN_##name name = NULL;
88 #define VULKAN_GLOBAL_FUNCTION(name) static PFN_##name name = NULL;
89 #define VULKAN_INSTANCE_FUNCTION(name) static PFN_##name name = NULL;
91 #undef VULKAN_DEVICE_FUNCTION
92 #undef VULKAN_GLOBAL_FUNCTION
93 #undef VULKAN_INSTANCE_FUNCTION
95 
96 /* Based on the headers found in
97  * https://github.com/KhronosGroup/Vulkan-LoaderAndValidationLayers
98  */
99 #if VK_HEADER_VERSION < 22
100 enum
101 {
103 };
104 #endif
105 #if VK_HEADER_VERSION < 38
106 enum {
107  VK_ERROR_OUT_OF_POOL_MEMORY_KHR = -1000069000
108 };
109 #endif
110 
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 }
175 
176 typedef struct VulkanContext
177 {
178  VkInstance instance;
179  VkDevice device;
180  VkSurfaceKHR surface;
181  VkSwapchainKHR swapchain;
186  VkPhysicalDevice physicalDevice;
187  VkQueue graphicsQueue;
188  VkQueue presentQueue;
198  VkCommandPool commandPool;
200  VkImage *swapchainImages;
201  VkCommandBuffer *commandBuffers;
202  VkFence *fences;
203 } VulkanContext;
204 
207 
208 static void shutdownVulkan(void);
209 
210 /* Call this instead of exit(), so we can clean up SDL: atexit() is evil. */
211 static void quit(int rc)
212 {
213  shutdownVulkan();
215  exit(rc);
216 }
217 
218 static void loadGlobalFunctions(void)
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 }
244 
245 static void createInstance(void)
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 }
292 
293 static void loadInstanceFunctions(void)
294 {
295 #define VULKAN_DEVICE_FUNCTION(name)
296 #define VULKAN_GLOBAL_FUNCTION(name)
297 #define VULKAN_INSTANCE_FUNCTION(name) \
298  name = (PFN_##name)vkGetInstanceProcAddr(vulkanContext.instance, #name); \
299  if(!name) \
300  { \
301  SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, \
302  "vkGetInstanceProcAddr(instance, \"" #name "\") failed\n"); \
303  quit(2); \
304  }
306 #undef VULKAN_DEVICE_FUNCTION
307 #undef VULKAN_GLOBAL_FUNCTION
308 #undef VULKAN_INSTANCE_FUNCTION
309 }
310 
311 static void createSurface(void)
312 {
316  {
318  SDL_LogError(
319  SDL_LOG_CATEGORY_APPLICATION, "SDL_Vulkan_CreateSurface(): %s\n", SDL_GetError());
320  quit(2);
321  }
322 }
323 
324 static void findPhysicalDevice(void)
325 {
326  uint32_t physicalDeviceCount = 0;
327  VkPhysicalDevice *physicalDevices;
328  VkQueueFamilyProperties *queueFamiliesProperties = NULL;
329  uint32_t queueFamiliesPropertiesAllocatedSize = 0;
330  VkExtensionProperties *deviceExtensions = NULL;
331  uint32_t deviceExtensionsAllocatedSize = 0;
332  uint32_t physicalDeviceIndex;
333 
334  VkResult result =
335  vkEnumeratePhysicalDevices(vulkanContext.instance, &physicalDeviceCount, NULL);
336  if(result != VK_SUCCESS)
337  {
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 }
496 
497 static void createDevice(void)
498 {
499  VkDeviceQueueCreateInfo deviceQueueCreateInfo[1] = {0};
500  static const float queuePriority[] = {1.0f};
501  VkDeviceCreateInfo deviceCreateInfo = {0};
502  static const char *const deviceExtensionNames[] = {
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 }
528 
529 static void loadDeviceFunctions(void)
530 {
531 #define VULKAN_DEVICE_FUNCTION(name) \
532  name = (PFN_##name)vkGetDeviceProcAddr(vulkanContext.device, #name); \
533  if(!name) \
534  { \
535  SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, \
536  "vkGetDeviceProcAddr(device, \"" #name "\") failed\n"); \
537  quit(2); \
538  }
539 #define VULKAN_GLOBAL_FUNCTION(name)
540 #define VULKAN_INSTANCE_FUNCTION(name)
542 #undef VULKAN_DEVICE_FUNCTION
543 #undef VULKAN_GLOBAL_FUNCTION
544 #undef VULKAN_INSTANCE_FUNCTION
545 }
546 
547 #undef VULKAN_FUNCTIONS
548 
549 static void getQueues(void)
550 {
553  0,
558  0,
560  else
562 }
563 
564 static void createSemaphore(VkSemaphore *semaphore)
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 }
580 
581 static void createSemaphores(void)
582 {
585 }
586 
587 static void getSurfaceCaps(void)
588 {
591  if(result != VK_SUCCESS)
592  {
594  "vkGetPhysicalDeviceSurfaceCapabilitiesKHR(): %s\n",
596  quit(2);
597  }
598 
599  // check surface usage
601  {
603  "Vulkan surface doesn't support VK_IMAGE_USAGE_TRANSFER_DST_BIT\n");
604  quit(2);
605  }
606 }
607 
608 static void getSurfaceFormats(void)
609 {
613  NULL);
614  if(result != VK_SUCCESS)
615  {
618  "vkGetPhysicalDeviceSurfaceFormatsKHR(): %s\n",
620  quit(2);
621  }
623  {
629  {
631  SDL_OutOfMemory();
632  quit(2);
633  }
634  }
639  if(result != VK_SUCCESS)
640  {
643  "vkGetPhysicalDeviceSurfaceFormatsKHR(): %s\n",
645  quit(2);
646  }
647 }
648 
649 static void getSwapchainImages(void)
650 {
652 
657  if(result != VK_SUCCESS)
658  {
661  "vkGetSwapchainImagesKHR(): %s\n",
663  quit(2);
664  }
667  {
668  SDL_OutOfMemory();
669  quit(2);
670  }
675  if(result != VK_SUCCESS)
676  {
681  "vkGetSwapchainImagesKHR(): %s\n",
683  quit(2);
684  }
685 }
686 
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 }
757 
758 static void destroySwapchain(void)
759 {
765 }
766 
767 static void destroyCommandBuffers(void)
768 {
776 }
777 
778 static void destroyCommandPool(void)
779 {
783 }
784 
785 static void createCommandPool(void)
786 {
788 
789  VkCommandPoolCreateInfo createInfo = {0};
791  createInfo.flags =
794  result =
796  if(result != VK_SUCCESS)
797  {
800  "vkCreateCommandPool(): %s\n",
802  quit(2);
803  }
804 }
805 
806 static void createCommandBuffers(void)
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 }
829 
830 static void createFences(void)
831 {
832  uint32_t i;
833 
835  if(!vulkanContext.fences)
836  {
837  SDL_OutOfMemory();
838  quit(2);
839  }
840  for(i = 0; i < vulkanContext.swapchainImageCount; i++)
841  {
843 
844  VkFenceCreateInfo createInfo = {0};
846  createInfo.flags = VK_FENCE_CREATE_SIGNALED_BIT;
847  result =
849  if(result != VK_SUCCESS)
850  {
851  for(; i > 0; i--)
852  {
854  }
858  "vkCreateFence(): %s\n",
860  quit(2);
861  }
862  }
863 }
864 
865 static void destroyFences(void)
866 {
867  uint32_t i;
868 
869  if(!vulkanContext.fences)
870  return;
871  for(i = 0; i < vulkanContext.swapchainImageCount; i++)
872  {
874  }
877 }
878 
879 static void recordPipelineImageBarrier(VkCommandBuffer commandBuffer,
880  VkAccessFlags sourceAccessMask,
881  VkAccessFlags destAccessMask,
882  VkImageLayout sourceLayout,
883  VkImageLayout destLayout,
884  VkImage image)
885 {
886  VkImageMemoryBarrier barrier = {0};
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 }
911 
912 static void rerecordCommandBuffer(uint32_t frameIndex, const VkClearColorValue *clearColor)
913 {
914  VkCommandBuffer commandBuffer = vulkanContext.commandBuffers[frameIndex];
915  VkImage image = vulkanContext.swapchainImages[frameIndex];
916  VkCommandBufferBeginInfo beginInfo = {0};
917  VkImageSubresourceRange clearRange = {0};
918 
919  VkResult result = vkResetCommandBuffer(commandBuffer, 0);
920  if(result != VK_SUCCESS)
921  {
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 }
965 
967 {
968  destroyFences();
971  if(doDestroySwapchain)
973 }
974 
976 {
978  getSurfaceCaps();
980  if(!createSwapchain())
981  return SDL_FALSE;
984  createFences();
985  return SDL_TRUE;
986 }
987 
988 static void initVulkan(void)
989 {
991  SDL_memset(&vulkanContext, 0, sizeof(VulkanContext));
993  createInstance();
995  createSurface();
997  createDevice();
999  getQueues();
1000  createSemaphores();
1002 }
1003 
1004 static void shutdownVulkan(void)
1005 {
1021 }
1022 
1023 static SDL_bool render(void)
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 }
1118 
1119 int main(int argc, char *argv[])
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 }
1188 
1189 #endif
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
Uint32
uint32_t Uint32
Definition: SDL_stdinc.h:203
VkPhysicalDeviceProperties::apiVersion
uint32_t apiVersion
Definition: vulkan_core.h:1989
VK_STRUCTURE_TYPE_FENCE_CREATE_INFO
@ 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
@ 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)
PFN_vkGetInstanceProcAddr
PFN_vkVoidFunction(VKAPI_PTR * PFN_vkGetInstanceProcAddr)(VkInstance instance, const char *pName)
Definition: vulkan_core.h:2859
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
@ 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
@ SDL_LOG_CATEGORY_APPLICATION
Definition: SDL_log.h:66
VK_FENCE_CREATE_SIGNALED_BIT
@ VK_FENCE_CREATE_SIGNALED_BIT
Definition: vulkan_core.h:1492
VkDeviceQueueCreateInfo::queueFamilyIndex
uint32_t queueFamilyIndex
Definition: vulkan_core.h:2029
main
int main(int argc, char *argv[])
Definition: testvulkan.c:1119
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
@ 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
@ VK_RESULT_MAX_ENUM
Definition: vulkan_core.h:156
NULL
#define NULL
Definition: begin_code.h:167
VK_NOT_READY
@ VK_NOT_READY
Definition: vulkan_core.h:122
VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT
@ 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
VkSurfaceCapabilitiesKHR
Definition: vulkan_core.h:4732
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
@ VK_STRUCTURE_TYPE_SUBMIT_INFO
Definition: vulkan_core.h:164
VkImageMemoryBarrier
Definition: vulkan_core.h:2795
SDLTest_CommonState
Definition: SDL_test_common.h:51
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
@ VK_STRUCTURE_TYPE_PRESENT_INFO_KHR
Definition: vulkan_core.h:275
VK_EVENT_SET
@ VK_EVENT_SET
Definition: vulkan_core.h:124
VK_ACCESS_TRANSFER_WRITE_BIT
@ VK_ACCESS_TRANSFER_WRITE_BIT
Definition: vulkan_core.h:1663
loadDeviceFunctions
static void loadDeviceFunctions(void)
Definition: testvulkan.c:529
SDL_vulkan.h
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
@ 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
@ VK_TIMEOUT
Definition: vulkan_core.h:123
VK_ACCESS_MEMORY_READ_BIT
@ 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
@ VK_RESULT_RANGE_SIZE
Definition: vulkan_core.h:155
VkImageSubresourceRange
Definition: vulkan_core.h:2249
VK_COMMAND_BUFFER_LEVEL_PRIMARY
@ VK_COMMAND_BUFFER_LEVEL_PRIMARY
Definition: vulkan_core.h:1216
VK_ERROR_FRAGMENTED_POOL
@ 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
@ 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
@ VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL
Definition: vulkan_core.h:873
VK_ERROR_OUT_OF_POOL_MEMORY_KHR
@ VK_ERROR_OUT_OF_POOL_MEMORY_KHR
Definition: vulkan_core.h:151
VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO
@ 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
@ 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
@ 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
@ 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
@ 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
@ VK_SHARING_MODE_EXCLUSIVE
Definition: vulkan_core.h:857
VK_SUCCESS
@ 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
@ 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
SDL_FALSE
@ SDL_FALSE
Definition: SDL_stdinc.h:163
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
VkAccessFlags
VkFlags VkAccessFlags
Definition: vulkan_core.h:1680
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
@ 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
@ VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER
Definition: vulkan_core.h:205
VK_FORMAT_UNDEFINED
@ VK_FORMAT_UNDEFINED
Definition: vulkan_core.h:545
SDL_test_common.h
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
@ 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)
VkCommandBufferAllocateInfo::commandPool
VkCommandPool commandPool
Definition: vulkan_core.h:2680
VkExtent2D::width
uint32_t width
Definition: vulkan_core.h:2360
VK_SUBOPTIMAL_KHR
@ 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
vulkan.h
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
@ VK_IMAGE_LAYOUT_PRESENT_SRC_KHR
Definition: vulkan_core.h:877
VK_ERROR_FEATURE_NOT_PRESENT
@ 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
@ VK_ERROR_TOO_MANY_OBJECTS
Definition: vulkan_core.h:136
VkExtent2D
Definition: vulkan_core.h:2359
vulkanContext
static VulkanContext vulkanContext
Definition: testvulkan.c:206
VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO
@ 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
@ VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR
Definition: vulkan_core.h:274
VkCommandPoolCreateInfo
Definition: vulkan_core.h:2670
VK_ERROR_INVALID_SHADER_NV
@ 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
@ 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
@ 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
vkGetPhysicalDeviceSurfaceFormatsKHR
VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t *pSurfaceFormatCount, VkSurfaceFormatKHR *pSurfaceFormats)
SDL_LOG_PRIORITY_INFO
@ 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
SDL_TRUE
@ SDL_TRUE
Definition: SDL_stdinc.h:164
getSwapchainImages
static void getSwapchainImages(void)
Definition: testvulkan.c:649
VK_ERROR_DEVICE_LOST
@ 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
@ 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
@ VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO
Definition: vulkan_core.h:162
VK_ERROR_INCOMPATIBLE_DRIVER
@ VK_ERROR_INCOMPATIBLE_DRIVER
Definition: vulkan_core.h:135
VK_ERROR_NATIVE_WINDOW_IN_USE_KHR
@ 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
@ 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
@ 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
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
@ VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO
Definition: vulkan_core.h:199
VkPhysicalDeviceProperties
Definition: vulkan_core.h:1988
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
@ 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
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
@ VK_ERROR_FORMAT_NOT_SUPPORTED
Definition: vulkan_core.h:137
VkPhysicalDeviceFeatures
Definition: vulkan_core.h:1793
VK_ERROR_OUT_OF_DEVICE_MEMORY
@ 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
@ 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
@ VK_ERROR_OUT_OF_DATE_KHR
Definition: vulkan_core.h:144
VK_FORMAT_R8G8B8A8_UNORM
@ 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
@ 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
@ VK_STRUCTURE_TYPE_APPLICATION_INFO
Definition: vulkan_core.h:160
VK_IMAGE_ASPECT_COLOR_BIT
@ 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
@ VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO
Definition: vulkan_core.h:169
VkImageMemoryBarrier::dstQueueFamilyIndex
uint32_t dstQueueFamilyIndex
Definition: vulkan_core.h:2803
VkImageLayout
VkImageLayout
Definition: vulkan_core.h:865
vkGetPhysicalDeviceProperties
VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties *pProperties)
VK_COLORSPACE_SRGB_NONLINEAR_KHR
@ VK_COLORSPACE_SRGB_NONLINEAR_KHR
Definition: vulkan_core.h:4688
SDL_bool
SDL_bool
Definition: SDL_stdinc.h:161
loadGlobalFunctions
static void loadGlobalFunctions(void)
Definition: testvulkan.c:218
VK_QUEUE_GRAPHICS_BIT
@ 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
@ SDL_WINDOW_VULKAN
Definition: SDL_video.h:122
VulkanContext::graphicsQueue
VkQueue graphicsQueue
Definition: testvulkan.c:187