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
21int 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
100enum
101{
103};
104#endif
105#if VK_HEADER_VERSION < 38
106enum {
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";
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";
169 break;
170 }
171 if(result < 0)
172 return "VK_ERROR_<Unknown>";
173 return "VK_<Unknown>";
174}
175
176typedef struct VulkanContext
177{
178 VkInstance instance;
179 VkDevice device;
180 VkSurfaceKHR surface;
181 VkSwapchainKHR swapchain;
186 VkPhysicalDevice physicalDevice;
198 VkCommandPool commandPool;
201 VkCommandBuffer *commandBuffers;
202 VkFence *fences;
204
207
208static void shutdownVulkan(void);
209
210/* Call this instead of exit(), so we can clean up SDL: atexit() is evil. */
211static void quit(int rc)
212{
215 exit(rc);
216}
217
218static 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
245static void createInstance(void)
246{
247 VkApplicationInfo appInfo = {0};
248 VkInstanceCreateInfo instanceCreateInfo = {0};
249 const char **extensions = NULL;
250 unsigned extensionCount = 0;
252
253
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 {
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
293static 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
311static void createSurface(void)
312{
316 {
319 SDL_LOG_CATEGORY_APPLICATION, "SDL_Vulkan_CreateSurface(): %s\n", SDL_GetError());
320 quit(2);
321 }
322}
323
324static 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
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 {
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);
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);
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
497static 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
513 deviceCreateInfo.queueCreateInfoCount = 1;
514 deviceCreateInfo.pQueueCreateInfos = deviceQueueCreateInfo;
515 deviceCreateInfo.pEnabledFeatures = NULL;
516 deviceCreateInfo.enabledExtensionCount = SDL_arraysize(deviceExtensionNames);
517 deviceCreateInfo.ppEnabledExtensionNames = deviceExtensionNames;
520 if(result != VK_SUCCESS)
521 {
524 SDL_LOG_CATEGORY_APPLICATION, "vkCreateDevice(): %s\n", getVulkanResultString(result));
525 quit(2);
526 }
527}
528
529static 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
549static void getQueues(void)
550{
553 0,
558 0,
560 else
562}
563
564static 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
581static void createSemaphores(void)
582{
585}
586
587static 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
608static void getSurfaceFormats(void)
609{
613 NULL);
614 if(result != VK_SUCCESS)
615 {
618 "vkGetPhysicalDeviceSurfaceFormatsKHR(): %s\n",
620 quit(2);
621 }
623 {
629 {
632 quit(2);
633 }
634 }
639 if(result != VK_SUCCESS)
640 {
643 "vkGetPhysicalDeviceSurfaceFormatsKHR(): %s\n",
645 quit(2);
646 }
647}
648
649static void getSwapchainImages(void)
650{
652
657 if(result != VK_SUCCESS)
658 {
661 "vkGetSwapchainImagesKHR(): %s\n",
663 quit(2);
664 }
667 {
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;
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
758static void destroySwapchain(void)
759{
765}
766
767static void destroyCommandBuffers(void)
768{
776}
777
778static void destroyCommandPool(void)
779{
783}
784
785static 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
806static void createCommandBuffers(void)
807{
809
810 VkCommandBufferAllocateInfo allocateInfo = {0};
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
830static void createFences(void)
831{
832 uint32_t i;
833
836 {
838 quit(2);
839 }
840 for(i = 0; i < vulkanContext.swapchainImageCount; i++)
841 {
843
844 VkFenceCreateInfo createInfo = {0};
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
865static void destroyFences(void)
866{
867 uint32_t i;
868
870 return;
871 for(i = 0; i < vulkanContext.swapchainImageCount; i++)
872 {
874 }
877}
878
879static 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;
899 barrier.subresourceRange.layerCount = 1;
900 vkCmdPipelineBarrier(commandBuffer,
903 0,
904 0,
905 NULL,
906 0,
907 NULL,
908 1,
909 &barrier);
910}
911
912static 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{
971 if(doDestroySwapchain)
973}
974
976{
980 if(!createSwapchain())
981 return SDL_FALSE;
984 createFences();
985 return SDL_TRUE;
986}
987
988static void initVulkan(void)
989{
997 createDevice();
999 getQueues();
1002}
1003
1004static void shutdownVulkan(void)
1005{
1021}
1022
1023static SDL_bool render(void)
1024{
1025 uint32_t frameIndex;
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 {
1061 SDL_LOG_CATEGORY_APPLICATION, "vkWaitForFences(): %s\n", getVulkanResultString(result));
1062 quit(2);
1063 }
1065 if(result != VK_SUCCESS)
1066 {
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);
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 {
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
1119int main(int argc, char *argv[])
1120{
1121 int fsaa, accel;
1122 int done;
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
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);
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
#define SDL_INIT_VIDEO
Definition: SDL.h:79
unsigned int uint32_t
#define SDL_memset
#define SDL_sin
#define SDL_GetWindowSize
#define SDL_GetError
#define SDL_PollEvent
#define SDL_Vulkan_UnloadLibrary
#define SDL_Vulkan_GetDrawableSize
#define SDL_Vulkan_GetVkGetInstanceProcAddr
#define SDL_malloc
#define SDL_LogSetPriority
#define SDL_LogError
#define SDL_free
#define SDL_GetPerformanceCounter
#define SDL_strcmp
#define SDL_Delay
#define SDL_Vulkan_CreateSurface
#define SDL_GetCurrentDisplayMode
#define SDL_Vulkan_LoadLibrary
#define SDL_Log
#define SDL_Vulkan_GetInstanceExtensions
#define SDL_OutOfMemory()
Definition: SDL_error.h:52
@ SDL_LOG_PRIORITY_INFO
Definition: SDL_log.h:106
@ SDL_LOG_CATEGORY_APPLICATION
Definition: SDL_log.h:66
GLeglImageOES image
Definition: SDL_opengl.h:2148
struct _cl_event * event
GLenum mode
GLuint64EXT * result
GLfloat GLfloat GLfloat GLfloat h
GLubyte GLubyte GLubyte GLubyte w
#define SDL_BITSPERPIXEL(X)
Definition: SDL_pixels.h:127
SDL_bool
Definition: SDL_stdinc.h:162
@ SDL_TRUE
Definition: SDL_stdinc.h:164
@ SDL_FALSE
Definition: SDL_stdinc.h:163
#define SDL_arraysize(array)
Definition: SDL_stdinc.h:115
uint32_t Uint32
Definition: SDL_stdinc.h:203
void SDLTest_CommonQuit(SDLTest_CommonState *state)
Close test window.
SDL_bool SDLTest_CommonDefaultArgs(SDLTest_CommonState *state, const int argc, char **argv)
Easy argument handling when test app doesn't need any custom args.
SDLTest_CommonState * SDLTest_CommonCreateState(char **argv, Uint32 flags)
Parse command line parameters and create common state.
void SDLTest_CommonEvent(SDLTest_CommonState *state, SDL_Event *event, int *done)
Common event handler for test windows.
SDL_bool SDLTest_CommonInit(SDLTest_CommonState *state)
Open test window.
Uint32 SDL_GetTicks(void)
Get the number of milliseconds since the SDL library initialization.
Uint64 SDL_GetPerformanceFrequency(void)
Get the count per second of the high resolution counter.
@ SDL_WINDOW_VULKAN
Definition: SDL_video.h:122
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
#define NULL
Definition: begin_code.h:167
int done
Definition: checkkeys.c:28
The structure that defines a display mode.
Definition: SDL_video.h:54
SDL_Window ** windows
VkStructureType sType
Definition: vulkan_core.h:1735
VkCommandBufferLevel level
Definition: vulkan_core.h:2681
VkStructureType sType
Definition: vulkan_core.h:2697
VkCommandBufferUsageFlags flags
Definition: vulkan_core.h:2699
VkStructureType sType
Definition: vulkan_core.h:2671
VkCommandPoolCreateFlags flags
Definition: vulkan_core.h:2673
uint32_t enabledExtensionCount
Definition: vulkan_core.h:2042
const VkDeviceQueueCreateInfo * pQueueCreateInfos
Definition: vulkan_core.h:2039
const VkPhysicalDeviceFeatures * pEnabledFeatures
Definition: vulkan_core.h:2044
const char *const * ppEnabledExtensionNames
Definition: vulkan_core.h:2043
uint32_t queueCreateInfoCount
Definition: vulkan_core.h:2038
VkStructureType sType
Definition: vulkan_core.h:2035
const float * pQueuePriorities
Definition: vulkan_core.h:2031
VkStructureType sType
Definition: vulkan_core.h:2026
uint32_t width
Definition: vulkan_core.h:2360
uint32_t height
Definition: vulkan_core.h:2361
VkFenceCreateFlags flags
Definition: vulkan_core.h:2171
VkStructureType sType
Definition: vulkan_core.h:2169
VkAccessFlags dstAccessMask
Definition: vulkan_core.h:2799
uint32_t dstQueueFamilyIndex
Definition: vulkan_core.h:2803
VkAccessFlags srcAccessMask
Definition: vulkan_core.h:2798
VkStructureType sType
Definition: vulkan_core.h:2796
VkImageLayout newLayout
Definition: vulkan_core.h:2801
VkImageSubresourceRange subresourceRange
Definition: vulkan_core.h:2805
VkImageLayout oldLayout
Definition: vulkan_core.h:2800
uint32_t srcQueueFamilyIndex
Definition: vulkan_core.h:2802
VkImageAspectFlags aspectMask
Definition: vulkan_core.h:2250
const char *const * ppEnabledExtensionNames
Definition: vulkan_core.h:1752
VkStructureType sType
Definition: vulkan_core.h:1745
uint32_t enabledExtensionCount
Definition: vulkan_core.h:1751
const VkApplicationInfo * pApplicationInfo
Definition: vulkan_core.h:1748
const VkSemaphore * pWaitSemaphores
Definition: vulkan_core.h:4835
uint32_t waitSemaphoreCount
Definition: vulkan_core.h:4834
uint32_t swapchainCount
Definition: vulkan_core.h:4836
const uint32_t * pImageIndices
Definition: vulkan_core.h:4838
VkStructureType sType
Definition: vulkan_core.h:4832
const VkSwapchainKHR * pSwapchains
Definition: vulkan_core.h:4837
VkStructureType sType
Definition: vulkan_core.h:2175
uint32_t waitSemaphoreCount
Definition: vulkan_core.h:2062
const VkPipelineStageFlags * pWaitDstStageMask
Definition: vulkan_core.h:2064
uint32_t commandBufferCount
Definition: vulkan_core.h:2065
const VkSemaphore * pWaitSemaphores
Definition: vulkan_core.h:2063
uint32_t signalSemaphoreCount
Definition: vulkan_core.h:2067
const VkCommandBuffer * pCommandBuffers
Definition: vulkan_core.h:2066
const VkSemaphore * pSignalSemaphores
Definition: vulkan_core.h:2068
VkStructureType sType
Definition: vulkan_core.h:2060
VkSurfaceTransformFlagBitsKHR currentTransform
Definition: vulkan_core.h:4740
VkImageUsageFlags supportedUsageFlags
Definition: vulkan_core.h:4742
VkColorSpaceKHR colorSpace
Definition: vulkan_core.h:4747
VkPresentModeKHR presentMode
Definition: vulkan_core.h:4826
VkImageUsageFlags imageUsage
Definition: vulkan_core.h:4820
VkSharingMode imageSharingMode
Definition: vulkan_core.h:4821
VkStructureType sType
Definition: vulkan_core.h:4811
VkSwapchainKHR oldSwapchain
Definition: vulkan_core.h:4828
VkColorSpaceKHR imageColorSpace
Definition: vulkan_core.h:4817
VkSurfaceTransformFlagBitsKHR preTransform
Definition: vulkan_core.h:4824
VkCompositeAlphaFlagBitsKHR compositeAlpha
Definition: vulkan_core.h:4825
VkQueue graphicsQueue
Definition: testvulkan.c:187
VkSurfaceKHR surface
Definition: testvulkan.c:180
VkFence * fences
Definition: testvulkan.c:202
VkSwapchainKHR swapchain
Definition: testvulkan.c:181
VkPhysicalDeviceProperties physicalDeviceProperties
Definition: testvulkan.c:182
VkSurfaceCapabilitiesKHR surfaceCapabilities
Definition: testvulkan.c:191
VkPhysicalDevice physicalDevice
Definition: testvulkan.c:186
VkSurfaceFormatKHR surfaceFormat
Definition: testvulkan.c:196
VkExtent2D swapchainSize
Definition: testvulkan.c:197
VkDevice device
Definition: testvulkan.c:179
VkCommandBuffer * commandBuffers
Definition: testvulkan.c:201
VkImage * swapchainImages
Definition: testvulkan.c:200
VkCommandPool commandPool
Definition: testvulkan.c:198
VkSemaphore renderingFinishedSemaphore
Definition: testvulkan.c:190
VkSemaphore imageAvailableSemaphore
Definition: testvulkan.c:189
uint32_t surfaceFormatsCount
Definition: testvulkan.c:194
uint32_t presentQueueFamilyIndex
Definition: testvulkan.c:185
uint32_t swapchainDesiredImageCount
Definition: testvulkan.c:195
uint32_t surfaceFormatsAllocatedCount
Definition: testvulkan.c:193
VkSurfaceFormatKHR * surfaceFormats
Definition: testvulkan.c:192
VkInstance instance
Definition: testvulkan.c:178
uint32_t graphicsQueueFamilyIndex
Definition: testvulkan.c:184
VkPhysicalDeviceFeatures physicalDeviceFeatures
Definition: testvulkan.c:183
uint32_t swapchainImageCount
Definition: testvulkan.c:199
VkQueue presentQueue
Definition: testvulkan.c:188
SDL_bool retval
static Uint32 frames
Definition: testsprite2.c:40
int main(int argc, char *argv[])
Definition: testvulkan.c:1119
static void getSurfaceFormats(void)
Definition: testvulkan.c:608
static void destroySwapchainAndSwapchainSpecificStuff(SDL_bool doDestroySwapchain)
Definition: testvulkan.c:966
#define UINT64_MAX
Definition: testvulkan.c:39
static void shutdownVulkan(void)
Definition: testvulkan.c:1004
static void quit(int rc)
Definition: testvulkan.c:211
#define VULKAN_FUNCTIONS()
Definition: testvulkan.c:42
static void destroyCommandBuffers(void)
Definition: testvulkan.c:767
static const char * getVulkanResultString(VkResult result)
Definition: testvulkan.c:111
static SDL_bool render(void)
Definition: testvulkan.c:1023
static void destroySwapchain(void)
Definition: testvulkan.c:758
static void createSemaphores(void)
Definition: testvulkan.c:581
static void initVulkan(void)
Definition: testvulkan.c:988
static void loadInstanceFunctions(void)
Definition: testvulkan.c:293
static void recordPipelineImageBarrier(VkCommandBuffer commandBuffer, VkAccessFlags sourceAccessMask, VkAccessFlags destAccessMask, VkImageLayout sourceLayout, VkImageLayout destLayout, VkImage image)
Definition: testvulkan.c:879
static void getSurfaceCaps(void)
Definition: testvulkan.c:587
static void createCommandBuffers(void)
Definition: testvulkan.c:806
static void createSurface(void)
Definition: testvulkan.c:311
static VulkanContext vulkanContext
Definition: testvulkan.c:206
static void loadGlobalFunctions(void)
Definition: testvulkan.c:218
static void destroyFences(void)
Definition: testvulkan.c:865
static void createFences(void)
Definition: testvulkan.c:830
static void createDevice(void)
Definition: testvulkan.c:497
static SDLTest_CommonState * state
Definition: testvulkan.c:205
static void findPhysicalDevice(void)
Definition: testvulkan.c:324
static PFN_vkGetInstanceProcAddr vkGetInstanceProcAddr
Definition: testvulkan.c:94
static void rerecordCommandBuffer(uint32_t frameIndex, const VkClearColorValue *clearColor)
Definition: testvulkan.c:912
static void destroyCommandPool(void)
Definition: testvulkan.c:778
static void loadDeviceFunctions(void)
Definition: testvulkan.c:529
static void createInstance(void)
Definition: testvulkan.c:245
static void createCommandPool(void)
Definition: testvulkan.c:785
static void getQueues(void)
Definition: testvulkan.c:549
static void createSemaphore(VkSemaphore *semaphore)
Definition: testvulkan.c:564
static SDL_bool createSwapchain(void)
Definition: testvulkan.c:687
static SDL_bool createNewSwapchainAndSwapchainSpecificStuff(void)
Definition: testvulkan.c:975
static void getSwapchainImages(void)
Definition: testvulkan.c:649
General event structure.
Definition: SDL_events.h:558
#define VK_API_VERSION_1_0
Definition: vulkan_core.h:40
VKAPI_ATTR VkResult VKAPI_CALL vkCreateSwapchainKHR(VkDevice device, const VkSwapchainCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSwapchainKHR *pSwapchain)
VKAPI_ATTR void VKAPI_CALL vkDestroyDevice(VkDevice device, const VkAllocationCallbacks *pAllocator)
VkFlags VkPipelineStageFlags
Definition: vulkan_core.h:1455
VKAPI_ATTR void VKAPI_CALL vkGetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue *pQueue)
VKAPI_ATTR VkResult VKAPI_CALL vkCreateFence(VkDevice device, const VkFenceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkFence *pFence)
VkImageLayout
Definition: vulkan_core.h:865
@ VK_IMAGE_LAYOUT_PRESENT_SRC_KHR
Definition: vulkan_core.h:877
@ VK_IMAGE_LAYOUT_UNDEFINED
Definition: vulkan_core.h:866
@ VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL
Definition: vulkan_core.h:873
#define VK_VERSION_MAJOR(version)
Definition: vulkan_core.h:42
VKAPI_ATTR VkResult VKAPI_CALL vkResetFences(VkDevice device, uint32_t fenceCount, const VkFence *pFences)
@ VK_COMMAND_BUFFER_LEVEL_PRIMARY
Definition: vulkan_core.h:1216
VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures *pFeatures)
VKAPI_ATTR VkResult VKAPI_CALL vkCreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSemaphore *pSemaphore)
@ VK_SHARING_MODE_EXCLUSIVE
Definition: vulkan_core.h:857
#define VK_TRUE
Definition: vulkan_core.h:100
VKAPI_ATTR void VKAPI_CALL vkDestroyFence(VkDevice device, VkFence fence, const VkAllocationCallbacks *pAllocator)
VkFlags VkAccessFlags
Definition: vulkan_core.h:1680
VKAPI_ATTR VkResult VKAPI_CALL vkQueuePresentKHR(VkQueue queue, const VkPresentInfoKHR *pPresentInfo)
VKAPI_ATTR void VKAPI_CALL vkFreeCommandBuffers(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer *pCommandBuffers)
VKAPI_ATTR VkResult VKAPI_CALL vkAcquireNextImageKHR(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t *pImageIndex)
VKAPI_ATTR VkResult VKAPI_CALL vkResetCommandBuffer(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags)
VKAPI_ATTR void VKAPI_CALL vkDestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks *pAllocator)
VKAPI_ATTR VkResult VKAPI_CALL vkCreateInstance(const VkInstanceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkInstance *pInstance)
VKAPI_ATTR VkResult VKAPI_CALL vkDeviceWaitIdle(VkDevice device)
@ VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT
Definition: vulkan_core.h:1709
VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties *pProperties)
@ VK_IMAGE_ASPECT_COLOR_BIT
Definition: vulkan_core.h:1459
@ VK_IMAGE_USAGE_TRANSFER_DST_BIT
Definition: vulkan_core.h:1342
@ VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT
Definition: vulkan_core.h:1345
VKAPI_ATTR void VKAPI_CALL vkCmdClearColorImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue *pColor, uint32_t rangeCount, const VkImageSubresourceRange *pRanges)
@ VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR
Definition: vulkan_core.h:4724
VKAPI_ATTR void VKAPI_CALL vkDestroyCommandPool(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks *pAllocator)
VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, const char *pLayerName, uint32_t *pPropertyCount, VkExtensionProperties *pProperties)
#define VK_FALSE
Definition: vulkan_core.h:101
VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32 *pSupported)
VKAPI_ATTR VkResult VKAPI_CALL vkWaitForFences(VkDevice device, uint32_t fenceCount, const VkFence *pFences, VkBool32 waitAll, uint64_t timeout)
VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR *pSurfaceCapabilities)
VKAPI_ATTR VkResult VKAPI_CALL vkCreateCommandPool(VkDevice device, const VkCommandPoolCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkCommandPool *pCommandPool)
VKAPI_ATTR VkResult VKAPI_CALL vkQueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo *pSubmits, VkFence fence)
VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDevices(VkInstance instance, uint32_t *pPhysicalDeviceCount, VkPhysicalDevice *pPhysicalDevices)
@ VK_QUEUE_GRAPHICS_BIT
Definition: vulkan_core.h:1392
VKAPI_ATTR VkResult VKAPI_CALL vkAllocateCommandBuffers(VkDevice device, const VkCommandBufferAllocateInfo *pAllocateInfo, VkCommandBuffer *pCommandBuffers)
VkResult
Definition: vulkan_core.h:120
@ VK_ERROR_VALIDATION_FAILED_EXT
Definition: vulkan_core.h:146
@ VK_ERROR_INVALID_SHADER_NV
Definition: vulkan_core.h:147
@ VK_SUBOPTIMAL_KHR
Definition: vulkan_core.h:143
@ VK_ERROR_EXTENSION_NOT_PRESENT
Definition: vulkan_core.h:133
@ VK_INCOMPLETE
Definition: vulkan_core.h:126
@ VK_ERROR_DEVICE_LOST
Definition: vulkan_core.h:130
@ VK_SUCCESS
Definition: vulkan_core.h:121
@ VK_EVENT_SET
Definition: vulkan_core.h:124
@ VK_EVENT_RESET
Definition: vulkan_core.h:125
@ VK_ERROR_OUT_OF_POOL_MEMORY_KHR
Definition: vulkan_core.h:151
@ VK_RESULT_RANGE_SIZE
Definition: vulkan_core.h:155
@ VK_ERROR_OUT_OF_HOST_MEMORY
Definition: vulkan_core.h:127
@ VK_ERROR_INITIALIZATION_FAILED
Definition: vulkan_core.h:129
@ VK_ERROR_INCOMPATIBLE_DISPLAY_KHR
Definition: vulkan_core.h:145
@ VK_ERROR_OUT_OF_DEVICE_MEMORY
Definition: vulkan_core.h:128
@ VK_ERROR_NATIVE_WINDOW_IN_USE_KHR
Definition: vulkan_core.h:142
@ VK_ERROR_OUT_OF_DATE_KHR
Definition: vulkan_core.h:144
@ VK_TIMEOUT
Definition: vulkan_core.h:123
@ VK_ERROR_FORMAT_NOT_SUPPORTED
Definition: vulkan_core.h:137
@ VK_ERROR_FRAGMENTED_POOL
Definition: vulkan_core.h:138
@ VK_ERROR_SURFACE_LOST_KHR
Definition: vulkan_core.h:141
@ VK_NOT_READY
Definition: vulkan_core.h:122
@ VK_ERROR_FEATURE_NOT_PRESENT
Definition: vulkan_core.h:134
@ VK_ERROR_TOO_MANY_OBJECTS
Definition: vulkan_core.h:136
@ VK_RESULT_MAX_ENUM
Definition: vulkan_core.h:156
@ VK_ERROR_MEMORY_MAP_FAILED
Definition: vulkan_core.h:131
@ VK_ERROR_LAYER_NOT_PRESENT
Definition: vulkan_core.h:132
@ VK_ERROR_INCOMPATIBLE_DRIVER
Definition: vulkan_core.h:135
@ VK_ACCESS_TRANSFER_WRITE_BIT
Definition: vulkan_core.h:1663
@ VK_ACCESS_MEMORY_READ_BIT
Definition: vulkan_core.h:1666
VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t *pSurfaceFormatCount, VkSurfaceFormatKHR *pSurfaceFormats)
@ VK_PRESENT_MODE_FIFO_KHR
Definition: vulkan_core.h:4698
#define VK_NULL_HANDLE
Definition: vulkan_core.h:49
VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice, uint32_t *pQueueFamilyPropertyCount, VkQueueFamilyProperties *pQueueFamilyProperties)
@ VK_FORMAT_R8G8B8A8_UNORM
Definition: vulkan_core.h:582
@ VK_FORMAT_UNDEFINED
Definition: vulkan_core.h:545
@ VK_COLORSPACE_SRGB_NONLINEAR_KHR
Definition: vulkan_core.h:4688
VKAPI_ATTR void VKAPI_CALL vkDestroyInstance(VkInstance instance, const VkAllocationCallbacks *pAllocator)
@ VK_COMMAND_POOL_CREATE_TRANSIENT_BIT
Definition: vulkan_core.h:1693
@ VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT
Definition: vulkan_core.h:1694
VKAPI_ATTR VkResult VKAPI_CALL vkEndCommandBuffer(VkCommandBuffer commandBuffer)
uint32_t VkBool32
Definition: vulkan_core.h:65
#define VK_KHR_SWAPCHAIN_EXTENSION_NAME
Definition: vulkan_core.h:4791
@ VK_PIPELINE_STAGE_TRANSFER_BIT
Definition: vulkan_core.h:1440
PFN_vkVoidFunction(VKAPI_PTR * PFN_vkGetInstanceProcAddr)(VkInstance instance, const char *pName)
Definition: vulkan_core.h:2859
VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain, uint32_t *pSwapchainImageCount, VkImage *pSwapchainImages)
@ VK_FENCE_CREATE_SIGNALED_BIT
Definition: vulkan_core.h:1492
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)
VKAPI_ATTR void VKAPI_CALL vkDestroySemaphore(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks *pAllocator)
#define VK_QUEUE_FAMILY_IGNORED
Definition: vulkan_core.h:102
VKAPI_ATTR VkResult VKAPI_CALL vkCreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDevice *pDevice)
VKAPI_ATTR void VKAPI_CALL vkDestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks *pAllocator)
@ VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO
Definition: vulkan_core.h:169
@ VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO
Definition: vulkan_core.h:162
@ VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO
Definition: vulkan_core.h:200
@ VK_STRUCTURE_TYPE_APPLICATION_INFO
Definition: vulkan_core.h:160
@ VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO
Definition: vulkan_core.h:202
@ VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO
Definition: vulkan_core.h:161
@ VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR
Definition: vulkan_core.h:274
@ VK_STRUCTURE_TYPE_FENCE_CREATE_INFO
Definition: vulkan_core.h:168
@ VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO
Definition: vulkan_core.h:163
@ VK_STRUCTURE_TYPE_SUBMIT_INFO
Definition: vulkan_core.h:164
@ VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO
Definition: vulkan_core.h:199
@ VK_STRUCTURE_TYPE_PRESENT_INFO_KHR
Definition: vulkan_core.h:275
@ VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER
Definition: vulkan_core.h:205
VKAPI_ATTR VkResult VKAPI_CALL vkBeginCommandBuffer(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo *pBeginInfo)