2 * Copyright (c) 2015-2016 The Khronos Group Inc.
3 * Copyright (c) 2015-2016 Valve Corporation
4 * Copyright (c) 2015-2016 LunarG, Inc.
6 * Licensed under the Apache License, Version 2.0 (the "License");
7 * you may not use this file except in compliance with the License.
8 * You may obtain a copy of the License at
10 * http://www.apache.org/licenses/LICENSE-2.0
12 * Unless required by applicable law or agreed to in writing, software
13 * distributed under the License is distributed on an "AS IS" BASIS,
14 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15 * See the License for the specific language governing permissions and
16 * limitations under the License.
18 * Author: Chia-I Wu <olv@lunarg.com>
19 * Author: Courtney Goeltzenleuchter <courtney@LunarG.com>
20 * Author: Ian Elliott <ian@LunarG.com>
21 * Author: Ian Elliott <ianelliott@google.com>
22 * Author: Jon Ashburn <jon@lunarg.com>
23 * Author: Gwan-gyeong Mun <elongbug@gmail.com>
24 * Author: Tony Barbour <tony@LunarG.com>
25 * Author: Bill Hollings <bill.hollings@brenwill.com>
36 #if defined(VK_USE_PLATFORM_XLIB_KHR) || defined(VK_USE_PLATFORM_XCB_KHR)
37 #include <X11/Xutil.h>
38 #elif defined(VK_USE_PLATFORM_WAYLAND_KHR)
39 #include <linux/input.h>
43 #pragma comment(linker, "/subsystem:windows")
44 #define APP_NAME_STR_LEN 80
47 #if defined(VK_USE_PLATFORM_MIR_KHR)
48 #warning "Cube does not have code for Mir at this time"
52 #include "vulkan_wrapper.h"
54 #include <vulkan/vulkan.h>
57 #include <vulkan/vk_sdk_platform.h>
59 #include "object_type_string_helper.h"
63 #define MILLION 1000000L
64 #define BILLION 1000000000L
66 #define DEMO_TEXTURE_COUNT 1
67 #define APP_SHORT_NAME "cube"
68 #define APP_LONG_NAME "The Vulkan Cube Demo Program"
70 // Allow a maximum of two outstanding presentation operations.
73 #define ARRAY_SIZE(a) (sizeof(a) / sizeof(a[0]))
75 #if defined(NDEBUG) && defined(__GNUC__)
76 #define U_ASSERT_ONLY __attribute__((unused))
82 #define UNUSED __attribute__((unused))
88 bool in_callback = false;
89 #define ERR_EXIT(err_msg, err_class) \
91 if (!demo->suppress_popups) MessageBox(NULL, err_msg, err_class, MB_OK); \
94 void DbgMsg(char *fmt, ...) {
102 #elif defined __ANDROID__
103 #include <android/log.h>
104 #define ERR_EXIT(err_msg, err_class) \
106 ((void)__android_log_print(ANDROID_LOG_INFO, "Cube", err_msg)); \
109 #ifdef VARARGS_WORKS_ON_ANDROID
110 void DbgMsg(const char *fmt, ...) {
113 __android_log_print(ANDROID_LOG_INFO, "Cube", fmt, va);
116 #else // VARARGS_WORKS_ON_ANDROID
117 #define DbgMsg(fmt, ...) \
119 ((void)__android_log_print(ANDROID_LOG_INFO, "Cube", fmt, ##__VA_ARGS__)); \
121 #endif // VARARGS_WORKS_ON_ANDROID
123 #define ERR_EXIT(err_msg, err_class) \
125 printf("%s\n", err_msg); \
129 void DbgMsg(char *fmt, ...) {
138 #define GET_INSTANCE_PROC_ADDR(inst, entrypoint) \
140 demo->fp##entrypoint = (PFN_vk##entrypoint)vkGetInstanceProcAddr(inst, "vk" #entrypoint); \
141 if (demo->fp##entrypoint == NULL) { \
142 ERR_EXIT("vkGetInstanceProcAddr failed to find vk" #entrypoint, "vkGetInstanceProcAddr Failure"); \
146 static PFN_vkGetDeviceProcAddr g_gdpa = NULL;
148 #define GET_DEVICE_PROC_ADDR(dev, entrypoint) \
150 if (!g_gdpa) g_gdpa = (PFN_vkGetDeviceProcAddr)vkGetInstanceProcAddr(demo->inst, "vkGetDeviceProcAddr"); \
151 demo->fp##entrypoint = (PFN_vk##entrypoint)g_gdpa(dev, "vk" #entrypoint); \
152 if (demo->fp##entrypoint == NULL) { \
153 ERR_EXIT("vkGetDeviceProcAddr failed to find vk" #entrypoint, "vkGetDeviceProcAddr Failure"); \
158 * structure to track all objects related to a texture.
160 struct texture_object {
165 VkImageLayout imageLayout;
167 VkMemoryAllocateInfo mem_alloc;
170 int32_t tex_width, tex_height;
173 static char *tex_files[] = {"lunarg.ppm"};
175 static int validation_error = 0;
177 struct vktexcube_vs_uniform {
178 // Must start with MVP
180 float position[12 * 3][4];
181 float attr[12 * 3][4];
184 //--------------------------------------------------------------------------------------
185 // Mesh and VertexFormat Data
186 //--------------------------------------------------------------------------------------
188 static const float g_vertex_buffer_data[] = {
189 -1.0f,-1.0f,-1.0f, // -X side
196 -1.0f,-1.0f,-1.0f, // -Z side
203 -1.0f,-1.0f,-1.0f, // -Y side
210 -1.0f, 1.0f,-1.0f, // +Y side
217 1.0f, 1.0f,-1.0f, // +X side
224 -1.0f, 1.0f, 1.0f, // +Z side
232 static const float g_uv_buffer_data[] = {
233 0.0f, 1.0f, // -X side
240 1.0f, 1.0f, // -Z side
247 1.0f, 0.0f, // -Y side
254 1.0f, 0.0f, // +Y side
261 1.0f, 0.0f, // +X side
268 0.0f, 0.0f, // +Z side
277 void dumpMatrix(const char *note, mat4x4 MVP) {
280 printf("%s: \n", note);
281 for (i = 0; i < 4; i++) {
282 printf("%f, %f, %f, %f\n", MVP[i][0], MVP[i][1], MVP[i][2], MVP[i][3]);
288 void dumpVec4(const char *note, vec4 vector) {
289 printf("%s: \n", note);
290 printf("%f, %f, %f, %f\n", vector[0], vector[1], vector[2], vector[3]);
298 VkCommandBuffer graphics_to_present_cmd;
300 VkBuffer uniform_buffer;
301 VkDeviceMemory uniform_memory;
302 VkFramebuffer framebuffer;
303 VkDescriptorSet descriptor_set;
304 } SwapchainImageResources;
307 #if defined(VK_USE_PLATFORM_WIN32_KHR)
308 #define APP_NAME_STR_LEN 80
309 HINSTANCE connection; // hInstance - Windows Instance
310 char name[APP_NAME_STR_LEN]; // Name to put on the window/icon
311 HWND window; // hWnd - window handle
312 POINT minsize; // minimum window size
313 #elif defined(VK_USE_PLATFORM_XLIB_KHR)
316 Atom xlib_wm_delete_window;
317 #elif defined(VK_USE_PLATFORM_XCB_KHR)
319 xcb_connection_t *connection;
320 xcb_screen_t *screen;
321 xcb_window_t xcb_window;
322 xcb_intern_atom_reply_t *atom_wm_delete_window;
323 #elif defined(VK_USE_PLATFORM_WAYLAND_KHR)
324 struct wl_display *display;
325 struct wl_registry *registry;
326 struct wl_compositor *compositor;
327 struct wl_surface *window;
328 struct wl_shell *shell;
329 struct wl_shell_surface *shell_surface;
330 struct wl_seat *seat;
331 struct wl_pointer *pointer;
332 struct wl_keyboard *keyboard;
333 #elif defined(VK_USE_PLATFORM_MIR_KHR)
334 #elif defined(VK_USE_PLATFORM_ANDROID_KHR)
335 struct ANativeWindow *window;
336 #elif (defined(VK_USE_PLATFORM_IOS_MVK) || defined(VK_USE_PLATFORM_MACOS_MVK))
339 VkSurfaceKHR surface;
341 bool use_staging_buffer;
342 bool separate_present_queue;
345 bool VK_KHR_incremental_present_enabled;
347 bool VK_GOOGLE_display_timing_enabled;
348 bool syncd_with_actual_presents;
349 uint64_t refresh_duration;
350 uint64_t refresh_duration_multiplier;
351 uint64_t target_IPD; // image present duration (inverse of frame rate)
352 uint64_t prev_desired_present_time;
353 uint32_t next_present_id;
354 uint32_t last_early_id; // 0 if no early images
355 uint32_t last_late_id; // 0 if no late images
358 VkPhysicalDevice gpu;
360 VkQueue graphics_queue;
361 VkQueue present_queue;
362 uint32_t graphics_queue_family_index;
363 uint32_t present_queue_family_index;
364 VkSemaphore image_acquired_semaphores[FRAME_LAG];
365 VkSemaphore draw_complete_semaphores[FRAME_LAG];
366 VkSemaphore image_ownership_semaphores[FRAME_LAG];
367 VkPhysicalDeviceProperties gpu_props;
368 VkQueueFamilyProperties *queue_props;
369 VkPhysicalDeviceMemoryProperties memory_properties;
371 uint32_t enabled_extension_count;
372 uint32_t enabled_layer_count;
373 char *extension_names[64];
374 char *enabled_layers[64];
378 VkColorSpaceKHR color_space;
380 PFN_vkGetPhysicalDeviceSurfaceSupportKHR fpGetPhysicalDeviceSurfaceSupportKHR;
381 PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR fpGetPhysicalDeviceSurfaceCapabilitiesKHR;
382 PFN_vkGetPhysicalDeviceSurfaceFormatsKHR fpGetPhysicalDeviceSurfaceFormatsKHR;
383 PFN_vkGetPhysicalDeviceSurfacePresentModesKHR fpGetPhysicalDeviceSurfacePresentModesKHR;
384 PFN_vkCreateSwapchainKHR fpCreateSwapchainKHR;
385 PFN_vkDestroySwapchainKHR fpDestroySwapchainKHR;
386 PFN_vkGetSwapchainImagesKHR fpGetSwapchainImagesKHR;
387 PFN_vkAcquireNextImageKHR fpAcquireNextImageKHR;
388 PFN_vkQueuePresentKHR fpQueuePresentKHR;
389 PFN_vkGetRefreshCycleDurationGOOGLE fpGetRefreshCycleDurationGOOGLE;
390 PFN_vkGetPastPresentationTimingGOOGLE fpGetPastPresentationTimingGOOGLE;
391 uint32_t swapchainImageCount;
392 VkSwapchainKHR swapchain;
393 SwapchainImageResources *swapchain_image_resources;
394 VkPresentModeKHR presentMode;
395 VkFence fences[FRAME_LAG];
398 VkCommandPool cmd_pool;
399 VkCommandPool present_cmd_pool;
405 VkMemoryAllocateInfo mem_alloc;
410 struct texture_object textures[DEMO_TEXTURE_COUNT];
411 struct texture_object staging_texture;
413 VkCommandBuffer cmd; // Buffer for initialization commands
414 VkPipelineLayout pipeline_layout;
415 VkDescriptorSetLayout desc_layout;
416 VkPipelineCache pipelineCache;
417 VkRenderPass render_pass;
420 mat4x4 projection_matrix;
425 float spin_increment;
428 VkShaderModule vert_shader_module;
429 VkShaderModule frag_shader_module;
431 VkDescriptorPool desc_pool;
437 bool validate_checks_disabled;
439 bool suppress_popups;
441 PFN_vkCreateDebugUtilsMessengerEXT CreateDebugUtilsMessengerEXT;
442 PFN_vkDestroyDebugUtilsMessengerEXT DestroyDebugUtilsMessengerEXT;
443 PFN_vkSubmitDebugUtilsMessageEXT SubmitDebugUtilsMessageEXT;
444 PFN_vkCmdBeginDebugUtilsLabelEXT CmdBeginDebugUtilsLabelEXT;
445 PFN_vkCmdEndDebugUtilsLabelEXT CmdEndDebugUtilsLabelEXT;
446 PFN_vkCmdInsertDebugUtilsLabelEXT CmdInsertDebugUtilsLabelEXT;
447 PFN_vkSetDebugUtilsObjectNameEXT SetDebugUtilsObjectNameEXT;
448 VkDebugUtilsMessengerEXT dbg_messenger;
450 uint32_t current_buffer;
451 uint32_t queue_family_count;
454 VKAPI_ATTR VkBool32 VKAPI_CALL debug_messenger_callback(VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity,
455 VkDebugUtilsMessageTypeFlagsEXT messageType,
456 const VkDebugUtilsMessengerCallbackDataEXT *pCallbackData,
458 char prefix[64] = "";
459 char *message = (char *)malloc(strlen(pCallbackData->pMessage) + 5000);
461 struct demo *demo = (struct demo *)pUserData;
463 if (demo->use_break) {
471 if (messageSeverity & VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT) {
472 strcat(prefix, "VERBOSE : ");
473 } else if (messageSeverity & VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT) {
474 strcat(prefix, "INFO : ");
475 } else if (messageSeverity & VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT) {
476 strcat(prefix, "WARNING : ");
477 } else if (messageSeverity & VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT) {
478 strcat(prefix, "ERROR : ");
481 if (messageType & VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT) {
482 strcat(prefix, "GENERAL");
484 if (messageType & VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT) {
485 strcat(prefix, "VALIDATION");
486 validation_error = 1;
488 if (messageType & VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT) {
489 if (messageType & VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT) {
492 strcat(prefix, "PERFORMANCE");
496 sprintf(message, "%s - Message Id Number: %d | Message Id Name: %s\n\t%s\n", prefix, pCallbackData->messageIdNumber,
497 pCallbackData->pMessageIdName, pCallbackData->pMessage);
498 if (pCallbackData->objectCount > 0) {
499 char tmp_message[500];
500 sprintf(tmp_message, "\n\tObjects - %d\n", pCallbackData->objectCount);
501 strcat(message, tmp_message);
502 for (uint32_t object = 0; object < pCallbackData->objectCount; ++object) {
503 if (NULL != pCallbackData->pObjects[object].pObjectName && strlen(pCallbackData->pObjects[object].pObjectName) > 0) {
504 sprintf(tmp_message, "\t\tObject[%d] - %s, Handle %p, Name \"%s\"\n", object,
505 string_VkObjectType(pCallbackData->pObjects[object].objectType),
506 (void *)(pCallbackData->pObjects[object].objectHandle), pCallbackData->pObjects[object].pObjectName);
508 sprintf(tmp_message, "\t\tObject[%d] - %s, Handle %p\n", object,
509 string_VkObjectType(pCallbackData->pObjects[object].objectType),
510 (void *)(pCallbackData->pObjects[object].objectHandle));
512 strcat(message, tmp_message);
515 if (pCallbackData->cmdBufLabelCount > 0) {
516 char tmp_message[500];
517 sprintf(tmp_message, "\n\tCommand Buffer Labels - %d\n", pCallbackData->cmdBufLabelCount);
518 strcat(message, tmp_message);
519 for (uint32_t cmd_buf_label = 0; cmd_buf_label < pCallbackData->cmdBufLabelCount; ++cmd_buf_label) {
520 sprintf(tmp_message, "\t\tLabel[%d] - %s { %f, %f, %f, %f}\n", cmd_buf_label,
521 pCallbackData->pCmdBufLabels[cmd_buf_label].pLabelName, pCallbackData->pCmdBufLabels[cmd_buf_label].color[0],
522 pCallbackData->pCmdBufLabels[cmd_buf_label].color[1], pCallbackData->pCmdBufLabels[cmd_buf_label].color[2],
523 pCallbackData->pCmdBufLabels[cmd_buf_label].color[3]);
524 strcat(message, tmp_message);
531 if (!demo->suppress_popups)
532 MessageBox(NULL, message, "Alert", MB_OK);
535 #elif defined(ANDROID)
537 if (messageSeverity & VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT) {
538 __android_log_print(ANDROID_LOG_INFO, APP_SHORT_NAME, "%s", message);
539 } else if (messageSeverity & VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT) {
540 __android_log_print(ANDROID_LOG_WARN, APP_SHORT_NAME, "%s", message);
541 } else if (messageSeverity & VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT) {
542 __android_log_print(ANDROID_LOG_ERROR, APP_SHORT_NAME, "%s", message);
543 } else if (messageSeverity & VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT) {
544 __android_log_print(ANDROID_LOG_VERBOSE, APP_SHORT_NAME, "%s", message);
546 __android_log_print(ANDROID_LOG_INFO, APP_SHORT_NAME, "%s", message);
551 printf("%s\n", message);
558 // Don't bail out, but keep going.
562 bool ActualTimeLate(uint64_t desired, uint64_t actual, uint64_t rdur) {
563 // The desired time was the earliest time that the present should have
564 // occured. In almost every case, the actual time should be later than the
565 // desired time. We should only consider the actual time "late" if it is
566 // after "desired + rdur".
567 if (actual <= desired) {
568 // The actual time was before or equal to the desired time. This will
569 // probably never happen, but in case it does, return false since the
570 // present was obviously NOT late.
573 uint64_t deadline = desired + rdur;
574 if (actual > deadline) {
580 bool CanPresentEarlier(uint64_t earliest, uint64_t actual, uint64_t margin, uint64_t rdur) {
581 if (earliest < actual) {
582 // Consider whether this present could have occured earlier. Make sure
583 // that earliest time was at least 2msec earlier than actual time, and
584 // that the margin was at least 2msec:
585 uint64_t diff = actual - earliest;
586 if ((diff >= (2 * MILLION)) && (margin >= (2 * MILLION))) {
587 // This present could have occured earlier because both: 1) the
588 // earliest time was at least 2 msec before actual time, and 2) the
589 // margin was at least 2msec.
596 // Forward declaration:
597 static void demo_resize(struct demo *demo);
599 static bool memory_type_from_properties(struct demo *demo, uint32_t typeBits, VkFlags requirements_mask, uint32_t *typeIndex) {
600 // Search memtypes to find first index with those properties
601 for (uint32_t i = 0; i < VK_MAX_MEMORY_TYPES; i++) {
602 if ((typeBits & 1) == 1) {
603 // Type is available, does it match user properties?
604 if ((demo->memory_properties.memoryTypes[i].propertyFlags & requirements_mask) == requirements_mask) {
611 // No memory types matched, return failure
615 static void demo_flush_init_cmd(struct demo *demo) {
616 VkResult U_ASSERT_ONLY err;
618 // This function could get called twice if the texture uses a staging buffer
619 // In that case the second call should be ignored
620 if (demo->cmd == VK_NULL_HANDLE) return;
622 err = vkEndCommandBuffer(demo->cmd);
626 VkFenceCreateInfo fence_ci = {.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO, .pNext = NULL, .flags = 0};
627 err = vkCreateFence(demo->device, &fence_ci, NULL, &fence);
630 const VkCommandBuffer cmd_bufs[] = {demo->cmd};
631 VkSubmitInfo submit_info = {.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO,
633 .waitSemaphoreCount = 0,
634 .pWaitSemaphores = NULL,
635 .pWaitDstStageMask = NULL,
636 .commandBufferCount = 1,
637 .pCommandBuffers = cmd_bufs,
638 .signalSemaphoreCount = 0,
639 .pSignalSemaphores = NULL};
641 err = vkQueueSubmit(demo->graphics_queue, 1, &submit_info, fence);
644 err = vkWaitForFences(demo->device, 1, &fence, VK_TRUE, UINT64_MAX);
647 vkFreeCommandBuffers(demo->device, demo->cmd_pool, 1, cmd_bufs);
648 vkDestroyFence(demo->device, fence, NULL);
649 demo->cmd = VK_NULL_HANDLE;
652 static void demo_set_image_layout(struct demo *demo, VkImage image, VkImageAspectFlags aspectMask, VkImageLayout old_image_layout,
653 VkImageLayout new_image_layout, VkAccessFlagBits srcAccessMask, VkPipelineStageFlags src_stages,
654 VkPipelineStageFlags dest_stages) {
657 VkImageMemoryBarrier image_memory_barrier = {.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
659 .srcAccessMask = srcAccessMask,
661 .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
662 .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
663 .oldLayout = old_image_layout,
664 .newLayout = new_image_layout,
666 .subresourceRange = {aspectMask, 0, 1, 0, 1}};
668 switch (new_image_layout) {
669 case VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL:
670 /* Make sure anything that was copying from this image has completed */
671 image_memory_barrier.dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
674 case VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL:
675 image_memory_barrier.dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
678 case VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL:
679 image_memory_barrier.dstAccessMask = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
682 case VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL:
683 image_memory_barrier.dstAccessMask = VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_INPUT_ATTACHMENT_READ_BIT;
686 case VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL:
687 image_memory_barrier.dstAccessMask = VK_ACCESS_TRANSFER_READ_BIT;
690 case VK_IMAGE_LAYOUT_PRESENT_SRC_KHR:
691 image_memory_barrier.dstAccessMask = VK_ACCESS_MEMORY_READ_BIT;
695 image_memory_barrier.dstAccessMask = 0;
699 VkImageMemoryBarrier *pmemory_barrier = &image_memory_barrier;
701 vkCmdPipelineBarrier(demo->cmd, src_stages, dest_stages, 0, 0, NULL, 0, NULL, 1, pmemory_barrier);
704 static void demo_draw_build_cmd(struct demo *demo, VkCommandBuffer cmd_buf) {
705 VkDebugUtilsLabelEXT label;
706 memset(&label, 0, sizeof(label));
707 const VkCommandBufferBeginInfo cmd_buf_info = {
708 .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
710 .flags = VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT,
711 .pInheritanceInfo = NULL,
713 const VkClearValue clear_values[2] = {
714 [0] = {.color.float32 = {0.2f, 0.2f, 0.2f, 0.2f}},
715 [1] = {.depthStencil = {1.0f, 0}},
717 const VkRenderPassBeginInfo rp_begin = {
718 .sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO,
720 .renderPass = demo->render_pass,
721 .framebuffer = demo->swapchain_image_resources[demo->current_buffer].framebuffer,
722 .renderArea.offset.x = 0,
723 .renderArea.offset.y = 0,
724 .renderArea.extent.width = demo->width,
725 .renderArea.extent.height = demo->height,
726 .clearValueCount = 2,
727 .pClearValues = clear_values,
729 VkResult U_ASSERT_ONLY err;
731 err = vkBeginCommandBuffer(cmd_buf, &cmd_buf_info);
733 if (demo->validate) {
734 // Set a name for the command buffer
735 VkDebugUtilsObjectNameInfoEXT cmd_buf_name = {
736 .sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT,
738 .objectType = VK_OBJECT_TYPE_COMMAND_BUFFER,
739 .objectHandle = (uint64_t)cmd_buf,
740 .pObjectName = "CubeDrawCommandBuf",
742 demo->SetDebugUtilsObjectNameEXT(demo->device, &cmd_buf_name);
744 label.sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT;
746 label.pLabelName = "DrawBegin";
747 label.color[0] = 0.4f;
748 label.color[1] = 0.3f;
749 label.color[2] = 0.2f;
750 label.color[3] = 0.1f;
751 demo->CmdBeginDebugUtilsLabelEXT(cmd_buf, &label);
755 vkCmdBeginRenderPass(cmd_buf, &rp_begin, VK_SUBPASS_CONTENTS_INLINE);
757 if (demo->validate) {
758 label.sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT;
760 label.pLabelName = "InsideRenderPass";
761 label.color[0] = 8.4f;
762 label.color[1] = 7.3f;
763 label.color[2] = 6.2f;
764 label.color[3] = 7.1f;
765 demo->CmdBeginDebugUtilsLabelEXT(cmd_buf, &label);
768 vkCmdBindPipeline(cmd_buf, VK_PIPELINE_BIND_POINT_GRAPHICS, demo->pipeline);
769 vkCmdBindDescriptorSets(cmd_buf, VK_PIPELINE_BIND_POINT_GRAPHICS, demo->pipeline_layout, 0, 1,
770 &demo->swapchain_image_resources[demo->current_buffer].descriptor_set, 0, NULL);
772 memset(&viewport, 0, sizeof(viewport));
773 viewport.height = (float)demo->height;
774 viewport.width = (float)demo->width;
775 viewport.minDepth = (float)0.0f;
776 viewport.maxDepth = (float)1.0f;
777 vkCmdSetViewport(cmd_buf, 0, 1, &viewport);
780 memset(&scissor, 0, sizeof(scissor));
781 scissor.extent.width = demo->width;
782 scissor.extent.height = demo->height;
783 scissor.offset.x = 0;
784 scissor.offset.y = 0;
785 vkCmdSetScissor(cmd_buf, 0, 1, &scissor);
787 if (demo->validate) {
788 label.sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT;
790 label.pLabelName = "ActualDraw";
791 label.color[0] = -0.4f;
792 label.color[1] = -0.3f;
793 label.color[2] = -0.2f;
794 label.color[3] = -0.1f;
795 demo->CmdBeginDebugUtilsLabelEXT(cmd_buf, &label);
798 vkCmdDraw(cmd_buf, 12 * 3, 1, 0, 0);
799 if (demo->validate) {
800 demo->CmdEndDebugUtilsLabelEXT(cmd_buf);
803 // Note that ending the renderpass changes the image's layout from
804 // COLOR_ATTACHMENT_OPTIMAL to PRESENT_SRC_KHR
805 vkCmdEndRenderPass(cmd_buf);
806 if (demo->validate) {
807 demo->CmdEndDebugUtilsLabelEXT(cmd_buf);
810 if (demo->separate_present_queue) {
811 // We have to transfer ownership from the graphics queue family to the
812 // present queue family to be able to present. Note that we don't have
813 // to transfer from present queue family back to graphics queue family at
814 // the start of the next frame because we don't care about the image's
815 // contents at that point.
816 VkImageMemoryBarrier image_ownership_barrier = {.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
820 .oldLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR,
821 .newLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR,
822 .srcQueueFamilyIndex = demo->graphics_queue_family_index,
823 .dstQueueFamilyIndex = demo->present_queue_family_index,
824 .image = demo->swapchain_image_resources[demo->current_buffer].image,
825 .subresourceRange = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1}};
827 vkCmdPipelineBarrier(cmd_buf, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, 0, 0, NULL, 0,
828 NULL, 1, &image_ownership_barrier);
830 if (demo->validate) {
831 demo->CmdEndDebugUtilsLabelEXT(cmd_buf);
833 err = vkEndCommandBuffer(cmd_buf);
837 void demo_build_image_ownership_cmd(struct demo *demo, int i) {
838 VkResult U_ASSERT_ONLY err;
840 const VkCommandBufferBeginInfo cmd_buf_info = {
841 .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
843 .flags = VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT,
844 .pInheritanceInfo = NULL,
846 err = vkBeginCommandBuffer(demo->swapchain_image_resources[i].graphics_to_present_cmd, &cmd_buf_info);
849 VkImageMemoryBarrier image_ownership_barrier = {.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
853 .oldLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR,
854 .newLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR,
855 .srcQueueFamilyIndex = demo->graphics_queue_family_index,
856 .dstQueueFamilyIndex = demo->present_queue_family_index,
857 .image = demo->swapchain_image_resources[i].image,
858 .subresourceRange = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1}};
860 vkCmdPipelineBarrier(demo->swapchain_image_resources[i].graphics_to_present_cmd, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT,
861 VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, 0, 0, NULL, 0, NULL, 1, &image_ownership_barrier);
862 err = vkEndCommandBuffer(demo->swapchain_image_resources[i].graphics_to_present_cmd);
866 void demo_update_data_buffer(struct demo *demo) {
867 mat4x4 MVP, Model, VP;
868 int matrixSize = sizeof(MVP);
870 VkResult U_ASSERT_ONLY err;
872 mat4x4_mul(VP, demo->projection_matrix, demo->view_matrix);
874 // Rotate around the Y axis
875 mat4x4_dup(Model, demo->model_matrix);
876 mat4x4_rotate(demo->model_matrix, Model, 0.0f, 1.0f, 0.0f, (float)degreesToRadians(demo->spin_angle));
877 mat4x4_mul(MVP, VP, demo->model_matrix);
879 err = vkMapMemory(demo->device, demo->swapchain_image_resources[demo->current_buffer].uniform_memory, 0, VK_WHOLE_SIZE, 0,
883 memcpy(pData, (const void *)&MVP[0][0], matrixSize);
885 vkUnmapMemory(demo->device, demo->swapchain_image_resources[demo->current_buffer].uniform_memory);
888 void DemoUpdateTargetIPD(struct demo *demo) {
889 // Look at what happened to previous presents, and make appropriate
890 // adjustments in timing:
891 VkResult U_ASSERT_ONLY err;
892 VkPastPresentationTimingGOOGLE *past = NULL;
895 err = demo->fpGetPastPresentationTimingGOOGLE(demo->device, demo->swapchain, &count, NULL);
898 past = (VkPastPresentationTimingGOOGLE *)malloc(sizeof(VkPastPresentationTimingGOOGLE) * count);
900 err = demo->fpGetPastPresentationTimingGOOGLE(demo->device, demo->swapchain, &count, past);
905 bool calibrate_next = false;
906 for (uint32_t i = 0; i < count; i++) {
907 if (!demo->syncd_with_actual_presents) {
908 // This is the first time that we've received an
909 // actualPresentTime for this swapchain. In order to not
910 // perceive these early frames as "late", we need to sync-up
911 // our future desiredPresentTime's with the
912 // actualPresentTime(s) that we're receiving now.
913 calibrate_next = true;
915 // So that we don't suspect any pending presents as late,
916 // record them all as suspected-late presents:
917 demo->last_late_id = demo->next_present_id - 1;
918 demo->last_early_id = 0;
919 demo->syncd_with_actual_presents = true;
921 } else if (CanPresentEarlier(past[i].earliestPresentTime, past[i].actualPresentTime, past[i].presentMargin,
922 demo->refresh_duration)) {
923 // This image could have been presented earlier. We don't want
924 // to decrease the target_IPD until we've seen early presents
925 // for at least two seconds.
926 if (demo->last_early_id == past[i].presentID) {
927 // We've now seen two seconds worth of early presents.
928 // Flag it as such, and reset the counter:
930 demo->last_early_id = 0;
931 } else if (demo->last_early_id == 0) {
932 // This is the first early present we've seen.
933 // Calculate the presentID for two seconds from now.
934 uint64_t lastEarlyTime = past[i].actualPresentTime + (2 * BILLION);
935 uint32_t howManyPresents = (uint32_t)((lastEarlyTime - past[i].actualPresentTime) / demo->target_IPD);
936 demo->last_early_id = past[i].presentID + howManyPresents;
938 // We are in the midst of a set of early images,
939 // and so we won't do anything.
942 demo->last_late_id = 0;
943 } else if (ActualTimeLate(past[i].desiredPresentTime, past[i].actualPresentTime, demo->refresh_duration)) {
944 // This image was presented after its desired time. Since
945 // there's a delay between calling vkQueuePresentKHR and when
946 // we get the timing data, several presents may have been late.
947 // Thus, we need to threat all of the outstanding presents as
948 // being likely late, so that we only increase the target_IPD
949 // once for all of those presents.
950 if ((demo->last_late_id == 0) || (demo->last_late_id < past[i].presentID)) {
952 // Record the last suspected-late present:
953 demo->last_late_id = demo->next_present_id - 1;
955 // We are in the midst of a set of likely-late images,
956 // and so we won't do anything.
959 demo->last_early_id = 0;
961 // Since this image was not presented early or late, reset
962 // any sets of early or late presentIDs:
965 calibrate_next = true;
966 demo->last_early_id = 0;
967 demo->last_late_id = 0;
972 // Since we've seen at least two-seconds worth of presnts that
973 // could have occured earlier than desired, let's decrease the
974 // target_IPD (i.e. increase the frame rate):
976 // TODO(ianelliott): Try to calculate a better target_IPD based
977 // on the most recently-seen present (this is overly-simplistic).
978 demo->refresh_duration_multiplier--;
979 if (demo->refresh_duration_multiplier == 0) {
980 // This should never happen, but in case it does, don't
982 demo->refresh_duration_multiplier = 1;
984 demo->target_IPD = demo->refresh_duration * demo->refresh_duration_multiplier;
987 // Since we found a new instance of a late present, we want to
988 // increase the target_IPD (i.e. decrease the frame rate):
990 // TODO(ianelliott): Try to calculate a better target_IPD based
991 // on the most recently-seen present (this is overly-simplistic).
992 demo->refresh_duration_multiplier++;
993 demo->target_IPD = demo->refresh_duration * demo->refresh_duration_multiplier;
996 if (calibrate_next) {
997 int64_t multiple = demo->next_present_id - past[count - 1].presentID;
998 demo->prev_desired_present_time = (past[count - 1].actualPresentTime + (multiple * demo->target_IPD));
1004 static void demo_draw(struct demo *demo) {
1005 VkResult U_ASSERT_ONLY err;
1007 // Ensure no more than FRAME_LAG renderings are outstanding
1008 vkWaitForFences(demo->device, 1, &demo->fences[demo->frame_index], VK_TRUE, UINT64_MAX);
1009 vkResetFences(demo->device, 1, &demo->fences[demo->frame_index]);
1012 // Get the index of the next available swapchain image:
1014 demo->fpAcquireNextImageKHR(demo->device, demo->swapchain, UINT64_MAX,
1015 demo->image_acquired_semaphores[demo->frame_index], VK_NULL_HANDLE, &demo->current_buffer);
1017 if (err == VK_ERROR_OUT_OF_DATE_KHR) {
1018 // demo->swapchain is out of date (e.g. the window was resized) and
1019 // must be recreated:
1021 } else if (err == VK_SUBOPTIMAL_KHR) {
1022 // demo->swapchain is not as optimal as it could be, but the platform's
1023 // presentation engine will still present the image correctly.
1028 } while (err != VK_SUCCESS);
1030 demo_update_data_buffer(demo);
1032 if (demo->VK_GOOGLE_display_timing_enabled) {
1033 // Look at what happened to previous presents, and make appropriate
1034 // adjustments in timing:
1035 DemoUpdateTargetIPD(demo);
1037 // Note: a real application would position its geometry to that it's in
1038 // the correct locatoin for when the next image is presented. It might
1039 // also wait, so that there's less latency between any input and when
1040 // the next image is rendered/presented. This demo program is so
1041 // simple that it doesn't do either of those.
1044 // Wait for the image acquired semaphore to be signaled to ensure
1045 // that the image won't be rendered to until the presentation
1046 // engine has fully released ownership to the application, and it is
1047 // okay to render to the image.
1048 VkPipelineStageFlags pipe_stage_flags;
1049 VkSubmitInfo submit_info;
1050 submit_info.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
1051 submit_info.pNext = NULL;
1052 submit_info.pWaitDstStageMask = &pipe_stage_flags;
1053 pipe_stage_flags = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
1054 submit_info.waitSemaphoreCount = 1;
1055 submit_info.pWaitSemaphores = &demo->image_acquired_semaphores[demo->frame_index];
1056 submit_info.commandBufferCount = 1;
1057 submit_info.pCommandBuffers = &demo->swapchain_image_resources[demo->current_buffer].cmd;
1058 submit_info.signalSemaphoreCount = 1;
1059 submit_info.pSignalSemaphores = &demo->draw_complete_semaphores[demo->frame_index];
1060 err = vkQueueSubmit(demo->graphics_queue, 1, &submit_info, demo->fences[demo->frame_index]);
1063 if (demo->separate_present_queue) {
1064 // If we are using separate queues, change image ownership to the
1065 // present queue before presenting, waiting for the draw complete
1066 // semaphore and signalling the ownership released semaphore when finished
1067 VkFence nullFence = VK_NULL_HANDLE;
1068 pipe_stage_flags = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
1069 submit_info.waitSemaphoreCount = 1;
1070 submit_info.pWaitSemaphores = &demo->draw_complete_semaphores[demo->frame_index];
1071 submit_info.commandBufferCount = 1;
1072 submit_info.pCommandBuffers = &demo->swapchain_image_resources[demo->current_buffer].graphics_to_present_cmd;
1073 submit_info.signalSemaphoreCount = 1;
1074 submit_info.pSignalSemaphores = &demo->image_ownership_semaphores[demo->frame_index];
1075 err = vkQueueSubmit(demo->present_queue, 1, &submit_info, nullFence);
1079 // If we are using separate queues we have to wait for image ownership,
1080 // otherwise wait for draw complete
1081 VkPresentInfoKHR present = {
1082 .sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR,
1084 .waitSemaphoreCount = 1,
1085 .pWaitSemaphores = (demo->separate_present_queue) ? &demo->image_ownership_semaphores[demo->frame_index]
1086 : &demo->draw_complete_semaphores[demo->frame_index],
1087 .swapchainCount = 1,
1088 .pSwapchains = &demo->swapchain,
1089 .pImageIndices = &demo->current_buffer,
1092 if (demo->VK_KHR_incremental_present_enabled) {
1093 // If using VK_KHR_incremental_present, we provide a hint of the region
1094 // that contains changed content relative to the previously-presented
1095 // image. The implementation can use this hint in order to save
1096 // work/power (by only copying the region in the hint). The
1097 // implementation is free to ignore the hint though, and so we must
1098 // ensure that the entire image has the correctly-drawn content.
1099 uint32_t eighthOfWidth = demo->width / 8;
1100 uint32_t eighthOfHeight = demo->height / 8;
1101 VkRectLayerKHR rect = {
1102 .offset.x = eighthOfWidth,
1103 .offset.y = eighthOfHeight,
1104 .extent.width = eighthOfWidth * 6,
1105 .extent.height = eighthOfHeight * 6,
1108 VkPresentRegionKHR region = {
1109 .rectangleCount = 1,
1110 .pRectangles = &rect,
1112 VkPresentRegionsKHR regions = {
1113 .sType = VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR,
1114 .pNext = present.pNext,
1115 .swapchainCount = present.swapchainCount,
1116 .pRegions = ®ion,
1118 present.pNext = ®ions;
1121 if (demo->VK_GOOGLE_display_timing_enabled) {
1122 VkPresentTimeGOOGLE ptime;
1123 if (demo->prev_desired_present_time == 0) {
1124 // This must be the first present for this swapchain.
1126 // We don't know where we are relative to the presentation engine's
1127 // display's refresh cycle. We also don't know how long rendering
1128 // takes. Let's make a grossly-simplified assumption that the
1129 // desiredPresentTime should be half way between now and
1130 // now+target_IPD. We will adjust over time.
1131 uint64_t curtime = getTimeInNanoseconds();
1133 // Since we didn't find out the current time, don't give a
1134 // desiredPresentTime:
1135 ptime.desiredPresentTime = 0;
1137 ptime.desiredPresentTime = curtime + (demo->target_IPD >> 1);
1140 ptime.desiredPresentTime = (demo->prev_desired_present_time + demo->target_IPD);
1142 ptime.presentID = demo->next_present_id++;
1143 demo->prev_desired_present_time = ptime.desiredPresentTime;
1145 VkPresentTimesInfoGOOGLE present_time = {
1146 .sType = VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE,
1147 .pNext = present.pNext,
1148 .swapchainCount = present.swapchainCount,
1151 if (demo->VK_GOOGLE_display_timing_enabled) {
1152 present.pNext = &present_time;
1156 err = demo->fpQueuePresentKHR(demo->present_queue, &present);
1157 demo->frame_index += 1;
1158 demo->frame_index %= FRAME_LAG;
1160 if (err == VK_ERROR_OUT_OF_DATE_KHR) {
1161 // demo->swapchain is out of date (e.g. the window was resized) and
1162 // must be recreated:
1164 } else if (err == VK_SUBOPTIMAL_KHR) {
1165 // demo->swapchain is not as optimal as it could be, but the platform's
1166 // presentation engine will still present the image correctly.
1172 static void demo_prepare_buffers(struct demo *demo) {
1173 VkResult U_ASSERT_ONLY err;
1174 VkSwapchainKHR oldSwapchain = demo->swapchain;
1176 // Check the surface capabilities and formats
1177 VkSurfaceCapabilitiesKHR surfCapabilities;
1178 err = demo->fpGetPhysicalDeviceSurfaceCapabilitiesKHR(demo->gpu, demo->surface, &surfCapabilities);
1181 uint32_t presentModeCount;
1182 err = demo->fpGetPhysicalDeviceSurfacePresentModesKHR(demo->gpu, demo->surface, &presentModeCount, NULL);
1184 VkPresentModeKHR *presentModes = (VkPresentModeKHR *)malloc(presentModeCount * sizeof(VkPresentModeKHR));
1185 assert(presentModes);
1186 err = demo->fpGetPhysicalDeviceSurfacePresentModesKHR(demo->gpu, demo->surface, &presentModeCount, presentModes);
1189 VkExtent2D swapchainExtent;
1190 // width and height are either both 0xFFFFFFFF, or both not 0xFFFFFFFF.
1191 if (surfCapabilities.currentExtent.width == 0xFFFFFFFF) {
1192 // If the surface size is undefined, the size is set to the size
1193 // of the images requested, which must fit within the minimum and
1195 swapchainExtent.width = demo->width;
1196 swapchainExtent.height = demo->height;
1198 if (swapchainExtent.width < surfCapabilities.minImageExtent.width) {
1199 swapchainExtent.width = surfCapabilities.minImageExtent.width;
1200 } else if (swapchainExtent.width > surfCapabilities.maxImageExtent.width) {
1201 swapchainExtent.width = surfCapabilities.maxImageExtent.width;
1204 if (swapchainExtent.height < surfCapabilities.minImageExtent.height) {
1205 swapchainExtent.height = surfCapabilities.minImageExtent.height;
1206 } else if (swapchainExtent.height > surfCapabilities.maxImageExtent.height) {
1207 swapchainExtent.height = surfCapabilities.maxImageExtent.height;
1210 // If the surface size is defined, the swap chain size must match
1211 swapchainExtent = surfCapabilities.currentExtent;
1212 demo->width = surfCapabilities.currentExtent.width;
1213 demo->height = surfCapabilities.currentExtent.height;
1216 if (demo->width == 0 || demo->height == 0) {
1217 demo->is_minimized = true;
1220 demo->is_minimized = false;
1223 // The FIFO present mode is guaranteed by the spec to be supported
1224 // and to have no tearing. It's a great default present mode to use.
1225 VkPresentModeKHR swapchainPresentMode = VK_PRESENT_MODE_FIFO_KHR;
1227 // There are times when you may wish to use another present mode. The
1228 // following code shows how to select them, and the comments provide some
1229 // reasons you may wish to use them.
1231 // It should be noted that Vulkan 1.0 doesn't provide a method for
1232 // synchronizing rendering with the presentation engine's display. There
1233 // is a method provided for throttling rendering with the display, but
1234 // there are some presentation engines for which this method will not work.
1235 // If an application doesn't throttle its rendering, and if it renders much
1236 // faster than the refresh rate of the display, this can waste power on
1237 // mobile devices. That is because power is being spent rendering images
1238 // that may never be seen.
1240 // VK_PRESENT_MODE_IMMEDIATE_KHR is for applications that don't care about
1241 // tearing, or have some way of synchronizing their rendering with the
1243 // VK_PRESENT_MODE_MAILBOX_KHR may be useful for applications that
1244 // generally render a new presentable image every refresh cycle, but are
1245 // occasionally early. In this case, the application wants the new image
1246 // to be displayed instead of the previously-queued-for-presentation image
1247 // that has not yet been displayed.
1248 // VK_PRESENT_MODE_FIFO_RELAXED_KHR is for applications that generally
1249 // render a new presentable image every refresh cycle, but are occasionally
1250 // late. In this case (perhaps because of stuttering/latency concerns),
1251 // the application wants the late image to be immediately displayed, even
1252 // though that may mean some tearing.
1254 if (demo->presentMode != swapchainPresentMode) {
1255 for (size_t i = 0; i < presentModeCount; ++i) {
1256 if (presentModes[i] == demo->presentMode) {
1257 swapchainPresentMode = demo->presentMode;
1262 if (swapchainPresentMode != demo->presentMode) {
1263 ERR_EXIT("Present mode specified is not supported\n", "Present mode unsupported");
1266 // Determine the number of VkImages to use in the swap chain.
1267 // Application desires to acquire 3 images at a time for triple
1269 uint32_t desiredNumOfSwapchainImages = 3;
1270 if (desiredNumOfSwapchainImages < surfCapabilities.minImageCount) {
1271 desiredNumOfSwapchainImages = surfCapabilities.minImageCount;
1273 // If maxImageCount is 0, we can ask for as many images as we want;
1274 // otherwise we're limited to maxImageCount
1275 if ((surfCapabilities.maxImageCount > 0) && (desiredNumOfSwapchainImages > surfCapabilities.maxImageCount)) {
1276 // Application must settle for fewer images than desired:
1277 desiredNumOfSwapchainImages = surfCapabilities.maxImageCount;
1280 VkSurfaceTransformFlagsKHR preTransform;
1281 if (surfCapabilities.supportedTransforms & VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR) {
1282 preTransform = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR;
1284 preTransform = surfCapabilities.currentTransform;
1287 // Find a supported composite alpha mode - one of these is guaranteed to be set
1288 VkCompositeAlphaFlagBitsKHR compositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR;
1289 VkCompositeAlphaFlagBitsKHR compositeAlphaFlags[4] = {
1290 VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR,
1291 VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR,
1292 VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR,
1293 VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR,
1295 for (uint32_t i = 0; i < ARRAY_SIZE(compositeAlphaFlags); i++) {
1296 if (surfCapabilities.supportedCompositeAlpha & compositeAlphaFlags[i]) {
1297 compositeAlpha = compositeAlphaFlags[i];
1302 VkSwapchainCreateInfoKHR swapchain_ci = {
1303 .sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR,
1305 .surface = demo->surface,
1306 .minImageCount = desiredNumOfSwapchainImages,
1307 .imageFormat = demo->format,
1308 .imageColorSpace = demo->color_space,
1311 .width = swapchainExtent.width,
1312 .height = swapchainExtent.height,
1314 .imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT,
1315 .preTransform = preTransform,
1316 .compositeAlpha = compositeAlpha,
1317 .imageArrayLayers = 1,
1318 .imageSharingMode = VK_SHARING_MODE_EXCLUSIVE,
1319 .queueFamilyIndexCount = 0,
1320 .pQueueFamilyIndices = NULL,
1321 .presentMode = swapchainPresentMode,
1322 .oldSwapchain = oldSwapchain,
1326 err = demo->fpCreateSwapchainKHR(demo->device, &swapchain_ci, NULL, &demo->swapchain);
1329 // If we just re-created an existing swapchain, we should destroy the old
1330 // swapchain at this point.
1331 // Note: destroying the swapchain also cleans up all its associated
1332 // presentable images once the platform is done with them.
1333 if (oldSwapchain != VK_NULL_HANDLE) {
1334 demo->fpDestroySwapchainKHR(demo->device, oldSwapchain, NULL);
1337 err = demo->fpGetSwapchainImagesKHR(demo->device, demo->swapchain, &demo->swapchainImageCount, NULL);
1340 VkImage *swapchainImages = (VkImage *)malloc(demo->swapchainImageCount * sizeof(VkImage));
1341 assert(swapchainImages);
1342 err = demo->fpGetSwapchainImagesKHR(demo->device, demo->swapchain, &demo->swapchainImageCount, swapchainImages);
1345 demo->swapchain_image_resources =
1346 (SwapchainImageResources *)malloc(sizeof(SwapchainImageResources) * demo->swapchainImageCount);
1347 assert(demo->swapchain_image_resources);
1349 for (i = 0; i < demo->swapchainImageCount; i++) {
1350 VkImageViewCreateInfo color_image_view = {
1351 .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
1353 .format = demo->format,
1356 .r = VK_COMPONENT_SWIZZLE_R,
1357 .g = VK_COMPONENT_SWIZZLE_G,
1358 .b = VK_COMPONENT_SWIZZLE_B,
1359 .a = VK_COMPONENT_SWIZZLE_A,
1362 {.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT, .baseMipLevel = 0, .levelCount = 1, .baseArrayLayer = 0, .layerCount = 1},
1363 .viewType = VK_IMAGE_VIEW_TYPE_2D,
1367 demo->swapchain_image_resources[i].image = swapchainImages[i];
1369 color_image_view.image = demo->swapchain_image_resources[i].image;
1371 err = vkCreateImageView(demo->device, &color_image_view, NULL, &demo->swapchain_image_resources[i].view);
1375 if (demo->VK_GOOGLE_display_timing_enabled) {
1376 VkRefreshCycleDurationGOOGLE rc_dur;
1377 err = demo->fpGetRefreshCycleDurationGOOGLE(demo->device, demo->swapchain, &rc_dur);
1379 demo->refresh_duration = rc_dur.refreshDuration;
1381 demo->syncd_with_actual_presents = false;
1382 // Initially target 1X the refresh duration:
1383 demo->target_IPD = demo->refresh_duration;
1384 demo->refresh_duration_multiplier = 1;
1385 demo->prev_desired_present_time = 0;
1386 demo->next_present_id = 1;
1389 if (NULL != presentModes) {
1394 static void demo_prepare_depth(struct demo *demo) {
1395 const VkFormat depth_format = VK_FORMAT_D16_UNORM;
1396 const VkImageCreateInfo image = {
1397 .sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,
1399 .imageType = VK_IMAGE_TYPE_2D,
1400 .format = depth_format,
1401 .extent = {demo->width, demo->height, 1},
1404 .samples = VK_SAMPLE_COUNT_1_BIT,
1405 .tiling = VK_IMAGE_TILING_OPTIMAL,
1406 .usage = VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT,
1410 VkImageViewCreateInfo view = {
1411 .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
1413 .image = VK_NULL_HANDLE,
1414 .format = depth_format,
1416 {.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT, .baseMipLevel = 0, .levelCount = 1, .baseArrayLayer = 0, .layerCount = 1},
1418 .viewType = VK_IMAGE_VIEW_TYPE_2D,
1421 VkMemoryRequirements mem_reqs;
1422 VkResult U_ASSERT_ONLY err;
1423 bool U_ASSERT_ONLY pass;
1425 demo->depth.format = depth_format;
1428 err = vkCreateImage(demo->device, &image, NULL, &demo->depth.image);
1431 vkGetImageMemoryRequirements(demo->device, demo->depth.image, &mem_reqs);
1434 demo->depth.mem_alloc.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
1435 demo->depth.mem_alloc.pNext = NULL;
1436 demo->depth.mem_alloc.allocationSize = mem_reqs.size;
1437 demo->depth.mem_alloc.memoryTypeIndex = 0;
1439 pass = memory_type_from_properties(demo, mem_reqs.memoryTypeBits, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT,
1440 &demo->depth.mem_alloc.memoryTypeIndex);
1443 /* allocate memory */
1444 err = vkAllocateMemory(demo->device, &demo->depth.mem_alloc, NULL, &demo->depth.mem);
1448 err = vkBindImageMemory(demo->device, demo->depth.image, demo->depth.mem, 0);
1451 /* create image view */
1452 view.image = demo->depth.image;
1453 err = vkCreateImageView(demo->device, &view, NULL, &demo->depth.view);
1457 /* Convert ppm image data from header file into RGBA texture image */
1458 #include "lunarg.ppm.h"
1459 bool loadTexture(const char *filename, uint8_t *rgba_data, VkSubresourceLayout *layout, int32_t *width, int32_t *height) {
1462 cPtr = (char *)lunarg_ppm;
1463 if ((unsigned char *)cPtr >= (lunarg_ppm + lunarg_ppm_len) || strncmp(cPtr, "P6\n", 3)) {
1466 while (strncmp(cPtr++, "\n", 1))
1468 sscanf(cPtr, "%u %u", width, height);
1469 if (rgba_data == NULL) {
1472 while (strncmp(cPtr++, "\n", 1))
1474 if ((unsigned char *)cPtr >= (lunarg_ppm + lunarg_ppm_len) || strncmp(cPtr, "255\n", 4)) {
1477 while (strncmp(cPtr++, "\n", 1))
1479 for (int y = 0; y < *height; y++) {
1480 uint8_t *rowPtr = rgba_data;
1481 for (int x = 0; x < *width; x++) {
1482 memcpy(rowPtr, cPtr, 3);
1483 rowPtr[3] = 255; /* Alpha of 1 */
1487 rgba_data += layout->rowPitch;
1492 static void demo_prepare_texture_buffer(struct demo *demo, const char *filename, struct texture_object *tex_obj) {
1495 VkResult U_ASSERT_ONLY err;
1496 bool U_ASSERT_ONLY pass;
1498 if (!loadTexture(filename, NULL, NULL, &tex_width, &tex_height)) {
1499 ERR_EXIT("Failed to load textures", "Load Texture Failure");
1502 tex_obj->tex_width = tex_width;
1503 tex_obj->tex_height = tex_height;
1505 const VkBufferCreateInfo buffer_create_info = {.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
1508 .size = tex_width * tex_height * 4,
1509 .usage = VK_BUFFER_USAGE_TRANSFER_SRC_BIT,
1510 .sharingMode = VK_SHARING_MODE_EXCLUSIVE,
1511 .queueFamilyIndexCount = 0,
1512 .pQueueFamilyIndices = NULL};
1514 err = vkCreateBuffer(demo->device, &buffer_create_info, NULL, &tex_obj->buffer);
1517 VkMemoryRequirements mem_reqs;
1518 vkGetBufferMemoryRequirements(demo->device, tex_obj->buffer, &mem_reqs);
1520 tex_obj->mem_alloc.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
1521 tex_obj->mem_alloc.pNext = NULL;
1522 tex_obj->mem_alloc.allocationSize = mem_reqs.size;
1523 tex_obj->mem_alloc.memoryTypeIndex = 0;
1525 VkFlags requirements = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT;
1526 pass = memory_type_from_properties(demo, mem_reqs.memoryTypeBits, requirements, &tex_obj->mem_alloc.memoryTypeIndex);
1529 err = vkAllocateMemory(demo->device, &tex_obj->mem_alloc, NULL, &(tex_obj->mem));
1533 err = vkBindBufferMemory(demo->device, tex_obj->buffer, tex_obj->mem, 0);
1536 VkSubresourceLayout layout;
1537 memset(&layout, 0, sizeof(layout));
1538 layout.rowPitch = tex_width * 4;
1541 err = vkMapMemory(demo->device, tex_obj->mem, 0, tex_obj->mem_alloc.allocationSize, 0, &data);
1544 if (!loadTexture(filename, data, &layout, &tex_width, &tex_height)) {
1545 fprintf(stderr, "Error loading texture: %s\n", filename);
1548 vkUnmapMemory(demo->device, tex_obj->mem);
1551 static void demo_prepare_texture_image(struct demo *demo, const char *filename, struct texture_object *tex_obj,
1552 VkImageTiling tiling, VkImageUsageFlags usage, VkFlags required_props) {
1553 const VkFormat tex_format = VK_FORMAT_R8G8B8A8_UNORM;
1556 VkResult U_ASSERT_ONLY err;
1557 bool U_ASSERT_ONLY pass;
1559 if (!loadTexture(filename, NULL, NULL, &tex_width, &tex_height)) {
1560 ERR_EXIT("Failed to load textures", "Load Texture Failure");
1563 tex_obj->tex_width = tex_width;
1564 tex_obj->tex_height = tex_height;
1566 const VkImageCreateInfo image_create_info = {
1567 .sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,
1569 .imageType = VK_IMAGE_TYPE_2D,
1570 .format = tex_format,
1571 .extent = {tex_width, tex_height, 1},
1574 .samples = VK_SAMPLE_COUNT_1_BIT,
1578 .initialLayout = VK_IMAGE_LAYOUT_PREINITIALIZED,
1581 VkMemoryRequirements mem_reqs;
1583 err = vkCreateImage(demo->device, &image_create_info, NULL, &tex_obj->image);
1586 vkGetImageMemoryRequirements(demo->device, tex_obj->image, &mem_reqs);
1588 tex_obj->mem_alloc.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
1589 tex_obj->mem_alloc.pNext = NULL;
1590 tex_obj->mem_alloc.allocationSize = mem_reqs.size;
1591 tex_obj->mem_alloc.memoryTypeIndex = 0;
1593 pass = memory_type_from_properties(demo, mem_reqs.memoryTypeBits, required_props, &tex_obj->mem_alloc.memoryTypeIndex);
1596 /* allocate memory */
1597 err = vkAllocateMemory(demo->device, &tex_obj->mem_alloc, NULL, &(tex_obj->mem));
1601 err = vkBindImageMemory(demo->device, tex_obj->image, tex_obj->mem, 0);
1604 if (required_props & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) {
1605 const VkImageSubresource subres = {
1606 .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
1610 VkSubresourceLayout layout;
1613 vkGetImageSubresourceLayout(demo->device, tex_obj->image, &subres, &layout);
1615 err = vkMapMemory(demo->device, tex_obj->mem, 0, tex_obj->mem_alloc.allocationSize, 0, &data);
1618 if (!loadTexture(filename, data, &layout, &tex_width, &tex_height)) {
1619 fprintf(stderr, "Error loading texture: %s\n", filename);
1622 vkUnmapMemory(demo->device, tex_obj->mem);
1625 tex_obj->imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
1628 static void demo_destroy_texture(struct demo *demo, struct texture_object *tex_objs) {
1629 /* clean up staging resources */
1630 vkFreeMemory(demo->device, tex_objs->mem, NULL);
1631 if (tex_objs->image) vkDestroyImage(demo->device, tex_objs->image, NULL);
1632 if (tex_objs->buffer) vkDestroyBuffer(demo->device, tex_objs->buffer, NULL);
1635 static void demo_prepare_textures(struct demo *demo) {
1636 const VkFormat tex_format = VK_FORMAT_R8G8B8A8_UNORM;
1637 VkFormatProperties props;
1640 vkGetPhysicalDeviceFormatProperties(demo->gpu, tex_format, &props);
1642 for (i = 0; i < DEMO_TEXTURE_COUNT; i++) {
1643 VkResult U_ASSERT_ONLY err;
1645 if ((props.linearTilingFeatures & VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT) && !demo->use_staging_buffer) {
1646 /* Device can texture using linear textures */
1647 demo_prepare_texture_image(demo, tex_files[i], &demo->textures[i], VK_IMAGE_TILING_LINEAR, VK_IMAGE_USAGE_SAMPLED_BIT,
1648 VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT);
1649 // Nothing in the pipeline needs to be complete to start, and don't allow fragment
1650 // shader to run until layout transition completes
1651 demo_set_image_layout(demo, demo->textures[i].image, VK_IMAGE_ASPECT_COLOR_BIT, VK_IMAGE_LAYOUT_PREINITIALIZED,
1652 demo->textures[i].imageLayout, 0, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
1653 VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT);
1654 demo->staging_texture.image = 0;
1655 } else if (props.optimalTilingFeatures & VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT) {
1656 /* Must use staging buffer to copy linear texture to optimized */
1658 memset(&demo->staging_texture, 0, sizeof(demo->staging_texture));
1659 demo_prepare_texture_buffer(demo, tex_files[i], &demo->staging_texture);
1661 demo_prepare_texture_image(demo, tex_files[i], &demo->textures[i], VK_IMAGE_TILING_OPTIMAL,
1662 (VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_SAMPLED_BIT),
1663 VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
1665 demo_set_image_layout(demo, demo->textures[i].image, VK_IMAGE_ASPECT_COLOR_BIT, VK_IMAGE_LAYOUT_PREINITIALIZED,
1666 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 0, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
1667 VK_PIPELINE_STAGE_TRANSFER_BIT);
1669 VkBufferImageCopy copy_region = {
1671 .bufferRowLength = demo->staging_texture.tex_width,
1672 .bufferImageHeight = demo->staging_texture.tex_height,
1673 .imageSubresource = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, 1},
1674 .imageOffset = {0, 0, 0},
1675 .imageExtent = {demo->staging_texture.tex_width, demo->staging_texture.tex_height, 1},
1678 vkCmdCopyBufferToImage(demo->cmd, demo->staging_texture.buffer, demo->textures[i].image,
1679 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, ©_region);
1681 demo_set_image_layout(demo, demo->textures[i].image, VK_IMAGE_ASPECT_COLOR_BIT, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
1682 demo->textures[i].imageLayout, VK_ACCESS_TRANSFER_WRITE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT,
1683 VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT);
1686 /* Can't support VK_FORMAT_R8G8B8A8_UNORM !? */
1687 assert(!"No support for R8G8B8A8_UNORM as texture image format");
1690 const VkSamplerCreateInfo sampler = {
1691 .sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO,
1693 .magFilter = VK_FILTER_NEAREST,
1694 .minFilter = VK_FILTER_NEAREST,
1695 .mipmapMode = VK_SAMPLER_MIPMAP_MODE_NEAREST,
1696 .addressModeU = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,
1697 .addressModeV = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,
1698 .addressModeW = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,
1700 .anisotropyEnable = VK_FALSE,
1702 .compareOp = VK_COMPARE_OP_NEVER,
1705 .borderColor = VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE,
1706 .unnormalizedCoordinates = VK_FALSE,
1709 VkImageViewCreateInfo view = {
1710 .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
1712 .image = VK_NULL_HANDLE,
1713 .viewType = VK_IMAGE_VIEW_TYPE_2D,
1714 .format = tex_format,
1717 VK_COMPONENT_SWIZZLE_R,
1718 VK_COMPONENT_SWIZZLE_G,
1719 VK_COMPONENT_SWIZZLE_B,
1720 VK_COMPONENT_SWIZZLE_A,
1722 .subresourceRange = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1},
1726 /* create sampler */
1727 err = vkCreateSampler(demo->device, &sampler, NULL, &demo->textures[i].sampler);
1730 /* create image view */
1731 view.image = demo->textures[i].image;
1732 err = vkCreateImageView(demo->device, &view, NULL, &demo->textures[i].view);
1737 void demo_prepare_cube_data_buffers(struct demo *demo) {
1738 VkBufferCreateInfo buf_info;
1739 VkMemoryRequirements mem_reqs;
1740 VkMemoryAllocateInfo mem_alloc;
1743 VkResult U_ASSERT_ONLY err;
1744 bool U_ASSERT_ONLY pass;
1745 struct vktexcube_vs_uniform data;
1747 mat4x4_mul(VP, demo->projection_matrix, demo->view_matrix);
1748 mat4x4_mul(MVP, VP, demo->model_matrix);
1749 memcpy(data.mvp, MVP, sizeof(MVP));
1750 // dumpMatrix("MVP", MVP);
1752 for (unsigned int i = 0; i < 12 * 3; i++) {
1753 data.position[i][0] = g_vertex_buffer_data[i * 3];
1754 data.position[i][1] = g_vertex_buffer_data[i * 3 + 1];
1755 data.position[i][2] = g_vertex_buffer_data[i * 3 + 2];
1756 data.position[i][3] = 1.0f;
1757 data.attr[i][0] = g_uv_buffer_data[2 * i];
1758 data.attr[i][1] = g_uv_buffer_data[2 * i + 1];
1759 data.attr[i][2] = 0;
1760 data.attr[i][3] = 0;
1763 memset(&buf_info, 0, sizeof(buf_info));
1764 buf_info.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
1765 buf_info.usage = VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT;
1766 buf_info.size = sizeof(data);
1768 for (unsigned int i = 0; i < demo->swapchainImageCount; i++) {
1769 err = vkCreateBuffer(demo->device, &buf_info, NULL, &demo->swapchain_image_resources[i].uniform_buffer);
1772 vkGetBufferMemoryRequirements(demo->device, demo->swapchain_image_resources[i].uniform_buffer, &mem_reqs);
1774 mem_alloc.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
1775 mem_alloc.pNext = NULL;
1776 mem_alloc.allocationSize = mem_reqs.size;
1777 mem_alloc.memoryTypeIndex = 0;
1779 pass = memory_type_from_properties(demo, mem_reqs.memoryTypeBits,
1780 VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
1781 &mem_alloc.memoryTypeIndex);
1784 err = vkAllocateMemory(demo->device, &mem_alloc, NULL, &demo->swapchain_image_resources[i].uniform_memory);
1787 err = vkMapMemory(demo->device, demo->swapchain_image_resources[i].uniform_memory, 0, VK_WHOLE_SIZE, 0, (void **)&pData);
1790 memcpy(pData, &data, sizeof data);
1792 vkUnmapMemory(demo->device, demo->swapchain_image_resources[i].uniform_memory);
1794 err = vkBindBufferMemory(demo->device, demo->swapchain_image_resources[i].uniform_buffer,
1795 demo->swapchain_image_resources[i].uniform_memory, 0);
1800 static void demo_prepare_descriptor_layout(struct demo *demo) {
1801 const VkDescriptorSetLayoutBinding layout_bindings[2] = {
1805 .descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
1806 .descriptorCount = 1,
1807 .stageFlags = VK_SHADER_STAGE_VERTEX_BIT,
1808 .pImmutableSamplers = NULL,
1813 .descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
1814 .descriptorCount = DEMO_TEXTURE_COUNT,
1815 .stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT,
1816 .pImmutableSamplers = NULL,
1819 const VkDescriptorSetLayoutCreateInfo descriptor_layout = {
1820 .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO,
1823 .pBindings = layout_bindings,
1825 VkResult U_ASSERT_ONLY err;
1827 err = vkCreateDescriptorSetLayout(demo->device, &descriptor_layout, NULL, &demo->desc_layout);
1830 const VkPipelineLayoutCreateInfo pPipelineLayoutCreateInfo = {
1831 .sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,
1833 .setLayoutCount = 1,
1834 .pSetLayouts = &demo->desc_layout,
1837 err = vkCreatePipelineLayout(demo->device, &pPipelineLayoutCreateInfo, NULL, &demo->pipeline_layout);
1841 static void demo_prepare_render_pass(struct demo *demo) {
1842 // The initial layout for the color and depth attachments will be LAYOUT_UNDEFINED
1843 // because at the start of the renderpass, we don't care about their contents.
1844 // At the start of the subpass, the color attachment's layout will be transitioned
1845 // to LAYOUT_COLOR_ATTACHMENT_OPTIMAL and the depth stencil attachment's layout
1846 // will be transitioned to LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL. At the end of
1847 // the renderpass, the color attachment's layout will be transitioned to
1848 // LAYOUT_PRESENT_SRC_KHR to be ready to present. This is all done as part of
1849 // the renderpass, no barriers are necessary.
1850 const VkAttachmentDescription attachments[2] = {
1853 .format = demo->format,
1855 .samples = VK_SAMPLE_COUNT_1_BIT,
1856 .loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR,
1857 .storeOp = VK_ATTACHMENT_STORE_OP_STORE,
1858 .stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE,
1859 .stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE,
1860 .initialLayout = VK_IMAGE_LAYOUT_UNDEFINED,
1861 .finalLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR,
1865 .format = demo->depth.format,
1867 .samples = VK_SAMPLE_COUNT_1_BIT,
1868 .loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR,
1869 .storeOp = VK_ATTACHMENT_STORE_OP_DONT_CARE,
1870 .stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE,
1871 .stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE,
1872 .initialLayout = VK_IMAGE_LAYOUT_UNDEFINED,
1873 .finalLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
1876 const VkAttachmentReference color_reference = {
1878 .layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
1880 const VkAttachmentReference depth_reference = {
1882 .layout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
1884 const VkSubpassDescription subpass = {
1885 .pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS,
1887 .inputAttachmentCount = 0,
1888 .pInputAttachments = NULL,
1889 .colorAttachmentCount = 1,
1890 .pColorAttachments = &color_reference,
1891 .pResolveAttachments = NULL,
1892 .pDepthStencilAttachment = &depth_reference,
1893 .preserveAttachmentCount = 0,
1894 .pPreserveAttachments = NULL,
1896 const VkRenderPassCreateInfo rp_info = {
1897 .sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO,
1900 .attachmentCount = 2,
1901 .pAttachments = attachments,
1903 .pSubpasses = &subpass,
1904 .dependencyCount = 0,
1905 .pDependencies = NULL,
1907 VkResult U_ASSERT_ONLY err;
1909 err = vkCreateRenderPass(demo->device, &rp_info, NULL, &demo->render_pass);
1913 static VkShaderModule demo_prepare_shader_module(struct demo *demo, const uint32_t *code, size_t size) {
1914 VkShaderModule module;
1915 VkShaderModuleCreateInfo moduleCreateInfo;
1916 VkResult U_ASSERT_ONLY err;
1918 moduleCreateInfo.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
1919 moduleCreateInfo.pNext = NULL;
1920 moduleCreateInfo.flags = 0;
1921 moduleCreateInfo.codeSize = size;
1922 moduleCreateInfo.pCode = code;
1924 err = vkCreateShaderModule(demo->device, &moduleCreateInfo, NULL, &module);
1930 static void demo_prepare_vs(struct demo *demo) {
1931 const uint32_t vs_code[] = {
1932 #include "cube.vert.inc"
1934 demo->vert_shader_module = demo_prepare_shader_module(demo, vs_code, sizeof(vs_code));
1937 static void demo_prepare_fs(struct demo *demo) {
1938 const uint32_t fs_code[] = {
1939 #include "cube.frag.inc"
1941 demo->frag_shader_module = demo_prepare_shader_module(demo, fs_code, sizeof(fs_code));
1944 static void demo_prepare_pipeline(struct demo *demo) {
1945 VkGraphicsPipelineCreateInfo pipeline;
1946 VkPipelineCacheCreateInfo pipelineCache;
1947 VkPipelineVertexInputStateCreateInfo vi;
1948 VkPipelineInputAssemblyStateCreateInfo ia;
1949 VkPipelineRasterizationStateCreateInfo rs;
1950 VkPipelineColorBlendStateCreateInfo cb;
1951 VkPipelineDepthStencilStateCreateInfo ds;
1952 VkPipelineViewportStateCreateInfo vp;
1953 VkPipelineMultisampleStateCreateInfo ms;
1954 VkDynamicState dynamicStateEnables[VK_DYNAMIC_STATE_RANGE_SIZE];
1955 VkPipelineDynamicStateCreateInfo dynamicState;
1956 VkResult U_ASSERT_ONLY err;
1958 memset(dynamicStateEnables, 0, sizeof dynamicStateEnables);
1959 memset(&dynamicState, 0, sizeof dynamicState);
1960 dynamicState.sType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO;
1961 dynamicState.pDynamicStates = dynamicStateEnables;
1963 memset(&pipeline, 0, sizeof(pipeline));
1964 pipeline.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO;
1965 pipeline.layout = demo->pipeline_layout;
1967 memset(&vi, 0, sizeof(vi));
1968 vi.sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO;
1970 memset(&ia, 0, sizeof(ia));
1971 ia.sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO;
1972 ia.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
1974 memset(&rs, 0, sizeof(rs));
1975 rs.sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO;
1976 rs.polygonMode = VK_POLYGON_MODE_FILL;
1977 rs.cullMode = VK_CULL_MODE_BACK_BIT;
1978 rs.frontFace = VK_FRONT_FACE_COUNTER_CLOCKWISE;
1979 rs.depthClampEnable = VK_FALSE;
1980 rs.rasterizerDiscardEnable = VK_FALSE;
1981 rs.depthBiasEnable = VK_FALSE;
1982 rs.lineWidth = 1.0f;
1984 memset(&cb, 0, sizeof(cb));
1985 cb.sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO;
1986 VkPipelineColorBlendAttachmentState att_state[1];
1987 memset(att_state, 0, sizeof(att_state));
1988 att_state[0].colorWriteMask = 0xf;
1989 att_state[0].blendEnable = VK_FALSE;
1990 cb.attachmentCount = 1;
1991 cb.pAttachments = att_state;
1993 memset(&vp, 0, sizeof(vp));
1994 vp.sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO;
1995 vp.viewportCount = 1;
1996 dynamicStateEnables[dynamicState.dynamicStateCount++] = VK_DYNAMIC_STATE_VIEWPORT;
1997 vp.scissorCount = 1;
1998 dynamicStateEnables[dynamicState.dynamicStateCount++] = VK_DYNAMIC_STATE_SCISSOR;
2000 memset(&ds, 0, sizeof(ds));
2001 ds.sType = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO;
2002 ds.depthTestEnable = VK_TRUE;
2003 ds.depthWriteEnable = VK_TRUE;
2004 ds.depthCompareOp = VK_COMPARE_OP_LESS_OR_EQUAL;
2005 ds.depthBoundsTestEnable = VK_FALSE;
2006 ds.back.failOp = VK_STENCIL_OP_KEEP;
2007 ds.back.passOp = VK_STENCIL_OP_KEEP;
2008 ds.back.compareOp = VK_COMPARE_OP_ALWAYS;
2009 ds.stencilTestEnable = VK_FALSE;
2012 memset(&ms, 0, sizeof(ms));
2013 ms.sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO;
2014 ms.pSampleMask = NULL;
2015 ms.rasterizationSamples = VK_SAMPLE_COUNT_1_BIT;
2017 demo_prepare_vs(demo);
2018 demo_prepare_fs(demo);
2020 // Two stages: vs and fs
2021 VkPipelineShaderStageCreateInfo shaderStages[2];
2022 memset(&shaderStages, 0, 2 * sizeof(VkPipelineShaderStageCreateInfo));
2024 shaderStages[0].sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
2025 shaderStages[0].stage = VK_SHADER_STAGE_VERTEX_BIT;
2026 shaderStages[0].module = demo->vert_shader_module;
2027 shaderStages[0].pName = "main";
2029 shaderStages[1].sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
2030 shaderStages[1].stage = VK_SHADER_STAGE_FRAGMENT_BIT;
2031 shaderStages[1].module = demo->frag_shader_module;
2032 shaderStages[1].pName = "main";
2034 memset(&pipelineCache, 0, sizeof(pipelineCache));
2035 pipelineCache.sType = VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO;
2037 err = vkCreatePipelineCache(demo->device, &pipelineCache, NULL, &demo->pipelineCache);
2040 pipeline.pVertexInputState = &vi;
2041 pipeline.pInputAssemblyState = &ia;
2042 pipeline.pRasterizationState = &rs;
2043 pipeline.pColorBlendState = &cb;
2044 pipeline.pMultisampleState = &ms;
2045 pipeline.pViewportState = &vp;
2046 pipeline.pDepthStencilState = &ds;
2047 pipeline.stageCount = ARRAY_SIZE(shaderStages);
2048 pipeline.pStages = shaderStages;
2049 pipeline.renderPass = demo->render_pass;
2050 pipeline.pDynamicState = &dynamicState;
2052 pipeline.renderPass = demo->render_pass;
2054 err = vkCreateGraphicsPipelines(demo->device, demo->pipelineCache, 1, &pipeline, NULL, &demo->pipeline);
2057 vkDestroyShaderModule(demo->device, demo->frag_shader_module, NULL);
2058 vkDestroyShaderModule(demo->device, demo->vert_shader_module, NULL);
2061 static void demo_prepare_descriptor_pool(struct demo *demo) {
2062 const VkDescriptorPoolSize type_counts[2] = {
2065 .type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
2066 .descriptorCount = demo->swapchainImageCount,
2070 .type = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
2071 .descriptorCount = demo->swapchainImageCount * DEMO_TEXTURE_COUNT,
2074 const VkDescriptorPoolCreateInfo descriptor_pool = {
2075 .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO,
2077 .maxSets = demo->swapchainImageCount,
2079 .pPoolSizes = type_counts,
2081 VkResult U_ASSERT_ONLY err;
2083 err = vkCreateDescriptorPool(demo->device, &descriptor_pool, NULL, &demo->desc_pool);
2087 static void demo_prepare_descriptor_set(struct demo *demo) {
2088 VkDescriptorImageInfo tex_descs[DEMO_TEXTURE_COUNT];
2089 VkWriteDescriptorSet writes[2];
2090 VkResult U_ASSERT_ONLY err;
2092 VkDescriptorSetAllocateInfo alloc_info = {.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO,
2094 .descriptorPool = demo->desc_pool,
2095 .descriptorSetCount = 1,
2096 .pSetLayouts = &demo->desc_layout};
2098 VkDescriptorBufferInfo buffer_info;
2099 buffer_info.offset = 0;
2100 buffer_info.range = sizeof(struct vktexcube_vs_uniform);
2102 memset(&tex_descs, 0, sizeof(tex_descs));
2103 for (unsigned int i = 0; i < DEMO_TEXTURE_COUNT; i++) {
2104 tex_descs[i].sampler = demo->textures[i].sampler;
2105 tex_descs[i].imageView = demo->textures[i].view;
2106 tex_descs[i].imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
2109 memset(&writes, 0, sizeof(writes));
2111 writes[0].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
2112 writes[0].descriptorCount = 1;
2113 writes[0].descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
2114 writes[0].pBufferInfo = &buffer_info;
2116 writes[1].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
2117 writes[1].dstBinding = 1;
2118 writes[1].descriptorCount = DEMO_TEXTURE_COUNT;
2119 writes[1].descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
2120 writes[1].pImageInfo = tex_descs;
2122 for (unsigned int i = 0; i < demo->swapchainImageCount; i++) {
2123 err = vkAllocateDescriptorSets(demo->device, &alloc_info, &demo->swapchain_image_resources[i].descriptor_set);
2125 buffer_info.buffer = demo->swapchain_image_resources[i].uniform_buffer;
2126 writes[0].dstSet = demo->swapchain_image_resources[i].descriptor_set;
2127 writes[1].dstSet = demo->swapchain_image_resources[i].descriptor_set;
2128 vkUpdateDescriptorSets(demo->device, 2, writes, 0, NULL);
2132 static void demo_prepare_framebuffers(struct demo *demo) {
2133 VkImageView attachments[2];
2134 attachments[1] = demo->depth.view;
2136 const VkFramebufferCreateInfo fb_info = {
2137 .sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO,
2139 .renderPass = demo->render_pass,
2140 .attachmentCount = 2,
2141 .pAttachments = attachments,
2142 .width = demo->width,
2143 .height = demo->height,
2146 VkResult U_ASSERT_ONLY err;
2149 for (i = 0; i < demo->swapchainImageCount; i++) {
2150 attachments[0] = demo->swapchain_image_resources[i].view;
2151 err = vkCreateFramebuffer(demo->device, &fb_info, NULL, &demo->swapchain_image_resources[i].framebuffer);
2156 static void demo_prepare(struct demo *demo) {
2157 VkResult U_ASSERT_ONLY err;
2158 if (demo->cmd_pool == VK_NULL_HANDLE) {
2159 const VkCommandPoolCreateInfo cmd_pool_info = {
2160 .sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,
2162 .queueFamilyIndex = demo->graphics_queue_family_index,
2165 err = vkCreateCommandPool(demo->device, &cmd_pool_info, NULL, &demo->cmd_pool);
2169 const VkCommandBufferAllocateInfo cmd = {
2170 .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,
2172 .commandPool = demo->cmd_pool,
2173 .level = VK_COMMAND_BUFFER_LEVEL_PRIMARY,
2174 .commandBufferCount = 1,
2176 err = vkAllocateCommandBuffers(demo->device, &cmd, &demo->cmd);
2178 VkCommandBufferBeginInfo cmd_buf_info = {
2179 .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
2182 .pInheritanceInfo = NULL,
2184 err = vkBeginCommandBuffer(demo->cmd, &cmd_buf_info);
2187 demo_prepare_buffers(demo);
2189 if (demo->is_minimized) {
2190 demo->prepared = false;
2194 demo_prepare_depth(demo);
2195 demo_prepare_textures(demo);
2196 demo_prepare_cube_data_buffers(demo);
2198 demo_prepare_descriptor_layout(demo);
2199 demo_prepare_render_pass(demo);
2200 demo_prepare_pipeline(demo);
2202 for (uint32_t i = 0; i < demo->swapchainImageCount; i++) {
2203 err = vkAllocateCommandBuffers(demo->device, &cmd, &demo->swapchain_image_resources[i].cmd);
2207 if (demo->separate_present_queue) {
2208 const VkCommandPoolCreateInfo present_cmd_pool_info = {
2209 .sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,
2211 .queueFamilyIndex = demo->present_queue_family_index,
2214 err = vkCreateCommandPool(demo->device, &present_cmd_pool_info, NULL, &demo->present_cmd_pool);
2216 const VkCommandBufferAllocateInfo present_cmd_info = {
2217 .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,
2219 .commandPool = demo->present_cmd_pool,
2220 .level = VK_COMMAND_BUFFER_LEVEL_PRIMARY,
2221 .commandBufferCount = 1,
2223 for (uint32_t i = 0; i < demo->swapchainImageCount; i++) {
2224 err = vkAllocateCommandBuffers(demo->device, &present_cmd_info,
2225 &demo->swapchain_image_resources[i].graphics_to_present_cmd);
2227 demo_build_image_ownership_cmd(demo, i);
2231 demo_prepare_descriptor_pool(demo);
2232 demo_prepare_descriptor_set(demo);
2234 demo_prepare_framebuffers(demo);
2236 for (uint32_t i = 0; i < demo->swapchainImageCount; i++) {
2237 demo->current_buffer = i;
2238 demo_draw_build_cmd(demo, demo->swapchain_image_resources[i].cmd);
2242 * Prepare functions above may generate pipeline commands
2243 * that need to be flushed before beginning the render loop.
2245 demo_flush_init_cmd(demo);
2246 if (demo->staging_texture.buffer) {
2247 demo_destroy_texture(demo, &demo->staging_texture);
2250 demo->current_buffer = 0;
2251 demo->prepared = true;
2254 static void demo_cleanup(struct demo *demo) {
2257 demo->prepared = false;
2258 vkDeviceWaitIdle(demo->device);
2260 // Wait for fences from present operations
2261 for (i = 0; i < FRAME_LAG; i++) {
2262 vkWaitForFences(demo->device, 1, &demo->fences[i], VK_TRUE, UINT64_MAX);
2263 vkDestroyFence(demo->device, demo->fences[i], NULL);
2264 vkDestroySemaphore(demo->device, demo->image_acquired_semaphores[i], NULL);
2265 vkDestroySemaphore(demo->device, demo->draw_complete_semaphores[i], NULL);
2266 if (demo->separate_present_queue) {
2267 vkDestroySemaphore(demo->device, demo->image_ownership_semaphores[i], NULL);
2271 // If the window is currently minimized, demo_resize has already done some cleanup for us.
2272 if (!demo->is_minimized) {
2273 for (i = 0; i < demo->swapchainImageCount; i++) {
2274 vkDestroyFramebuffer(demo->device, demo->swapchain_image_resources[i].framebuffer, NULL);
2276 vkDestroyDescriptorPool(demo->device, demo->desc_pool, NULL);
2278 vkDestroyPipeline(demo->device, demo->pipeline, NULL);
2279 vkDestroyPipelineCache(demo->device, demo->pipelineCache, NULL);
2280 vkDestroyRenderPass(demo->device, demo->render_pass, NULL);
2281 vkDestroyPipelineLayout(demo->device, demo->pipeline_layout, NULL);
2282 vkDestroyDescriptorSetLayout(demo->device, demo->desc_layout, NULL);
2284 for (i = 0; i < DEMO_TEXTURE_COUNT; i++) {
2285 vkDestroyImageView(demo->device, demo->textures[i].view, NULL);
2286 vkDestroyImage(demo->device, demo->textures[i].image, NULL);
2287 vkFreeMemory(demo->device, demo->textures[i].mem, NULL);
2288 vkDestroySampler(demo->device, demo->textures[i].sampler, NULL);
2290 demo->fpDestroySwapchainKHR(demo->device, demo->swapchain, NULL);
2292 vkDestroyImageView(demo->device, demo->depth.view, NULL);
2293 vkDestroyImage(demo->device, demo->depth.image, NULL);
2294 vkFreeMemory(demo->device, demo->depth.mem, NULL);
2296 for (i = 0; i < demo->swapchainImageCount; i++) {
2297 vkDestroyImageView(demo->device, demo->swapchain_image_resources[i].view, NULL);
2298 vkFreeCommandBuffers(demo->device, demo->cmd_pool, 1, &demo->swapchain_image_resources[i].cmd);
2299 vkDestroyBuffer(demo->device, demo->swapchain_image_resources[i].uniform_buffer, NULL);
2300 vkFreeMemory(demo->device, demo->swapchain_image_resources[i].uniform_memory, NULL);
2302 free(demo->swapchain_image_resources);
2303 free(demo->queue_props);
2304 vkDestroyCommandPool(demo->device, demo->cmd_pool, NULL);
2306 if (demo->separate_present_queue) {
2307 vkDestroyCommandPool(demo->device, demo->present_cmd_pool, NULL);
2310 vkDeviceWaitIdle(demo->device);
2311 vkDestroyDevice(demo->device, NULL);
2312 if (demo->validate) {
2313 demo->DestroyDebugUtilsMessengerEXT(demo->inst, demo->dbg_messenger, NULL);
2315 vkDestroySurfaceKHR(demo->inst, demo->surface, NULL);
2317 #if defined(VK_USE_PLATFORM_XLIB_KHR)
2318 XDestroyWindow(demo->display, demo->xlib_window);
2319 XCloseDisplay(demo->display);
2320 #elif defined(VK_USE_PLATFORM_XCB_KHR)
2321 xcb_destroy_window(demo->connection, demo->xcb_window);
2322 xcb_disconnect(demo->connection);
2323 free(demo->atom_wm_delete_window);
2324 #elif defined(VK_USE_PLATFORM_WAYLAND_KHR)
2325 wl_keyboard_destroy(demo->keyboard);
2326 wl_pointer_destroy(demo->pointer);
2327 wl_seat_destroy(demo->seat);
2328 wl_shell_surface_destroy(demo->shell_surface);
2329 wl_surface_destroy(demo->window);
2330 wl_shell_destroy(demo->shell);
2331 wl_compositor_destroy(demo->compositor);
2332 wl_registry_destroy(demo->registry);
2333 wl_display_disconnect(demo->display);
2334 #elif defined(VK_USE_PLATFORM_MIR_KHR)
2337 vkDestroyInstance(demo->inst, NULL);
2340 static void demo_resize(struct demo *demo) {
2343 // Don't react to resize until after first initialization.
2344 if (!demo->prepared) {
2345 if (demo->is_minimized) {
2350 // In order to properly resize the window, we must re-create the swapchain
2351 // AND redo the command buffers, etc.
2353 // First, perform part of the demo_cleanup() function:
2354 demo->prepared = false;
2355 vkDeviceWaitIdle(demo->device);
2357 for (i = 0; i < demo->swapchainImageCount; i++) {
2358 vkDestroyFramebuffer(demo->device, demo->swapchain_image_resources[i].framebuffer, NULL);
2360 vkDestroyDescriptorPool(demo->device, demo->desc_pool, NULL);
2362 vkDestroyPipeline(demo->device, demo->pipeline, NULL);
2363 vkDestroyPipelineCache(demo->device, demo->pipelineCache, NULL);
2364 vkDestroyRenderPass(demo->device, demo->render_pass, NULL);
2365 vkDestroyPipelineLayout(demo->device, demo->pipeline_layout, NULL);
2366 vkDestroyDescriptorSetLayout(demo->device, demo->desc_layout, NULL);
2368 for (i = 0; i < DEMO_TEXTURE_COUNT; i++) {
2369 vkDestroyImageView(demo->device, demo->textures[i].view, NULL);
2370 vkDestroyImage(demo->device, demo->textures[i].image, NULL);
2371 vkFreeMemory(demo->device, demo->textures[i].mem, NULL);
2372 vkDestroySampler(demo->device, demo->textures[i].sampler, NULL);
2375 vkDestroyImageView(demo->device, demo->depth.view, NULL);
2376 vkDestroyImage(demo->device, demo->depth.image, NULL);
2377 vkFreeMemory(demo->device, demo->depth.mem, NULL);
2379 for (i = 0; i < demo->swapchainImageCount; i++) {
2380 vkDestroyImageView(demo->device, demo->swapchain_image_resources[i].view, NULL);
2381 vkFreeCommandBuffers(demo->device, demo->cmd_pool, 1, &demo->swapchain_image_resources[i].cmd);
2382 vkDestroyBuffer(demo->device, demo->swapchain_image_resources[i].uniform_buffer, NULL);
2383 vkFreeMemory(demo->device, demo->swapchain_image_resources[i].uniform_memory, NULL);
2385 vkDestroyCommandPool(demo->device, demo->cmd_pool, NULL);
2386 demo->cmd_pool = VK_NULL_HANDLE;
2387 if (demo->separate_present_queue) {
2388 vkDestroyCommandPool(demo->device, demo->present_cmd_pool, NULL);
2390 free(demo->swapchain_image_resources);
2392 // Second, re-perform the demo_prepare() function, which will re-create the
2397 // On MS-Windows, make this a global, so it's available to WndProc()
2400 #if defined(VK_USE_PLATFORM_WIN32_KHR)
2401 static void demo_run(struct demo *demo) {
2402 if (!demo->prepared) return;
2406 if (demo->frameCount != INT_MAX && demo->curFrame == demo->frameCount) {
2407 PostQuitMessage(validation_error);
2411 // MS-Windows event handling function:
2412 LRESULT CALLBACK WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam) {
2415 PostQuitMessage(validation_error);
2418 // The validation callback calls MessageBox which can generate paint
2419 // events - don't make more Vulkan calls if we got here from the
2425 case WM_GETMINMAXINFO: // set window's minimum size
2426 ((MINMAXINFO *)lParam)->ptMinTrackSize = demo.minsize;
2429 // Resize the application to the new window size, except when
2430 // it was minimized. Vulkan doesn't support images or swapchains
2431 // with width=0 and height=0.
2432 if (wParam != SIZE_MINIMIZED) {
2433 demo.width = lParam & 0xffff;
2434 demo.height = (lParam & 0xffff0000) >> 16;
2441 return (DefWindowProc(hWnd, uMsg, wParam, lParam));
2444 static void demo_create_window(struct demo *demo) {
2445 WNDCLASSEX win_class;
2447 // Initialize the window class structure:
2448 win_class.cbSize = sizeof(WNDCLASSEX);
2449 win_class.style = CS_HREDRAW | CS_VREDRAW;
2450 win_class.lpfnWndProc = WndProc;
2451 win_class.cbClsExtra = 0;
2452 win_class.cbWndExtra = 0;
2453 win_class.hInstance = demo->connection; // hInstance
2454 win_class.hIcon = LoadIcon(NULL, IDI_APPLICATION);
2455 win_class.hCursor = LoadCursor(NULL, IDC_ARROW);
2456 win_class.hbrBackground = (HBRUSH)GetStockObject(WHITE_BRUSH);
2457 win_class.lpszMenuName = NULL;
2458 win_class.lpszClassName = demo->name;
2459 win_class.hIconSm = LoadIcon(NULL, IDI_WINLOGO);
2460 // Register window class:
2461 if (!RegisterClassEx(&win_class)) {
2462 // It didn't work, so try to give a useful error:
2463 printf("Unexpected error trying to start the application!\n");
2467 // Create window with the registered class:
2468 RECT wr = {0, 0, demo->width, demo->height};
2469 AdjustWindowRect(&wr, WS_OVERLAPPEDWINDOW, FALSE);
2470 demo->window = CreateWindowEx(0,
2471 demo->name, // class name
2472 demo->name, // app name
2473 WS_OVERLAPPEDWINDOW | // window style
2474 WS_VISIBLE | WS_SYSMENU,
2475 100, 100, // x/y coords
2476 wr.right - wr.left, // width
2477 wr.bottom - wr.top, // height
2478 NULL, // handle to parent
2479 NULL, // handle to menu
2480 demo->connection, // hInstance
2481 NULL); // no extra parameters
2482 if (!demo->window) {
2483 // It didn't work, so try to give a useful error:
2484 printf("Cannot create a window in which to draw!\n");
2488 // Window client area size must be at least 1 pixel high, to prevent crash.
2489 demo->minsize.x = GetSystemMetrics(SM_CXMINTRACK);
2490 demo->minsize.y = GetSystemMetrics(SM_CYMINTRACK) + 1;
2492 #elif defined(VK_USE_PLATFORM_XLIB_KHR)
2493 static void demo_create_xlib_window(struct demo *demo) {
2494 const char *display_envar = getenv("DISPLAY");
2495 if (display_envar == NULL || display_envar[0] == '\0') {
2496 printf("Environment variable DISPLAY requires a valid value.\nExiting ...\n");
2502 demo->display = XOpenDisplay(NULL);
2503 long visualMask = VisualScreenMask;
2504 int numberOfVisuals;
2505 XVisualInfo vInfoTemplate = {};
2506 vInfoTemplate.screen = DefaultScreen(demo->display);
2507 XVisualInfo *visualInfo = XGetVisualInfo(demo->display, visualMask, &vInfoTemplate, &numberOfVisuals);
2510 XCreateColormap(demo->display, RootWindow(demo->display, vInfoTemplate.screen), visualInfo->visual, AllocNone);
2512 XSetWindowAttributes windowAttributes = {};
2513 windowAttributes.colormap = colormap;
2514 windowAttributes.background_pixel = 0xFFFFFFFF;
2515 windowAttributes.border_pixel = 0;
2516 windowAttributes.event_mask = KeyPressMask | KeyReleaseMask | StructureNotifyMask | ExposureMask;
2518 demo->xlib_window = XCreateWindow(demo->display, RootWindow(demo->display, vInfoTemplate.screen), 0, 0, demo->width,
2519 demo->height, 0, visualInfo->depth, InputOutput, visualInfo->visual,
2520 CWBackPixel | CWBorderPixel | CWEventMask | CWColormap, &windowAttributes);
2522 XSelectInput(demo->display, demo->xlib_window, ExposureMask | KeyPressMask);
2523 XMapWindow(demo->display, demo->xlib_window);
2524 XFlush(demo->display);
2525 demo->xlib_wm_delete_window = XInternAtom(demo->display, "WM_DELETE_WINDOW", False);
2527 static void demo_handle_xlib_event(struct demo *demo, const XEvent *event) {
2528 switch (event->type) {
2530 if ((Atom)event->xclient.data.l[0] == demo->xlib_wm_delete_window) demo->quit = true;
2533 switch (event->xkey.keycode) {
2537 case 0x71: // left arrow key
2538 demo->spin_angle -= demo->spin_increment;
2540 case 0x72: // right arrow key
2541 demo->spin_angle += demo->spin_increment;
2543 case 0x41: // space bar
2544 demo->pause = !demo->pause;
2548 case ConfigureNotify:
2549 if ((demo->width != event->xconfigure.width) || (demo->height != event->xconfigure.height)) {
2550 demo->width = event->xconfigure.width;
2551 demo->height = event->xconfigure.height;
2560 static void demo_run_xlib(struct demo *demo) {
2561 while (!demo->quit) {
2565 XNextEvent(demo->display, &event);
2566 demo_handle_xlib_event(demo, &event);
2568 while (XPending(demo->display) > 0) {
2569 XNextEvent(demo->display, &event);
2570 demo_handle_xlib_event(demo, &event);
2575 if (demo->frameCount != INT32_MAX && demo->curFrame == demo->frameCount) demo->quit = true;
2578 #elif defined(VK_USE_PLATFORM_XCB_KHR)
2579 static void demo_handle_xcb_event(struct demo *demo, const xcb_generic_event_t *event) {
2580 uint8_t event_code = event->response_type & 0x7f;
2581 switch (event_code) {
2583 // TODO: Resize window
2585 case XCB_CLIENT_MESSAGE:
2586 if ((*(xcb_client_message_event_t *)event).data.data32[0] == (*demo->atom_wm_delete_window).atom) {
2590 case XCB_KEY_RELEASE: {
2591 const xcb_key_release_event_t *key = (const xcb_key_release_event_t *)event;
2593 switch (key->detail) {
2597 case 0x71: // left arrow key
2598 demo->spin_angle -= demo->spin_increment;
2600 case 0x72: // right arrow key
2601 demo->spin_angle += demo->spin_increment;
2603 case 0x41: // space bar
2604 demo->pause = !demo->pause;
2608 case XCB_CONFIGURE_NOTIFY: {
2609 const xcb_configure_notify_event_t *cfg = (const xcb_configure_notify_event_t *)event;
2610 if ((demo->width != cfg->width) || (demo->height != cfg->height)) {
2611 demo->width = cfg->width;
2612 demo->height = cfg->height;
2621 static void demo_run_xcb(struct demo *demo) {
2622 xcb_flush(demo->connection);
2624 while (!demo->quit) {
2625 xcb_generic_event_t *event;
2628 event = xcb_wait_for_event(demo->connection);
2630 event = xcb_poll_for_event(demo->connection);
2633 demo_handle_xcb_event(demo, event);
2635 event = xcb_poll_for_event(demo->connection);
2640 if (demo->frameCount != INT32_MAX && demo->curFrame == demo->frameCount) demo->quit = true;
2644 static void demo_create_xcb_window(struct demo *demo) {
2645 uint32_t value_mask, value_list[32];
2647 demo->xcb_window = xcb_generate_id(demo->connection);
2649 value_mask = XCB_CW_BACK_PIXEL | XCB_CW_EVENT_MASK;
2650 value_list[0] = demo->screen->black_pixel;
2651 value_list[1] = XCB_EVENT_MASK_KEY_RELEASE | XCB_EVENT_MASK_EXPOSURE | XCB_EVENT_MASK_STRUCTURE_NOTIFY;
2653 xcb_create_window(demo->connection, XCB_COPY_FROM_PARENT, demo->xcb_window, demo->screen->root, 0, 0, demo->width, demo->height,
2654 0, XCB_WINDOW_CLASS_INPUT_OUTPUT, demo->screen->root_visual, value_mask, value_list);
2656 /* Magic code that will send notification when window is destroyed */
2657 xcb_intern_atom_cookie_t cookie = xcb_intern_atom(demo->connection, 1, 12, "WM_PROTOCOLS");
2658 xcb_intern_atom_reply_t *reply = xcb_intern_atom_reply(demo->connection, cookie, 0);
2660 xcb_intern_atom_cookie_t cookie2 = xcb_intern_atom(demo->connection, 0, 16, "WM_DELETE_WINDOW");
2661 demo->atom_wm_delete_window = xcb_intern_atom_reply(demo->connection, cookie2, 0);
2663 xcb_change_property(demo->connection, XCB_PROP_MODE_REPLACE, demo->xcb_window, (*reply).atom, 4, 32, 1,
2664 &(*demo->atom_wm_delete_window).atom);
2667 xcb_map_window(demo->connection, demo->xcb_window);
2669 // Force the x/y coordinates to 100,100 results are identical in consecutive
2671 const uint32_t coords[] = {100, 100};
2672 xcb_configure_window(demo->connection, demo->xcb_window, XCB_CONFIG_WINDOW_X | XCB_CONFIG_WINDOW_Y, coords);
2674 // VK_USE_PLATFORM_XCB_KHR
2675 #elif defined(VK_USE_PLATFORM_WAYLAND_KHR)
2676 static void demo_run(struct demo *demo) {
2677 while (!demo->quit) {
2679 wl_display_dispatch(demo->display); // block and wait for input
2681 wl_display_dispatch_pending(demo->display); // don't block
2684 if (demo->frameCount != INT32_MAX && demo->curFrame == demo->frameCount) demo->quit = true;
2689 static void handle_ping(void *data UNUSED, struct wl_shell_surface *shell_surface, uint32_t serial) {
2690 wl_shell_surface_pong(shell_surface, serial);
2693 static void handle_configure(void *data UNUSED, struct wl_shell_surface *shell_surface UNUSED, uint32_t edges UNUSED,
2694 int32_t width UNUSED, int32_t height UNUSED) {}
2696 static void handle_popup_done(void *data UNUSED, struct wl_shell_surface *shell_surface UNUSED) {}
2698 static const struct wl_shell_surface_listener shell_surface_listener = {handle_ping, handle_configure, handle_popup_done};
2700 static void demo_create_window(struct demo *demo) {
2701 demo->window = wl_compositor_create_surface(demo->compositor);
2702 if (!demo->window) {
2703 printf("Can not create wayland_surface from compositor!\n");
2708 demo->shell_surface = wl_shell_get_shell_surface(demo->shell, demo->window);
2709 if (!demo->shell_surface) {
2710 printf("Can not get shell_surface from wayland_surface!\n");
2714 wl_shell_surface_add_listener(demo->shell_surface, &shell_surface_listener, demo);
2715 wl_shell_surface_set_toplevel(demo->shell_surface);
2716 wl_shell_surface_set_title(demo->shell_surface, APP_SHORT_NAME);
2718 #elif defined(VK_USE_PLATFORM_ANDROID_KHR)
2719 static void demo_run(struct demo *demo) {
2720 if (!demo->prepared) return;
2725 #elif defined(VK_USE_PLATFORM_MACOS_MVK)
2726 static void demo_run(struct demo *demo) {
2729 if (demo->frameCount != INT32_MAX && demo->curFrame == demo->frameCount) {
2733 #elif defined(VK_USE_PLATFORM_MIR_KHR)
2734 #elif defined(VK_USE_PLATFORM_DISPLAY_KHR)
2735 static VkResult demo_create_display_surface(struct demo *demo) {
2736 VkResult U_ASSERT_ONLY err;
2737 uint32_t display_count;
2738 uint32_t mode_count;
2739 uint32_t plane_count;
2740 VkDisplayPropertiesKHR display_props;
2741 VkDisplayKHR display;
2742 VkDisplayModePropertiesKHR mode_props;
2743 VkDisplayPlanePropertiesKHR *plane_props;
2744 VkBool32 found_plane = VK_FALSE;
2745 uint32_t plane_index;
2746 VkExtent2D image_extent;
2747 VkDisplaySurfaceCreateInfoKHR create_info;
2749 // Get the first display
2750 err = vkGetPhysicalDeviceDisplayPropertiesKHR(demo->gpu, &display_count, NULL);
2753 if (display_count == 0) {
2754 printf("Cannot find any display!\n");
2760 err = vkGetPhysicalDeviceDisplayPropertiesKHR(demo->gpu, &display_count, &display_props);
2761 assert(!err || (err == VK_INCOMPLETE));
2763 display = display_props.display;
2765 // Get the first mode of the display
2766 err = vkGetDisplayModePropertiesKHR(demo->gpu, display, &mode_count, NULL);
2769 if (mode_count == 0) {
2770 printf("Cannot find any mode for the display!\n");
2776 err = vkGetDisplayModePropertiesKHR(demo->gpu, display, &mode_count, &mode_props);
2777 assert(!err || (err == VK_INCOMPLETE));
2779 // Get the list of planes
2780 err = vkGetPhysicalDeviceDisplayPlanePropertiesKHR(demo->gpu, &plane_count, NULL);
2783 if (plane_count == 0) {
2784 printf("Cannot find any plane!\n");
2789 plane_props = malloc(sizeof(VkDisplayPlanePropertiesKHR) * plane_count);
2790 assert(plane_props);
2792 err = vkGetPhysicalDeviceDisplayPlanePropertiesKHR(demo->gpu, &plane_count, plane_props);
2795 // Find a plane compatible with the display
2796 for (plane_index = 0; plane_index < plane_count; plane_index++) {
2797 uint32_t supported_count;
2798 VkDisplayKHR *supported_displays;
2800 // Disqualify planes that are bound to a different display
2801 if ((plane_props[plane_index].currentDisplay != VK_NULL_HANDLE) && (plane_props[plane_index].currentDisplay != display)) {
2805 err = vkGetDisplayPlaneSupportedDisplaysKHR(demo->gpu, plane_index, &supported_count, NULL);
2808 if (supported_count == 0) {
2812 supported_displays = malloc(sizeof(VkDisplayKHR) * supported_count);
2813 assert(supported_displays);
2815 err = vkGetDisplayPlaneSupportedDisplaysKHR(demo->gpu, plane_index, &supported_count, supported_displays);
2818 for (uint32_t i = 0; i < supported_count; i++) {
2819 if (supported_displays[i] == display) {
2820 found_plane = VK_TRUE;
2825 free(supported_displays);
2833 printf("Cannot find a plane compatible with the display!\n");
2840 VkDisplayPlaneCapabilitiesKHR planeCaps;
2841 vkGetDisplayPlaneCapabilitiesKHR(demo->gpu, mode_props.displayMode, plane_index, &planeCaps);
2842 // Find a supported alpha mode
2843 VkCompositeAlphaFlagBitsKHR alphaMode = VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR;
2844 VkCompositeAlphaFlagBitsKHR alphaModes[4] = {
2845 VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR,
2846 VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR,
2847 VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR,
2848 VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR,
2850 for (uint32_t i = 0; i < sizeof(alphaModes); i++) {
2851 if (planeCaps.supportedAlpha & alphaModes[i]) {
2852 alphaMode = alphaModes[i];
2856 image_extent.width = mode_props.parameters.visibleRegion.width;
2857 image_extent.height = mode_props.parameters.visibleRegion.height;
2859 create_info.sType = VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR;
2860 create_info.pNext = NULL;
2861 create_info.flags = 0;
2862 create_info.displayMode = mode_props.displayMode;
2863 create_info.planeIndex = plane_index;
2864 create_info.planeStackIndex = plane_props[plane_index].currentStackIndex;
2865 create_info.transform = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR;
2866 create_info.alphaMode = alphaMode;
2867 create_info.globalAlpha = 1.0f;
2868 create_info.imageExtent = image_extent;
2870 return vkCreateDisplayPlaneSurfaceKHR(demo->inst, &create_info, NULL, &demo->surface);
2873 static void demo_run_display(struct demo *demo) {
2874 while (!demo->quit) {
2878 if (demo->frameCount != INT32_MAX && demo->curFrame == demo->frameCount) {
2886 * Return 1 (true) if all layer names specified in check_names
2887 * can be found in given layer properties.
2889 static VkBool32 demo_check_layers(uint32_t check_count, char **check_names, uint32_t layer_count, VkLayerProperties *layers) {
2890 for (uint32_t i = 0; i < check_count; i++) {
2892 for (uint32_t j = 0; j < layer_count; j++) {
2893 if (!strcmp(check_names[i], layers[j].layerName)) {
2899 fprintf(stderr, "Cannot find layer: %s\n", check_names[i]);
2906 static void demo_init_vk(struct demo *demo) {
2908 uint32_t instance_extension_count = 0;
2909 uint32_t instance_layer_count = 0;
2910 uint32_t validation_layer_count = 0;
2911 char **instance_validation_layers = NULL;
2912 demo->enabled_extension_count = 0;
2913 demo->enabled_layer_count = 0;
2914 demo->is_minimized = false;
2915 demo->cmd_pool = VK_NULL_HANDLE;
2917 char *instance_validation_layers_alt1[] = {"VK_LAYER_LUNARG_standard_validation"};
2919 char *instance_validation_layers_alt2[] = {"VK_LAYER_GOOGLE_threading", "VK_LAYER_LUNARG_parameter_validation",
2920 "VK_LAYER_LUNARG_object_tracker", "VK_LAYER_LUNARG_core_validation",
2921 "VK_LAYER_GOOGLE_unique_objects"};
2923 /* Look for validation layers */
2924 VkBool32 validation_found = 0;
2925 if (demo->validate) {
2926 err = vkEnumerateInstanceLayerProperties(&instance_layer_count, NULL);
2929 instance_validation_layers = instance_validation_layers_alt1;
2930 if (instance_layer_count > 0) {
2931 VkLayerProperties *instance_layers = malloc(sizeof(VkLayerProperties) * instance_layer_count);
2932 err = vkEnumerateInstanceLayerProperties(&instance_layer_count, instance_layers);
2935 validation_found = demo_check_layers(ARRAY_SIZE(instance_validation_layers_alt1), instance_validation_layers,
2936 instance_layer_count, instance_layers);
2937 if (validation_found) {
2938 demo->enabled_layer_count = ARRAY_SIZE(instance_validation_layers_alt1);
2939 demo->enabled_layers[0] = "VK_LAYER_LUNARG_standard_validation";
2940 validation_layer_count = 1;
2942 // use alternative set of validation layers
2943 instance_validation_layers = instance_validation_layers_alt2;
2944 demo->enabled_layer_count = ARRAY_SIZE(instance_validation_layers_alt2);
2945 validation_found = demo_check_layers(ARRAY_SIZE(instance_validation_layers_alt2), instance_validation_layers,
2946 instance_layer_count, instance_layers);
2947 validation_layer_count = ARRAY_SIZE(instance_validation_layers_alt2);
2948 for (uint32_t i = 0; i < validation_layer_count; i++) {
2949 demo->enabled_layers[i] = instance_validation_layers[i];
2952 free(instance_layers);
2955 if (!validation_found) {
2957 "vkEnumerateInstanceLayerProperties failed to find required validation layer.\n\n"
2958 "Please look at the Getting Started guide for additional information.\n",
2959 "vkCreateInstance Failure");
2963 /* Look for instance extensions */
2964 VkBool32 surfaceExtFound = 0;
2965 VkBool32 platformSurfaceExtFound = 0;
2966 memset(demo->extension_names, 0, sizeof(demo->extension_names));
2968 err = vkEnumerateInstanceExtensionProperties(NULL, &instance_extension_count, NULL);
2971 if (instance_extension_count > 0) {
2972 VkExtensionProperties *instance_extensions = malloc(sizeof(VkExtensionProperties) * instance_extension_count);
2973 err = vkEnumerateInstanceExtensionProperties(NULL, &instance_extension_count, instance_extensions);
2975 for (uint32_t i = 0; i < instance_extension_count; i++) {
2976 if (!strcmp(VK_KHR_SURFACE_EXTENSION_NAME, instance_extensions[i].extensionName)) {
2977 surfaceExtFound = 1;
2978 demo->extension_names[demo->enabled_extension_count++] = VK_KHR_SURFACE_EXTENSION_NAME;
2980 #if defined(VK_USE_PLATFORM_WIN32_KHR)
2981 if (!strcmp(VK_KHR_WIN32_SURFACE_EXTENSION_NAME, instance_extensions[i].extensionName)) {
2982 platformSurfaceExtFound = 1;
2983 demo->extension_names[demo->enabled_extension_count++] = VK_KHR_WIN32_SURFACE_EXTENSION_NAME;
2985 #elif defined(VK_USE_PLATFORM_XLIB_KHR)
2986 if (!strcmp(VK_KHR_XLIB_SURFACE_EXTENSION_NAME, instance_extensions[i].extensionName)) {
2987 platformSurfaceExtFound = 1;
2988 demo->extension_names[demo->enabled_extension_count++] = VK_KHR_XLIB_SURFACE_EXTENSION_NAME;
2990 #elif defined(VK_USE_PLATFORM_XCB_KHR)
2991 if (!strcmp(VK_KHR_XCB_SURFACE_EXTENSION_NAME, instance_extensions[i].extensionName)) {
2992 platformSurfaceExtFound = 1;
2993 demo->extension_names[demo->enabled_extension_count++] = VK_KHR_XCB_SURFACE_EXTENSION_NAME;
2995 #elif defined(VK_USE_PLATFORM_WAYLAND_KHR)
2996 if (!strcmp(VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME, instance_extensions[i].extensionName)) {
2997 platformSurfaceExtFound = 1;
2998 demo->extension_names[demo->enabled_extension_count++] = VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME;
3000 #elif defined(VK_USE_PLATFORM_MIR_KHR)
3001 #elif defined(VK_USE_PLATFORM_DISPLAY_KHR)
3002 if (!strcmp(VK_KHR_DISPLAY_EXTENSION_NAME, instance_extensions[i].extensionName)) {
3003 platformSurfaceExtFound = 1;
3004 demo->extension_names[demo->enabled_extension_count++] = VK_KHR_DISPLAY_EXTENSION_NAME;
3006 #elif defined(VK_USE_PLATFORM_ANDROID_KHR)
3007 if (!strcmp(VK_KHR_ANDROID_SURFACE_EXTENSION_NAME, instance_extensions[i].extensionName)) {
3008 platformSurfaceExtFound = 1;
3009 demo->extension_names[demo->enabled_extension_count++] = VK_KHR_ANDROID_SURFACE_EXTENSION_NAME;
3011 #elif defined(VK_USE_PLATFORM_IOS_MVK)
3012 if (!strcmp(VK_MVK_IOS_SURFACE_EXTENSION_NAME, instance_extensions[i].extensionName)) {
3013 platformSurfaceExtFound = 1;
3014 demo->extension_names[demo->enabled_extension_count++] = VK_MVK_IOS_SURFACE_EXTENSION_NAME;
3016 #elif defined(VK_USE_PLATFORM_MACOS_MVK)
3017 if (!strcmp(VK_MVK_MACOS_SURFACE_EXTENSION_NAME, instance_extensions[i].extensionName)) {
3018 platformSurfaceExtFound = 1;
3019 demo->extension_names[demo->enabled_extension_count++] = VK_MVK_MACOS_SURFACE_EXTENSION_NAME;
3022 if (!strcmp(VK_EXT_DEBUG_UTILS_EXTENSION_NAME, instance_extensions[i].extensionName)) {
3023 if (demo->validate) {
3024 demo->extension_names[demo->enabled_extension_count++] = VK_EXT_DEBUG_UTILS_EXTENSION_NAME;
3027 assert(demo->enabled_extension_count < 64);
3030 free(instance_extensions);
3033 if (!surfaceExtFound) {
3034 ERR_EXIT("vkEnumerateInstanceExtensionProperties failed to find the " VK_KHR_SURFACE_EXTENSION_NAME
3036 "Do you have a compatible Vulkan installable client driver (ICD) installed?\n"
3037 "Please look at the Getting Started guide for additional information.\n",
3038 "vkCreateInstance Failure");
3040 if (!platformSurfaceExtFound) {
3041 #if defined(VK_USE_PLATFORM_WIN32_KHR)
3042 ERR_EXIT("vkEnumerateInstanceExtensionProperties failed to find the " VK_KHR_WIN32_SURFACE_EXTENSION_NAME
3044 "Do you have a compatible Vulkan installable client driver (ICD) installed?\n"
3045 "Please look at the Getting Started guide for additional information.\n",
3046 "vkCreateInstance Failure");
3047 #elif defined(VK_USE_PLATFORM_IOS_MVK)
3048 ERR_EXIT("vkEnumerateInstanceExtensionProperties failed to find the " VK_MVK_IOS_SURFACE_EXTENSION_NAME
3050 "Do you have a compatible Vulkan installable client driver (ICD) installed?\n"
3051 "Please look at the Getting Started guide for additional information.\n",
3052 "vkCreateInstance Failure");
3053 #elif defined(VK_USE_PLATFORM_MACOS_MVK)
3054 ERR_EXIT("vkEnumerateInstanceExtensionProperties failed to find the " VK_MVK_MACOS_SURFACE_EXTENSION_NAME
3056 "Do you have a compatible Vulkan installable client driver (ICD) installed?\n"
3057 "Please look at the Getting Started guide for additional information.\n",
3058 "vkCreateInstance Failure");
3059 #elif defined(VK_USE_PLATFORM_XCB_KHR)
3060 ERR_EXIT("vkEnumerateInstanceExtensionProperties failed to find the " VK_KHR_XCB_SURFACE_EXTENSION_NAME
3062 "Do you have a compatible Vulkan installable client driver (ICD) installed?\n"
3063 "Please look at the Getting Started guide for additional information.\n",
3064 "vkCreateInstance Failure");
3065 #elif defined(VK_USE_PLATFORM_WAYLAND_KHR)
3066 ERR_EXIT("vkEnumerateInstanceExtensionProperties failed to find the " VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME
3068 "Do you have a compatible Vulkan installable client driver (ICD) installed?\n"
3069 "Please look at the Getting Started guide for additional information.\n",
3070 "vkCreateInstance Failure");
3071 #elif defined(VK_USE_PLATFORM_MIR_KHR)
3072 #elif defined(VK_USE_PLATFORM_DISPLAY_KHR)
3073 ERR_EXIT("vkEnumerateInstanceExtensionProperties failed to find the " VK_KHR_DISPLAY_EXTENSION_NAME
3075 "Do you have a compatible Vulkan installable client driver (ICD) installed?\n"
3076 "Please look at the Getting Started guide for additional information.\n",
3077 "vkCreateInstance Failure");
3078 #elif defined(VK_USE_PLATFORM_ANDROID_KHR)
3079 ERR_EXIT("vkEnumerateInstanceExtensionProperties failed to find the " VK_KHR_ANDROID_SURFACE_EXTENSION_NAME
3081 "Do you have a compatible Vulkan installable client driver (ICD) installed?\n"
3082 "Please look at the Getting Started guide for additional information.\n",
3083 "vkCreateInstance Failure");
3084 #elif defined(VK_USE_PLATFORM_XLIB_KHR)
3085 ERR_EXIT("vkEnumerateInstanceExtensionProperties failed to find the " VK_KHR_XLIB_SURFACE_EXTENSION_NAME
3087 "Do you have a compatible Vulkan installable client driver (ICD) installed?\n"
3088 "Please look at the Getting Started guide for additional information.\n",
3089 "vkCreateInstance Failure");
3092 const VkApplicationInfo app = {
3093 .sType = VK_STRUCTURE_TYPE_APPLICATION_INFO,
3095 .pApplicationName = APP_SHORT_NAME,
3096 .applicationVersion = 0,
3097 .pEngineName = APP_SHORT_NAME,
3099 .apiVersion = VK_API_VERSION_1_0,
3101 VkInstanceCreateInfo inst_info = {
3102 .sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO,
3104 .pApplicationInfo = &app,
3105 .enabledLayerCount = demo->enabled_layer_count,
3106 .ppEnabledLayerNames = (const char *const *)instance_validation_layers,
3107 .enabledExtensionCount = demo->enabled_extension_count,
3108 .ppEnabledExtensionNames = (const char *const *)demo->extension_names,
3112 * This is info for a temp callback to use during CreateInstance.
3113 * After the instance is created, we use the instance-based
3114 * function to register the final callback.
3116 VkDebugUtilsMessengerCreateInfoEXT dbg_messenger_create_info;
3117 if (demo->validate) {
3118 // VK_EXT_debug_utils style
3119 dbg_messenger_create_info.sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT;
3120 dbg_messenger_create_info.pNext = NULL;
3121 dbg_messenger_create_info.flags = 0;
3122 dbg_messenger_create_info.messageSeverity =
3123 VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT | VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT;
3124 dbg_messenger_create_info.messageType = VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT |
3125 VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT |
3126 VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT;
3127 dbg_messenger_create_info.pfnUserCallback = debug_messenger_callback;
3128 dbg_messenger_create_info.pUserData = demo;
3129 inst_info.pNext = &dbg_messenger_create_info;
3134 err = vkCreateInstance(&inst_info, NULL, &demo->inst);
3135 if (err == VK_ERROR_INCOMPATIBLE_DRIVER) {
3137 "Cannot find a compatible Vulkan installable client driver (ICD).\n\n"
3138 "Please look at the Getting Started guide for additional information.\n",
3139 "vkCreateInstance Failure");
3140 } else if (err == VK_ERROR_EXTENSION_NOT_PRESENT) {
3142 "Cannot find a specified extension library.\n"
3143 "Make sure your layers path is set appropriately.\n",
3144 "vkCreateInstance Failure");
3147 "vkCreateInstance failed.\n\n"
3148 "Do you have a compatible Vulkan installable client driver (ICD) installed?\n"
3149 "Please look at the Getting Started guide for additional information.\n",
3150 "vkCreateInstance Failure");
3153 /* Make initial call to query gpu_count, then second call for gpu info*/
3154 err = vkEnumeratePhysicalDevices(demo->inst, &gpu_count, NULL);
3157 if (gpu_count > 0) {
3158 VkPhysicalDevice *physical_devices = malloc(sizeof(VkPhysicalDevice) * gpu_count);
3159 err = vkEnumeratePhysicalDevices(demo->inst, &gpu_count, physical_devices);
3161 /* For cube demo we just grab the first physical device */
3162 demo->gpu = physical_devices[0];
3163 free(physical_devices);
3166 "vkEnumeratePhysicalDevices reported zero accessible devices.\n\n"
3167 "Do you have a compatible Vulkan installable client driver (ICD) installed?\n"
3168 "Please look at the Getting Started guide for additional information.\n",
3169 "vkEnumeratePhysicalDevices Failure");
3172 /* Look for device extensions */
3173 uint32_t device_extension_count = 0;
3174 VkBool32 swapchainExtFound = 0;
3175 demo->enabled_extension_count = 0;
3176 memset(demo->extension_names, 0, sizeof(demo->extension_names));
3178 err = vkEnumerateDeviceExtensionProperties(demo->gpu, NULL, &device_extension_count, NULL);
3181 if (device_extension_count > 0) {
3182 VkExtensionProperties *device_extensions = malloc(sizeof(VkExtensionProperties) * device_extension_count);
3183 err = vkEnumerateDeviceExtensionProperties(demo->gpu, NULL, &device_extension_count, device_extensions);
3186 for (uint32_t i = 0; i < device_extension_count; i++) {
3187 if (!strcmp(VK_KHR_SWAPCHAIN_EXTENSION_NAME, device_extensions[i].extensionName)) {
3188 swapchainExtFound = 1;
3189 demo->extension_names[demo->enabled_extension_count++] = VK_KHR_SWAPCHAIN_EXTENSION_NAME;
3191 assert(demo->enabled_extension_count < 64);
3194 if (demo->VK_KHR_incremental_present_enabled) {
3195 // Even though the user "enabled" the extension via the command
3196 // line, we must make sure that it's enumerated for use with the
3197 // device. Therefore, disable it here, and re-enable it again if
3199 demo->VK_KHR_incremental_present_enabled = false;
3200 for (uint32_t i = 0; i < device_extension_count; i++) {
3201 if (!strcmp(VK_KHR_INCREMENTAL_PRESENT_EXTENSION_NAME, device_extensions[i].extensionName)) {
3202 demo->extension_names[demo->enabled_extension_count++] = VK_KHR_INCREMENTAL_PRESENT_EXTENSION_NAME;
3203 demo->VK_KHR_incremental_present_enabled = true;
3204 DbgMsg("VK_KHR_incremental_present extension enabled\n");
3206 assert(demo->enabled_extension_count < 64);
3208 if (!demo->VK_KHR_incremental_present_enabled) {
3209 DbgMsg("VK_KHR_incremental_present extension NOT AVAILABLE\n");
3213 if (demo->VK_GOOGLE_display_timing_enabled) {
3214 // Even though the user "enabled" the extension via the command
3215 // line, we must make sure that it's enumerated for use with the
3216 // device. Therefore, disable it here, and re-enable it again if
3218 demo->VK_GOOGLE_display_timing_enabled = false;
3219 for (uint32_t i = 0; i < device_extension_count; i++) {
3220 if (!strcmp(VK_GOOGLE_DISPLAY_TIMING_EXTENSION_NAME, device_extensions[i].extensionName)) {
3221 demo->extension_names[demo->enabled_extension_count++] = VK_GOOGLE_DISPLAY_TIMING_EXTENSION_NAME;
3222 demo->VK_GOOGLE_display_timing_enabled = true;
3223 DbgMsg("VK_GOOGLE_display_timing extension enabled\n");
3225 assert(demo->enabled_extension_count < 64);
3227 if (!demo->VK_GOOGLE_display_timing_enabled) {
3228 DbgMsg("VK_GOOGLE_display_timing extension NOT AVAILABLE\n");
3232 free(device_extensions);
3235 if (!swapchainExtFound) {
3236 ERR_EXIT("vkEnumerateDeviceExtensionProperties failed to find the " VK_KHR_SWAPCHAIN_EXTENSION_NAME
3237 " extension.\n\nDo you have a compatible Vulkan installable client driver (ICD) installed?\n"
3238 "Please look at the Getting Started guide for additional information.\n",
3239 "vkCreateInstance Failure");
3242 if (demo->validate) {
3243 // Setup VK_EXT_debug_utils function pointers always (we use them for
3244 // debug labels and names).
3245 demo->CreateDebugUtilsMessengerEXT =
3246 (PFN_vkCreateDebugUtilsMessengerEXT)vkGetInstanceProcAddr(demo->inst, "vkCreateDebugUtilsMessengerEXT");
3247 demo->DestroyDebugUtilsMessengerEXT =
3248 (PFN_vkDestroyDebugUtilsMessengerEXT)vkGetInstanceProcAddr(demo->inst, "vkDestroyDebugUtilsMessengerEXT");
3249 demo->SubmitDebugUtilsMessageEXT =
3250 (PFN_vkSubmitDebugUtilsMessageEXT)vkGetInstanceProcAddr(demo->inst, "vkSubmitDebugUtilsMessageEXT");
3251 demo->CmdBeginDebugUtilsLabelEXT =
3252 (PFN_vkCmdBeginDebugUtilsLabelEXT)vkGetInstanceProcAddr(demo->inst, "vkCmdBeginDebugUtilsLabelEXT");
3253 demo->CmdEndDebugUtilsLabelEXT =
3254 (PFN_vkCmdEndDebugUtilsLabelEXT)vkGetInstanceProcAddr(demo->inst, "vkCmdEndDebugUtilsLabelEXT");
3255 demo->CmdInsertDebugUtilsLabelEXT =
3256 (PFN_vkCmdInsertDebugUtilsLabelEXT)vkGetInstanceProcAddr(demo->inst, "vkCmdInsertDebugUtilsLabelEXT");
3257 demo->SetDebugUtilsObjectNameEXT =
3258 (PFN_vkSetDebugUtilsObjectNameEXT)vkGetInstanceProcAddr(demo->inst, "vkSetDebugUtilsObjectNameEXT");
3259 if (NULL == demo->CreateDebugUtilsMessengerEXT || NULL == demo->DestroyDebugUtilsMessengerEXT ||
3260 NULL == demo->SubmitDebugUtilsMessageEXT || NULL == demo->CmdBeginDebugUtilsLabelEXT ||
3261 NULL == demo->CmdEndDebugUtilsLabelEXT || NULL == demo->CmdInsertDebugUtilsLabelEXT ||
3262 NULL == demo->SetDebugUtilsObjectNameEXT) {
3263 ERR_EXIT("GetProcAddr: Failed to init VK_EXT_debug_utils\n", "GetProcAddr: Failure");
3266 err = demo->CreateDebugUtilsMessengerEXT(demo->inst, &dbg_messenger_create_info, NULL, &demo->dbg_messenger);
3270 case VK_ERROR_OUT_OF_HOST_MEMORY:
3271 ERR_EXIT("CreateDebugUtilsMessengerEXT: out of host memory\n", "CreateDebugUtilsMessengerEXT Failure");
3274 ERR_EXIT("CreateDebugUtilsMessengerEXT: unknown failure\n", "CreateDebugUtilsMessengerEXT Failure");
3278 vkGetPhysicalDeviceProperties(demo->gpu, &demo->gpu_props);
3280 /* Call with NULL data to get count */
3281 vkGetPhysicalDeviceQueueFamilyProperties(demo->gpu, &demo->queue_family_count, NULL);
3282 assert(demo->queue_family_count >= 1);
3284 demo->queue_props = (VkQueueFamilyProperties *)malloc(demo->queue_family_count * sizeof(VkQueueFamilyProperties));
3285 vkGetPhysicalDeviceQueueFamilyProperties(demo->gpu, &demo->queue_family_count, demo->queue_props);
3287 // Query fine-grained feature support for this device.
3288 // If app has specific feature requirements it should check supported
3289 // features based on this query
3290 VkPhysicalDeviceFeatures physDevFeatures;
3291 vkGetPhysicalDeviceFeatures(demo->gpu, &physDevFeatures);
3293 GET_INSTANCE_PROC_ADDR(demo->inst, GetPhysicalDeviceSurfaceSupportKHR);
3294 GET_INSTANCE_PROC_ADDR(demo->inst, GetPhysicalDeviceSurfaceCapabilitiesKHR);
3295 GET_INSTANCE_PROC_ADDR(demo->inst, GetPhysicalDeviceSurfaceFormatsKHR);
3296 GET_INSTANCE_PROC_ADDR(demo->inst, GetPhysicalDeviceSurfacePresentModesKHR);
3297 GET_INSTANCE_PROC_ADDR(demo->inst, GetSwapchainImagesKHR);
3300 static void demo_create_device(struct demo *demo) {
3301 VkResult U_ASSERT_ONLY err;
3302 float queue_priorities[1] = {0.0};
3303 VkDeviceQueueCreateInfo queues[2];
3304 queues[0].sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
3305 queues[0].pNext = NULL;
3306 queues[0].queueFamilyIndex = demo->graphics_queue_family_index;
3307 queues[0].queueCount = 1;
3308 queues[0].pQueuePriorities = queue_priorities;
3309 queues[0].flags = 0;
3311 VkDeviceCreateInfo device = {
3312 .sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO,
3314 .queueCreateInfoCount = 1,
3315 .pQueueCreateInfos = queues,
3316 .enabledLayerCount = 0,
3317 .ppEnabledLayerNames = NULL,
3318 .enabledExtensionCount = demo->enabled_extension_count,
3319 .ppEnabledExtensionNames = (const char *const *)demo->extension_names,
3320 .pEnabledFeatures = NULL, // If specific features are required, pass them in here
3322 if (demo->separate_present_queue) {
3323 queues[1].sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
3324 queues[1].pNext = NULL;
3325 queues[1].queueFamilyIndex = demo->present_queue_family_index;
3326 queues[1].queueCount = 1;
3327 queues[1].pQueuePriorities = queue_priorities;
3328 queues[1].flags = 0;
3329 device.queueCreateInfoCount = 2;
3331 err = vkCreateDevice(demo->gpu, &device, NULL, &demo->device);
3335 static void demo_init_vk_swapchain(struct demo *demo) {
3336 VkResult U_ASSERT_ONLY err;
3338 // Create a WSI surface for the window:
3339 #if defined(VK_USE_PLATFORM_WIN32_KHR)
3340 VkWin32SurfaceCreateInfoKHR createInfo;
3341 createInfo.sType = VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR;
3342 createInfo.pNext = NULL;
3343 createInfo.flags = 0;
3344 createInfo.hinstance = demo->connection;
3345 createInfo.hwnd = demo->window;
3347 err = vkCreateWin32SurfaceKHR(demo->inst, &createInfo, NULL, &demo->surface);
3348 #elif defined(VK_USE_PLATFORM_WAYLAND_KHR)
3349 VkWaylandSurfaceCreateInfoKHR createInfo;
3350 createInfo.sType = VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR;
3351 createInfo.pNext = NULL;
3352 createInfo.flags = 0;
3353 createInfo.display = demo->display;
3354 createInfo.surface = demo->window;
3356 err = vkCreateWaylandSurfaceKHR(demo->inst, &createInfo, NULL, &demo->surface);
3357 #elif defined(VK_USE_PLATFORM_MIR_KHR)
3358 #elif defined(VK_USE_PLATFORM_ANDROID_KHR)
3359 VkAndroidSurfaceCreateInfoKHR createInfo;
3360 createInfo.sType = VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR;
3361 createInfo.pNext = NULL;
3362 createInfo.flags = 0;
3363 createInfo.window = (struct ANativeWindow *)(demo->window);
3365 err = vkCreateAndroidSurfaceKHR(demo->inst, &createInfo, NULL, &demo->surface);
3366 #elif defined(VK_USE_PLATFORM_XLIB_KHR)
3367 VkXlibSurfaceCreateInfoKHR createInfo;
3368 createInfo.sType = VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR;
3369 createInfo.pNext = NULL;
3370 createInfo.flags = 0;
3371 createInfo.dpy = demo->display;
3372 createInfo.window = demo->xlib_window;
3374 err = vkCreateXlibSurfaceKHR(demo->inst, &createInfo, NULL, &demo->surface);
3375 #elif defined(VK_USE_PLATFORM_XCB_KHR)
3376 VkXcbSurfaceCreateInfoKHR createInfo;
3377 createInfo.sType = VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR;
3378 createInfo.pNext = NULL;
3379 createInfo.flags = 0;
3380 createInfo.connection = demo->connection;
3381 createInfo.window = demo->xcb_window;
3383 err = vkCreateXcbSurfaceKHR(demo->inst, &createInfo, NULL, &demo->surface);
3384 #elif defined(VK_USE_PLATFORM_DISPLAY_KHR)
3385 err = demo_create_display_surface(demo);
3386 #elif defined(VK_USE_PLATFORM_IOS_MVK)
3387 VkIOSSurfaceCreateInfoMVK surface;
3388 surface.sType = VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK;
3389 surface.pNext = NULL;
3391 surface.pView = demo->window;
3393 err = vkCreateIOSSurfaceMVK(demo->inst, &surface, NULL, &demo->surface);
3394 #elif defined(VK_USE_PLATFORM_MACOS_MVK)
3395 VkMacOSSurfaceCreateInfoMVK surface;
3396 surface.sType = VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK;
3397 surface.pNext = NULL;
3399 surface.pView = demo->window;
3401 err = vkCreateMacOSSurfaceMVK(demo->inst, &surface, NULL, &demo->surface);
3405 // Iterate over each queue to learn whether it supports presenting:
3406 VkBool32 *supportsPresent = (VkBool32 *)malloc(demo->queue_family_count * sizeof(VkBool32));
3407 for (uint32_t i = 0; i < demo->queue_family_count; i++) {
3408 demo->fpGetPhysicalDeviceSurfaceSupportKHR(demo->gpu, i, demo->surface, &supportsPresent[i]);
3411 // Search for a graphics and a present queue in the array of queue
3412 // families, try to find one that supports both
3413 uint32_t graphicsQueueFamilyIndex = UINT32_MAX;
3414 uint32_t presentQueueFamilyIndex = UINT32_MAX;
3415 for (uint32_t i = 0; i < demo->queue_family_count; i++) {
3416 if ((demo->queue_props[i].queueFlags & VK_QUEUE_GRAPHICS_BIT) != 0) {
3417 if (graphicsQueueFamilyIndex == UINT32_MAX) {
3418 graphicsQueueFamilyIndex = i;
3421 if (supportsPresent[i] == VK_TRUE) {
3422 graphicsQueueFamilyIndex = i;
3423 presentQueueFamilyIndex = i;
3429 if (presentQueueFamilyIndex == UINT32_MAX) {
3430 // If didn't find a queue that supports both graphics and present, then
3431 // find a separate present queue.
3432 for (uint32_t i = 0; i < demo->queue_family_count; ++i) {
3433 if (supportsPresent[i] == VK_TRUE) {
3434 presentQueueFamilyIndex = i;
3440 // Generate error if could not find both a graphics and a present queue
3441 if (graphicsQueueFamilyIndex == UINT32_MAX || presentQueueFamilyIndex == UINT32_MAX) {
3442 ERR_EXIT("Could not find both graphics and present queues\n", "Swapchain Initialization Failure");
3445 demo->graphics_queue_family_index = graphicsQueueFamilyIndex;
3446 demo->present_queue_family_index = presentQueueFamilyIndex;
3447 demo->separate_present_queue = (demo->graphics_queue_family_index != demo->present_queue_family_index);
3448 free(supportsPresent);
3450 demo_create_device(demo);
3452 GET_DEVICE_PROC_ADDR(demo->device, CreateSwapchainKHR);
3453 GET_DEVICE_PROC_ADDR(demo->device, DestroySwapchainKHR);
3454 GET_DEVICE_PROC_ADDR(demo->device, GetSwapchainImagesKHR);
3455 GET_DEVICE_PROC_ADDR(demo->device, AcquireNextImageKHR);
3456 GET_DEVICE_PROC_ADDR(demo->device, QueuePresentKHR);
3457 if (demo->VK_GOOGLE_display_timing_enabled) {
3458 GET_DEVICE_PROC_ADDR(demo->device, GetRefreshCycleDurationGOOGLE);
3459 GET_DEVICE_PROC_ADDR(demo->device, GetPastPresentationTimingGOOGLE);
3462 vkGetDeviceQueue(demo->device, demo->graphics_queue_family_index, 0, &demo->graphics_queue);
3464 if (!demo->separate_present_queue) {
3465 demo->present_queue = demo->graphics_queue;
3467 vkGetDeviceQueue(demo->device, demo->present_queue_family_index, 0, &demo->present_queue);
3470 // Get the list of VkFormat's that are supported:
3471 uint32_t formatCount;
3472 err = demo->fpGetPhysicalDeviceSurfaceFormatsKHR(demo->gpu, demo->surface, &formatCount, NULL);
3474 VkSurfaceFormatKHR *surfFormats = (VkSurfaceFormatKHR *)malloc(formatCount * sizeof(VkSurfaceFormatKHR));
3475 err = demo->fpGetPhysicalDeviceSurfaceFormatsKHR(demo->gpu, demo->surface, &formatCount, surfFormats);
3477 // If the format list includes just one entry of VK_FORMAT_UNDEFINED,
3478 // the surface has no preferred format. Otherwise, at least one
3479 // supported format will be returned.
3480 if (formatCount == 1 && surfFormats[0].format == VK_FORMAT_UNDEFINED) {
3481 demo->format = VK_FORMAT_B8G8R8A8_UNORM;
3483 assert(formatCount >= 1);
3484 demo->format = surfFormats[0].format;
3486 demo->color_space = surfFormats[0].colorSpace;
3491 // Create semaphores to synchronize acquiring presentable buffers before
3492 // rendering and waiting for drawing to be complete before presenting
3493 VkSemaphoreCreateInfo semaphoreCreateInfo = {
3494 .sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO,
3499 // Create fences that we can use to throttle if we get too far
3500 // ahead of the image presents
3501 VkFenceCreateInfo fence_ci = {
3502 .sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO, .pNext = NULL, .flags = VK_FENCE_CREATE_SIGNALED_BIT};
3503 for (uint32_t i = 0; i < FRAME_LAG; i++) {
3504 err = vkCreateFence(demo->device, &fence_ci, NULL, &demo->fences[i]);
3507 err = vkCreateSemaphore(demo->device, &semaphoreCreateInfo, NULL, &demo->image_acquired_semaphores[i]);
3510 err = vkCreateSemaphore(demo->device, &semaphoreCreateInfo, NULL, &demo->draw_complete_semaphores[i]);
3513 if (demo->separate_present_queue) {
3514 err = vkCreateSemaphore(demo->device, &semaphoreCreateInfo, NULL, &demo->image_ownership_semaphores[i]);
3518 demo->frame_index = 0;
3520 // Get Memory information and properties
3521 vkGetPhysicalDeviceMemoryProperties(demo->gpu, &demo->memory_properties);
3524 #if defined(VK_USE_PLATFORM_WAYLAND_KHR)
3525 static void pointer_handle_enter(void *data, struct wl_pointer *pointer, uint32_t serial, struct wl_surface *surface, wl_fixed_t sx,
3528 static void pointer_handle_leave(void *data, struct wl_pointer *pointer, uint32_t serial, struct wl_surface *surface) {}
3530 static void pointer_handle_motion(void *data, struct wl_pointer *pointer, uint32_t time, wl_fixed_t sx, wl_fixed_t sy) {}
3532 static void pointer_handle_button(void *data, struct wl_pointer *wl_pointer, uint32_t serial, uint32_t time, uint32_t button,
3534 struct demo *demo = data;
3535 if (button == BTN_LEFT && state == WL_POINTER_BUTTON_STATE_PRESSED) {
3536 wl_shell_surface_move(demo->shell_surface, demo->seat, serial);
3540 static void pointer_handle_axis(void *data, struct wl_pointer *wl_pointer, uint32_t time, uint32_t axis, wl_fixed_t value) {}
3542 static const struct wl_pointer_listener pointer_listener = {
3543 pointer_handle_enter, pointer_handle_leave, pointer_handle_motion, pointer_handle_button, pointer_handle_axis,
3546 static void keyboard_handle_keymap(void *data, struct wl_keyboard *keyboard, uint32_t format, int fd, uint32_t size) {}
3548 static void keyboard_handle_enter(void *data, struct wl_keyboard *keyboard, uint32_t serial, struct wl_surface *surface,
3549 struct wl_array *keys) {}
3551 static void keyboard_handle_leave(void *data, struct wl_keyboard *keyboard, uint32_t serial, struct wl_surface *surface) {}
3553 static void keyboard_handle_key(void *data, struct wl_keyboard *keyboard, uint32_t serial, uint32_t time, uint32_t key,
3555 if (state != WL_KEYBOARD_KEY_STATE_RELEASED) return;
3556 struct demo *demo = data;
3558 case KEY_ESC: // Escape
3561 case KEY_LEFT: // left arrow key
3562 demo->spin_angle -= demo->spin_increment;
3564 case KEY_RIGHT: // right arrow key
3565 demo->spin_angle += demo->spin_increment;
3567 case KEY_SPACE: // space bar
3568 demo->pause = !demo->pause;
3573 static void keyboard_handle_modifiers(void *data, struct wl_keyboard *keyboard, uint32_t serial, uint32_t mods_depressed,
3574 uint32_t mods_latched, uint32_t mods_locked, uint32_t group) {}
3576 static const struct wl_keyboard_listener keyboard_listener = {
3577 keyboard_handle_keymap, keyboard_handle_enter, keyboard_handle_leave, keyboard_handle_key, keyboard_handle_modifiers,
3580 static void seat_handle_capabilities(void *data, struct wl_seat *seat, enum wl_seat_capability caps) {
3581 // Subscribe to pointer events
3582 struct demo *demo = data;
3583 if ((caps & WL_SEAT_CAPABILITY_POINTER) && !demo->pointer) {
3584 demo->pointer = wl_seat_get_pointer(seat);
3585 wl_pointer_add_listener(demo->pointer, &pointer_listener, demo);
3586 } else if (!(caps & WL_SEAT_CAPABILITY_POINTER) && demo->pointer) {
3587 wl_pointer_destroy(demo->pointer);
3588 demo->pointer = NULL;
3590 // Subscribe to keyboard events
3591 if (caps & WL_SEAT_CAPABILITY_KEYBOARD) {
3592 demo->keyboard = wl_seat_get_keyboard(seat);
3593 wl_keyboard_add_listener(demo->keyboard, &keyboard_listener, demo);
3594 } else if (!(caps & WL_SEAT_CAPABILITY_KEYBOARD)) {
3595 wl_keyboard_destroy(demo->keyboard);
3596 demo->keyboard = NULL;
3600 static const struct wl_seat_listener seat_listener = {
3601 seat_handle_capabilities,
3604 static void registry_handle_global(void *data, struct wl_registry *registry, uint32_t id, const char *interface,
3605 uint32_t version UNUSED) {
3606 struct demo *demo = data;
3607 // pickup wayland objects when they appear
3608 if (strcmp(interface, "wl_compositor") == 0) {
3609 demo->compositor = wl_registry_bind(registry, id, &wl_compositor_interface, 1);
3610 } else if (strcmp(interface, "wl_shell") == 0) {
3611 demo->shell = wl_registry_bind(registry, id, &wl_shell_interface, 1);
3612 } else if (strcmp(interface, "wl_seat") == 0) {
3613 demo->seat = wl_registry_bind(registry, id, &wl_seat_interface, 1);
3614 wl_seat_add_listener(demo->seat, &seat_listener, demo);
3618 static void registry_handle_global_remove(void *data UNUSED, struct wl_registry *registry UNUSED, uint32_t name UNUSED) {}
3620 static const struct wl_registry_listener registry_listener = {registry_handle_global, registry_handle_global_remove};
3621 #elif defined(VK_USE_PLATFORM_MIR_KHR)
3624 static void demo_init_connection(struct demo *demo) {
3625 #if defined(VK_USE_PLATFORM_XCB_KHR)
3626 const xcb_setup_t *setup;
3627 xcb_screen_iterator_t iter;
3630 const char *display_envar = getenv("DISPLAY");
3631 if (display_envar == NULL || display_envar[0] == '\0') {
3632 printf("Environment variable DISPLAY requires a valid value.\nExiting ...\n");
3637 demo->connection = xcb_connect(NULL, &scr);
3638 if (xcb_connection_has_error(demo->connection) > 0) {
3639 printf("Cannot find a compatible Vulkan installable client driver (ICD).\nExiting ...\n");
3644 setup = xcb_get_setup(demo->connection);
3645 iter = xcb_setup_roots_iterator(setup);
3646 while (scr-- > 0) xcb_screen_next(&iter);
3648 demo->screen = iter.data;
3649 #elif defined(VK_USE_PLATFORM_WAYLAND_KHR)
3650 demo->display = wl_display_connect(NULL);
3652 if (demo->display == NULL) {
3653 printf("Cannot find a compatible Vulkan installable client driver (ICD).\nExiting ...\n");
3658 demo->registry = wl_display_get_registry(demo->display);
3659 wl_registry_add_listener(demo->registry, ®istry_listener, demo);
3660 wl_display_dispatch(demo->display);
3661 #elif defined(VK_USE_PLATFORM_MIR_KHR)
3665 static void demo_init(struct demo *demo, int argc, char **argv) {
3666 vec3 eye = {0.0f, 3.0f, 5.0f};
3667 vec3 origin = {0, 0, 0};
3668 vec3 up = {0.0f, 1.0f, 0.0};
3670 memset(demo, 0, sizeof(*demo));
3671 demo->presentMode = VK_PRESENT_MODE_FIFO_KHR;
3672 demo->frameCount = INT32_MAX;
3674 for (int i = 1; i < argc; i++) {
3675 if (strcmp(argv[i], "--use_staging") == 0) {
3676 demo->use_staging_buffer = true;
3679 if ((strcmp(argv[i], "--present_mode") == 0) && (i < argc - 1)) {
3680 demo->presentMode = atoi(argv[i + 1]);
3684 if (strcmp(argv[i], "--break") == 0) {
3685 demo->use_break = true;
3688 if (strcmp(argv[i], "--validate") == 0) {
3689 demo->validate = true;
3692 if (strcmp(argv[i], "--validate-checks-disabled") == 0) {
3693 demo->validate = true;
3694 demo->validate_checks_disabled = true;
3697 if (strcmp(argv[i], "--xlib") == 0) {
3698 fprintf(stderr, "--xlib is deprecated and no longer does anything");
3701 if (strcmp(argv[i], "--c") == 0 && demo->frameCount == INT32_MAX && i < argc - 1 &&
3702 sscanf(argv[i + 1], "%d", &demo->frameCount) == 1 && demo->frameCount >= 0) {
3706 if (strcmp(argv[i], "--suppress_popups") == 0) {
3707 demo->suppress_popups = true;
3710 if (strcmp(argv[i], "--display_timing") == 0) {
3711 demo->VK_GOOGLE_display_timing_enabled = true;
3714 if (strcmp(argv[i], "--incremental_present") == 0) {
3715 demo->VK_KHR_incremental_present_enabled = true;
3719 #if defined(ANDROID)
3720 ERR_EXIT("Usage: cube [--validate]\n", "Usage");
3723 "Usage:\n %s\t[--use_staging] [--validate] [--validate-checks-disabled] [--break]\n"
3724 "\t[--c <framecount>] [--suppress_popups] [--incremental_present] [--display_timing]\n"
3725 "\t[--present_mode <present mode enum>]\n"
3726 "\t <present_mode_enum>\tVK_PRESENT_MODE_IMMEDIATE_KHR = %d\n"
3727 "\t\t\t\tVK_PRESENT_MODE_MAILBOX_KHR = %d\n"
3728 "\t\t\t\tVK_PRESENT_MODE_FIFO_KHR = %d\n"
3729 "\t\t\t\tVK_PRESENT_MODE_FIFO_RELAXED_KHR = %d\n",
3730 APP_SHORT_NAME, VK_PRESENT_MODE_IMMEDIATE_KHR, VK_PRESENT_MODE_MAILBOX_KHR, VK_PRESENT_MODE_FIFO_KHR,
3731 VK_PRESENT_MODE_FIFO_RELAXED_KHR);
3737 demo_init_connection(demo);
3744 demo->spin_angle = 4.0f;
3745 demo->spin_increment = 0.2f;
3746 demo->pause = false;
3748 mat4x4_perspective(demo->projection_matrix, (float)degreesToRadians(45.0f), 1.0f, 0.1f, 100.0f);
3749 mat4x4_look_at(demo->view_matrix, eye, origin, up);
3750 mat4x4_identity(demo->model_matrix);
3752 demo->projection_matrix[1][1] *= -1; // Flip projection matrix from GL to Vulkan orientation.
3755 #if defined(VK_USE_PLATFORM_WIN32_KHR)
3756 // Include header required for parsing the command line options.
3757 #include <shellapi.h>
3759 int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR pCmdLine, int nCmdShow) {
3761 bool done; // flag saying when app is complete
3765 // Ensure wParam is initialized.
3768 // Use the CommandLine functions to get the command line arguments.
3769 // Unfortunately, Microsoft outputs
3770 // this information as wide characters for Unicode, and we simply want the
3771 // Ascii version to be compatible
3772 // with the non-Windows side. So, we have to convert the information to
3773 // Ascii character strings.
3774 LPWSTR *commandLineArgs = CommandLineToArgvW(GetCommandLineW(), &argc);
3775 if (NULL == commandLineArgs) {
3780 argv = (char **)malloc(sizeof(char *) * argc);
3784 for (int iii = 0; iii < argc; iii++) {
3785 size_t wideCharLen = wcslen(commandLineArgs[iii]);
3786 size_t numConverted = 0;
3788 argv[iii] = (char *)malloc(sizeof(char) * (wideCharLen + 1));
3789 if (argv[iii] != NULL) {
3790 wcstombs_s(&numConverted, argv[iii], wideCharLen + 1, commandLineArgs[iii], wideCharLen + 1);
3798 demo_init(&demo, argc, argv);
3800 // Free up the items we had to allocate for the command line arguments.
3801 if (argc > 0 && argv != NULL) {
3802 for (int iii = 0; iii < argc; iii++) {
3803 if (argv[iii] != NULL) {
3810 demo.connection = hInstance;
3811 strncpy(demo.name, "cube", APP_NAME_STR_LEN);
3812 demo_create_window(&demo);
3813 demo_init_vk_swapchain(&demo);
3815 demo_prepare(&demo);
3817 done = false; // initialize loop condition variable
3819 // main message loop
3821 PeekMessage(&msg, NULL, 0, 0, PM_REMOVE);
3822 if (msg.message == WM_QUIT) // check for a quit message
3824 done = true; // if found, quit app
3826 /* Translate and dispatch to event queue*/
3827 TranslateMessage(&msg);
3828 DispatchMessage(&msg);
3830 RedrawWindow(demo.window, NULL, NULL, RDW_INTERNALPAINT);
3833 demo_cleanup(&demo);
3835 return (int)msg.wParam;
3838 #elif defined(VK_USE_PLATFORM_IOS_MVK) || defined(VK_USE_PLATFORM_MACOS_MVK)
3839 static void demo_main(struct demo *demo, void *view, int argc, const char *argv[]) {
3841 demo_init(demo, argc, (char **)argv);
3842 demo->window = view;
3843 demo_init_vk_swapchain(demo);
3845 demo->spin_angle = 0.4f;
3848 #elif defined(VK_USE_PLATFORM_ANDROID_KHR)
3849 #include <android/log.h>
3850 #include <android_native_app_glue.h>
3851 #include "android_util.h"
3853 static bool initialized = false;
3854 static bool active = false;
3857 static int32_t processInput(struct android_app *app, AInputEvent *event) { return 0; }
3859 static void processCommand(struct android_app *app, int32_t cmd) {
3861 case APP_CMD_INIT_WINDOW: {
3863 // We're getting a new window. If the app is starting up, we
3864 // need to initialize. If the app has already been
3865 // initialized, that means that we lost our previous window,
3866 // which means that we have a lot of work to do. At a minimum,
3867 // we need to destroy the swapchain and surface associated with
3868 // the old window, and create a new surface and swapchain.
3869 // However, since there are a lot of other objects/state that
3870 // is tied to the swapchain, it's easiest to simply cleanup and
3871 // start over (i.e. use a brute-force approach of re-starting
3873 if (demo.prepared) {
3874 demo_cleanup(&demo);
3877 // Parse Intents into argc, argv
3878 // Use the following key to send arguments, i.e.
3879 // --es args "--validate"
3880 const char key[] = "args";
3881 char *appTag = (char *)APP_SHORT_NAME;
3883 char **argv = get_args(app, key, appTag, &argc);
3885 __android_log_print(ANDROID_LOG_INFO, appTag, "argc = %i", argc);
3886 for (int i = 0; i < argc; i++) __android_log_print(ANDROID_LOG_INFO, appTag, "argv[%i] = %s", i, argv[i]);
3888 demo_init(&demo, argc, argv);
3890 // Free the argv malloc'd by get_args
3891 for (int i = 0; i < argc; i++) free(argv[i]);
3893 demo.window = (void *)app->window;
3894 demo_init_vk_swapchain(&demo);
3895 demo_prepare(&demo);
3900 case APP_CMD_GAINED_FOCUS: {
3904 case APP_CMD_LOST_FOCUS: {
3911 void android_main(struct android_app *app) {
3913 int vulkanSupport = InitVulkan();
3914 if (vulkanSupport == 0) return;
3917 demo.prepared = false;
3919 app->onAppCmd = processCommand;
3920 app->onInputEvent = processInput;
3924 struct android_poll_source *source;
3925 while (ALooper_pollAll(active ? 0 : -1, NULL, &events, (void **)&source) >= 0) {
3927 source->process(app, source);
3930 if (app->destroyRequested != 0) {
3931 demo_cleanup(&demo);
3935 if (initialized && active) {
3941 int main(int argc, char **argv) {
3944 demo_init(&demo, argc, argv);
3945 #if defined(VK_USE_PLATFORM_XCB_KHR)
3946 demo_create_xcb_window(&demo);
3947 #elif defined(VK_USE_PLATFORM_XLIB_KHR)
3948 demo_create_xlib_window(&demo);
3949 #elif defined(VK_USE_PLATFORM_WAYLAND_KHR)
3950 demo_create_window(&demo);
3951 #elif defined(VK_USE_PLATFORM_MIR_KHR)
3954 demo_init_vk_swapchain(&demo);
3956 demo_prepare(&demo);
3958 #if defined(VK_USE_PLATFORM_XCB_KHR)
3959 demo_run_xcb(&demo);
3960 #elif defined(VK_USE_PLATFORM_XLIB_KHR)
3961 demo_run_xlib(&demo);
3962 #elif defined(VK_USE_PLATFORM_WAYLAND_KHR)
3964 #elif defined(VK_USE_PLATFORM_MIR_KHR)
3965 #elif defined(VK_USE_PLATFORM_DISPLAY_KHR)
3966 demo_run_display(&demo);
3969 demo_cleanup(&demo);
3971 return validation_error;