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 {
164 VkImageLayout imageLayout;
166 VkMemoryAllocateInfo mem_alloc;
169 int32_t tex_width, tex_height;
172 static char *tex_files[] = {"lunarg.ppm"};
174 static int validation_error = 0;
176 struct vktexcube_vs_uniform {
177 // Must start with MVP
179 float position[12 * 3][4];
180 float attr[12 * 3][4];
183 //--------------------------------------------------------------------------------------
184 // Mesh and VertexFormat Data
185 //--------------------------------------------------------------------------------------
187 static const float g_vertex_buffer_data[] = {
188 -1.0f,-1.0f,-1.0f, // -X side
195 -1.0f,-1.0f,-1.0f, // -Z side
202 -1.0f,-1.0f,-1.0f, // -Y side
209 -1.0f, 1.0f,-1.0f, // +Y side
216 1.0f, 1.0f,-1.0f, // +X side
223 -1.0f, 1.0f, 1.0f, // +Z side
231 static const float g_uv_buffer_data[] = {
232 0.0f, 1.0f, // -X side
239 1.0f, 1.0f, // -Z side
246 1.0f, 0.0f, // -Y side
253 1.0f, 0.0f, // +Y side
260 1.0f, 0.0f, // +X side
267 0.0f, 0.0f, // +Z side
276 void dumpMatrix(const char *note, mat4x4 MVP) {
279 printf("%s: \n", note);
280 for (i = 0; i < 4; i++) {
281 printf("%f, %f, %f, %f\n", MVP[i][0], MVP[i][1], MVP[i][2], MVP[i][3]);
287 void dumpVec4(const char *note, vec4 vector) {
288 printf("%s: \n", note);
289 printf("%f, %f, %f, %f\n", vector[0], vector[1], vector[2], vector[3]);
297 VkCommandBuffer graphics_to_present_cmd;
299 VkBuffer uniform_buffer;
300 VkDeviceMemory uniform_memory;
301 VkFramebuffer framebuffer;
302 VkDescriptorSet descriptor_set;
303 } SwapchainImageResources;
306 #if defined(VK_USE_PLATFORM_WIN32_KHR)
307 #define APP_NAME_STR_LEN 80
308 HINSTANCE connection; // hInstance - Windows Instance
309 char name[APP_NAME_STR_LEN]; // Name to put on the window/icon
310 HWND window; // hWnd - window handle
311 POINT minsize; // minimum window size
312 #elif defined(VK_USE_PLATFORM_XLIB_KHR)
315 Atom xlib_wm_delete_window;
316 #elif defined(VK_USE_PLATFORM_XCB_KHR)
318 xcb_connection_t *connection;
319 xcb_screen_t *screen;
320 xcb_window_t xcb_window;
321 xcb_intern_atom_reply_t *atom_wm_delete_window;
322 #elif defined(VK_USE_PLATFORM_WAYLAND_KHR)
323 struct wl_display *display;
324 struct wl_registry *registry;
325 struct wl_compositor *compositor;
326 struct wl_surface *window;
327 struct wl_shell *shell;
328 struct wl_shell_surface *shell_surface;
329 struct wl_seat *seat;
330 struct wl_pointer *pointer;
331 struct wl_keyboard *keyboard;
332 #elif defined(VK_USE_PLATFORM_MIR_KHR)
333 #elif defined(VK_USE_PLATFORM_ANDROID_KHR)
334 struct ANativeWindow *window;
335 #elif (defined(VK_USE_PLATFORM_IOS_MVK) || defined(VK_USE_PLATFORM_MACOS_MVK))
338 VkSurfaceKHR surface;
340 bool use_staging_buffer;
341 bool separate_present_queue;
344 bool VK_KHR_incremental_present_enabled;
346 bool VK_GOOGLE_display_timing_enabled;
347 bool syncd_with_actual_presents;
348 uint64_t refresh_duration;
349 uint64_t refresh_duration_multiplier;
350 uint64_t target_IPD; // image present duration (inverse of frame rate)
351 uint64_t prev_desired_present_time;
352 uint32_t next_present_id;
353 uint32_t last_early_id; // 0 if no early images
354 uint32_t last_late_id; // 0 if no late images
357 VkPhysicalDevice gpu;
359 VkQueue graphics_queue;
360 VkQueue present_queue;
361 uint32_t graphics_queue_family_index;
362 uint32_t present_queue_family_index;
363 VkSemaphore image_acquired_semaphores[FRAME_LAG];
364 VkSemaphore draw_complete_semaphores[FRAME_LAG];
365 VkSemaphore image_ownership_semaphores[FRAME_LAG];
366 VkPhysicalDeviceProperties gpu_props;
367 VkQueueFamilyProperties *queue_props;
368 VkPhysicalDeviceMemoryProperties memory_properties;
370 uint32_t enabled_extension_count;
371 uint32_t enabled_layer_count;
372 char *extension_names[64];
373 char *enabled_layers[64];
377 VkColorSpaceKHR color_space;
379 PFN_vkGetPhysicalDeviceSurfaceSupportKHR fpGetPhysicalDeviceSurfaceSupportKHR;
380 PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR fpGetPhysicalDeviceSurfaceCapabilitiesKHR;
381 PFN_vkGetPhysicalDeviceSurfaceFormatsKHR fpGetPhysicalDeviceSurfaceFormatsKHR;
382 PFN_vkGetPhysicalDeviceSurfacePresentModesKHR fpGetPhysicalDeviceSurfacePresentModesKHR;
383 PFN_vkCreateSwapchainKHR fpCreateSwapchainKHR;
384 PFN_vkDestroySwapchainKHR fpDestroySwapchainKHR;
385 PFN_vkGetSwapchainImagesKHR fpGetSwapchainImagesKHR;
386 PFN_vkAcquireNextImageKHR fpAcquireNextImageKHR;
387 PFN_vkQueuePresentKHR fpQueuePresentKHR;
388 PFN_vkGetRefreshCycleDurationGOOGLE fpGetRefreshCycleDurationGOOGLE;
389 PFN_vkGetPastPresentationTimingGOOGLE fpGetPastPresentationTimingGOOGLE;
390 uint32_t swapchainImageCount;
391 VkSwapchainKHR swapchain;
392 SwapchainImageResources *swapchain_image_resources;
393 VkPresentModeKHR presentMode;
394 VkFence fences[FRAME_LAG];
397 VkCommandPool cmd_pool;
398 VkCommandPool present_cmd_pool;
404 VkMemoryAllocateInfo mem_alloc;
409 struct texture_object textures[DEMO_TEXTURE_COUNT];
410 struct texture_object staging_texture;
412 VkCommandBuffer cmd; // Buffer for initialization commands
413 VkPipelineLayout pipeline_layout;
414 VkDescriptorSetLayout desc_layout;
415 VkPipelineCache pipelineCache;
416 VkRenderPass render_pass;
419 mat4x4 projection_matrix;
424 float spin_increment;
427 VkShaderModule vert_shader_module;
428 VkShaderModule frag_shader_module;
430 VkDescriptorPool desc_pool;
436 bool validate_checks_disabled;
438 bool suppress_popups;
440 PFN_vkCreateDebugUtilsMessengerEXT CreateDebugUtilsMessengerEXT;
441 PFN_vkDestroyDebugUtilsMessengerEXT DestroyDebugUtilsMessengerEXT;
442 PFN_vkSubmitDebugUtilsMessageEXT SubmitDebugUtilsMessageEXT;
443 PFN_vkCmdBeginDebugUtilsLabelEXT CmdBeginDebugUtilsLabelEXT;
444 PFN_vkCmdEndDebugUtilsLabelEXT CmdEndDebugUtilsLabelEXT;
445 PFN_vkCmdInsertDebugUtilsLabelEXT CmdInsertDebugUtilsLabelEXT;
446 PFN_vkSetDebugUtilsObjectNameEXT SetDebugUtilsObjectNameEXT;
447 VkDebugUtilsMessengerEXT dbg_messenger;
449 uint32_t current_buffer;
450 uint32_t queue_family_count;
453 VKAPI_ATTR VkBool32 VKAPI_CALL debug_messenger_callback(VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity,
454 VkDebugUtilsMessageTypeFlagsEXT messageType,
455 const VkDebugUtilsMessengerCallbackDataEXT *pCallbackData,
457 char prefix[64] = "";
458 char *message = (char *)malloc(strlen(pCallbackData->pMessage) + 5000);
460 struct demo *demo = (struct demo *)pUserData;
462 if (demo->use_break) {
470 if (messageSeverity & VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT) {
471 strcat(prefix, "VERBOSE : ");
472 } else if (messageSeverity & VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT) {
473 strcat(prefix, "INFO : ");
474 } else if (messageSeverity & VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT) {
475 strcat(prefix, "WARNING : ");
476 } else if (messageSeverity & VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT) {
477 strcat(prefix, "ERROR : ");
480 if (messageType & VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT) {
481 strcat(prefix, "GENERAL");
483 if (messageType & VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT) {
484 strcat(prefix, "VALIDATION");
485 validation_error = 1;
487 if (messageType & VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT) {
488 if (messageType & VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT) {
491 strcat(prefix, "PERFORMANCE");
495 sprintf(message, "%s - Message Id Number: %d | Message Id Name: %s\n\t%s\n", prefix, pCallbackData->messageIdNumber,
496 pCallbackData->pMessageIdName, pCallbackData->pMessage);
497 if (pCallbackData->objectCount > 0) {
498 char tmp_message[500];
499 sprintf(tmp_message, "\n\tObjects - %d\n", pCallbackData->objectCount);
500 strcat(message, tmp_message);
501 for (uint32_t object = 0; object < pCallbackData->objectCount; ++object) {
502 if (NULL != pCallbackData->pObjects[object].pObjectName && strlen(pCallbackData->pObjects[object].pObjectName) > 0) {
503 sprintf(tmp_message, "\t\tObject[%d] - %s, Handle %p, Name \"%s\"\n", object,
504 string_VkObjectType(pCallbackData->pObjects[object].objectType),
505 (void *)(pCallbackData->pObjects[object].objectHandle), pCallbackData->pObjects[object].pObjectName);
507 sprintf(tmp_message, "\t\tObject[%d] - %s, Handle %p\n", object,
508 string_VkObjectType(pCallbackData->pObjects[object].objectType),
509 (void *)(pCallbackData->pObjects[object].objectHandle));
511 strcat(message, tmp_message);
514 if (pCallbackData->cmdBufLabelCount > 0) {
515 char tmp_message[500];
516 sprintf(tmp_message, "\n\tCommand Buffer Labels - %d\n", pCallbackData->cmdBufLabelCount);
517 strcat(message, tmp_message);
518 for (uint32_t cmd_buf_label = 0; cmd_buf_label < pCallbackData->cmdBufLabelCount; ++cmd_buf_label) {
519 sprintf(tmp_message, "\t\tLabel[%d] - %s { %f, %f, %f, %f}\n", cmd_buf_label,
520 pCallbackData->pCmdBufLabels[cmd_buf_label].pLabelName, pCallbackData->pCmdBufLabels[cmd_buf_label].color[0],
521 pCallbackData->pCmdBufLabels[cmd_buf_label].color[1], pCallbackData->pCmdBufLabels[cmd_buf_label].color[2],
522 pCallbackData->pCmdBufLabels[cmd_buf_label].color[3]);
523 strcat(message, tmp_message);
530 if (!demo->suppress_popups)
531 MessageBox(NULL, message, "Alert", MB_OK);
534 #elif defined(ANDROID)
536 if (messageSeverity & VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT) {
537 __android_log_print(ANDROID_LOG_INFO, APP_SHORT_NAME, "%s", message);
538 } else if (messageSeverity & VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT) {
539 __android_log_print(ANDROID_LOG_WARN, APP_SHORT_NAME, "%s", message);
540 } else if (messageSeverity & VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT) {
541 __android_log_print(ANDROID_LOG_ERROR, APP_SHORT_NAME, "%s", message);
542 } else if (messageSeverity & VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT) {
543 __android_log_print(ANDROID_LOG_VERBOSE, APP_SHORT_NAME, "%s", message);
545 __android_log_print(ANDROID_LOG_INFO, APP_SHORT_NAME, "%s", message);
550 printf("%s\n", message);
557 // Don't bail out, but keep going.
561 bool ActualTimeLate(uint64_t desired, uint64_t actual, uint64_t rdur) {
562 // The desired time was the earliest time that the present should have
563 // occured. In almost every case, the actual time should be later than the
564 // desired time. We should only consider the actual time "late" if it is
565 // after "desired + rdur".
566 if (actual <= desired) {
567 // The actual time was before or equal to the desired time. This will
568 // probably never happen, but in case it does, return false since the
569 // present was obviously NOT late.
572 uint64_t deadline = desired + rdur;
573 if (actual > deadline) {
579 bool CanPresentEarlier(uint64_t earliest, uint64_t actual, uint64_t margin, uint64_t rdur) {
580 if (earliest < actual) {
581 // Consider whether this present could have occured earlier. Make sure
582 // that earliest time was at least 2msec earlier than actual time, and
583 // that the margin was at least 2msec:
584 uint64_t diff = actual - earliest;
585 if ((diff >= (2 * MILLION)) && (margin >= (2 * MILLION))) {
586 // This present could have occured earlier because both: 1) the
587 // earliest time was at least 2 msec before actual time, and 2) the
588 // margin was at least 2msec.
595 // Forward declaration:
596 static void demo_resize(struct demo *demo);
598 static bool memory_type_from_properties(struct demo *demo, uint32_t typeBits, VkFlags requirements_mask, uint32_t *typeIndex) {
599 // Search memtypes to find first index with those properties
600 for (uint32_t i = 0; i < VK_MAX_MEMORY_TYPES; i++) {
601 if ((typeBits & 1) == 1) {
602 // Type is available, does it match user properties?
603 if ((demo->memory_properties.memoryTypes[i].propertyFlags & requirements_mask) == requirements_mask) {
610 // No memory types matched, return failure
614 static void demo_flush_init_cmd(struct demo *demo) {
615 VkResult U_ASSERT_ONLY err;
617 // This function could get called twice if the texture uses a staging buffer
618 // In that case the second call should be ignored
619 if (demo->cmd == VK_NULL_HANDLE) return;
621 err = vkEndCommandBuffer(demo->cmd);
625 VkFenceCreateInfo fence_ci = {.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO, .pNext = NULL, .flags = 0};
626 err = vkCreateFence(demo->device, &fence_ci, NULL, &fence);
629 const VkCommandBuffer cmd_bufs[] = {demo->cmd};
630 VkSubmitInfo submit_info = {.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO,
632 .waitSemaphoreCount = 0,
633 .pWaitSemaphores = NULL,
634 .pWaitDstStageMask = NULL,
635 .commandBufferCount = 1,
636 .pCommandBuffers = cmd_bufs,
637 .signalSemaphoreCount = 0,
638 .pSignalSemaphores = NULL};
640 err = vkQueueSubmit(demo->graphics_queue, 1, &submit_info, fence);
643 err = vkWaitForFences(demo->device, 1, &fence, VK_TRUE, UINT64_MAX);
646 vkFreeCommandBuffers(demo->device, demo->cmd_pool, 1, cmd_bufs);
647 vkDestroyFence(demo->device, fence, NULL);
648 demo->cmd = VK_NULL_HANDLE;
651 static void demo_set_image_layout(struct demo *demo, VkImage image, VkImageAspectFlags aspectMask, VkImageLayout old_image_layout,
652 VkImageLayout new_image_layout, VkAccessFlagBits srcAccessMask, VkPipelineStageFlags src_stages,
653 VkPipelineStageFlags dest_stages) {
656 VkImageMemoryBarrier image_memory_barrier = {.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
658 .srcAccessMask = srcAccessMask,
660 .oldLayout = old_image_layout,
661 .newLayout = new_image_layout,
663 .subresourceRange = {aspectMask, 0, 1, 0, 1}};
665 switch (new_image_layout) {
666 case VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL:
667 /* Make sure anything that was copying from this image has completed */
668 image_memory_barrier.dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
671 case VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL:
672 image_memory_barrier.dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
675 case VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL:
676 image_memory_barrier.dstAccessMask = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
679 case VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL:
680 image_memory_barrier.dstAccessMask = VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_INPUT_ATTACHMENT_READ_BIT;
683 case VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL:
684 image_memory_barrier.dstAccessMask = VK_ACCESS_TRANSFER_READ_BIT;
687 case VK_IMAGE_LAYOUT_PRESENT_SRC_KHR:
688 image_memory_barrier.dstAccessMask = VK_ACCESS_MEMORY_READ_BIT;
692 image_memory_barrier.dstAccessMask = 0;
696 VkImageMemoryBarrier *pmemory_barrier = &image_memory_barrier;
698 vkCmdPipelineBarrier(demo->cmd, src_stages, dest_stages, 0, 0, NULL, 0, NULL, 1, pmemory_barrier);
701 static void demo_draw_build_cmd(struct demo *demo, VkCommandBuffer cmd_buf) {
702 VkDebugUtilsLabelEXT label;
703 memset(&label, 0, sizeof(label));
704 const VkCommandBufferBeginInfo cmd_buf_info = {
705 .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
707 .flags = VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT,
708 .pInheritanceInfo = NULL,
710 const VkClearValue clear_values[2] = {
711 [0] = {.color.float32 = {0.2f, 0.2f, 0.2f, 0.2f}},
712 [1] = {.depthStencil = {1.0f, 0}},
714 const VkRenderPassBeginInfo rp_begin = {
715 .sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO,
717 .renderPass = demo->render_pass,
718 .framebuffer = demo->swapchain_image_resources[demo->current_buffer].framebuffer,
719 .renderArea.offset.x = 0,
720 .renderArea.offset.y = 0,
721 .renderArea.extent.width = demo->width,
722 .renderArea.extent.height = demo->height,
723 .clearValueCount = 2,
724 .pClearValues = clear_values,
726 VkResult U_ASSERT_ONLY err;
728 err = vkBeginCommandBuffer(cmd_buf, &cmd_buf_info);
730 if (demo->validate) {
731 // Set a name for the command buffer
732 VkDebugUtilsObjectNameInfoEXT cmd_buf_name = {
733 .sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT,
735 .objectType = VK_OBJECT_TYPE_COMMAND_BUFFER,
736 .objectHandle = (uint64_t)cmd_buf,
737 .pObjectName = "CubeDrawCommandBuf",
739 demo->SetDebugUtilsObjectNameEXT(demo->device, &cmd_buf_name);
741 label.sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT;
743 label.pLabelName = "DrawBegin";
744 label.color[0] = 0.4f;
745 label.color[1] = 0.3f;
746 label.color[2] = 0.2f;
747 label.color[3] = 0.1f;
748 demo->CmdBeginDebugUtilsLabelEXT(cmd_buf, &label);
752 vkCmdBeginRenderPass(cmd_buf, &rp_begin, VK_SUBPASS_CONTENTS_INLINE);
754 if (demo->validate) {
755 label.sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT;
757 label.pLabelName = "InsideRenderPass";
758 label.color[0] = 8.4f;
759 label.color[1] = 7.3f;
760 label.color[2] = 6.2f;
761 label.color[3] = 7.1f;
762 demo->CmdBeginDebugUtilsLabelEXT(cmd_buf, &label);
765 vkCmdBindPipeline(cmd_buf, VK_PIPELINE_BIND_POINT_GRAPHICS, demo->pipeline);
766 vkCmdBindDescriptorSets(cmd_buf, VK_PIPELINE_BIND_POINT_GRAPHICS, demo->pipeline_layout, 0, 1,
767 &demo->swapchain_image_resources[demo->current_buffer].descriptor_set, 0, NULL);
769 memset(&viewport, 0, sizeof(viewport));
770 viewport.height = (float)demo->height;
771 viewport.width = (float)demo->width;
772 viewport.minDepth = (float)0.0f;
773 viewport.maxDepth = (float)1.0f;
774 vkCmdSetViewport(cmd_buf, 0, 1, &viewport);
777 memset(&scissor, 0, sizeof(scissor));
778 scissor.extent.width = demo->width;
779 scissor.extent.height = demo->height;
780 scissor.offset.x = 0;
781 scissor.offset.y = 0;
782 vkCmdSetScissor(cmd_buf, 0, 1, &scissor);
784 if (demo->validate) {
785 label.sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT;
787 label.pLabelName = "ActualDraw";
788 label.color[0] = -0.4f;
789 label.color[1] = -0.3f;
790 label.color[2] = -0.2f;
791 label.color[3] = -0.1f;
792 demo->CmdBeginDebugUtilsLabelEXT(cmd_buf, &label);
795 vkCmdDraw(cmd_buf, 12 * 3, 1, 0, 0);
796 if (demo->validate) {
797 demo->CmdEndDebugUtilsLabelEXT(cmd_buf);
800 // Note that ending the renderpass changes the image's layout from
801 // COLOR_ATTACHMENT_OPTIMAL to PRESENT_SRC_KHR
802 vkCmdEndRenderPass(cmd_buf);
803 if (demo->validate) {
804 demo->CmdEndDebugUtilsLabelEXT(cmd_buf);
807 if (demo->separate_present_queue) {
808 // We have to transfer ownership from the graphics queue family to the
809 // present queue family to be able to present. Note that we don't have
810 // to transfer from present queue family back to graphics queue family at
811 // the start of the next frame because we don't care about the image's
812 // contents at that point.
813 VkImageMemoryBarrier image_ownership_barrier = {.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
816 .dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
817 .oldLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR,
818 .newLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR,
819 .srcQueueFamilyIndex = demo->graphics_queue_family_index,
820 .dstQueueFamilyIndex = demo->present_queue_family_index,
821 .image = demo->swapchain_image_resources[demo->current_buffer].image,
822 .subresourceRange = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1}};
824 vkCmdPipelineBarrier(cmd_buf, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, 0, 0,
825 NULL, 0, NULL, 1, &image_ownership_barrier);
827 if (demo->validate) {
828 demo->CmdEndDebugUtilsLabelEXT(cmd_buf);
830 err = vkEndCommandBuffer(cmd_buf);
834 void demo_build_image_ownership_cmd(struct demo *demo, int i) {
835 VkResult U_ASSERT_ONLY err;
837 const VkCommandBufferBeginInfo cmd_buf_info = {
838 .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
840 .flags = VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT,
841 .pInheritanceInfo = NULL,
843 err = vkBeginCommandBuffer(demo->swapchain_image_resources[i].graphics_to_present_cmd, &cmd_buf_info);
846 VkImageMemoryBarrier image_ownership_barrier = {.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
849 .dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
850 .oldLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR,
851 .newLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR,
852 .srcQueueFamilyIndex = demo->graphics_queue_family_index,
853 .dstQueueFamilyIndex = demo->present_queue_family_index,
854 .image = demo->swapchain_image_resources[i].image,
855 .subresourceRange = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1}};
857 vkCmdPipelineBarrier(demo->swapchain_image_resources[i].graphics_to_present_cmd, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
858 VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, 0, 0, NULL, 0, NULL, 1, &image_ownership_barrier);
859 err = vkEndCommandBuffer(demo->swapchain_image_resources[i].graphics_to_present_cmd);
863 void demo_update_data_buffer(struct demo *demo) {
864 mat4x4 MVP, Model, VP;
865 int matrixSize = sizeof(MVP);
867 VkResult U_ASSERT_ONLY err;
869 mat4x4_mul(VP, demo->projection_matrix, demo->view_matrix);
871 // Rotate around the Y axis
872 mat4x4_dup(Model, demo->model_matrix);
873 mat4x4_rotate(demo->model_matrix, Model, 0.0f, 1.0f, 0.0f, (float)degreesToRadians(demo->spin_angle));
874 mat4x4_mul(MVP, VP, demo->model_matrix);
876 err = vkMapMemory(demo->device, demo->swapchain_image_resources[demo->current_buffer].uniform_memory, 0, VK_WHOLE_SIZE, 0,
880 memcpy(pData, (const void *)&MVP[0][0], matrixSize);
882 vkUnmapMemory(demo->device, demo->swapchain_image_resources[demo->current_buffer].uniform_memory);
885 void DemoUpdateTargetIPD(struct demo *demo) {
886 // Look at what happened to previous presents, and make appropriate
887 // adjustments in timing:
888 VkResult U_ASSERT_ONLY err;
889 VkPastPresentationTimingGOOGLE *past = NULL;
892 err = demo->fpGetPastPresentationTimingGOOGLE(demo->device, demo->swapchain, &count, NULL);
895 past = (VkPastPresentationTimingGOOGLE *)malloc(sizeof(VkPastPresentationTimingGOOGLE) * count);
897 err = demo->fpGetPastPresentationTimingGOOGLE(demo->device, demo->swapchain, &count, past);
902 bool calibrate_next = false;
903 for (uint32_t i = 0; i < count; i++) {
904 if (!demo->syncd_with_actual_presents) {
905 // This is the first time that we've received an
906 // actualPresentTime for this swapchain. In order to not
907 // perceive these early frames as "late", we need to sync-up
908 // our future desiredPresentTime's with the
909 // actualPresentTime(s) that we're receiving now.
910 calibrate_next = true;
912 // So that we don't suspect any pending presents as late,
913 // record them all as suspected-late presents:
914 demo->last_late_id = demo->next_present_id - 1;
915 demo->last_early_id = 0;
916 demo->syncd_with_actual_presents = true;
918 } else if (CanPresentEarlier(past[i].earliestPresentTime, past[i].actualPresentTime, past[i].presentMargin,
919 demo->refresh_duration)) {
920 // This image could have been presented earlier. We don't want
921 // to decrease the target_IPD until we've seen early presents
922 // for at least two seconds.
923 if (demo->last_early_id == past[i].presentID) {
924 // We've now seen two seconds worth of early presents.
925 // Flag it as such, and reset the counter:
927 demo->last_early_id = 0;
928 } else if (demo->last_early_id == 0) {
929 // This is the first early present we've seen.
930 // Calculate the presentID for two seconds from now.
931 uint64_t lastEarlyTime = past[i].actualPresentTime + (2 * BILLION);
932 uint32_t howManyPresents = (uint32_t)((lastEarlyTime - past[i].actualPresentTime) / demo->target_IPD);
933 demo->last_early_id = past[i].presentID + howManyPresents;
935 // We are in the midst of a set of early images,
936 // and so we won't do anything.
939 demo->last_late_id = 0;
940 } else if (ActualTimeLate(past[i].desiredPresentTime, past[i].actualPresentTime, demo->refresh_duration)) {
941 // This image was presented after its desired time. Since
942 // there's a delay between calling vkQueuePresentKHR and when
943 // we get the timing data, several presents may have been late.
944 // Thus, we need to threat all of the outstanding presents as
945 // being likely late, so that we only increase the target_IPD
946 // once for all of those presents.
947 if ((demo->last_late_id == 0) || (demo->last_late_id < past[i].presentID)) {
949 // Record the last suspected-late present:
950 demo->last_late_id = demo->next_present_id - 1;
952 // We are in the midst of a set of likely-late images,
953 // and so we won't do anything.
956 demo->last_early_id = 0;
958 // Since this image was not presented early or late, reset
959 // any sets of early or late presentIDs:
962 calibrate_next = true;
963 demo->last_early_id = 0;
964 demo->last_late_id = 0;
969 // Since we've seen at least two-seconds worth of presnts that
970 // could have occured earlier than desired, let's decrease the
971 // target_IPD (i.e. increase the frame rate):
973 // TODO(ianelliott): Try to calculate a better target_IPD based
974 // on the most recently-seen present (this is overly-simplistic).
975 demo->refresh_duration_multiplier--;
976 if (demo->refresh_duration_multiplier == 0) {
977 // This should never happen, but in case it does, don't
979 demo->refresh_duration_multiplier = 1;
981 demo->target_IPD = demo->refresh_duration * demo->refresh_duration_multiplier;
984 // Since we found a new instance of a late present, we want to
985 // increase the target_IPD (i.e. decrease the frame rate):
987 // TODO(ianelliott): Try to calculate a better target_IPD based
988 // on the most recently-seen present (this is overly-simplistic).
989 demo->refresh_duration_multiplier++;
990 demo->target_IPD = demo->refresh_duration * demo->refresh_duration_multiplier;
993 if (calibrate_next) {
994 int64_t multiple = demo->next_present_id - past[count - 1].presentID;
995 demo->prev_desired_present_time = (past[count - 1].actualPresentTime + (multiple * demo->target_IPD));
1000 static void demo_draw(struct demo *demo) {
1001 VkResult U_ASSERT_ONLY err;
1003 // Ensure no more than FRAME_LAG renderings are outstanding
1004 vkWaitForFences(demo->device, 1, &demo->fences[demo->frame_index], VK_TRUE, UINT64_MAX);
1005 vkResetFences(demo->device, 1, &demo->fences[demo->frame_index]);
1008 // Get the index of the next available swapchain image:
1010 demo->fpAcquireNextImageKHR(demo->device, demo->swapchain, UINT64_MAX,
1011 demo->image_acquired_semaphores[demo->frame_index], VK_NULL_HANDLE, &demo->current_buffer);
1013 if (err == VK_ERROR_OUT_OF_DATE_KHR) {
1014 // demo->swapchain is out of date (e.g. the window was resized) and
1015 // must be recreated:
1017 } else if (err == VK_SUBOPTIMAL_KHR) {
1018 // demo->swapchain is not as optimal as it could be, but the platform's
1019 // presentation engine will still present the image correctly.
1024 } while (err != VK_SUCCESS);
1026 demo_update_data_buffer(demo);
1028 if (demo->VK_GOOGLE_display_timing_enabled) {
1029 // Look at what happened to previous presents, and make appropriate
1030 // adjustments in timing:
1031 DemoUpdateTargetIPD(demo);
1033 // Note: a real application would position its geometry to that it's in
1034 // the correct locatoin for when the next image is presented. It might
1035 // also wait, so that there's less latency between any input and when
1036 // the next image is rendered/presented. This demo program is so
1037 // simple that it doesn't do either of those.
1040 // Wait for the image acquired semaphore to be signaled to ensure
1041 // that the image won't be rendered to until the presentation
1042 // engine has fully released ownership to the application, and it is
1043 // okay to render to the image.
1044 VkPipelineStageFlags pipe_stage_flags;
1045 VkSubmitInfo submit_info;
1046 submit_info.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
1047 submit_info.pNext = NULL;
1048 submit_info.pWaitDstStageMask = &pipe_stage_flags;
1049 pipe_stage_flags = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
1050 submit_info.waitSemaphoreCount = 1;
1051 submit_info.pWaitSemaphores = &demo->image_acquired_semaphores[demo->frame_index];
1052 submit_info.commandBufferCount = 1;
1053 submit_info.pCommandBuffers = &demo->swapchain_image_resources[demo->current_buffer].cmd;
1054 submit_info.signalSemaphoreCount = 1;
1055 submit_info.pSignalSemaphores = &demo->draw_complete_semaphores[demo->frame_index];
1056 err = vkQueueSubmit(demo->graphics_queue, 1, &submit_info, demo->fences[demo->frame_index]);
1059 if (demo->separate_present_queue) {
1060 // If we are using separate queues, change image ownership to the
1061 // present queue before presenting, waiting for the draw complete
1062 // semaphore and signalling the ownership released semaphore when finished
1063 VkFence nullFence = VK_NULL_HANDLE;
1064 pipe_stage_flags = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
1065 submit_info.waitSemaphoreCount = 1;
1066 submit_info.pWaitSemaphores = &demo->draw_complete_semaphores[demo->frame_index];
1067 submit_info.commandBufferCount = 1;
1068 submit_info.pCommandBuffers = &demo->swapchain_image_resources[demo->current_buffer].graphics_to_present_cmd;
1069 submit_info.signalSemaphoreCount = 1;
1070 submit_info.pSignalSemaphores = &demo->image_ownership_semaphores[demo->frame_index];
1071 err = vkQueueSubmit(demo->present_queue, 1, &submit_info, nullFence);
1075 // If we are using separate queues we have to wait for image ownership,
1076 // otherwise wait for draw complete
1077 VkPresentInfoKHR present = {
1078 .sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR,
1080 .waitSemaphoreCount = 1,
1081 .pWaitSemaphores = (demo->separate_present_queue) ? &demo->image_ownership_semaphores[demo->frame_index]
1082 : &demo->draw_complete_semaphores[demo->frame_index],
1083 .swapchainCount = 1,
1084 .pSwapchains = &demo->swapchain,
1085 .pImageIndices = &demo->current_buffer,
1088 if (demo->VK_KHR_incremental_present_enabled) {
1089 // If using VK_KHR_incremental_present, we provide a hint of the region
1090 // that contains changed content relative to the previously-presented
1091 // image. The implementation can use this hint in order to save
1092 // work/power (by only copying the region in the hint). The
1093 // implementation is free to ignore the hint though, and so we must
1094 // ensure that the entire image has the correctly-drawn content.
1095 uint32_t eighthOfWidth = demo->width / 8;
1096 uint32_t eighthOfHeight = demo->height / 8;
1097 VkRectLayerKHR rect = {
1098 .offset.x = eighthOfWidth,
1099 .offset.y = eighthOfHeight,
1100 .extent.width = eighthOfWidth * 6,
1101 .extent.height = eighthOfHeight * 6,
1104 VkPresentRegionKHR region = {
1105 .rectangleCount = 1,
1106 .pRectangles = &rect,
1108 VkPresentRegionsKHR regions = {
1109 .sType = VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR,
1110 .pNext = present.pNext,
1111 .swapchainCount = present.swapchainCount,
1112 .pRegions = ®ion,
1114 present.pNext = ®ions;
1117 if (demo->VK_GOOGLE_display_timing_enabled) {
1118 VkPresentTimeGOOGLE ptime;
1119 if (demo->prev_desired_present_time == 0) {
1120 // This must be the first present for this swapchain.
1122 // We don't know where we are relative to the presentation engine's
1123 // display's refresh cycle. We also don't know how long rendering
1124 // takes. Let's make a grossly-simplified assumption that the
1125 // desiredPresentTime should be half way between now and
1126 // now+target_IPD. We will adjust over time.
1127 uint64_t curtime = getTimeInNanoseconds();
1129 // Since we didn't find out the current time, don't give a
1130 // desiredPresentTime:
1131 ptime.desiredPresentTime = 0;
1133 ptime.desiredPresentTime = curtime + (demo->target_IPD >> 1);
1136 ptime.desiredPresentTime = (demo->prev_desired_present_time + demo->target_IPD);
1138 ptime.presentID = demo->next_present_id++;
1139 demo->prev_desired_present_time = ptime.desiredPresentTime;
1141 VkPresentTimesInfoGOOGLE present_time = {
1142 .sType = VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE,
1143 .pNext = present.pNext,
1144 .swapchainCount = present.swapchainCount,
1147 if (demo->VK_GOOGLE_display_timing_enabled) {
1148 present.pNext = &present_time;
1152 err = demo->fpQueuePresentKHR(demo->present_queue, &present);
1153 demo->frame_index += 1;
1154 demo->frame_index %= FRAME_LAG;
1156 if (err == VK_ERROR_OUT_OF_DATE_KHR) {
1157 // demo->swapchain is out of date (e.g. the window was resized) and
1158 // must be recreated:
1160 } else if (err == VK_SUBOPTIMAL_KHR) {
1161 // demo->swapchain is not as optimal as it could be, but the platform's
1162 // presentation engine will still present the image correctly.
1168 static void demo_prepare_buffers(struct demo *demo) {
1169 VkResult U_ASSERT_ONLY err;
1170 VkSwapchainKHR oldSwapchain = demo->swapchain;
1172 // Check the surface capabilities and formats
1173 VkSurfaceCapabilitiesKHR surfCapabilities;
1174 err = demo->fpGetPhysicalDeviceSurfaceCapabilitiesKHR(demo->gpu, demo->surface, &surfCapabilities);
1177 uint32_t presentModeCount;
1178 err = demo->fpGetPhysicalDeviceSurfacePresentModesKHR(demo->gpu, demo->surface, &presentModeCount, NULL);
1180 VkPresentModeKHR *presentModes = (VkPresentModeKHR *)malloc(presentModeCount * sizeof(VkPresentModeKHR));
1181 assert(presentModes);
1182 err = demo->fpGetPhysicalDeviceSurfacePresentModesKHR(demo->gpu, demo->surface, &presentModeCount, presentModes);
1185 VkExtent2D swapchainExtent;
1186 // width and height are either both 0xFFFFFFFF, or both not 0xFFFFFFFF.
1187 if (surfCapabilities.currentExtent.width == 0xFFFFFFFF) {
1188 // If the surface size is undefined, the size is set to the size
1189 // of the images requested, which must fit within the minimum and
1191 swapchainExtent.width = demo->width;
1192 swapchainExtent.height = demo->height;
1194 if (swapchainExtent.width < surfCapabilities.minImageExtent.width) {
1195 swapchainExtent.width = surfCapabilities.minImageExtent.width;
1196 } else if (swapchainExtent.width > surfCapabilities.maxImageExtent.width) {
1197 swapchainExtent.width = surfCapabilities.maxImageExtent.width;
1200 if (swapchainExtent.height < surfCapabilities.minImageExtent.height) {
1201 swapchainExtent.height = surfCapabilities.minImageExtent.height;
1202 } else if (swapchainExtent.height > surfCapabilities.maxImageExtent.height) {
1203 swapchainExtent.height = surfCapabilities.maxImageExtent.height;
1206 // If the surface size is defined, the swap chain size must match
1207 swapchainExtent = surfCapabilities.currentExtent;
1208 demo->width = surfCapabilities.currentExtent.width;
1209 demo->height = surfCapabilities.currentExtent.height;
1212 if (demo->width == 0 || demo->height == 0) {
1213 demo->is_minimized = true;
1216 demo->is_minimized = false;
1219 // The FIFO present mode is guaranteed by the spec to be supported
1220 // and to have no tearing. It's a great default present mode to use.
1221 VkPresentModeKHR swapchainPresentMode = VK_PRESENT_MODE_FIFO_KHR;
1223 // There are times when you may wish to use another present mode. The
1224 // following code shows how to select them, and the comments provide some
1225 // reasons you may wish to use them.
1227 // It should be noted that Vulkan 1.0 doesn't provide a method for
1228 // synchronizing rendering with the presentation engine's display. There
1229 // is a method provided for throttling rendering with the display, but
1230 // there are some presentation engines for which this method will not work.
1231 // If an application doesn't throttle its rendering, and if it renders much
1232 // faster than the refresh rate of the display, this can waste power on
1233 // mobile devices. That is because power is being spent rendering images
1234 // that may never be seen.
1236 // VK_PRESENT_MODE_IMMEDIATE_KHR is for applications that don't care about
1237 // tearing, or have some way of synchronizing their rendering with the
1239 // VK_PRESENT_MODE_MAILBOX_KHR may be useful for applications that
1240 // generally render a new presentable image every refresh cycle, but are
1241 // occasionally early. In this case, the application wants the new image
1242 // to be displayed instead of the previously-queued-for-presentation image
1243 // that has not yet been displayed.
1244 // VK_PRESENT_MODE_FIFO_RELAXED_KHR is for applications that generally
1245 // render a new presentable image every refresh cycle, but are occasionally
1246 // late. In this case (perhaps because of stuttering/latency concerns),
1247 // the application wants the late image to be immediately displayed, even
1248 // though that may mean some tearing.
1250 if (demo->presentMode != swapchainPresentMode) {
1251 for (size_t i = 0; i < presentModeCount; ++i) {
1252 if (presentModes[i] == demo->presentMode) {
1253 swapchainPresentMode = demo->presentMode;
1258 if (swapchainPresentMode != demo->presentMode) {
1259 ERR_EXIT("Present mode specified is not supported\n", "Present mode unsupported");
1262 // Determine the number of VkImages to use in the swap chain.
1263 // Application desires to acquire 3 images at a time for triple
1265 uint32_t desiredNumOfSwapchainImages = 3;
1266 if (desiredNumOfSwapchainImages < surfCapabilities.minImageCount) {
1267 desiredNumOfSwapchainImages = surfCapabilities.minImageCount;
1269 // If maxImageCount is 0, we can ask for as many images as we want;
1270 // otherwise we're limited to maxImageCount
1271 if ((surfCapabilities.maxImageCount > 0) && (desiredNumOfSwapchainImages > surfCapabilities.maxImageCount)) {
1272 // Application must settle for fewer images than desired:
1273 desiredNumOfSwapchainImages = surfCapabilities.maxImageCount;
1276 VkSurfaceTransformFlagsKHR preTransform;
1277 if (surfCapabilities.supportedTransforms & VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR) {
1278 preTransform = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR;
1280 preTransform = surfCapabilities.currentTransform;
1283 // Find a supported composite alpha mode - one of these is guaranteed to be set
1284 VkCompositeAlphaFlagBitsKHR compositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR;
1285 VkCompositeAlphaFlagBitsKHR compositeAlphaFlags[4] = {
1286 VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR,
1287 VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR,
1288 VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR,
1289 VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR,
1291 for (uint32_t i = 0; i < ARRAY_SIZE(compositeAlphaFlags); i++) {
1292 if (surfCapabilities.supportedCompositeAlpha & compositeAlphaFlags[i]) {
1293 compositeAlpha = compositeAlphaFlags[i];
1298 VkSwapchainCreateInfoKHR swapchain_ci = {
1299 .sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR,
1301 .surface = demo->surface,
1302 .minImageCount = desiredNumOfSwapchainImages,
1303 .imageFormat = demo->format,
1304 .imageColorSpace = demo->color_space,
1307 .width = swapchainExtent.width,
1308 .height = swapchainExtent.height,
1310 .imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT,
1311 .preTransform = preTransform,
1312 .compositeAlpha = compositeAlpha,
1313 .imageArrayLayers = 1,
1314 .imageSharingMode = VK_SHARING_MODE_EXCLUSIVE,
1315 .queueFamilyIndexCount = 0,
1316 .pQueueFamilyIndices = NULL,
1317 .presentMode = swapchainPresentMode,
1318 .oldSwapchain = oldSwapchain,
1322 err = demo->fpCreateSwapchainKHR(demo->device, &swapchain_ci, NULL, &demo->swapchain);
1325 // If we just re-created an existing swapchain, we should destroy the old
1326 // swapchain at this point.
1327 // Note: destroying the swapchain also cleans up all its associated
1328 // presentable images once the platform is done with them.
1329 if (oldSwapchain != VK_NULL_HANDLE) {
1330 demo->fpDestroySwapchainKHR(demo->device, oldSwapchain, NULL);
1333 err = demo->fpGetSwapchainImagesKHR(demo->device, demo->swapchain, &demo->swapchainImageCount, NULL);
1336 VkImage *swapchainImages = (VkImage *)malloc(demo->swapchainImageCount * sizeof(VkImage));
1337 assert(swapchainImages);
1338 err = demo->fpGetSwapchainImagesKHR(demo->device, demo->swapchain, &demo->swapchainImageCount, swapchainImages);
1341 demo->swapchain_image_resources =
1342 (SwapchainImageResources *)malloc(sizeof(SwapchainImageResources) * demo->swapchainImageCount);
1343 assert(demo->swapchain_image_resources);
1345 for (i = 0; i < demo->swapchainImageCount; i++) {
1346 VkImageViewCreateInfo color_image_view = {
1347 .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
1349 .format = demo->format,
1352 .r = VK_COMPONENT_SWIZZLE_R,
1353 .g = VK_COMPONENT_SWIZZLE_G,
1354 .b = VK_COMPONENT_SWIZZLE_B,
1355 .a = VK_COMPONENT_SWIZZLE_A,
1358 {.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT, .baseMipLevel = 0, .levelCount = 1, .baseArrayLayer = 0, .layerCount = 1},
1359 .viewType = VK_IMAGE_VIEW_TYPE_2D,
1363 demo->swapchain_image_resources[i].image = swapchainImages[i];
1365 color_image_view.image = demo->swapchain_image_resources[i].image;
1367 err = vkCreateImageView(demo->device, &color_image_view, NULL, &demo->swapchain_image_resources[i].view);
1371 if (demo->VK_GOOGLE_display_timing_enabled) {
1372 VkRefreshCycleDurationGOOGLE rc_dur;
1373 err = demo->fpGetRefreshCycleDurationGOOGLE(demo->device, demo->swapchain, &rc_dur);
1375 demo->refresh_duration = rc_dur.refreshDuration;
1377 demo->syncd_with_actual_presents = false;
1378 // Initially target 1X the refresh duration:
1379 demo->target_IPD = demo->refresh_duration;
1380 demo->refresh_duration_multiplier = 1;
1381 demo->prev_desired_present_time = 0;
1382 demo->next_present_id = 1;
1385 if (NULL != presentModes) {
1390 static void demo_prepare_depth(struct demo *demo) {
1391 const VkFormat depth_format = VK_FORMAT_D16_UNORM;
1392 const VkImageCreateInfo image = {
1393 .sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,
1395 .imageType = VK_IMAGE_TYPE_2D,
1396 .format = depth_format,
1397 .extent = {demo->width, demo->height, 1},
1400 .samples = VK_SAMPLE_COUNT_1_BIT,
1401 .tiling = VK_IMAGE_TILING_OPTIMAL,
1402 .usage = VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT,
1406 VkImageViewCreateInfo view = {
1407 .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
1409 .image = VK_NULL_HANDLE,
1410 .format = depth_format,
1412 {.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT, .baseMipLevel = 0, .levelCount = 1, .baseArrayLayer = 0, .layerCount = 1},
1414 .viewType = VK_IMAGE_VIEW_TYPE_2D,
1417 VkMemoryRequirements mem_reqs;
1418 VkResult U_ASSERT_ONLY err;
1419 bool U_ASSERT_ONLY pass;
1421 demo->depth.format = depth_format;
1424 err = vkCreateImage(demo->device, &image, NULL, &demo->depth.image);
1427 vkGetImageMemoryRequirements(demo->device, demo->depth.image, &mem_reqs);
1430 demo->depth.mem_alloc.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
1431 demo->depth.mem_alloc.pNext = NULL;
1432 demo->depth.mem_alloc.allocationSize = mem_reqs.size;
1433 demo->depth.mem_alloc.memoryTypeIndex = 0;
1435 pass = memory_type_from_properties(demo, mem_reqs.memoryTypeBits, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT,
1436 &demo->depth.mem_alloc.memoryTypeIndex);
1439 /* allocate memory */
1440 err = vkAllocateMemory(demo->device, &demo->depth.mem_alloc, NULL, &demo->depth.mem);
1444 err = vkBindImageMemory(demo->device, demo->depth.image, demo->depth.mem, 0);
1447 /* create image view */
1448 view.image = demo->depth.image;
1449 err = vkCreateImageView(demo->device, &view, NULL, &demo->depth.view);
1453 /* Load a ppm file into memory */
1454 bool loadTexture(const char *filename, uint8_t *rgba_data, VkSubresourceLayout *layout, int32_t *width, int32_t *height) {
1455 #if (defined(VK_USE_PLATFORM_IOS_MVK) || defined(VK_USE_PLATFORM_MACOS_MVK))
1456 filename = [[[NSBundle mainBundle] resourcePath] stringByAppendingPathComponent:@(filename)].UTF8String;
1460 #include <lunarg.ppm.h>
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))
1480 for (int y = 0; y < *height; y++) {
1481 uint8_t *rowPtr = rgba_data;
1482 for (int x = 0; x < *width; x++) {
1483 memcpy(rowPtr, cPtr, 3);
1484 rowPtr[3] = 255; /* Alpha of 1 */
1488 rgba_data += layout->rowPitch;
1493 FILE *fPtr = fopen(filename, "rb");
1494 char header[256], *cPtr, *tmp;
1496 if (!fPtr) return false;
1498 cPtr = fgets(header, 256, fPtr); // P6
1499 if (cPtr == NULL || strncmp(header, "P6\n", 3)) {
1505 cPtr = fgets(header, 256, fPtr);
1510 } while (!strncmp(header, "#", 1));
1512 sscanf(header, "%u %u", width, height);
1513 if (rgba_data == NULL) {
1517 tmp = fgets(header, 256, fPtr); // Format
1519 if (cPtr == NULL || strncmp(header, "255\n", 3)) {
1524 for (int y = 0; y < *height; y++) {
1525 uint8_t *rowPtr = rgba_data;
1526 for (int x = 0; x < *width; x++) {
1527 size_t s = fread(rowPtr, 3, 1, fPtr);
1529 rowPtr[3] = 255; /* Alpha of 1 */
1532 rgba_data += layout->rowPitch;
1539 static void demo_prepare_texture_image(struct demo *demo, const char *filename, struct texture_object *tex_obj,
1540 VkImageTiling tiling, VkImageUsageFlags usage, VkFlags required_props) {
1541 const VkFormat tex_format = VK_FORMAT_R8G8B8A8_UNORM;
1544 VkResult U_ASSERT_ONLY err;
1545 bool U_ASSERT_ONLY pass;
1547 if (!loadTexture(filename, NULL, NULL, &tex_width, &tex_height)) {
1548 ERR_EXIT("Failed to load textures", "Load Texture Failure");
1551 tex_obj->tex_width = tex_width;
1552 tex_obj->tex_height = tex_height;
1554 const VkImageCreateInfo image_create_info = {
1555 .sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,
1557 .imageType = VK_IMAGE_TYPE_2D,
1558 .format = tex_format,
1559 .extent = {tex_width, tex_height, 1},
1562 .samples = VK_SAMPLE_COUNT_1_BIT,
1566 .initialLayout = VK_IMAGE_LAYOUT_PREINITIALIZED,
1569 VkMemoryRequirements mem_reqs;
1571 err = vkCreateImage(demo->device, &image_create_info, NULL, &tex_obj->image);
1574 vkGetImageMemoryRequirements(demo->device, tex_obj->image, &mem_reqs);
1576 tex_obj->mem_alloc.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
1577 tex_obj->mem_alloc.pNext = NULL;
1578 tex_obj->mem_alloc.allocationSize = mem_reqs.size;
1579 tex_obj->mem_alloc.memoryTypeIndex = 0;
1581 pass = memory_type_from_properties(demo, mem_reqs.memoryTypeBits, required_props, &tex_obj->mem_alloc.memoryTypeIndex);
1584 /* allocate memory */
1585 err = vkAllocateMemory(demo->device, &tex_obj->mem_alloc, NULL, &(tex_obj->mem));
1589 err = vkBindImageMemory(demo->device, tex_obj->image, tex_obj->mem, 0);
1592 if (required_props & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) {
1593 const VkImageSubresource subres = {
1594 .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
1598 VkSubresourceLayout layout;
1601 vkGetImageSubresourceLayout(demo->device, tex_obj->image, &subres, &layout);
1603 err = vkMapMemory(demo->device, tex_obj->mem, 0, tex_obj->mem_alloc.allocationSize, 0, &data);
1606 if (!loadTexture(filename, data, &layout, &tex_width, &tex_height)) {
1607 fprintf(stderr, "Error loading texture: %s\n", filename);
1610 vkUnmapMemory(demo->device, tex_obj->mem);
1613 tex_obj->imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
1616 static void demo_destroy_texture_image(struct demo *demo, struct texture_object *tex_objs) {
1617 /* clean up staging resources */
1618 vkFreeMemory(demo->device, tex_objs->mem, NULL);
1619 vkDestroyImage(demo->device, tex_objs->image, NULL);
1622 static void demo_prepare_textures(struct demo *demo) {
1623 const VkFormat tex_format = VK_FORMAT_R8G8B8A8_UNORM;
1624 VkFormatProperties props;
1627 vkGetPhysicalDeviceFormatProperties(demo->gpu, tex_format, &props);
1629 for (i = 0; i < DEMO_TEXTURE_COUNT; i++) {
1630 VkResult U_ASSERT_ONLY err;
1632 if ((props.linearTilingFeatures & VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT) && !demo->use_staging_buffer) {
1633 /* Device can texture using linear textures */
1634 demo_prepare_texture_image(demo, tex_files[i], &demo->textures[i], VK_IMAGE_TILING_LINEAR, VK_IMAGE_USAGE_SAMPLED_BIT,
1635 VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT);
1636 // Nothing in the pipeline needs to be complete to start, and don't allow fragment
1637 // shader to run until layout transition completes
1638 demo_set_image_layout(demo, demo->textures[i].image, VK_IMAGE_ASPECT_COLOR_BIT, VK_IMAGE_LAYOUT_PREINITIALIZED,
1639 demo->textures[i].imageLayout, 0, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
1640 VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT);
1641 demo->staging_texture.image = 0;
1642 } else if (props.optimalTilingFeatures & VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT) {
1643 /* Must use staging buffer to copy linear texture to optimized */
1645 memset(&demo->staging_texture, 0, sizeof(demo->staging_texture));
1646 demo_prepare_texture_image(demo, tex_files[i], &demo->staging_texture, VK_IMAGE_TILING_LINEAR,
1647 VK_IMAGE_USAGE_TRANSFER_SRC_BIT,
1648 VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT);
1650 demo_prepare_texture_image(demo, tex_files[i], &demo->textures[i], VK_IMAGE_TILING_OPTIMAL,
1651 (VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_SAMPLED_BIT),
1652 VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
1654 demo_set_image_layout(demo, demo->staging_texture.image, VK_IMAGE_ASPECT_COLOR_BIT, VK_IMAGE_LAYOUT_PREINITIALIZED,
1655 VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, 0, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
1656 VK_PIPELINE_STAGE_TRANSFER_BIT);
1658 demo_set_image_layout(demo, demo->textures[i].image, VK_IMAGE_ASPECT_COLOR_BIT, VK_IMAGE_LAYOUT_PREINITIALIZED,
1659 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 0, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
1660 VK_PIPELINE_STAGE_TRANSFER_BIT);
1662 VkImageCopy copy_region = {
1663 .srcSubresource = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, 1},
1664 .srcOffset = {0, 0, 0},
1665 .dstSubresource = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, 1},
1666 .dstOffset = {0, 0, 0},
1667 .extent = {demo->staging_texture.tex_width, demo->staging_texture.tex_height, 1},
1669 vkCmdCopyImage(demo->cmd, demo->staging_texture.image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, demo->textures[i].image,
1670 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, ©_region);
1672 demo_set_image_layout(demo, demo->textures[i].image, VK_IMAGE_ASPECT_COLOR_BIT, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
1673 demo->textures[i].imageLayout, VK_ACCESS_TRANSFER_WRITE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT,
1674 VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT);
1677 /* Can't support VK_FORMAT_R8G8B8A8_UNORM !? */
1678 assert(!"No support for R8G8B8A8_UNORM as texture image format");
1681 const VkSamplerCreateInfo sampler = {
1682 .sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO,
1684 .magFilter = VK_FILTER_NEAREST,
1685 .minFilter = VK_FILTER_NEAREST,
1686 .mipmapMode = VK_SAMPLER_MIPMAP_MODE_NEAREST,
1687 .addressModeU = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,
1688 .addressModeV = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,
1689 .addressModeW = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,
1691 .anisotropyEnable = VK_FALSE,
1693 .compareOp = VK_COMPARE_OP_NEVER,
1696 .borderColor = VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE,
1697 .unnormalizedCoordinates = VK_FALSE,
1700 VkImageViewCreateInfo view = {
1701 .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
1703 .image = VK_NULL_HANDLE,
1704 .viewType = VK_IMAGE_VIEW_TYPE_2D,
1705 .format = tex_format,
1708 VK_COMPONENT_SWIZZLE_R,
1709 VK_COMPONENT_SWIZZLE_G,
1710 VK_COMPONENT_SWIZZLE_B,
1711 VK_COMPONENT_SWIZZLE_A,
1713 .subresourceRange = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1},
1717 /* create sampler */
1718 err = vkCreateSampler(demo->device, &sampler, NULL, &demo->textures[i].sampler);
1721 /* create image view */
1722 view.image = demo->textures[i].image;
1723 err = vkCreateImageView(demo->device, &view, NULL, &demo->textures[i].view);
1728 void demo_prepare_cube_data_buffers(struct demo *demo) {
1729 VkBufferCreateInfo buf_info;
1730 VkMemoryRequirements mem_reqs;
1731 VkMemoryAllocateInfo mem_alloc;
1734 VkResult U_ASSERT_ONLY err;
1735 bool U_ASSERT_ONLY pass;
1736 struct vktexcube_vs_uniform data;
1738 mat4x4_mul(VP, demo->projection_matrix, demo->view_matrix);
1739 mat4x4_mul(MVP, VP, demo->model_matrix);
1740 memcpy(data.mvp, MVP, sizeof(MVP));
1741 // dumpMatrix("MVP", MVP);
1743 for (unsigned int i = 0; i < 12 * 3; i++) {
1744 data.position[i][0] = g_vertex_buffer_data[i * 3];
1745 data.position[i][1] = g_vertex_buffer_data[i * 3 + 1];
1746 data.position[i][2] = g_vertex_buffer_data[i * 3 + 2];
1747 data.position[i][3] = 1.0f;
1748 data.attr[i][0] = g_uv_buffer_data[2 * i];
1749 data.attr[i][1] = g_uv_buffer_data[2 * i + 1];
1750 data.attr[i][2] = 0;
1751 data.attr[i][3] = 0;
1754 memset(&buf_info, 0, sizeof(buf_info));
1755 buf_info.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
1756 buf_info.usage = VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT;
1757 buf_info.size = sizeof(data);
1759 for (unsigned int i = 0; i < demo->swapchainImageCount; i++) {
1760 err = vkCreateBuffer(demo->device, &buf_info, NULL, &demo->swapchain_image_resources[i].uniform_buffer);
1763 vkGetBufferMemoryRequirements(demo->device, demo->swapchain_image_resources[i].uniform_buffer, &mem_reqs);
1765 mem_alloc.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
1766 mem_alloc.pNext = NULL;
1767 mem_alloc.allocationSize = mem_reqs.size;
1768 mem_alloc.memoryTypeIndex = 0;
1770 pass = memory_type_from_properties(demo, mem_reqs.memoryTypeBits,
1771 VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
1772 &mem_alloc.memoryTypeIndex);
1775 err = vkAllocateMemory(demo->device, &mem_alloc, NULL, &demo->swapchain_image_resources[i].uniform_memory);
1778 err = vkMapMemory(demo->device, demo->swapchain_image_resources[i].uniform_memory, 0, VK_WHOLE_SIZE, 0, (void **)&pData);
1781 memcpy(pData, &data, sizeof data);
1783 vkUnmapMemory(demo->device, demo->swapchain_image_resources[i].uniform_memory);
1785 err = vkBindBufferMemory(demo->device, demo->swapchain_image_resources[i].uniform_buffer,
1786 demo->swapchain_image_resources[i].uniform_memory, 0);
1791 static void demo_prepare_descriptor_layout(struct demo *demo) {
1792 const VkDescriptorSetLayoutBinding layout_bindings[2] = {
1796 .descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
1797 .descriptorCount = 1,
1798 .stageFlags = VK_SHADER_STAGE_VERTEX_BIT,
1799 .pImmutableSamplers = NULL,
1804 .descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
1805 .descriptorCount = DEMO_TEXTURE_COUNT,
1806 .stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT,
1807 .pImmutableSamplers = NULL,
1810 const VkDescriptorSetLayoutCreateInfo descriptor_layout = {
1811 .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO,
1814 .pBindings = layout_bindings,
1816 VkResult U_ASSERT_ONLY err;
1818 err = vkCreateDescriptorSetLayout(demo->device, &descriptor_layout, NULL, &demo->desc_layout);
1821 const VkPipelineLayoutCreateInfo pPipelineLayoutCreateInfo = {
1822 .sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,
1824 .setLayoutCount = 1,
1825 .pSetLayouts = &demo->desc_layout,
1828 err = vkCreatePipelineLayout(demo->device, &pPipelineLayoutCreateInfo, NULL, &demo->pipeline_layout);
1832 static void demo_prepare_render_pass(struct demo *demo) {
1833 // The initial layout for the color and depth attachments will be LAYOUT_UNDEFINED
1834 // because at the start of the renderpass, we don't care about their contents.
1835 // At the start of the subpass, the color attachment's layout will be transitioned
1836 // to LAYOUT_COLOR_ATTACHMENT_OPTIMAL and the depth stencil attachment's layout
1837 // will be transitioned to LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL. At the end of
1838 // the renderpass, the color attachment's layout will be transitioned to
1839 // LAYOUT_PRESENT_SRC_KHR to be ready to present. This is all done as part of
1840 // the renderpass, no barriers are necessary.
1841 const VkAttachmentDescription attachments[2] = {
1844 .format = demo->format,
1846 .samples = VK_SAMPLE_COUNT_1_BIT,
1847 .loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR,
1848 .storeOp = VK_ATTACHMENT_STORE_OP_STORE,
1849 .stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE,
1850 .stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE,
1851 .initialLayout = VK_IMAGE_LAYOUT_UNDEFINED,
1852 .finalLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR,
1856 .format = demo->depth.format,
1858 .samples = VK_SAMPLE_COUNT_1_BIT,
1859 .loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR,
1860 .storeOp = VK_ATTACHMENT_STORE_OP_DONT_CARE,
1861 .stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE,
1862 .stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE,
1863 .initialLayout = VK_IMAGE_LAYOUT_UNDEFINED,
1864 .finalLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
1867 const VkAttachmentReference color_reference = {
1869 .layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
1871 const VkAttachmentReference depth_reference = {
1873 .layout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
1875 const VkSubpassDescription subpass = {
1876 .pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS,
1878 .inputAttachmentCount = 0,
1879 .pInputAttachments = NULL,
1880 .colorAttachmentCount = 1,
1881 .pColorAttachments = &color_reference,
1882 .pResolveAttachments = NULL,
1883 .pDepthStencilAttachment = &depth_reference,
1884 .preserveAttachmentCount = 0,
1885 .pPreserveAttachments = NULL,
1887 const VkRenderPassCreateInfo rp_info = {
1888 .sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO,
1891 .attachmentCount = 2,
1892 .pAttachments = attachments,
1894 .pSubpasses = &subpass,
1895 .dependencyCount = 0,
1896 .pDependencies = NULL,
1898 VkResult U_ASSERT_ONLY err;
1900 err = vkCreateRenderPass(demo->device, &rp_info, NULL, &demo->render_pass);
1904 static VkShaderModule demo_prepare_shader_module(struct demo *demo, const uint32_t *code, size_t size) {
1905 VkShaderModule module;
1906 VkShaderModuleCreateInfo moduleCreateInfo;
1907 VkResult U_ASSERT_ONLY err;
1909 moduleCreateInfo.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
1910 moduleCreateInfo.pNext = NULL;
1911 moduleCreateInfo.flags = 0;
1912 moduleCreateInfo.codeSize = size;
1913 moduleCreateInfo.pCode = code;
1915 err = vkCreateShaderModule(demo->device, &moduleCreateInfo, NULL, &module);
1921 static void demo_prepare_vs(struct demo *demo) {
1922 const uint32_t vs_code[] = {
1923 #include "cube.vert.inc"
1925 demo->vert_shader_module = demo_prepare_shader_module(demo, vs_code, sizeof(vs_code));
1928 static void demo_prepare_fs(struct demo *demo) {
1929 const uint32_t fs_code[] = {
1930 #include "cube.frag.inc"
1932 demo->frag_shader_module = demo_prepare_shader_module(demo, fs_code, sizeof(fs_code));
1935 static void demo_prepare_pipeline(struct demo *demo) {
1936 VkGraphicsPipelineCreateInfo pipeline;
1937 VkPipelineCacheCreateInfo pipelineCache;
1938 VkPipelineVertexInputStateCreateInfo vi;
1939 VkPipelineInputAssemblyStateCreateInfo ia;
1940 VkPipelineRasterizationStateCreateInfo rs;
1941 VkPipelineColorBlendStateCreateInfo cb;
1942 VkPipelineDepthStencilStateCreateInfo ds;
1943 VkPipelineViewportStateCreateInfo vp;
1944 VkPipelineMultisampleStateCreateInfo ms;
1945 VkDynamicState dynamicStateEnables[VK_DYNAMIC_STATE_RANGE_SIZE];
1946 VkPipelineDynamicStateCreateInfo dynamicState;
1947 VkResult U_ASSERT_ONLY err;
1949 memset(dynamicStateEnables, 0, sizeof dynamicStateEnables);
1950 memset(&dynamicState, 0, sizeof dynamicState);
1951 dynamicState.sType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO;
1952 dynamicState.pDynamicStates = dynamicStateEnables;
1954 memset(&pipeline, 0, sizeof(pipeline));
1955 pipeline.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO;
1956 pipeline.layout = demo->pipeline_layout;
1958 memset(&vi, 0, sizeof(vi));
1959 vi.sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO;
1961 memset(&ia, 0, sizeof(ia));
1962 ia.sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO;
1963 ia.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
1965 memset(&rs, 0, sizeof(rs));
1966 rs.sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO;
1967 rs.polygonMode = VK_POLYGON_MODE_FILL;
1968 rs.cullMode = VK_CULL_MODE_BACK_BIT;
1969 rs.frontFace = VK_FRONT_FACE_COUNTER_CLOCKWISE;
1970 rs.depthClampEnable = VK_FALSE;
1971 rs.rasterizerDiscardEnable = VK_FALSE;
1972 rs.depthBiasEnable = VK_FALSE;
1973 rs.lineWidth = 1.0f;
1975 memset(&cb, 0, sizeof(cb));
1976 cb.sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO;
1977 VkPipelineColorBlendAttachmentState att_state[1];
1978 memset(att_state, 0, sizeof(att_state));
1979 att_state[0].colorWriteMask = 0xf;
1980 att_state[0].blendEnable = VK_FALSE;
1981 cb.attachmentCount = 1;
1982 cb.pAttachments = att_state;
1984 memset(&vp, 0, sizeof(vp));
1985 vp.sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO;
1986 vp.viewportCount = 1;
1987 dynamicStateEnables[dynamicState.dynamicStateCount++] = VK_DYNAMIC_STATE_VIEWPORT;
1988 vp.scissorCount = 1;
1989 dynamicStateEnables[dynamicState.dynamicStateCount++] = VK_DYNAMIC_STATE_SCISSOR;
1991 memset(&ds, 0, sizeof(ds));
1992 ds.sType = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO;
1993 ds.depthTestEnable = VK_TRUE;
1994 ds.depthWriteEnable = VK_TRUE;
1995 ds.depthCompareOp = VK_COMPARE_OP_LESS_OR_EQUAL;
1996 ds.depthBoundsTestEnable = VK_FALSE;
1997 ds.back.failOp = VK_STENCIL_OP_KEEP;
1998 ds.back.passOp = VK_STENCIL_OP_KEEP;
1999 ds.back.compareOp = VK_COMPARE_OP_ALWAYS;
2000 ds.stencilTestEnable = VK_FALSE;
2003 memset(&ms, 0, sizeof(ms));
2004 ms.sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO;
2005 ms.pSampleMask = NULL;
2006 ms.rasterizationSamples = VK_SAMPLE_COUNT_1_BIT;
2008 demo_prepare_vs(demo);
2009 demo_prepare_fs(demo);
2011 // Two stages: vs and fs
2012 VkPipelineShaderStageCreateInfo shaderStages[2];
2013 memset(&shaderStages, 0, 2 * sizeof(VkPipelineShaderStageCreateInfo));
2015 shaderStages[0].sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
2016 shaderStages[0].stage = VK_SHADER_STAGE_VERTEX_BIT;
2017 shaderStages[0].module = demo->vert_shader_module;
2018 shaderStages[0].pName = "main";
2020 shaderStages[1].sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
2021 shaderStages[1].stage = VK_SHADER_STAGE_FRAGMENT_BIT;
2022 shaderStages[1].module = demo->frag_shader_module;
2023 shaderStages[1].pName = "main";
2025 memset(&pipelineCache, 0, sizeof(pipelineCache));
2026 pipelineCache.sType = VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO;
2028 err = vkCreatePipelineCache(demo->device, &pipelineCache, NULL, &demo->pipelineCache);
2031 pipeline.pVertexInputState = &vi;
2032 pipeline.pInputAssemblyState = &ia;
2033 pipeline.pRasterizationState = &rs;
2034 pipeline.pColorBlendState = &cb;
2035 pipeline.pMultisampleState = &ms;
2036 pipeline.pViewportState = &vp;
2037 pipeline.pDepthStencilState = &ds;
2038 pipeline.stageCount = ARRAY_SIZE(shaderStages);
2039 pipeline.pStages = shaderStages;
2040 pipeline.renderPass = demo->render_pass;
2041 pipeline.pDynamicState = &dynamicState;
2043 pipeline.renderPass = demo->render_pass;
2045 err = vkCreateGraphicsPipelines(demo->device, demo->pipelineCache, 1, &pipeline, NULL, &demo->pipeline);
2048 vkDestroyShaderModule(demo->device, demo->frag_shader_module, NULL);
2049 vkDestroyShaderModule(demo->device, demo->vert_shader_module, NULL);
2052 static void demo_prepare_descriptor_pool(struct demo *demo) {
2053 const VkDescriptorPoolSize type_counts[2] = {
2056 .type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
2057 .descriptorCount = demo->swapchainImageCount,
2061 .type = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
2062 .descriptorCount = demo->swapchainImageCount * DEMO_TEXTURE_COUNT,
2065 const VkDescriptorPoolCreateInfo descriptor_pool = {
2066 .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO,
2068 .maxSets = demo->swapchainImageCount,
2070 .pPoolSizes = type_counts,
2072 VkResult U_ASSERT_ONLY err;
2074 err = vkCreateDescriptorPool(demo->device, &descriptor_pool, NULL, &demo->desc_pool);
2078 static void demo_prepare_descriptor_set(struct demo *demo) {
2079 VkDescriptorImageInfo tex_descs[DEMO_TEXTURE_COUNT];
2080 VkWriteDescriptorSet writes[2];
2081 VkResult U_ASSERT_ONLY err;
2083 VkDescriptorSetAllocateInfo alloc_info = {.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO,
2085 .descriptorPool = demo->desc_pool,
2086 .descriptorSetCount = 1,
2087 .pSetLayouts = &demo->desc_layout};
2089 VkDescriptorBufferInfo buffer_info;
2090 buffer_info.offset = 0;
2091 buffer_info.range = sizeof(struct vktexcube_vs_uniform);
2093 memset(&tex_descs, 0, sizeof(tex_descs));
2094 for (unsigned int i = 0; i < DEMO_TEXTURE_COUNT; i++) {
2095 tex_descs[i].sampler = demo->textures[i].sampler;
2096 tex_descs[i].imageView = demo->textures[i].view;
2097 tex_descs[i].imageLayout = VK_IMAGE_LAYOUT_GENERAL;
2100 memset(&writes, 0, sizeof(writes));
2102 writes[0].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
2103 writes[0].descriptorCount = 1;
2104 writes[0].descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
2105 writes[0].pBufferInfo = &buffer_info;
2107 writes[1].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
2108 writes[1].dstBinding = 1;
2109 writes[1].descriptorCount = DEMO_TEXTURE_COUNT;
2110 writes[1].descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
2111 writes[1].pImageInfo = tex_descs;
2113 for (unsigned int i = 0; i < demo->swapchainImageCount; i++) {
2114 err = vkAllocateDescriptorSets(demo->device, &alloc_info, &demo->swapchain_image_resources[i].descriptor_set);
2116 buffer_info.buffer = demo->swapchain_image_resources[i].uniform_buffer;
2117 writes[0].dstSet = demo->swapchain_image_resources[i].descriptor_set;
2118 writes[1].dstSet = demo->swapchain_image_resources[i].descriptor_set;
2119 vkUpdateDescriptorSets(demo->device, 2, writes, 0, NULL);
2123 static void demo_prepare_framebuffers(struct demo *demo) {
2124 VkImageView attachments[2];
2125 attachments[1] = demo->depth.view;
2127 const VkFramebufferCreateInfo fb_info = {
2128 .sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO,
2130 .renderPass = demo->render_pass,
2131 .attachmentCount = 2,
2132 .pAttachments = attachments,
2133 .width = demo->width,
2134 .height = demo->height,
2137 VkResult U_ASSERT_ONLY err;
2140 for (i = 0; i < demo->swapchainImageCount; i++) {
2141 attachments[0] = demo->swapchain_image_resources[i].view;
2142 err = vkCreateFramebuffer(demo->device, &fb_info, NULL, &demo->swapchain_image_resources[i].framebuffer);
2147 static void demo_prepare(struct demo *demo) {
2148 VkResult U_ASSERT_ONLY err;
2149 if (demo->cmd_pool == VK_NULL_HANDLE) {
2150 const VkCommandPoolCreateInfo cmd_pool_info = {
2151 .sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,
2153 .queueFamilyIndex = demo->graphics_queue_family_index,
2156 err = vkCreateCommandPool(demo->device, &cmd_pool_info, NULL, &demo->cmd_pool);
2160 const VkCommandBufferAllocateInfo cmd = {
2161 .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,
2163 .commandPool = demo->cmd_pool,
2164 .level = VK_COMMAND_BUFFER_LEVEL_PRIMARY,
2165 .commandBufferCount = 1,
2167 err = vkAllocateCommandBuffers(demo->device, &cmd, &demo->cmd);
2169 VkCommandBufferBeginInfo cmd_buf_info = {
2170 .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
2173 .pInheritanceInfo = NULL,
2175 err = vkBeginCommandBuffer(demo->cmd, &cmd_buf_info);
2178 demo_prepare_buffers(demo);
2180 if (demo->is_minimized) {
2181 demo->prepared = false;
2185 demo_prepare_depth(demo);
2186 demo_prepare_textures(demo);
2187 demo_prepare_cube_data_buffers(demo);
2189 demo_prepare_descriptor_layout(demo);
2190 demo_prepare_render_pass(demo);
2191 demo_prepare_pipeline(demo);
2193 for (uint32_t i = 0; i < demo->swapchainImageCount; i++) {
2194 err = vkAllocateCommandBuffers(demo->device, &cmd, &demo->swapchain_image_resources[i].cmd);
2198 if (demo->separate_present_queue) {
2199 const VkCommandPoolCreateInfo present_cmd_pool_info = {
2200 .sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,
2202 .queueFamilyIndex = demo->present_queue_family_index,
2205 err = vkCreateCommandPool(demo->device, &present_cmd_pool_info, NULL, &demo->present_cmd_pool);
2207 const VkCommandBufferAllocateInfo present_cmd_info = {
2208 .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,
2210 .commandPool = demo->present_cmd_pool,
2211 .level = VK_COMMAND_BUFFER_LEVEL_PRIMARY,
2212 .commandBufferCount = 1,
2214 for (uint32_t i = 0; i < demo->swapchainImageCount; i++) {
2215 err = vkAllocateCommandBuffers(demo->device, &present_cmd_info,
2216 &demo->swapchain_image_resources[i].graphics_to_present_cmd);
2218 demo_build_image_ownership_cmd(demo, i);
2222 demo_prepare_descriptor_pool(demo);
2223 demo_prepare_descriptor_set(demo);
2225 demo_prepare_framebuffers(demo);
2227 for (uint32_t i = 0; i < demo->swapchainImageCount; i++) {
2228 demo->current_buffer = i;
2229 demo_draw_build_cmd(demo, demo->swapchain_image_resources[i].cmd);
2233 * Prepare functions above may generate pipeline commands
2234 * that need to be flushed before beginning the render loop.
2236 demo_flush_init_cmd(demo);
2237 if (demo->staging_texture.image) {
2238 demo_destroy_texture_image(demo, &demo->staging_texture);
2241 demo->current_buffer = 0;
2242 demo->prepared = true;
2245 static void demo_cleanup(struct demo *demo) {
2248 demo->prepared = false;
2249 vkDeviceWaitIdle(demo->device);
2251 // Wait for fences from present operations
2252 for (i = 0; i < FRAME_LAG; i++) {
2253 vkWaitForFences(demo->device, 1, &demo->fences[i], VK_TRUE, UINT64_MAX);
2254 vkDestroyFence(demo->device, demo->fences[i], NULL);
2255 vkDestroySemaphore(demo->device, demo->image_acquired_semaphores[i], NULL);
2256 vkDestroySemaphore(demo->device, demo->draw_complete_semaphores[i], NULL);
2257 if (demo->separate_present_queue) {
2258 vkDestroySemaphore(demo->device, demo->image_ownership_semaphores[i], NULL);
2262 // If the window is currently minimized, demo_resize has already done some cleanup for us.
2263 if (!demo->is_minimized) {
2264 for (i = 0; i < demo->swapchainImageCount; i++) {
2265 vkDestroyFramebuffer(demo->device, demo->swapchain_image_resources[i].framebuffer, NULL);
2267 vkDestroyDescriptorPool(demo->device, demo->desc_pool, NULL);
2269 vkDestroyPipeline(demo->device, demo->pipeline, NULL);
2270 vkDestroyPipelineCache(demo->device, demo->pipelineCache, NULL);
2271 vkDestroyRenderPass(demo->device, demo->render_pass, NULL);
2272 vkDestroyPipelineLayout(demo->device, demo->pipeline_layout, NULL);
2273 vkDestroyDescriptorSetLayout(demo->device, demo->desc_layout, NULL);
2275 for (i = 0; i < DEMO_TEXTURE_COUNT; i++) {
2276 vkDestroyImageView(demo->device, demo->textures[i].view, NULL);
2277 vkDestroyImage(demo->device, demo->textures[i].image, NULL);
2278 vkFreeMemory(demo->device, demo->textures[i].mem, NULL);
2279 vkDestroySampler(demo->device, demo->textures[i].sampler, NULL);
2281 demo->fpDestroySwapchainKHR(demo->device, demo->swapchain, NULL);
2283 vkDestroyImageView(demo->device, demo->depth.view, NULL);
2284 vkDestroyImage(demo->device, demo->depth.image, NULL);
2285 vkFreeMemory(demo->device, demo->depth.mem, NULL);
2287 for (i = 0; i < demo->swapchainImageCount; i++) {
2288 vkDestroyImageView(demo->device, demo->swapchain_image_resources[i].view, NULL);
2289 vkFreeCommandBuffers(demo->device, demo->cmd_pool, 1, &demo->swapchain_image_resources[i].cmd);
2290 vkDestroyBuffer(demo->device, demo->swapchain_image_resources[i].uniform_buffer, NULL);
2291 vkFreeMemory(demo->device, demo->swapchain_image_resources[i].uniform_memory, NULL);
2293 free(demo->swapchain_image_resources);
2294 free(demo->queue_props);
2295 vkDestroyCommandPool(demo->device, demo->cmd_pool, NULL);
2297 if (demo->separate_present_queue) {
2298 vkDestroyCommandPool(demo->device, demo->present_cmd_pool, NULL);
2301 vkDeviceWaitIdle(demo->device);
2302 vkDestroyDevice(demo->device, NULL);
2303 if (demo->validate) {
2304 demo->DestroyDebugUtilsMessengerEXT(demo->inst, demo->dbg_messenger, NULL);
2306 vkDestroySurfaceKHR(demo->inst, demo->surface, NULL);
2308 #if defined(VK_USE_PLATFORM_XLIB_KHR)
2309 XDestroyWindow(demo->display, demo->xlib_window);
2310 XCloseDisplay(demo->display);
2311 #elif defined(VK_USE_PLATFORM_XCB_KHR)
2312 xcb_destroy_window(demo->connection, demo->xcb_window);
2313 xcb_disconnect(demo->connection);
2314 free(demo->atom_wm_delete_window);
2315 #elif defined(VK_USE_PLATFORM_WAYLAND_KHR)
2316 wl_keyboard_destroy(demo->keyboard);
2317 wl_pointer_destroy(demo->pointer);
2318 wl_seat_destroy(demo->seat);
2319 wl_shell_surface_destroy(demo->shell_surface);
2320 wl_surface_destroy(demo->window);
2321 wl_shell_destroy(demo->shell);
2322 wl_compositor_destroy(demo->compositor);
2323 wl_registry_destroy(demo->registry);
2324 wl_display_disconnect(demo->display);
2325 #elif defined(VK_USE_PLATFORM_MIR_KHR)
2328 vkDestroyInstance(demo->inst, NULL);
2331 static void demo_resize(struct demo *demo) {
2334 // Don't react to resize until after first initialization.
2335 if (!demo->prepared) {
2336 if (demo->is_minimized) {
2341 // In order to properly resize the window, we must re-create the swapchain
2342 // AND redo the command buffers, etc.
2344 // First, perform part of the demo_cleanup() function:
2345 demo->prepared = false;
2346 vkDeviceWaitIdle(demo->device);
2348 for (i = 0; i < demo->swapchainImageCount; i++) {
2349 vkDestroyFramebuffer(demo->device, demo->swapchain_image_resources[i].framebuffer, NULL);
2351 vkDestroyDescriptorPool(demo->device, demo->desc_pool, NULL);
2353 vkDestroyPipeline(demo->device, demo->pipeline, NULL);
2354 vkDestroyPipelineCache(demo->device, demo->pipelineCache, NULL);
2355 vkDestroyRenderPass(demo->device, demo->render_pass, NULL);
2356 vkDestroyPipelineLayout(demo->device, demo->pipeline_layout, NULL);
2357 vkDestroyDescriptorSetLayout(demo->device, demo->desc_layout, NULL);
2359 for (i = 0; i < DEMO_TEXTURE_COUNT; i++) {
2360 vkDestroyImageView(demo->device, demo->textures[i].view, NULL);
2361 vkDestroyImage(demo->device, demo->textures[i].image, NULL);
2362 vkFreeMemory(demo->device, demo->textures[i].mem, NULL);
2363 vkDestroySampler(demo->device, demo->textures[i].sampler, NULL);
2366 vkDestroyImageView(demo->device, demo->depth.view, NULL);
2367 vkDestroyImage(demo->device, demo->depth.image, NULL);
2368 vkFreeMemory(demo->device, demo->depth.mem, NULL);
2370 for (i = 0; i < demo->swapchainImageCount; i++) {
2371 vkDestroyImageView(demo->device, demo->swapchain_image_resources[i].view, NULL);
2372 vkFreeCommandBuffers(demo->device, demo->cmd_pool, 1, &demo->swapchain_image_resources[i].cmd);
2373 vkDestroyBuffer(demo->device, demo->swapchain_image_resources[i].uniform_buffer, NULL);
2374 vkFreeMemory(demo->device, demo->swapchain_image_resources[i].uniform_memory, NULL);
2376 vkDestroyCommandPool(demo->device, demo->cmd_pool, NULL);
2377 demo->cmd_pool = VK_NULL_HANDLE;
2378 if (demo->separate_present_queue) {
2379 vkDestroyCommandPool(demo->device, demo->present_cmd_pool, NULL);
2381 free(demo->swapchain_image_resources);
2383 // Second, re-perform the demo_prepare() function, which will re-create the
2388 // On MS-Windows, make this a global, so it's available to WndProc()
2391 #if defined(VK_USE_PLATFORM_WIN32_KHR)
2392 static void demo_run(struct demo *demo) {
2393 if (!demo->prepared) return;
2397 if (demo->frameCount != INT_MAX && demo->curFrame == demo->frameCount) {
2398 PostQuitMessage(validation_error);
2402 // MS-Windows event handling function:
2403 LRESULT CALLBACK WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam) {
2406 PostQuitMessage(validation_error);
2409 // The validation callback calls MessageBox which can generate paint
2410 // events - don't make more Vulkan calls if we got here from the
2416 case WM_GETMINMAXINFO: // set window's minimum size
2417 ((MINMAXINFO *)lParam)->ptMinTrackSize = demo.minsize;
2420 // Resize the application to the new window size, except when
2421 // it was minimized. Vulkan doesn't support images or swapchains
2422 // with width=0 and height=0.
2423 if (wParam != SIZE_MINIMIZED) {
2424 demo.width = lParam & 0xffff;
2425 demo.height = (lParam & 0xffff0000) >> 16;
2432 return (DefWindowProc(hWnd, uMsg, wParam, lParam));
2435 static void demo_create_window(struct demo *demo) {
2436 WNDCLASSEX win_class;
2438 // Initialize the window class structure:
2439 win_class.cbSize = sizeof(WNDCLASSEX);
2440 win_class.style = CS_HREDRAW | CS_VREDRAW;
2441 win_class.lpfnWndProc = WndProc;
2442 win_class.cbClsExtra = 0;
2443 win_class.cbWndExtra = 0;
2444 win_class.hInstance = demo->connection; // hInstance
2445 win_class.hIcon = LoadIcon(NULL, IDI_APPLICATION);
2446 win_class.hCursor = LoadCursor(NULL, IDC_ARROW);
2447 win_class.hbrBackground = (HBRUSH)GetStockObject(WHITE_BRUSH);
2448 win_class.lpszMenuName = NULL;
2449 win_class.lpszClassName = demo->name;
2450 win_class.hIconSm = LoadIcon(NULL, IDI_WINLOGO);
2451 // Register window class:
2452 if (!RegisterClassEx(&win_class)) {
2453 // It didn't work, so try to give a useful error:
2454 printf("Unexpected error trying to start the application!\n");
2458 // Create window with the registered class:
2459 RECT wr = {0, 0, demo->width, demo->height};
2460 AdjustWindowRect(&wr, WS_OVERLAPPEDWINDOW, FALSE);
2461 demo->window = CreateWindowEx(0,
2462 demo->name, // class name
2463 demo->name, // app name
2464 WS_OVERLAPPEDWINDOW | // window style
2465 WS_VISIBLE | WS_SYSMENU,
2466 100, 100, // x/y coords
2467 wr.right - wr.left, // width
2468 wr.bottom - wr.top, // height
2469 NULL, // handle to parent
2470 NULL, // handle to menu
2471 demo->connection, // hInstance
2472 NULL); // no extra parameters
2473 if (!demo->window) {
2474 // It didn't work, so try to give a useful error:
2475 printf("Cannot create a window in which to draw!\n");
2479 // Window client area size must be at least 1 pixel high, to prevent crash.
2480 demo->minsize.x = GetSystemMetrics(SM_CXMINTRACK);
2481 demo->minsize.y = GetSystemMetrics(SM_CYMINTRACK) + 1;
2483 #elif defined(VK_USE_PLATFORM_XLIB_KHR)
2484 static void demo_create_xlib_window(struct demo *demo) {
2485 const char *display_envar = getenv("DISPLAY");
2486 if (display_envar == NULL || display_envar[0] == '\0') {
2487 printf("Environment variable DISPLAY requires a valid value.\nExiting ...\n");
2493 demo->display = XOpenDisplay(NULL);
2494 long visualMask = VisualScreenMask;
2495 int numberOfVisuals;
2496 XVisualInfo vInfoTemplate = {};
2497 vInfoTemplate.screen = DefaultScreen(demo->display);
2498 XVisualInfo *visualInfo = XGetVisualInfo(demo->display, visualMask, &vInfoTemplate, &numberOfVisuals);
2501 XCreateColormap(demo->display, RootWindow(demo->display, vInfoTemplate.screen), visualInfo->visual, AllocNone);
2503 XSetWindowAttributes windowAttributes = {};
2504 windowAttributes.colormap = colormap;
2505 windowAttributes.background_pixel = 0xFFFFFFFF;
2506 windowAttributes.border_pixel = 0;
2507 windowAttributes.event_mask = KeyPressMask | KeyReleaseMask | StructureNotifyMask | ExposureMask;
2509 demo->xlib_window = XCreateWindow(demo->display, RootWindow(demo->display, vInfoTemplate.screen), 0, 0, demo->width,
2510 demo->height, 0, visualInfo->depth, InputOutput, visualInfo->visual,
2511 CWBackPixel | CWBorderPixel | CWEventMask | CWColormap, &windowAttributes);
2513 XSelectInput(demo->display, demo->xlib_window, ExposureMask | KeyPressMask);
2514 XMapWindow(demo->display, demo->xlib_window);
2515 XFlush(demo->display);
2516 demo->xlib_wm_delete_window = XInternAtom(demo->display, "WM_DELETE_WINDOW", False);
2518 static void demo_handle_xlib_event(struct demo *demo, const XEvent *event) {
2519 switch (event->type) {
2521 if ((Atom)event->xclient.data.l[0] == demo->xlib_wm_delete_window) demo->quit = true;
2524 switch (event->xkey.keycode) {
2528 case 0x71: // left arrow key
2529 demo->spin_angle -= demo->spin_increment;
2531 case 0x72: // right arrow key
2532 demo->spin_angle += demo->spin_increment;
2534 case 0x41: // space bar
2535 demo->pause = !demo->pause;
2539 case ConfigureNotify:
2540 if ((demo->width != event->xconfigure.width) || (demo->height != event->xconfigure.height)) {
2541 demo->width = event->xconfigure.width;
2542 demo->height = event->xconfigure.height;
2551 static void demo_run_xlib(struct demo *demo) {
2552 while (!demo->quit) {
2556 XNextEvent(demo->display, &event);
2557 demo_handle_xlib_event(demo, &event);
2559 while (XPending(demo->display) > 0) {
2560 XNextEvent(demo->display, &event);
2561 demo_handle_xlib_event(demo, &event);
2566 if (demo->frameCount != INT32_MAX && demo->curFrame == demo->frameCount) demo->quit = true;
2569 #elif defined(VK_USE_PLATFORM_XCB_KHR)
2570 static void demo_handle_xcb_event(struct demo *demo, const xcb_generic_event_t *event) {
2571 uint8_t event_code = event->response_type & 0x7f;
2572 switch (event_code) {
2574 // TODO: Resize window
2576 case XCB_CLIENT_MESSAGE:
2577 if ((*(xcb_client_message_event_t *)event).data.data32[0] == (*demo->atom_wm_delete_window).atom) {
2581 case XCB_KEY_RELEASE: {
2582 const xcb_key_release_event_t *key = (const xcb_key_release_event_t *)event;
2584 switch (key->detail) {
2588 case 0x71: // left arrow key
2589 demo->spin_angle -= demo->spin_increment;
2591 case 0x72: // right arrow key
2592 demo->spin_angle += demo->spin_increment;
2594 case 0x41: // space bar
2595 demo->pause = !demo->pause;
2599 case XCB_CONFIGURE_NOTIFY: {
2600 const xcb_configure_notify_event_t *cfg = (const xcb_configure_notify_event_t *)event;
2601 if ((demo->width != cfg->width) || (demo->height != cfg->height)) {
2602 demo->width = cfg->width;
2603 demo->height = cfg->height;
2612 static void demo_run_xcb(struct demo *demo) {
2613 xcb_flush(demo->connection);
2615 while (!demo->quit) {
2616 xcb_generic_event_t *event;
2619 event = xcb_wait_for_event(demo->connection);
2621 event = xcb_poll_for_event(demo->connection);
2624 demo_handle_xcb_event(demo, event);
2626 event = xcb_poll_for_event(demo->connection);
2631 if (demo->frameCount != INT32_MAX && demo->curFrame == demo->frameCount) demo->quit = true;
2635 static void demo_create_xcb_window(struct demo *demo) {
2636 uint32_t value_mask, value_list[32];
2638 demo->xcb_window = xcb_generate_id(demo->connection);
2640 value_mask = XCB_CW_BACK_PIXEL | XCB_CW_EVENT_MASK;
2641 value_list[0] = demo->screen->black_pixel;
2642 value_list[1] = XCB_EVENT_MASK_KEY_RELEASE | XCB_EVENT_MASK_EXPOSURE | XCB_EVENT_MASK_STRUCTURE_NOTIFY;
2644 xcb_create_window(demo->connection, XCB_COPY_FROM_PARENT, demo->xcb_window, demo->screen->root, 0, 0, demo->width, demo->height,
2645 0, XCB_WINDOW_CLASS_INPUT_OUTPUT, demo->screen->root_visual, value_mask, value_list);
2647 /* Magic code that will send notification when window is destroyed */
2648 xcb_intern_atom_cookie_t cookie = xcb_intern_atom(demo->connection, 1, 12, "WM_PROTOCOLS");
2649 xcb_intern_atom_reply_t *reply = xcb_intern_atom_reply(demo->connection, cookie, 0);
2651 xcb_intern_atom_cookie_t cookie2 = xcb_intern_atom(demo->connection, 0, 16, "WM_DELETE_WINDOW");
2652 demo->atom_wm_delete_window = xcb_intern_atom_reply(demo->connection, cookie2, 0);
2654 xcb_change_property(demo->connection, XCB_PROP_MODE_REPLACE, demo->xcb_window, (*reply).atom, 4, 32, 1,
2655 &(*demo->atom_wm_delete_window).atom);
2658 xcb_map_window(demo->connection, demo->xcb_window);
2660 // Force the x/y coordinates to 100,100 results are identical in consecutive
2662 const uint32_t coords[] = {100, 100};
2663 xcb_configure_window(demo->connection, demo->xcb_window, XCB_CONFIG_WINDOW_X | XCB_CONFIG_WINDOW_Y, coords);
2665 // VK_USE_PLATFORM_XCB_KHR
2666 #elif defined(VK_USE_PLATFORM_WAYLAND_KHR)
2667 static void demo_run(struct demo *demo) {
2668 while (!demo->quit) {
2670 wl_display_dispatch(demo->display); // block and wait for input
2672 wl_display_dispatch_pending(demo->display); // don't block
2675 if (demo->frameCount != INT32_MAX && demo->curFrame == demo->frameCount) demo->quit = true;
2680 static void handle_ping(void *data UNUSED, struct wl_shell_surface *shell_surface, uint32_t serial) {
2681 wl_shell_surface_pong(shell_surface, serial);
2684 static void handle_configure(void *data UNUSED, struct wl_shell_surface *shell_surface UNUSED, uint32_t edges UNUSED,
2685 int32_t width UNUSED, int32_t height UNUSED) {}
2687 static void handle_popup_done(void *data UNUSED, struct wl_shell_surface *shell_surface UNUSED) {}
2689 static const struct wl_shell_surface_listener shell_surface_listener = {handle_ping, handle_configure, handle_popup_done};
2691 static void demo_create_window(struct demo *demo) {
2692 demo->window = wl_compositor_create_surface(demo->compositor);
2693 if (!demo->window) {
2694 printf("Can not create wayland_surface from compositor!\n");
2699 demo->shell_surface = wl_shell_get_shell_surface(demo->shell, demo->window);
2700 if (!demo->shell_surface) {
2701 printf("Can not get shell_surface from wayland_surface!\n");
2705 wl_shell_surface_add_listener(demo->shell_surface, &shell_surface_listener, demo);
2706 wl_shell_surface_set_toplevel(demo->shell_surface);
2707 wl_shell_surface_set_title(demo->shell_surface, APP_SHORT_NAME);
2709 #elif defined(VK_USE_PLATFORM_ANDROID_KHR)
2710 static void demo_run(struct demo *demo) {
2711 if (!demo->prepared) return;
2716 #elif defined(VK_USE_PLATFORM_MACOS_MVK)
2717 static void demo_run(struct demo *demo) {
2720 if (demo->frameCount != INT32_MAX && demo->curFrame == demo->frameCount) {
2724 #elif defined(VK_USE_PLATFORM_MIR_KHR)
2725 #elif defined(VK_USE_PLATFORM_DISPLAY_KHR)
2726 static VkResult demo_create_display_surface(struct demo *demo) {
2727 VkResult U_ASSERT_ONLY err;
2728 uint32_t display_count;
2729 uint32_t mode_count;
2730 uint32_t plane_count;
2731 VkDisplayPropertiesKHR display_props;
2732 VkDisplayKHR display;
2733 VkDisplayModePropertiesKHR mode_props;
2734 VkDisplayPlanePropertiesKHR *plane_props;
2735 VkBool32 found_plane = VK_FALSE;
2736 uint32_t plane_index;
2737 VkExtent2D image_extent;
2738 VkDisplaySurfaceCreateInfoKHR create_info;
2740 // Get the first display
2741 err = vkGetPhysicalDeviceDisplayPropertiesKHR(demo->gpu, &display_count, NULL);
2744 if (display_count == 0) {
2745 printf("Cannot find any display!\n");
2751 err = vkGetPhysicalDeviceDisplayPropertiesKHR(demo->gpu, &display_count, &display_props);
2752 assert(!err || (err == VK_INCOMPLETE));
2754 display = display_props.display;
2756 // Get the first mode of the display
2757 err = vkGetDisplayModePropertiesKHR(demo->gpu, display, &mode_count, NULL);
2760 if (mode_count == 0) {
2761 printf("Cannot find any mode for the display!\n");
2767 err = vkGetDisplayModePropertiesKHR(demo->gpu, display, &mode_count, &mode_props);
2768 assert(!err || (err == VK_INCOMPLETE));
2770 // Get the list of planes
2771 err = vkGetPhysicalDeviceDisplayPlanePropertiesKHR(demo->gpu, &plane_count, NULL);
2774 if (plane_count == 0) {
2775 printf("Cannot find any plane!\n");
2780 plane_props = malloc(sizeof(VkDisplayPlanePropertiesKHR) * plane_count);
2781 assert(plane_props);
2783 err = vkGetPhysicalDeviceDisplayPlanePropertiesKHR(demo->gpu, &plane_count, plane_props);
2786 // Find a plane compatible with the display
2787 for (plane_index = 0; plane_index < plane_count; plane_index++) {
2788 uint32_t supported_count;
2789 VkDisplayKHR *supported_displays;
2791 // Disqualify planes that are bound to a different display
2792 if ((plane_props[plane_index].currentDisplay != VK_NULL_HANDLE) && (plane_props[plane_index].currentDisplay != display)) {
2796 err = vkGetDisplayPlaneSupportedDisplaysKHR(demo->gpu, plane_index, &supported_count, NULL);
2799 if (supported_count == 0) {
2803 supported_displays = malloc(sizeof(VkDisplayKHR) * supported_count);
2804 assert(supported_displays);
2806 err = vkGetDisplayPlaneSupportedDisplaysKHR(demo->gpu, plane_index, &supported_count, supported_displays);
2809 for (uint32_t i = 0; i < supported_count; i++) {
2810 if (supported_displays[i] == display) {
2811 found_plane = VK_TRUE;
2816 free(supported_displays);
2824 printf("Cannot find a plane compatible with the display!\n");
2831 VkDisplayPlaneCapabilitiesKHR planeCaps;
2832 vkGetDisplayPlaneCapabilitiesKHR(demo->gpu, mode_props.displayMode, plane_index, &planeCaps);
2833 // Find a supported alpha mode
2834 VkCompositeAlphaFlagBitsKHR alphaMode = VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR;
2835 VkCompositeAlphaFlagBitsKHR alphaModes[4] = {
2836 VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR,
2837 VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR,
2838 VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR,
2839 VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR,
2841 for (uint32_t i = 0; i < sizeof(alphaModes); i++) {
2842 if (planeCaps.supportedAlpha & alphaModes[i]) {
2843 alphaMode = alphaModes[i];
2847 image_extent.width = mode_props.parameters.visibleRegion.width;
2848 image_extent.height = mode_props.parameters.visibleRegion.height;
2850 create_info.sType = VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR;
2851 create_info.pNext = NULL;
2852 create_info.flags = 0;
2853 create_info.displayMode = mode_props.displayMode;
2854 create_info.planeIndex = plane_index;
2855 create_info.planeStackIndex = plane_props[plane_index].currentStackIndex;
2856 create_info.transform = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR;
2857 create_info.alphaMode = alphaMode;
2858 create_info.globalAlpha = 1.0f;
2859 create_info.imageExtent = image_extent;
2861 return vkCreateDisplayPlaneSurfaceKHR(demo->inst, &create_info, NULL, &demo->surface);
2864 static void demo_run_display(struct demo *demo) {
2865 while (!demo->quit) {
2869 if (demo->frameCount != INT32_MAX && demo->curFrame == demo->frameCount) {
2877 * Return 1 (true) if all layer names specified in check_names
2878 * can be found in given layer properties.
2880 static VkBool32 demo_check_layers(uint32_t check_count, char **check_names, uint32_t layer_count, VkLayerProperties *layers) {
2881 for (uint32_t i = 0; i < check_count; i++) {
2883 for (uint32_t j = 0; j < layer_count; j++) {
2884 if (!strcmp(check_names[i], layers[j].layerName)) {
2890 fprintf(stderr, "Cannot find layer: %s\n", check_names[i]);
2897 static void demo_init_vk(struct demo *demo) {
2899 uint32_t instance_extension_count = 0;
2900 uint32_t instance_layer_count = 0;
2901 uint32_t validation_layer_count = 0;
2902 char **instance_validation_layers = NULL;
2903 demo->enabled_extension_count = 0;
2904 demo->enabled_layer_count = 0;
2905 demo->is_minimized = false;
2906 demo->cmd_pool = VK_NULL_HANDLE;
2908 char *instance_validation_layers_alt1[] = {"VK_LAYER_LUNARG_standard_validation"};
2910 char *instance_validation_layers_alt2[] = {"VK_LAYER_GOOGLE_threading", "VK_LAYER_LUNARG_parameter_validation",
2911 "VK_LAYER_LUNARG_object_tracker", "VK_LAYER_LUNARG_core_validation",
2912 "VK_LAYER_GOOGLE_unique_objects"};
2914 /* Look for validation layers */
2915 VkBool32 validation_found = 0;
2916 if (demo->validate) {
2917 err = vkEnumerateInstanceLayerProperties(&instance_layer_count, NULL);
2920 instance_validation_layers = instance_validation_layers_alt1;
2921 if (instance_layer_count > 0) {
2922 VkLayerProperties *instance_layers = malloc(sizeof(VkLayerProperties) * instance_layer_count);
2923 err = vkEnumerateInstanceLayerProperties(&instance_layer_count, instance_layers);
2926 validation_found = demo_check_layers(ARRAY_SIZE(instance_validation_layers_alt1), instance_validation_layers,
2927 instance_layer_count, instance_layers);
2928 if (validation_found) {
2929 demo->enabled_layer_count = ARRAY_SIZE(instance_validation_layers_alt1);
2930 demo->enabled_layers[0] = "VK_LAYER_LUNARG_standard_validation";
2931 validation_layer_count = 1;
2933 // use alternative set of validation layers
2934 instance_validation_layers = instance_validation_layers_alt2;
2935 demo->enabled_layer_count = ARRAY_SIZE(instance_validation_layers_alt2);
2936 validation_found = demo_check_layers(ARRAY_SIZE(instance_validation_layers_alt2), instance_validation_layers,
2937 instance_layer_count, instance_layers);
2938 validation_layer_count = ARRAY_SIZE(instance_validation_layers_alt2);
2939 for (uint32_t i = 0; i < validation_layer_count; i++) {
2940 demo->enabled_layers[i] = instance_validation_layers[i];
2943 free(instance_layers);
2946 if (!validation_found) {
2948 "vkEnumerateInstanceLayerProperties failed to find required validation layer.\n\n"
2949 "Please look at the Getting Started guide for additional information.\n",
2950 "vkCreateInstance Failure");
2954 /* Look for instance extensions */
2955 VkBool32 surfaceExtFound = 0;
2956 VkBool32 platformSurfaceExtFound = 0;
2957 memset(demo->extension_names, 0, sizeof(demo->extension_names));
2959 err = vkEnumerateInstanceExtensionProperties(NULL, &instance_extension_count, NULL);
2962 if (instance_extension_count > 0) {
2963 VkExtensionProperties *instance_extensions = malloc(sizeof(VkExtensionProperties) * instance_extension_count);
2964 err = vkEnumerateInstanceExtensionProperties(NULL, &instance_extension_count, instance_extensions);
2966 for (uint32_t i = 0; i < instance_extension_count; i++) {
2967 if (!strcmp(VK_KHR_SURFACE_EXTENSION_NAME, instance_extensions[i].extensionName)) {
2968 surfaceExtFound = 1;
2969 demo->extension_names[demo->enabled_extension_count++] = VK_KHR_SURFACE_EXTENSION_NAME;
2971 #if defined(VK_USE_PLATFORM_WIN32_KHR)
2972 if (!strcmp(VK_KHR_WIN32_SURFACE_EXTENSION_NAME, instance_extensions[i].extensionName)) {
2973 platformSurfaceExtFound = 1;
2974 demo->extension_names[demo->enabled_extension_count++] = VK_KHR_WIN32_SURFACE_EXTENSION_NAME;
2976 #elif defined(VK_USE_PLATFORM_XLIB_KHR)
2977 if (!strcmp(VK_KHR_XLIB_SURFACE_EXTENSION_NAME, instance_extensions[i].extensionName)) {
2978 platformSurfaceExtFound = 1;
2979 demo->extension_names[demo->enabled_extension_count++] = VK_KHR_XLIB_SURFACE_EXTENSION_NAME;
2981 #elif defined(VK_USE_PLATFORM_XCB_KHR)
2982 if (!strcmp(VK_KHR_XCB_SURFACE_EXTENSION_NAME, instance_extensions[i].extensionName)) {
2983 platformSurfaceExtFound = 1;
2984 demo->extension_names[demo->enabled_extension_count++] = VK_KHR_XCB_SURFACE_EXTENSION_NAME;
2986 #elif defined(VK_USE_PLATFORM_WAYLAND_KHR)
2987 if (!strcmp(VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME, instance_extensions[i].extensionName)) {
2988 platformSurfaceExtFound = 1;
2989 demo->extension_names[demo->enabled_extension_count++] = VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME;
2991 #elif defined(VK_USE_PLATFORM_MIR_KHR)
2992 #elif defined(VK_USE_PLATFORM_DISPLAY_KHR)
2993 if (!strcmp(VK_KHR_DISPLAY_EXTENSION_NAME, instance_extensions[i].extensionName)) {
2994 platformSurfaceExtFound = 1;
2995 demo->extension_names[demo->enabled_extension_count++] = VK_KHR_DISPLAY_EXTENSION_NAME;
2997 #elif defined(VK_USE_PLATFORM_ANDROID_KHR)
2998 if (!strcmp(VK_KHR_ANDROID_SURFACE_EXTENSION_NAME, instance_extensions[i].extensionName)) {
2999 platformSurfaceExtFound = 1;
3000 demo->extension_names[demo->enabled_extension_count++] = VK_KHR_ANDROID_SURFACE_EXTENSION_NAME;
3002 #elif defined(VK_USE_PLATFORM_IOS_MVK)
3003 if (!strcmp(VK_MVK_IOS_SURFACE_EXTENSION_NAME, instance_extensions[i].extensionName)) {
3004 platformSurfaceExtFound = 1;
3005 demo->extension_names[demo->enabled_extension_count++] = VK_MVK_IOS_SURFACE_EXTENSION_NAME;
3007 #elif defined(VK_USE_PLATFORM_MACOS_MVK)
3008 if (!strcmp(VK_MVK_MACOS_SURFACE_EXTENSION_NAME, instance_extensions[i].extensionName)) {
3009 platformSurfaceExtFound = 1;
3010 demo->extension_names[demo->enabled_extension_count++] = VK_MVK_MACOS_SURFACE_EXTENSION_NAME;
3013 if (!strcmp(VK_EXT_DEBUG_REPORT_EXTENSION_NAME, instance_extensions[i].extensionName)) {
3014 if (demo->validate) {
3015 demo->extension_names[demo->enabled_extension_count++] = VK_EXT_DEBUG_REPORT_EXTENSION_NAME;
3018 if (!strcmp(VK_EXT_DEBUG_UTILS_EXTENSION_NAME, instance_extensions[i].extensionName)) {
3019 if (demo->validate) {
3020 demo->extension_names[demo->enabled_extension_count++] = VK_EXT_DEBUG_UTILS_EXTENSION_NAME;
3023 assert(demo->enabled_extension_count < 64);
3026 free(instance_extensions);
3029 if (!surfaceExtFound) {
3030 ERR_EXIT("vkEnumerateInstanceExtensionProperties failed to find the " VK_KHR_SURFACE_EXTENSION_NAME
3032 "Do you have a compatible Vulkan installable client driver (ICD) installed?\n"
3033 "Please look at the Getting Started guide for additional information.\n",
3034 "vkCreateInstance Failure");
3036 if (!platformSurfaceExtFound) {
3037 #if defined(VK_USE_PLATFORM_WIN32_KHR)
3038 ERR_EXIT("vkEnumerateInstanceExtensionProperties failed to find the " VK_KHR_WIN32_SURFACE_EXTENSION_NAME
3040 "Do you have a compatible Vulkan installable client driver (ICD) installed?\n"
3041 "Please look at the Getting Started guide for additional information.\n",
3042 "vkCreateInstance Failure");
3043 #elif defined(VK_USE_PLATFORM_IOS_MVK)
3044 ERR_EXIT("vkEnumerateInstanceExtensionProperties failed to find the " VK_MVK_IOS_SURFACE_EXTENSION_NAME
3046 "Do you have a compatible Vulkan installable client driver (ICD) installed?\n"
3047 "Please look at the Getting Started guide for additional information.\n",
3048 "vkCreateInstance Failure");
3049 #elif defined(VK_USE_PLATFORM_MACOS_MVK)
3050 ERR_EXIT("vkEnumerateInstanceExtensionProperties failed to find the " VK_MVK_MACOS_SURFACE_EXTENSION_NAME
3052 "Do you have a compatible Vulkan installable client driver (ICD) installed?\n"
3053 "Please look at the Getting Started guide for additional information.\n",
3054 "vkCreateInstance Failure");
3055 #elif defined(VK_USE_PLATFORM_XCB_KHR)
3056 ERR_EXIT("vkEnumerateInstanceExtensionProperties failed to find the " VK_KHR_XCB_SURFACE_EXTENSION_NAME
3058 "Do you have a compatible Vulkan installable client driver (ICD) installed?\n"
3059 "Please look at the Getting Started guide for additional information.\n",
3060 "vkCreateInstance Failure");
3061 #elif defined(VK_USE_PLATFORM_WAYLAND_KHR)
3062 ERR_EXIT("vkEnumerateInstanceExtensionProperties failed to find the " VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME
3064 "Do you have a compatible Vulkan installable client driver (ICD) installed?\n"
3065 "Please look at the Getting Started guide for additional information.\n",
3066 "vkCreateInstance Failure");
3067 #elif defined(VK_USE_PLATFORM_MIR_KHR)
3068 #elif defined(VK_USE_PLATFORM_DISPLAY_KHR)
3069 ERR_EXIT("vkEnumerateInstanceExtensionProperties failed to find the " VK_KHR_DISPLAY_EXTENSION_NAME
3071 "Do you have a compatible Vulkan installable client driver (ICD) installed?\n"
3072 "Please look at the Getting Started guide for additional information.\n",
3073 "vkCreateInstance Failure");
3074 #elif defined(VK_USE_PLATFORM_ANDROID_KHR)
3075 ERR_EXIT("vkEnumerateInstanceExtensionProperties failed to find the " VK_KHR_ANDROID_SURFACE_EXTENSION_NAME
3077 "Do you have a compatible Vulkan installable client driver (ICD) installed?\n"
3078 "Please look at the Getting Started guide for additional information.\n",
3079 "vkCreateInstance Failure");
3080 #elif defined(VK_USE_PLATFORM_XLIB_KHR)
3081 ERR_EXIT("vkEnumerateInstanceExtensionProperties failed to find the " VK_KHR_XLIB_SURFACE_EXTENSION_NAME
3083 "Do you have a compatible Vulkan installable client driver (ICD) installed?\n"
3084 "Please look at the Getting Started guide for additional information.\n",
3085 "vkCreateInstance Failure");
3088 const VkApplicationInfo app = {
3089 .sType = VK_STRUCTURE_TYPE_APPLICATION_INFO,
3091 .pApplicationName = APP_SHORT_NAME,
3092 .applicationVersion = 0,
3093 .pEngineName = APP_SHORT_NAME,
3095 .apiVersion = VK_API_VERSION_1_0,
3097 VkInstanceCreateInfo inst_info = {
3098 .sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO,
3100 .pApplicationInfo = &app,
3101 .enabledLayerCount = demo->enabled_layer_count,
3102 .ppEnabledLayerNames = (const char *const *)instance_validation_layers,
3103 .enabledExtensionCount = demo->enabled_extension_count,
3104 .ppEnabledExtensionNames = (const char *const *)demo->extension_names,
3108 * This is info for a temp callback to use during CreateInstance.
3109 * After the instance is created, we use the instance-based
3110 * function to register the final callback.
3112 VkDebugUtilsMessengerCreateInfoEXT dbg_messenger_create_info;
3113 if (demo->validate) {
3114 // VK_EXT_debug_utils style
3115 dbg_messenger_create_info.sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT;
3116 dbg_messenger_create_info.pNext = NULL;
3117 dbg_messenger_create_info.flags = 0;
3118 dbg_messenger_create_info.messageSeverity =
3119 VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT | VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT;
3120 dbg_messenger_create_info.messageType = VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT |
3121 VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT |
3122 VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT;
3123 dbg_messenger_create_info.pfnUserCallback = debug_messenger_callback;
3124 dbg_messenger_create_info.pUserData = demo;
3125 inst_info.pNext = &dbg_messenger_create_info;
3130 err = vkCreateInstance(&inst_info, NULL, &demo->inst);
3131 if (err == VK_ERROR_INCOMPATIBLE_DRIVER) {
3133 "Cannot find a compatible Vulkan installable client driver (ICD).\n\n"
3134 "Please look at the Getting Started guide for additional information.\n",
3135 "vkCreateInstance Failure");
3136 } else if (err == VK_ERROR_EXTENSION_NOT_PRESENT) {
3138 "Cannot find a specified extension library.\n"
3139 "Make sure your layers path is set appropriately.\n",
3140 "vkCreateInstance Failure");
3143 "vkCreateInstance failed.\n\n"
3144 "Do you have a compatible Vulkan installable client driver (ICD) installed?\n"
3145 "Please look at the Getting Started guide for additional information.\n",
3146 "vkCreateInstance Failure");
3149 /* Make initial call to query gpu_count, then second call for gpu info*/
3150 err = vkEnumeratePhysicalDevices(demo->inst, &gpu_count, NULL);
3153 if (gpu_count > 0) {
3154 VkPhysicalDevice *physical_devices = malloc(sizeof(VkPhysicalDevice) * gpu_count);
3155 err = vkEnumeratePhysicalDevices(demo->inst, &gpu_count, physical_devices);
3157 /* For cube demo we just grab the first physical device */
3158 demo->gpu = physical_devices[0];
3159 free(physical_devices);
3162 "vkEnumeratePhysicalDevices reported zero accessible devices.\n\n"
3163 "Do you have a compatible Vulkan installable client driver (ICD) installed?\n"
3164 "Please look at the Getting Started guide for additional information.\n",
3165 "vkEnumeratePhysicalDevices Failure");
3168 /* Look for device extensions */
3169 uint32_t device_extension_count = 0;
3170 VkBool32 swapchainExtFound = 0;
3171 demo->enabled_extension_count = 0;
3172 memset(demo->extension_names, 0, sizeof(demo->extension_names));
3174 err = vkEnumerateDeviceExtensionProperties(demo->gpu, NULL, &device_extension_count, NULL);
3177 if (device_extension_count > 0) {
3178 VkExtensionProperties *device_extensions = malloc(sizeof(VkExtensionProperties) * device_extension_count);
3179 err = vkEnumerateDeviceExtensionProperties(demo->gpu, NULL, &device_extension_count, device_extensions);
3182 for (uint32_t i = 0; i < device_extension_count; i++) {
3183 if (!strcmp(VK_KHR_SWAPCHAIN_EXTENSION_NAME, device_extensions[i].extensionName)) {
3184 swapchainExtFound = 1;
3185 demo->extension_names[demo->enabled_extension_count++] = VK_KHR_SWAPCHAIN_EXTENSION_NAME;
3187 assert(demo->enabled_extension_count < 64);
3190 if (demo->VK_KHR_incremental_present_enabled) {
3191 // Even though the user "enabled" the extension via the command
3192 // line, we must make sure that it's enumerated for use with the
3193 // device. Therefore, disable it here, and re-enable it again if
3195 demo->VK_KHR_incremental_present_enabled = false;
3196 for (uint32_t i = 0; i < device_extension_count; i++) {
3197 if (!strcmp(VK_KHR_INCREMENTAL_PRESENT_EXTENSION_NAME, device_extensions[i].extensionName)) {
3198 demo->extension_names[demo->enabled_extension_count++] = VK_KHR_INCREMENTAL_PRESENT_EXTENSION_NAME;
3199 demo->VK_KHR_incremental_present_enabled = true;
3200 DbgMsg("VK_KHR_incremental_present extension enabled\n");
3202 assert(demo->enabled_extension_count < 64);
3204 if (!demo->VK_KHR_incremental_present_enabled) {
3205 DbgMsg("VK_KHR_incremental_present extension NOT AVAILABLE\n");
3209 if (demo->VK_GOOGLE_display_timing_enabled) {
3210 // Even though the user "enabled" the extension via the command
3211 // line, we must make sure that it's enumerated for use with the
3212 // device. Therefore, disable it here, and re-enable it again if
3214 demo->VK_GOOGLE_display_timing_enabled = false;
3215 for (uint32_t i = 0; i < device_extension_count; i++) {
3216 if (!strcmp(VK_GOOGLE_DISPLAY_TIMING_EXTENSION_NAME, device_extensions[i].extensionName)) {
3217 demo->extension_names[demo->enabled_extension_count++] = VK_GOOGLE_DISPLAY_TIMING_EXTENSION_NAME;
3218 demo->VK_GOOGLE_display_timing_enabled = true;
3219 DbgMsg("VK_GOOGLE_display_timing extension enabled\n");
3221 assert(demo->enabled_extension_count < 64);
3223 if (!demo->VK_GOOGLE_display_timing_enabled) {
3224 DbgMsg("VK_GOOGLE_display_timing extension NOT AVAILABLE\n");
3228 free(device_extensions);
3231 if (!swapchainExtFound) {
3232 ERR_EXIT("vkEnumerateDeviceExtensionProperties failed to find the " VK_KHR_SWAPCHAIN_EXTENSION_NAME
3233 " extension.\n\nDo you have a compatible Vulkan installable client driver (ICD) installed?\n"
3234 "Please look at the Getting Started guide for additional information.\n",
3235 "vkCreateInstance Failure");
3238 if (demo->validate) {
3239 // Setup VK_EXT_debug_utils function pointers always (we use them for
3240 // debug labels and names).
3241 demo->CreateDebugUtilsMessengerEXT =
3242 (PFN_vkCreateDebugUtilsMessengerEXT)vkGetInstanceProcAddr(demo->inst, "vkCreateDebugUtilsMessengerEXT");
3243 demo->DestroyDebugUtilsMessengerEXT =
3244 (PFN_vkDestroyDebugUtilsMessengerEXT)vkGetInstanceProcAddr(demo->inst, "vkDestroyDebugUtilsMessengerEXT");
3245 demo->SubmitDebugUtilsMessageEXT =
3246 (PFN_vkSubmitDebugUtilsMessageEXT)vkGetInstanceProcAddr(demo->inst, "vkSubmitDebugUtilsMessageEXT");
3247 demo->CmdBeginDebugUtilsLabelEXT =
3248 (PFN_vkCmdBeginDebugUtilsLabelEXT)vkGetInstanceProcAddr(demo->inst, "vkCmdBeginDebugUtilsLabelEXT");
3249 demo->CmdEndDebugUtilsLabelEXT =
3250 (PFN_vkCmdEndDebugUtilsLabelEXT)vkGetInstanceProcAddr(demo->inst, "vkCmdEndDebugUtilsLabelEXT");
3251 demo->CmdInsertDebugUtilsLabelEXT =
3252 (PFN_vkCmdInsertDebugUtilsLabelEXT)vkGetInstanceProcAddr(demo->inst, "vkCmdInsertDebugUtilsLabelEXT");
3253 demo->SetDebugUtilsObjectNameEXT =
3254 (PFN_vkSetDebugUtilsObjectNameEXT)vkGetInstanceProcAddr(demo->inst, "vkSetDebugUtilsObjectNameEXT");
3255 if (NULL == demo->CreateDebugUtilsMessengerEXT || NULL == demo->DestroyDebugUtilsMessengerEXT ||
3256 NULL == demo->SubmitDebugUtilsMessageEXT || NULL == demo->CmdBeginDebugUtilsLabelEXT ||
3257 NULL == demo->CmdEndDebugUtilsLabelEXT || NULL == demo->CmdInsertDebugUtilsLabelEXT ||
3258 NULL == demo->SetDebugUtilsObjectNameEXT) {
3259 ERR_EXIT("GetProcAddr: Failed to init VK_EXT_debug_utils\n", "GetProcAddr: Failure");
3262 err = demo->CreateDebugUtilsMessengerEXT(demo->inst, &dbg_messenger_create_info, NULL, &demo->dbg_messenger);
3266 case VK_ERROR_OUT_OF_HOST_MEMORY:
3267 ERR_EXIT("CreateDebugUtilsMessengerEXT: out of host memory\n", "CreateDebugUtilsMessengerEXT Failure");
3270 ERR_EXIT("CreateDebugUtilsMessengerEXT: unknown failure\n", "CreateDebugUtilsMessengerEXT Failure");
3274 vkGetPhysicalDeviceProperties(demo->gpu, &demo->gpu_props);
3276 /* Call with NULL data to get count */
3277 vkGetPhysicalDeviceQueueFamilyProperties(demo->gpu, &demo->queue_family_count, NULL);
3278 assert(demo->queue_family_count >= 1);
3280 demo->queue_props = (VkQueueFamilyProperties *)malloc(demo->queue_family_count * sizeof(VkQueueFamilyProperties));
3281 vkGetPhysicalDeviceQueueFamilyProperties(demo->gpu, &demo->queue_family_count, demo->queue_props);
3283 // Query fine-grained feature support for this device.
3284 // If app has specific feature requirements it should check supported
3285 // features based on this query
3286 VkPhysicalDeviceFeatures physDevFeatures;
3287 vkGetPhysicalDeviceFeatures(demo->gpu, &physDevFeatures);
3289 GET_INSTANCE_PROC_ADDR(demo->inst, GetPhysicalDeviceSurfaceSupportKHR);
3290 GET_INSTANCE_PROC_ADDR(demo->inst, GetPhysicalDeviceSurfaceCapabilitiesKHR);
3291 GET_INSTANCE_PROC_ADDR(demo->inst, GetPhysicalDeviceSurfaceFormatsKHR);
3292 GET_INSTANCE_PROC_ADDR(demo->inst, GetPhysicalDeviceSurfacePresentModesKHR);
3293 GET_INSTANCE_PROC_ADDR(demo->inst, GetSwapchainImagesKHR);
3296 static void demo_create_device(struct demo *demo) {
3297 VkResult U_ASSERT_ONLY err;
3298 float queue_priorities[1] = {0.0};
3299 VkDeviceQueueCreateInfo queues[2];
3300 queues[0].sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
3301 queues[0].pNext = NULL;
3302 queues[0].queueFamilyIndex = demo->graphics_queue_family_index;
3303 queues[0].queueCount = 1;
3304 queues[0].pQueuePriorities = queue_priorities;
3305 queues[0].flags = 0;
3307 VkDeviceCreateInfo device = {
3308 .sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO,
3310 .queueCreateInfoCount = 1,
3311 .pQueueCreateInfos = queues,
3312 .enabledLayerCount = 0,
3313 .ppEnabledLayerNames = NULL,
3314 .enabledExtensionCount = demo->enabled_extension_count,
3315 .ppEnabledExtensionNames = (const char *const *)demo->extension_names,
3316 .pEnabledFeatures = NULL, // If specific features are required, pass them in here
3318 if (demo->separate_present_queue) {
3319 queues[1].sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
3320 queues[1].pNext = NULL;
3321 queues[1].queueFamilyIndex = demo->present_queue_family_index;
3322 queues[1].queueCount = 1;
3323 queues[1].pQueuePriorities = queue_priorities;
3324 queues[1].flags = 0;
3325 device.queueCreateInfoCount = 2;
3327 err = vkCreateDevice(demo->gpu, &device, NULL, &demo->device);
3331 static void demo_init_vk_swapchain(struct demo *demo) {
3332 VkResult U_ASSERT_ONLY err;
3334 // Create a WSI surface for the window:
3335 #if defined(VK_USE_PLATFORM_WIN32_KHR)
3336 VkWin32SurfaceCreateInfoKHR createInfo;
3337 createInfo.sType = VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR;
3338 createInfo.pNext = NULL;
3339 createInfo.flags = 0;
3340 createInfo.hinstance = demo->connection;
3341 createInfo.hwnd = demo->window;
3343 err = vkCreateWin32SurfaceKHR(demo->inst, &createInfo, NULL, &demo->surface);
3344 #elif defined(VK_USE_PLATFORM_WAYLAND_KHR)
3345 VkWaylandSurfaceCreateInfoKHR createInfo;
3346 createInfo.sType = VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR;
3347 createInfo.pNext = NULL;
3348 createInfo.flags = 0;
3349 createInfo.display = demo->display;
3350 createInfo.surface = demo->window;
3352 err = vkCreateWaylandSurfaceKHR(demo->inst, &createInfo, NULL, &demo->surface);
3353 #elif defined(VK_USE_PLATFORM_MIR_KHR)
3354 #elif defined(VK_USE_PLATFORM_ANDROID_KHR)
3355 VkAndroidSurfaceCreateInfoKHR createInfo;
3356 createInfo.sType = VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR;
3357 createInfo.pNext = NULL;
3358 createInfo.flags = 0;
3359 createInfo.window = (struct ANativeWindow *)(demo->window);
3361 err = vkCreateAndroidSurfaceKHR(demo->inst, &createInfo, NULL, &demo->surface);
3362 #elif defined(VK_USE_PLATFORM_XLIB_KHR)
3363 VkXlibSurfaceCreateInfoKHR createInfo;
3364 createInfo.sType = VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR;
3365 createInfo.pNext = NULL;
3366 createInfo.flags = 0;
3367 createInfo.dpy = demo->display;
3368 createInfo.window = demo->xlib_window;
3370 err = vkCreateXlibSurfaceKHR(demo->inst, &createInfo, NULL, &demo->surface);
3371 #elif defined(VK_USE_PLATFORM_XCB_KHR)
3372 VkXcbSurfaceCreateInfoKHR createInfo;
3373 createInfo.sType = VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR;
3374 createInfo.pNext = NULL;
3375 createInfo.flags = 0;
3376 createInfo.connection = demo->connection;
3377 createInfo.window = demo->xcb_window;
3379 err = vkCreateXcbSurfaceKHR(demo->inst, &createInfo, NULL, &demo->surface);
3380 #elif defined(VK_USE_PLATFORM_DISPLAY_KHR)
3381 err = demo_create_display_surface(demo);
3382 #elif defined(VK_USE_PLATFORM_IOS_MVK)
3383 VkIOSSurfaceCreateInfoMVK surface;
3384 surface.sType = VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK;
3385 surface.pNext = NULL;
3387 surface.pView = demo->window;
3389 err = vkCreateIOSSurfaceMVK(demo->inst, &surface, NULL, &demo->surface);
3390 #elif defined(VK_USE_PLATFORM_MACOS_MVK)
3391 VkMacOSSurfaceCreateInfoMVK surface;
3392 surface.sType = VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK;
3393 surface.pNext = NULL;
3395 surface.pView = demo->window;
3397 err = vkCreateMacOSSurfaceMVK(demo->inst, &surface, NULL, &demo->surface);
3401 // Iterate over each queue to learn whether it supports presenting:
3402 VkBool32 *supportsPresent = (VkBool32 *)malloc(demo->queue_family_count * sizeof(VkBool32));
3403 for (uint32_t i = 0; i < demo->queue_family_count; i++) {
3404 demo->fpGetPhysicalDeviceSurfaceSupportKHR(demo->gpu, i, demo->surface, &supportsPresent[i]);
3407 // Search for a graphics and a present queue in the array of queue
3408 // families, try to find one that supports both
3409 uint32_t graphicsQueueFamilyIndex = UINT32_MAX;
3410 uint32_t presentQueueFamilyIndex = UINT32_MAX;
3411 for (uint32_t i = 0; i < demo->queue_family_count; i++) {
3412 if ((demo->queue_props[i].queueFlags & VK_QUEUE_GRAPHICS_BIT) != 0) {
3413 if (graphicsQueueFamilyIndex == UINT32_MAX) {
3414 graphicsQueueFamilyIndex = i;
3417 if (supportsPresent[i] == VK_TRUE) {
3418 graphicsQueueFamilyIndex = i;
3419 presentQueueFamilyIndex = i;
3425 if (presentQueueFamilyIndex == UINT32_MAX) {
3426 // If didn't find a queue that supports both graphics and present, then
3427 // find a separate present queue.
3428 for (uint32_t i = 0; i < demo->queue_family_count; ++i) {
3429 if (supportsPresent[i] == VK_TRUE) {
3430 presentQueueFamilyIndex = i;
3436 // Generate error if could not find both a graphics and a present queue
3437 if (graphicsQueueFamilyIndex == UINT32_MAX || presentQueueFamilyIndex == UINT32_MAX) {
3438 ERR_EXIT("Could not find both graphics and present queues\n", "Swapchain Initialization Failure");
3441 demo->graphics_queue_family_index = graphicsQueueFamilyIndex;
3442 demo->present_queue_family_index = presentQueueFamilyIndex;
3443 demo->separate_present_queue = (demo->graphics_queue_family_index != demo->present_queue_family_index);
3444 free(supportsPresent);
3446 demo_create_device(demo);
3448 GET_DEVICE_PROC_ADDR(demo->device, CreateSwapchainKHR);
3449 GET_DEVICE_PROC_ADDR(demo->device, DestroySwapchainKHR);
3450 GET_DEVICE_PROC_ADDR(demo->device, GetSwapchainImagesKHR);
3451 GET_DEVICE_PROC_ADDR(demo->device, AcquireNextImageKHR);
3452 GET_DEVICE_PROC_ADDR(demo->device, QueuePresentKHR);
3453 if (demo->VK_GOOGLE_display_timing_enabled) {
3454 GET_DEVICE_PROC_ADDR(demo->device, GetRefreshCycleDurationGOOGLE);
3455 GET_DEVICE_PROC_ADDR(demo->device, GetPastPresentationTimingGOOGLE);
3458 vkGetDeviceQueue(demo->device, demo->graphics_queue_family_index, 0, &demo->graphics_queue);
3460 if (!demo->separate_present_queue) {
3461 demo->present_queue = demo->graphics_queue;
3463 vkGetDeviceQueue(demo->device, demo->present_queue_family_index, 0, &demo->present_queue);
3466 // Get the list of VkFormat's that are supported:
3467 uint32_t formatCount;
3468 err = demo->fpGetPhysicalDeviceSurfaceFormatsKHR(demo->gpu, demo->surface, &formatCount, NULL);
3470 VkSurfaceFormatKHR *surfFormats = (VkSurfaceFormatKHR *)malloc(formatCount * sizeof(VkSurfaceFormatKHR));
3471 err = demo->fpGetPhysicalDeviceSurfaceFormatsKHR(demo->gpu, demo->surface, &formatCount, surfFormats);
3473 // If the format list includes just one entry of VK_FORMAT_UNDEFINED,
3474 // the surface has no preferred format. Otherwise, at least one
3475 // supported format will be returned.
3476 if (formatCount == 1 && surfFormats[0].format == VK_FORMAT_UNDEFINED) {
3477 demo->format = VK_FORMAT_B8G8R8A8_UNORM;
3479 assert(formatCount >= 1);
3480 demo->format = surfFormats[0].format;
3482 demo->color_space = surfFormats[0].colorSpace;
3487 // Create semaphores to synchronize acquiring presentable buffers before
3488 // rendering and waiting for drawing to be complete before presenting
3489 VkSemaphoreCreateInfo semaphoreCreateInfo = {
3490 .sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO,
3495 // Create fences that we can use to throttle if we get too far
3496 // ahead of the image presents
3497 VkFenceCreateInfo fence_ci = {
3498 .sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO, .pNext = NULL, .flags = VK_FENCE_CREATE_SIGNALED_BIT};
3499 for (uint32_t i = 0; i < FRAME_LAG; i++) {
3500 err = vkCreateFence(demo->device, &fence_ci, NULL, &demo->fences[i]);
3503 err = vkCreateSemaphore(demo->device, &semaphoreCreateInfo, NULL, &demo->image_acquired_semaphores[i]);
3506 err = vkCreateSemaphore(demo->device, &semaphoreCreateInfo, NULL, &demo->draw_complete_semaphores[i]);
3509 if (demo->separate_present_queue) {
3510 err = vkCreateSemaphore(demo->device, &semaphoreCreateInfo, NULL, &demo->image_ownership_semaphores[i]);
3514 demo->frame_index = 0;
3516 // Get Memory information and properties
3517 vkGetPhysicalDeviceMemoryProperties(demo->gpu, &demo->memory_properties);
3520 #if defined(VK_USE_PLATFORM_WAYLAND_KHR)
3521 static void pointer_handle_enter(void *data, struct wl_pointer *pointer, uint32_t serial, struct wl_surface *surface, wl_fixed_t sx,
3524 static void pointer_handle_leave(void *data, struct wl_pointer *pointer, uint32_t serial, struct wl_surface *surface) {}
3526 static void pointer_handle_motion(void *data, struct wl_pointer *pointer, uint32_t time, wl_fixed_t sx, wl_fixed_t sy) {}
3528 static void pointer_handle_button(void *data, struct wl_pointer *wl_pointer, uint32_t serial, uint32_t time, uint32_t button,
3530 struct demo *demo = data;
3531 if (button == BTN_LEFT && state == WL_POINTER_BUTTON_STATE_PRESSED) {
3532 wl_shell_surface_move(demo->shell_surface, demo->seat, serial);
3536 static void pointer_handle_axis(void *data, struct wl_pointer *wl_pointer, uint32_t time, uint32_t axis, wl_fixed_t value) {}
3538 static const struct wl_pointer_listener pointer_listener = {
3539 pointer_handle_enter, pointer_handle_leave, pointer_handle_motion, pointer_handle_button, pointer_handle_axis,
3542 static void keyboard_handle_keymap(void *data, struct wl_keyboard *keyboard, uint32_t format, int fd, uint32_t size) {}
3544 static void keyboard_handle_enter(void *data, struct wl_keyboard *keyboard, uint32_t serial, struct wl_surface *surface,
3545 struct wl_array *keys) {}
3547 static void keyboard_handle_leave(void *data, struct wl_keyboard *keyboard, uint32_t serial, struct wl_surface *surface) {}
3549 static void keyboard_handle_key(void *data, struct wl_keyboard *keyboard, uint32_t serial, uint32_t time, uint32_t key,
3551 if (state != WL_KEYBOARD_KEY_STATE_RELEASED) return;
3552 struct demo *demo = data;
3554 case KEY_ESC: // Escape
3557 case KEY_LEFT: // left arrow key
3558 demo->spin_angle -= demo->spin_increment;
3560 case KEY_RIGHT: // right arrow key
3561 demo->spin_angle += demo->spin_increment;
3563 case KEY_SPACE: // space bar
3564 demo->pause = !demo->pause;
3569 static void keyboard_handle_modifiers(void *data, struct wl_keyboard *keyboard, uint32_t serial, uint32_t mods_depressed,
3570 uint32_t mods_latched, uint32_t mods_locked, uint32_t group) {}
3572 static const struct wl_keyboard_listener keyboard_listener = {
3573 keyboard_handle_keymap, keyboard_handle_enter, keyboard_handle_leave, keyboard_handle_key, keyboard_handle_modifiers,
3576 static void seat_handle_capabilities(void *data, struct wl_seat *seat, enum wl_seat_capability caps) {
3577 // Subscribe to pointer events
3578 struct demo *demo = data;
3579 if ((caps & WL_SEAT_CAPABILITY_POINTER) && !demo->pointer) {
3580 demo->pointer = wl_seat_get_pointer(seat);
3581 wl_pointer_add_listener(demo->pointer, &pointer_listener, demo);
3582 } else if (!(caps & WL_SEAT_CAPABILITY_POINTER) && demo->pointer) {
3583 wl_pointer_destroy(demo->pointer);
3584 demo->pointer = NULL;
3586 // Subscribe to keyboard events
3587 if (caps & WL_SEAT_CAPABILITY_KEYBOARD) {
3588 demo->keyboard = wl_seat_get_keyboard(seat);
3589 wl_keyboard_add_listener(demo->keyboard, &keyboard_listener, demo);
3590 } else if (!(caps & WL_SEAT_CAPABILITY_KEYBOARD)) {
3591 wl_keyboard_destroy(demo->keyboard);
3592 demo->keyboard = NULL;
3596 static const struct wl_seat_listener seat_listener = {
3597 seat_handle_capabilities,
3600 static void registry_handle_global(void *data, struct wl_registry *registry, uint32_t id, const char *interface,
3601 uint32_t version UNUSED) {
3602 struct demo *demo = data;
3603 // pickup wayland objects when they appear
3604 if (strcmp(interface, "wl_compositor") == 0) {
3605 demo->compositor = wl_registry_bind(registry, id, &wl_compositor_interface, 1);
3606 } else if (strcmp(interface, "wl_shell") == 0) {
3607 demo->shell = wl_registry_bind(registry, id, &wl_shell_interface, 1);
3608 } else if (strcmp(interface, "wl_seat") == 0) {
3609 demo->seat = wl_registry_bind(registry, id, &wl_seat_interface, 1);
3610 wl_seat_add_listener(demo->seat, &seat_listener, demo);
3614 static void registry_handle_global_remove(void *data UNUSED, struct wl_registry *registry UNUSED, uint32_t name UNUSED) {}
3616 static const struct wl_registry_listener registry_listener = {registry_handle_global, registry_handle_global_remove};
3617 #elif defined(VK_USE_PLATFORM_MIR_KHR)
3620 static void demo_init_connection(struct demo *demo) {
3621 #if defined(VK_USE_PLATFORM_XCB_KHR)
3622 const xcb_setup_t *setup;
3623 xcb_screen_iterator_t iter;
3626 const char *display_envar = getenv("DISPLAY");
3627 if (display_envar == NULL || display_envar[0] == '\0') {
3628 printf("Environment variable DISPLAY requires a valid value.\nExiting ...\n");
3633 demo->connection = xcb_connect(NULL, &scr);
3634 if (xcb_connection_has_error(demo->connection) > 0) {
3635 printf("Cannot find a compatible Vulkan installable client driver (ICD).\nExiting ...\n");
3640 setup = xcb_get_setup(demo->connection);
3641 iter = xcb_setup_roots_iterator(setup);
3642 while (scr-- > 0) xcb_screen_next(&iter);
3644 demo->screen = iter.data;
3645 #elif defined(VK_USE_PLATFORM_WAYLAND_KHR)
3646 demo->display = wl_display_connect(NULL);
3648 if (demo->display == NULL) {
3649 printf("Cannot find a compatible Vulkan installable client driver (ICD).\nExiting ...\n");
3654 demo->registry = wl_display_get_registry(demo->display);
3655 wl_registry_add_listener(demo->registry, ®istry_listener, demo);
3656 wl_display_dispatch(demo->display);
3657 #elif defined(VK_USE_PLATFORM_MIR_KHR)
3661 static void demo_init(struct demo *demo, int argc, char **argv) {
3662 vec3 eye = {0.0f, 3.0f, 5.0f};
3663 vec3 origin = {0, 0, 0};
3664 vec3 up = {0.0f, 1.0f, 0.0};
3666 memset(demo, 0, sizeof(*demo));
3667 demo->presentMode = VK_PRESENT_MODE_FIFO_KHR;
3668 demo->frameCount = INT32_MAX;
3670 for (int i = 1; i < argc; i++) {
3671 if (strcmp(argv[i], "--use_staging") == 0) {
3672 demo->use_staging_buffer = true;
3675 if ((strcmp(argv[i], "--present_mode") == 0) && (i < argc - 1)) {
3676 demo->presentMode = atoi(argv[i + 1]);
3680 if (strcmp(argv[i], "--break") == 0) {
3681 demo->use_break = true;
3684 if (strcmp(argv[i], "--validate") == 0) {
3685 demo->validate = true;
3688 if (strcmp(argv[i], "--validate-checks-disabled") == 0) {
3689 demo->validate = true;
3690 demo->validate_checks_disabled = true;
3693 if (strcmp(argv[i], "--xlib") == 0) {
3694 fprintf(stderr, "--xlib is deprecated and no longer does anything");
3697 if (strcmp(argv[i], "--c") == 0 && demo->frameCount == INT32_MAX && i < argc - 1 &&
3698 sscanf(argv[i + 1], "%d", &demo->frameCount) == 1 && demo->frameCount >= 0) {
3702 if (strcmp(argv[i], "--suppress_popups") == 0) {
3703 demo->suppress_popups = true;
3706 if (strcmp(argv[i], "--display_timing") == 0) {
3707 demo->VK_GOOGLE_display_timing_enabled = true;
3710 if (strcmp(argv[i], "--incremental_present") == 0) {
3711 demo->VK_KHR_incremental_present_enabled = true;
3715 #if defined(ANDROID)
3716 ERR_EXIT("Usage: cube [--validate]\n", "Usage");
3719 "Usage:\n %s\t[--use_staging] [--validate] [--validate-checks-disabled] [--break]\n"
3720 "\t[--c <framecount>] [--suppress_popups] [--incremental_present] [--display_timing]\n"
3721 "\t[--present_mode <present mode enum>]\n"
3722 "\t <present_mode_enum>\tVK_PRESENT_MODE_IMMEDIATE_KHR = %d\n"
3723 "\t\t\t\tVK_PRESENT_MODE_MAILBOX_KHR = %d\n"
3724 "\t\t\t\tVK_PRESENT_MODE_FIFO_KHR = %d\n"
3725 "\t\t\t\tVK_PRESENT_MODE_FIFO_RELAXED_KHR = %d\n",
3726 APP_SHORT_NAME, VK_PRESENT_MODE_IMMEDIATE_KHR, VK_PRESENT_MODE_MAILBOX_KHR, VK_PRESENT_MODE_FIFO_KHR,
3727 VK_PRESENT_MODE_FIFO_RELAXED_KHR);
3733 demo_init_connection(demo);
3740 demo->spin_angle = 4.0f;
3741 demo->spin_increment = 0.2f;
3742 demo->pause = false;
3744 mat4x4_perspective(demo->projection_matrix, (float)degreesToRadians(45.0f), 1.0f, 0.1f, 100.0f);
3745 mat4x4_look_at(demo->view_matrix, eye, origin, up);
3746 mat4x4_identity(demo->model_matrix);
3748 demo->projection_matrix[1][1] *= -1; // Flip projection matrix from GL to Vulkan orientation.
3751 #if defined(VK_USE_PLATFORM_WIN32_KHR)
3752 // Include header required for parsing the command line options.
3753 #include <shellapi.h>
3755 int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR pCmdLine, int nCmdShow) {
3757 bool done; // flag saying when app is complete
3761 // Ensure wParam is initialized.
3764 // Use the CommandLine functions to get the command line arguments.
3765 // Unfortunately, Microsoft outputs
3766 // this information as wide characters for Unicode, and we simply want the
3767 // Ascii version to be compatible
3768 // with the non-Windows side. So, we have to convert the information to
3769 // Ascii character strings.
3770 LPWSTR *commandLineArgs = CommandLineToArgvW(GetCommandLineW(), &argc);
3771 if (NULL == commandLineArgs) {
3776 argv = (char **)malloc(sizeof(char *) * argc);
3780 for (int iii = 0; iii < argc; iii++) {
3781 size_t wideCharLen = wcslen(commandLineArgs[iii]);
3782 size_t numConverted = 0;
3784 argv[iii] = (char *)malloc(sizeof(char) * (wideCharLen + 1));
3785 if (argv[iii] != NULL) {
3786 wcstombs_s(&numConverted, argv[iii], wideCharLen + 1, commandLineArgs[iii], wideCharLen + 1);
3794 demo_init(&demo, argc, argv);
3796 // Free up the items we had to allocate for the command line arguments.
3797 if (argc > 0 && argv != NULL) {
3798 for (int iii = 0; iii < argc; iii++) {
3799 if (argv[iii] != NULL) {
3806 demo.connection = hInstance;
3807 strncpy(demo.name, "cube", APP_NAME_STR_LEN);
3808 demo_create_window(&demo);
3809 demo_init_vk_swapchain(&demo);
3811 demo_prepare(&demo);
3813 done = false; // initialize loop condition variable
3815 // main message loop
3817 PeekMessage(&msg, NULL, 0, 0, PM_REMOVE);
3818 if (msg.message == WM_QUIT) // check for a quit message
3820 done = true; // if found, quit app
3822 /* Translate and dispatch to event queue*/
3823 TranslateMessage(&msg);
3824 DispatchMessage(&msg);
3826 RedrawWindow(demo.window, NULL, NULL, RDW_INTERNALPAINT);
3829 demo_cleanup(&demo);
3831 return (int)msg.wParam;
3834 #elif defined(VK_USE_PLATFORM_IOS_MVK) || defined(VK_USE_PLATFORM_MACOS_MVK)
3835 static void demo_main(struct demo *demo, void *view, int argc, const char *argv[]) {
3837 demo_init(demo, argc, (char **)argv);
3838 demo->window = view;
3839 demo_init_vk_swapchain(demo);
3841 demo->spin_angle = 0.4f;
3844 #elif defined(VK_USE_PLATFORM_ANDROID_KHR)
3845 #include <android/log.h>
3846 #include <android_native_app_glue.h>
3847 #include "android_util.h"
3849 static bool initialized = false;
3850 static bool active = false;
3853 static int32_t processInput(struct android_app *app, AInputEvent *event) { return 0; }
3855 static void processCommand(struct android_app *app, int32_t cmd) {
3857 case APP_CMD_INIT_WINDOW: {
3859 // We're getting a new window. If the app is starting up, we
3860 // need to initialize. If the app has already been
3861 // initialized, that means that we lost our previous window,
3862 // which means that we have a lot of work to do. At a minimum,
3863 // we need to destroy the swapchain and surface associated with
3864 // the old window, and create a new surface and swapchain.
3865 // However, since there are a lot of other objects/state that
3866 // is tied to the swapchain, it's easiest to simply cleanup and
3867 // start over (i.e. use a brute-force approach of re-starting
3869 if (demo.prepared) {
3870 demo_cleanup(&demo);
3873 // Parse Intents into argc, argv
3874 // Use the following key to send arguments, i.e.
3875 // --es args "--validate"
3876 const char key[] = "args";
3877 char *appTag = (char *)APP_SHORT_NAME;
3879 char **argv = get_args(app, key, appTag, &argc);
3881 __android_log_print(ANDROID_LOG_INFO, appTag, "argc = %i", argc);
3882 for (int i = 0; i < argc; i++) __android_log_print(ANDROID_LOG_INFO, appTag, "argv[%i] = %s", i, argv[i]);
3884 demo_init(&demo, argc, argv);
3886 // Free the argv malloc'd by get_args
3887 for (int i = 0; i < argc; i++) free(argv[i]);
3889 demo.window = (void *)app->window;
3890 demo_init_vk_swapchain(&demo);
3891 demo_prepare(&demo);
3896 case APP_CMD_GAINED_FOCUS: {
3900 case APP_CMD_LOST_FOCUS: {
3907 void android_main(struct android_app *app) {
3909 int vulkanSupport = InitVulkan();
3910 if (vulkanSupport == 0) return;
3913 demo.prepared = false;
3915 app->onAppCmd = processCommand;
3916 app->onInputEvent = processInput;
3920 struct android_poll_source *source;
3921 while (ALooper_pollAll(active ? 0 : -1, NULL, &events, (void **)&source) >= 0) {
3923 source->process(app, source);
3926 if (app->destroyRequested != 0) {
3927 demo_cleanup(&demo);
3931 if (initialized && active) {
3937 int main(int argc, char **argv) {
3940 demo_init(&demo, argc, argv);
3941 #if defined(VK_USE_PLATFORM_XCB_KHR)
3942 demo_create_xcb_window(&demo);
3943 #elif defined(VK_USE_PLATFORM_XLIB_KHR)
3944 demo_create_xlib_window(&demo);
3945 #elif defined(VK_USE_PLATFORM_WAYLAND_KHR)
3946 demo_create_window(&demo);
3947 #elif defined(VK_USE_PLATFORM_MIR_KHR)
3950 demo_init_vk_swapchain(&demo);
3952 demo_prepare(&demo);
3954 #if defined(VK_USE_PLATFORM_XCB_KHR)
3955 demo_run_xcb(&demo);
3956 #elif defined(VK_USE_PLATFORM_XLIB_KHR)
3957 demo_run_xlib(&demo);
3958 #elif defined(VK_USE_PLATFORM_WAYLAND_KHR)
3960 #elif defined(VK_USE_PLATFORM_MIR_KHR)
3961 #elif defined(VK_USE_PLATFORM_DISPLAY_KHR)
3962 demo_run_display(&demo);
3965 demo_cleanup(&demo);
3967 return validation_error;