cube/cube.c

   1 /*
   2  * Copyright (c) 2015-2016 The Khronos Group Inc.
   3  * Copyright (c) 2015-2016 Valve Corporation
   4  * Copyright (c) 2015-2016 LunarG, Inc.
   5  *
   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
   9  *
  10  *     http://www.apache.org/licenses/LICENSE-2.0
  11  *
  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.
  17  *
  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>
  26  */
  27
  28 #define _GNU_SOURCE
  29 #include <stdio.h>
  30 #include <stdarg.h>
  31 #include <stdlib.h>
  32 #include <string.h>
  33 #include <stdbool.h>
  34 #include <assert.h>
  35 #include <signal.h>
  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>
  40 #endif
  41
  42 #ifdef _WIN32
  43 #pragma comment(linker, "/subsystem:windows")
  44 #define APP_NAME_STR_LEN 80
  45 #endif  // _WIN32
  46
  47 #if defined(VK_USE_PLATFORM_MIR_KHR)
  48 #warning "Cube does not have code for Mir at this time"
  49 #endif
  50
  51 #ifdef ANDROID
  52 #include "vulkan_wrapper.h"
  53 #else
  54 #include <vulkan/vulkan.h>
  55 #endif
  56
  57 #include <vulkan/vk_sdk_platform.h>
  58 #include "linmath.h"
  59 #include "object_type_string_helper.h"
  60
  61 #include "gettime.h"
  62 #include "inttypes.h"
  63 #define MILLION 1000000L
  64 #define BILLION 1000000000L
  65
  66 #define DEMO_TEXTURE_COUNT 1
  67 #define APP_SHORT_NAME "cube"
  68 #define APP_LONG_NAME "The Vulkan Cube Demo Program"
  69
  70 // Allow a maximum of two outstanding presentation operations.
  71 #define FRAME_LAG 2
  72
  73 #define ARRAY_SIZE(a) (sizeof(a) / sizeof(a[0]))
  74
  75 #if defined(NDEBUG) && defined(__GNUC__)
  76 #define U_ASSERT_ONLY __attribute__((unused))
  77 #else
  78 #define U_ASSERT_ONLY
  79 #endif
  80
  81 #if defined(__GNUC__)
  82 #define UNUSED __attribute__((unused))
  83 #else
  84 #define UNUSED
  85 #endif
  86
  87 #ifdef _WIN32
  88 bool in_callback = false;
  89 #define ERR_EXIT(err_msg, err_class)                                             \
  90     do {                                                                         \
  91         if (!demo->suppress_popups) MessageBox(NULL, err_msg, err_class, MB_OK); \
  92         exit(1);                                                                 \
  93     } while (0)
  94 void DbgMsg(char *fmt, ...) {
  95     va_list va;
  96     va_start(va, fmt);
  97     printf(fmt, va);
  98     fflush(stdout);
  99     va_end(va);
 100 }
 101
 102 #elif defined __ANDROID__
 103 #include <android/log.h>
 104 #define ERR_EXIT(err_msg, err_class)                                    \
 105     do {                                                                \
 106         ((void)__android_log_print(ANDROID_LOG_INFO, "Cube", err_msg)); \
 107         exit(1);                                                        \
 108     } while (0)
 109 #ifdef VARARGS_WORKS_ON_ANDROID
 110 void DbgMsg(const char *fmt, ...) {
 111     va_list va;
 112     va_start(va, fmt);
 113     __android_log_print(ANDROID_LOG_INFO, "Cube", fmt, va);
 114     va_end(va);
 115 }
 116 #else  // VARARGS_WORKS_ON_ANDROID
 117 #define DbgMsg(fmt, ...)                                                           \
 118     do {                                                                           \
 119         ((void)__android_log_print(ANDROID_LOG_INFO, "Cube", fmt, ##__VA_ARGS__)); \
 120     } while (0)
 121 #endif  // VARARGS_WORKS_ON_ANDROID
 122 #else
 123 #define ERR_EXIT(err_msg, err_class) \
 124     do {                             \
 125         printf("%s\n", err_msg);     \
 126         fflush(stdout);              \
 127         exit(1);                     \
 128     } while (0)
 129 void DbgMsg(char *fmt, ...) {
 130     va_list va;
 131     va_start(va, fmt);
 132     printf(fmt, va);
 133     fflush(stdout);
 134     va_end(va);
 135 }
 136 #endif
 137
 138 #define GET_INSTANCE_PROC_ADDR(inst, entrypoint)                                                              \
 139     {                                                                                                         \
 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"); \
 143         }                                                                                                     \
 144     }
 145
 146 static PFN_vkGetDeviceProcAddr g_gdpa = NULL;
 147
 148 #define GET_DEVICE_PROC_ADDR(dev, entrypoint)                                                                    \
 149     {                                                                                                            \
 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");        \
 154         }                                                                                                        \
 155     }
 156
 157 /*
 158  * structure to track all objects related to a texture.
 159  */
 160 struct texture_object {
 161     VkSampler sampler;
 162
 163     VkImage image;
 164     VkImageLayout imageLayout;
 165
 166     VkMemoryAllocateInfo mem_alloc;
 167     VkDeviceMemory mem;
 168     VkImageView view;
 169     int32_t tex_width, tex_height;
 170 };
 171
 172 static char *tex_files[] = {"lunarg.ppm"};
 173
 174 static int validation_error = 0;
 175
 176 struct vktexcube_vs_uniform {
 177     // Must start with MVP
 178     float mvp[4][4];
 179     float position[12 * 3][4];
 180     float attr[12 * 3][4];
 181 };
 182
 183 //--------------------------------------------------------------------------------------
 184 // Mesh and VertexFormat Data
 185 //--------------------------------------------------------------------------------------
 186 // clang-format off
 187 static const float g_vertex_buffer_data[] = {
 188     -1.0f,-1.0f,-1.0f,  // -X side
 189     -1.0f,-1.0f, 1.0f,
 190     -1.0f, 1.0f, 1.0f,
 191     -1.0f, 1.0f, 1.0f,
 192     -1.0f, 1.0f,-1.0f,
 193     -1.0f,-1.0f,-1.0f,
 194
 195     -1.0f,-1.0f,-1.0f,  // -Z side
 196      1.0f, 1.0f,-1.0f,
 197      1.0f,-1.0f,-1.0f,
 198     -1.0f,-1.0f,-1.0f,
 199     -1.0f, 1.0f,-1.0f,
 200      1.0f, 1.0f,-1.0f,
 201
 202     -1.0f,-1.0f,-1.0f,  // -Y side
 203      1.0f,-1.0f,-1.0f,
 204      1.0f,-1.0f, 1.0f,
 205     -1.0f,-1.0f,-1.0f,
 206      1.0f,-1.0f, 1.0f,
 207     -1.0f,-1.0f, 1.0f,
 208
 209     -1.0f, 1.0f,-1.0f,  // +Y side
 210     -1.0f, 1.0f, 1.0f,
 211      1.0f, 1.0f, 1.0f,
 212     -1.0f, 1.0f,-1.0f,
 213      1.0f, 1.0f, 1.0f,
 214      1.0f, 1.0f,-1.0f,
 215
 216      1.0f, 1.0f,-1.0f,  // +X side
 217      1.0f, 1.0f, 1.0f,
 218      1.0f,-1.0f, 1.0f,
 219      1.0f,-1.0f, 1.0f,
 220      1.0f,-1.0f,-1.0f,
 221      1.0f, 1.0f,-1.0f,
 222
 223     -1.0f, 1.0f, 1.0f,  // +Z side
 224     -1.0f,-1.0f, 1.0f,
 225      1.0f, 1.0f, 1.0f,
 226     -1.0f,-1.0f, 1.0f,
 227      1.0f,-1.0f, 1.0f,
 228      1.0f, 1.0f, 1.0f,
 229 };
 230
 231 static const float g_uv_buffer_data[] = {
 232     0.0f, 1.0f,  // -X side
 233     1.0f, 1.0f,
 234     1.0f, 0.0f,
 235     1.0f, 0.0f,
 236     0.0f, 0.0f,
 237     0.0f, 1.0f,
 238
 239     1.0f, 1.0f,  // -Z side
 240     0.0f, 0.0f,
 241     0.0f, 1.0f,
 242     1.0f, 1.0f,
 243     1.0f, 0.0f,
 244     0.0f, 0.0f,
 245
 246     1.0f, 0.0f,  // -Y side
 247     1.0f, 1.0f,
 248     0.0f, 1.0f,
 249     1.0f, 0.0f,
 250     0.0f, 1.0f,
 251     0.0f, 0.0f,
 252
 253     1.0f, 0.0f,  // +Y side
 254     0.0f, 0.0f,
 255     0.0f, 1.0f,
 256     1.0f, 0.0f,
 257     0.0f, 1.0f,
 258     1.0f, 1.0f,
 259
 260     1.0f, 0.0f,  // +X side
 261     0.0f, 0.0f,
 262     0.0f, 1.0f,
 263     0.0f, 1.0f,
 264     1.0f, 1.0f,
 265     1.0f, 0.0f,
 266
 267     0.0f, 0.0f,  // +Z side
 268     0.0f, 1.0f,
 269     1.0f, 0.0f,
 270     0.0f, 1.0f,
 271     1.0f, 1.0f,
 272     1.0f, 0.0f,
 273 };
 274 // clang-format on
 275
 276 void dumpMatrix(const char *note, mat4x4 MVP) {
 277     int i;
 278
 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]);
 282     }
 283     printf("\n");
 284     fflush(stdout);
 285 }
 286
 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]);
 290     printf("\n");
 291     fflush(stdout);
 292 }
 293
 294 typedef struct {
 295     VkImage image;
 296     VkCommandBuffer cmd;
 297     VkCommandBuffer graphics_to_present_cmd;
 298     VkImageView view;
 299     VkBuffer uniform_buffer;
 300     VkDeviceMemory uniform_memory;
 301     VkFramebuffer framebuffer;
 302     VkDescriptorSet descriptor_set;
 303 } SwapchainImageResources;
 304
 305 struct demo {
 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)
 313     Display *display;
 314     Window xlib_window;
 315     Atom xlib_wm_delete_window;
 316 #elif defined(VK_USE_PLATFORM_XCB_KHR)
 317     Display *display;
 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))
 336     void *window;
 337 #endif
 338     VkSurfaceKHR surface;
 339     bool prepared;
 340     bool use_staging_buffer;
 341     bool separate_present_queue;
 342     bool is_minimized;
 343
 344     bool VK_KHR_incremental_present_enabled;
 345
 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
 355
 356     VkInstance inst;
 357     VkPhysicalDevice gpu;
 358     VkDevice device;
 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;
 369
 370     uint32_t enabled_extension_count;
 371     uint32_t enabled_layer_count;
 372     char *extension_names[64];
 373     char *enabled_layers[64];
 374
 375     int width, height;
 376     VkFormat format;
 377     VkColorSpaceKHR color_space;
 378
 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];
 395     int frame_index;
 396
 397     VkCommandPool cmd_pool;
 398     VkCommandPool present_cmd_pool;
 399
 400     struct {
 401         VkFormat format;
 402
 403         VkImage image;
 404         VkMemoryAllocateInfo mem_alloc;
 405         VkDeviceMemory mem;
 406         VkImageView view;
 407     } depth;
 408
 409     struct texture_object textures[DEMO_TEXTURE_COUNT];
 410     struct texture_object staging_texture;
 411
 412     VkCommandBuffer cmd;  // Buffer for initialization commands
 413     VkPipelineLayout pipeline_layout;
 414     VkDescriptorSetLayout desc_layout;
 415     VkPipelineCache pipelineCache;
 416     VkRenderPass render_pass;
 417     VkPipeline pipeline;
 418
 419     mat4x4 projection_matrix;
 420     mat4x4 view_matrix;
 421     mat4x4 model_matrix;
 422
 423     float spin_angle;
 424     float spin_increment;
 425     bool pause;
 426
 427     VkShaderModule vert_shader_module;
 428     VkShaderModule frag_shader_module;
 429
 430     VkDescriptorPool desc_pool;
 431
 432     bool quit;
 433     int32_t curFrame;
 434     int32_t frameCount;
 435     bool validate;
 436     bool validate_checks_disabled;
 437     bool use_break;
 438     bool suppress_popups;
 439
 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;
 448
 449     uint32_t current_buffer;
 450     uint32_t queue_family_count;
 451 };
 452
 453 VKAPI_ATTR VkBool32 VKAPI_CALL debug_messenger_callback(VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity,
 454                                                         VkDebugUtilsMessageTypeFlagsEXT messageType,
 455                                                         const VkDebugUtilsMessengerCallbackDataEXT *pCallbackData,
 456                                                         void *pUserData) {
 457     char prefix[64] = "";
 458     char *message = (char *)malloc(strlen(pCallbackData->pMessage) + 5000);
 459     assert(message);
 460     struct demo *demo = (struct demo *)pUserData;
 461
 462     if (demo->use_break) {
 463 #ifndef WIN32
 464         raise(SIGTRAP);
 465 #else
 466         DebugBreak();
 467 #endif
 468     }
 469
 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 : ");
 478     }
 479
 480     if (messageType & VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT) {
 481         strcat(prefix, "GENERAL");
 482     } else {
 483         if (messageType & VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT) {
 484             strcat(prefix, "VALIDATION");
 485             validation_error = 1;
 486         }
 487         if (messageType & VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT) {
 488             if (messageType & VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT) {
 489                 strcat(prefix, "|");
 490             }
 491             strcat(prefix, "PERFORMANCE");
 492         }
 493     }
 494
 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);
 506             } else {
 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));
 510             }
 511             strcat(message, tmp_message);
 512         }
 513     }
 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);
 524         }
 525     }
 526
 527 #ifdef _WIN32
 528
 529     in_callback = true;
 530     if (!demo->suppress_popups)
 531         MessageBox(NULL, message, "Alert", MB_OK);
 532     in_callback = false;
 533
 534 #elif defined(ANDROID)
 535
 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);
 544     } else {
 545         __android_log_print(ANDROID_LOG_INFO,  APP_SHORT_NAME, "%s", message);
 546     }
 547
 548 #else
 549
 550     printf("%s\n", message);
 551     fflush(stdout);
 552
 553 #endif
 554
 555     free(message);
 556
 557     // Don't bail out, but keep going.
 558     return false;
 559 }
 560
 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.
 570         return false;
 571     }
 572     uint64_t deadline = desired + rdur;
 573     if (actual > deadline) {
 574         return true;
 575     } else {
 576         return false;
 577     }
 578 }
 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.
 589             return true;
 590         }
 591     }
 592     return false;
 593 }
 594
 595 // Forward declaration:
 596 static void demo_resize(struct demo *demo);
 597
 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) {
 604                 *typeIndex = i;
 605                 return true;
 606             }
 607         }
 608         typeBits >>= 1;
 609     }
 610     // No memory types matched, return failure
 611     return false;
 612 }
 613
 614 static void demo_flush_init_cmd(struct demo *demo) {
 615     VkResult U_ASSERT_ONLY err;
 616
 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;
 620
 621     err = vkEndCommandBuffer(demo->cmd);
 622     assert(!err);
 623
 624     VkFence fence;
 625     VkFenceCreateInfo fence_ci = {.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO, .pNext = NULL, .flags = 0};
 626     err = vkCreateFence(demo->device, &fence_ci, NULL, &fence);
 627     assert(!err);
 628
 629     const VkCommandBuffer cmd_bufs[] = {demo->cmd};
 630     VkSubmitInfo submit_info = {.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO,
 631                                 .pNext = NULL,
 632                                 .waitSemaphoreCount = 0,
 633                                 .pWaitSemaphores = NULL,
 634                                 .pWaitDstStageMask = NULL,
 635                                 .commandBufferCount = 1,
 636                                 .pCommandBuffers = cmd_bufs,
 637                                 .signalSemaphoreCount = 0,
 638                                 .pSignalSemaphores = NULL};
 639
 640     err = vkQueueSubmit(demo->graphics_queue, 1, &submit_info, fence);
 641     assert(!err);
 642
 643     err = vkWaitForFences(demo->device, 1, &fence, VK_TRUE, UINT64_MAX);
 644     assert(!err);
 645
 646     vkFreeCommandBuffers(demo->device, demo->cmd_pool, 1, cmd_bufs);
 647     vkDestroyFence(demo->device, fence, NULL);
 648     demo->cmd = VK_NULL_HANDLE;
 649 }
 650
 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) {
 654     assert(demo->cmd);
 655
 656     VkImageMemoryBarrier image_memory_barrier = {.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
 657                                                  .pNext = NULL,
 658                                                  .srcAccessMask = srcAccessMask,
 659                                                  .dstAccessMask = 0,
 660                                                  .oldLayout = old_image_layout,
 661                                                  .newLayout = new_image_layout,
 662                                                  .image = image,
 663                                                  .subresourceRange = {aspectMask, 0, 1, 0, 1}};
 664
 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;
 669             break;
 670
 671         case VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL:
 672             image_memory_barrier.dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
 673             break;
 674
 675         case VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL:
 676             image_memory_barrier.dstAccessMask = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
 677             break;
 678
 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;
 681             break;
 682
 683         case VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL:
 684             image_memory_barrier.dstAccessMask = VK_ACCESS_TRANSFER_READ_BIT;
 685             break;
 686
 687         case VK_IMAGE_LAYOUT_PRESENT_SRC_KHR:
 688             image_memory_barrier.dstAccessMask = VK_ACCESS_MEMORY_READ_BIT;
 689             break;
 690
 691         default:
 692             image_memory_barrier.dstAccessMask = 0;
 693             break;
 694     }
 695
 696     VkImageMemoryBarrier *pmemory_barrier = &image_memory_barrier;
 697
 698     vkCmdPipelineBarrier(demo->cmd, src_stages, dest_stages, 0, 0, NULL, 0, NULL, 1, pmemory_barrier);
 699 }
 700
 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,
 706         .pNext = NULL,
 707         .flags = VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT,
 708         .pInheritanceInfo = NULL,
 709     };
 710     const VkClearValue clear_values[2] = {
 711         [0] = {.color.float32 = {0.2f, 0.2f, 0.2f, 0.2f}},
 712         [1] = {.depthStencil = {1.0f, 0}},
 713     };
 714     const VkRenderPassBeginInfo rp_begin = {
 715         .sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO,
 716         .pNext = NULL,
 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,
 725     };
 726     VkResult U_ASSERT_ONLY err;
 727
 728     err = vkBeginCommandBuffer(cmd_buf, &cmd_buf_info);
 729
 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,
 734             .pNext = NULL,
 735             .objectType = VK_OBJECT_TYPE_COMMAND_BUFFER,
 736             .objectHandle = (uint64_t)cmd_buf,
 737             .pObjectName = "CubeDrawCommandBuf",
 738         };
 739         demo->SetDebugUtilsObjectNameEXT(demo->device, &cmd_buf_name);
 740
 741         label.sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT;
 742         label.pNext = NULL;
 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);
 749     }
 750
 751     assert(!err);
 752     vkCmdBeginRenderPass(cmd_buf, &rp_begin, VK_SUBPASS_CONTENTS_INLINE);
 753
 754     if (demo->validate) {
 755         label.sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT;
 756         label.pNext = NULL;
 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);
 763     }
 764
 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);
 768     VkViewport viewport;
 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);
 775
 776     VkRect2D scissor;
 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);
 783
 784     if (demo->validate) {
 785         label.sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT;
 786         label.pNext = NULL;
 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);
 793     }
 794
 795     vkCmdDraw(cmd_buf, 12 * 3, 1, 0, 0);
 796     if (demo->validate) {
 797         demo->CmdEndDebugUtilsLabelEXT(cmd_buf);
 798     }
 799
 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);
 805     }
 806
 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,
 814                                                         .pNext = NULL,
 815                                                         .srcAccessMask = 0,
 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}};
 823
 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);
 826     }
 827     if (demo->validate) {
 828         demo->CmdEndDebugUtilsLabelEXT(cmd_buf);
 829     }
 830     err = vkEndCommandBuffer(cmd_buf);
 831     assert(!err);
 832 }
 833
 834 void demo_build_image_ownership_cmd(struct demo *demo, int i) {
 835     VkResult U_ASSERT_ONLY err;
 836
 837     const VkCommandBufferBeginInfo cmd_buf_info = {
 838         .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
 839         .pNext = NULL,
 840         .flags = VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT,
 841         .pInheritanceInfo = NULL,
 842     };
 843     err = vkBeginCommandBuffer(demo->swapchain_image_resources[i].graphics_to_present_cmd, &cmd_buf_info);
 844     assert(!err);
 845
 846     VkImageMemoryBarrier image_ownership_barrier = {.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
 847                                                     .pNext = NULL,
 848                                                     .srcAccessMask = 0,
 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}};
 856
 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);
 860     assert(!err);
 861 }
 862
 863 void demo_update_data_buffer(struct demo *demo) {
 864     mat4x4 MVP, Model, VP;
 865     int matrixSize = sizeof(MVP);
 866     uint8_t *pData;
 867     VkResult U_ASSERT_ONLY err;
 868
 869     mat4x4_mul(VP, demo->projection_matrix, demo->view_matrix);
 870
 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);
 875
 876     err = vkMapMemory(demo->device, demo->swapchain_image_resources[demo->current_buffer].uniform_memory, 0, VK_WHOLE_SIZE, 0,
 877                       (void **)&pData);
 878     assert(!err);
 879
 880     memcpy(pData, (const void *)&MVP[0][0], matrixSize);
 881
 882     vkUnmapMemory(demo->device, demo->swapchain_image_resources[demo->current_buffer].uniform_memory);
 883 }
 884
 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;
 890     uint32_t count = 0;
 891
 892     err = demo->fpGetPastPresentationTimingGOOGLE(demo->device, demo->swapchain, &count, NULL);
 893     assert(!err);
 894     if (count) {
 895         past = (VkPastPresentationTimingGOOGLE *)malloc(sizeof(VkPastPresentationTimingGOOGLE) * count);
 896         assert(past);
 897         err = demo->fpGetPastPresentationTimingGOOGLE(demo->device, demo->swapchain, &count, past);
 898         assert(!err);
 899
 900         bool early = false;
 901         bool late = false;
 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;
 911
 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;
 917                 break;
 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:
 926                     early = true;
 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;
 934                 } else {
 935                     // We are in the midst of a set of early images,
 936                     // and so we won't do anything.
 937                 }
 938                 late = false;
 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)) {
 948                     late = true;
 949                     // Record the last suspected-late present:
 950                     demo->last_late_id = demo->next_present_id - 1;
 951                 } else {
 952                     // We are in the midst of a set of likely-late images,
 953                     // and so we won't do anything.
 954                 }
 955                 early = false;
 956                 demo->last_early_id = 0;
 957             } else {
 958                 // Since this image was not presented early or late, reset
 959                 // any sets of early or late presentIDs:
 960                 early = false;
 961                 late = false;
 962                 calibrate_next = true;
 963                 demo->last_early_id = 0;
 964                 demo->last_late_id = 0;
 965             }
 966         }
 967
 968         if (early) {
 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):
 972             //
 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
 978                 // try to go faster.
 979                 demo->refresh_duration_multiplier = 1;
 980             }
 981             demo->target_IPD = demo->refresh_duration * demo->refresh_duration_multiplier;
 982         }
 983         if (late) {
 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):
 986             //
 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;
 991         }
 992
 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));
 996         }
 997     }
 998 }
 999
1000 static void demo_draw(struct demo *demo) {
1001     VkResult U_ASSERT_ONLY err;
1002
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]);
1006
1007     do {
1008         // Get the index of the next available swapchain image:
1009         err =
1010             demo->fpAcquireNextImageKHR(demo->device, demo->swapchain, UINT64_MAX,
1011                                         demo->image_acquired_semaphores[demo->frame_index], VK_NULL_HANDLE, &demo->current_buffer);
1012
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:
1016             demo_resize(demo);
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.
1020             break;
1021         } else {
1022             assert(!err);
1023         }
1024     } while (err != VK_SUCCESS);
1025
1026     demo_update_data_buffer(demo);
1027
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);
1032
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.
1038     }
1039
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]);
1057     assert(!err);
1058
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);
1072         assert(!err);
1073     }
1074
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,
1079         .pNext = NULL,
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,
1086     };
1087
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,
1102             .layer = 0,
1103         };
1104         VkPresentRegionKHR region = {
1105             .rectangleCount = 1,
1106             .pRectangles = &rect,
1107         };
1108         VkPresentRegionsKHR regions = {
1109             .sType = VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR,
1110             .pNext = present.pNext,
1111             .swapchainCount = present.swapchainCount,
1112             .pRegions = &region,
1113         };
1114         present.pNext = &regions;
1115     }
1116
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.
1121             //
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();
1128             if (curtime == 0) {
1129                 // Since we didn't find out the current time, don't give a
1130                 // desiredPresentTime:
1131                 ptime.desiredPresentTime = 0;
1132             } else {
1133                 ptime.desiredPresentTime = curtime + (demo->target_IPD >> 1);
1134             }
1135         } else {
1136             ptime.desiredPresentTime = (demo->prev_desired_present_time + demo->target_IPD);
1137         }
1138         ptime.presentID = demo->next_present_id++;
1139         demo->prev_desired_present_time = ptime.desiredPresentTime;
1140
1141         VkPresentTimesInfoGOOGLE present_time = {
1142             .sType = VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE,
1143             .pNext = present.pNext,
1144             .swapchainCount = present.swapchainCount,
1145             .pTimes = &ptime,
1146         };
1147         if (demo->VK_GOOGLE_display_timing_enabled) {
1148             present.pNext = &present_time;
1149         }
1150     }
1151
1152     err = demo->fpQueuePresentKHR(demo->present_queue, &present);
1153     demo->frame_index += 1;
1154     demo->frame_index %= FRAME_LAG;
1155
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:
1159         demo_resize(demo);
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.
1163     } else {
1164         assert(!err);
1165     }
1166 }
1167
1168 static void demo_prepare_buffers(struct demo *demo) {
1169     VkResult U_ASSERT_ONLY err;
1170     VkSwapchainKHR oldSwapchain = demo->swapchain;
1171
1172     // Check the surface capabilities and formats
1173     VkSurfaceCapabilitiesKHR surfCapabilities;
1174     err = demo->fpGetPhysicalDeviceSurfaceCapabilitiesKHR(demo->gpu, demo->surface, &surfCapabilities);
1175     assert(!err);
1176
1177     uint32_t presentModeCount;
1178     err = demo->fpGetPhysicalDeviceSurfacePresentModesKHR(demo->gpu, demo->surface, &presentModeCount, NULL);
1179     assert(!err);
1180     VkPresentModeKHR *presentModes = (VkPresentModeKHR *)malloc(presentModeCount * sizeof(VkPresentModeKHR));
1181     assert(presentModes);
1182     err = demo->fpGetPhysicalDeviceSurfacePresentModesKHR(demo->gpu, demo->surface, &presentModeCount, presentModes);
1183     assert(!err);
1184
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
1190         // maximum values.
1191         swapchainExtent.width = demo->width;
1192         swapchainExtent.height = demo->height;
1193
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;
1198         }
1199
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;
1204         }
1205     } else {
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;
1210     }
1211
1212     if (demo->width == 0 || demo->height == 0) {
1213         demo->is_minimized = true;
1214         return;
1215     } else {
1216         demo->is_minimized = false;
1217     }
1218
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;
1222
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.
1226     //
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.
1235
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
1238     // display.
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.
1249
1250     if (demo->presentMode != swapchainPresentMode) {
1251         for (size_t i = 0; i < presentModeCount; ++i) {
1252             if (presentModes[i] == demo->presentMode) {
1253                 swapchainPresentMode = demo->presentMode;
1254                 break;
1255             }
1256         }
1257     }
1258     if (swapchainPresentMode != demo->presentMode) {
1259         ERR_EXIT("Present mode specified is not supported\n", "Present mode unsupported");
1260     }
1261
1262     // Determine the number of VkImages to use in the swap chain.
1263     // Application desires to acquire 3 images at a time for triple
1264     // buffering
1265     uint32_t desiredNumOfSwapchainImages = 3;
1266     if (desiredNumOfSwapchainImages < surfCapabilities.minImageCount) {
1267         desiredNumOfSwapchainImages = surfCapabilities.minImageCount;
1268     }
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;
1274     }
1275
1276     VkSurfaceTransformFlagsKHR preTransform;
1277     if (surfCapabilities.supportedTransforms & VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR) {
1278         preTransform = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR;
1279     } else {
1280         preTransform = surfCapabilities.currentTransform;
1281     }
1282
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,
1290     };
1291     for (uint32_t i = 0; i < ARRAY_SIZE(compositeAlphaFlags); i++) {
1292         if (surfCapabilities.supportedCompositeAlpha & compositeAlphaFlags[i]) {
1293             compositeAlpha = compositeAlphaFlags[i];
1294             break;
1295         }
1296     }
1297
1298     VkSwapchainCreateInfoKHR swapchain_ci = {
1299         .sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR,
1300         .pNext = NULL,
1301         .surface = demo->surface,
1302         .minImageCount = desiredNumOfSwapchainImages,
1303         .imageFormat = demo->format,
1304         .imageColorSpace = demo->color_space,
1305         .imageExtent =
1306             {
1307                 .width = swapchainExtent.width,
1308                 .height = swapchainExtent.height,
1309             },
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,
1319         .clipped = true,
1320     };
1321     uint32_t i;
1322     err = demo->fpCreateSwapchainKHR(demo->device, &swapchain_ci, NULL, &demo->swapchain);
1323     assert(!err);
1324
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);
1331     }
1332
1333     err = demo->fpGetSwapchainImagesKHR(demo->device, demo->swapchain, &demo->swapchainImageCount, NULL);
1334     assert(!err);
1335
1336     VkImage *swapchainImages = (VkImage *)malloc(demo->swapchainImageCount * sizeof(VkImage));
1337     assert(swapchainImages);
1338     err = demo->fpGetSwapchainImagesKHR(demo->device, demo->swapchain, &demo->swapchainImageCount, swapchainImages);
1339     assert(!err);
1340
1341     demo->swapchain_image_resources =
1342         (SwapchainImageResources *)malloc(sizeof(SwapchainImageResources) * demo->swapchainImageCount);
1343     assert(demo->swapchain_image_resources);
1344
1345     for (i = 0; i < demo->swapchainImageCount; i++) {
1346         VkImageViewCreateInfo color_image_view = {
1347             .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
1348             .pNext = NULL,
1349             .format = demo->format,
1350             .components =
1351                 {
1352                     .r = VK_COMPONENT_SWIZZLE_R,
1353                     .g = VK_COMPONENT_SWIZZLE_G,
1354                     .b = VK_COMPONENT_SWIZZLE_B,
1355                     .a = VK_COMPONENT_SWIZZLE_A,
1356                 },
1357             .subresourceRange =
1358                 {.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT, .baseMipLevel = 0, .levelCount = 1, .baseArrayLayer = 0, .layerCount = 1},
1359             .viewType = VK_IMAGE_VIEW_TYPE_2D,
1360             .flags = 0,
1361         };
1362
1363         demo->swapchain_image_resources[i].image = swapchainImages[i];
1364
1365         color_image_view.image = demo->swapchain_image_resources[i].image;
1366
1367         err = vkCreateImageView(demo->device, &color_image_view, NULL, &demo->swapchain_image_resources[i].view);
1368         assert(!err);
1369     }
1370
1371     if (demo->VK_GOOGLE_display_timing_enabled) {
1372         VkRefreshCycleDurationGOOGLE rc_dur;
1373         err = demo->fpGetRefreshCycleDurationGOOGLE(demo->device, demo->swapchain, &rc_dur);
1374         assert(!err);
1375         demo->refresh_duration = rc_dur.refreshDuration;
1376
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;
1383     }
1384
1385     if (NULL != presentModes) {
1386         free(presentModes);
1387     }
1388 }
1389
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,
1394         .pNext = NULL,
1395         .imageType = VK_IMAGE_TYPE_2D,
1396         .format = depth_format,
1397         .extent = {demo->width, demo->height, 1},
1398         .mipLevels = 1,
1399         .arrayLayers = 1,
1400         .samples = VK_SAMPLE_COUNT_1_BIT,
1401         .tiling = VK_IMAGE_TILING_OPTIMAL,
1402         .usage = VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT,
1403         .flags = 0,
1404     };
1405
1406     VkImageViewCreateInfo view = {
1407         .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
1408         .pNext = NULL,
1409         .image = VK_NULL_HANDLE,
1410         .format = depth_format,
1411         .subresourceRange =
1412             {.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT, .baseMipLevel = 0, .levelCount = 1, .baseArrayLayer = 0, .layerCount = 1},
1413         .flags = 0,
1414         .viewType = VK_IMAGE_VIEW_TYPE_2D,
1415     };
1416
1417     VkMemoryRequirements mem_reqs;
1418     VkResult U_ASSERT_ONLY err;
1419     bool U_ASSERT_ONLY pass;
1420
1421     demo->depth.format = depth_format;
1422
1423     /* create image */
1424     err = vkCreateImage(demo->device, &image, NULL, &demo->depth.image);
1425     assert(!err);
1426
1427     vkGetImageMemoryRequirements(demo->device, demo->depth.image, &mem_reqs);
1428     assert(!err);
1429
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;
1434
1435     pass = memory_type_from_properties(demo, mem_reqs.memoryTypeBits, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT,
1436                                        &demo->depth.mem_alloc.memoryTypeIndex);
1437     assert(pass);
1438
1439     /* allocate memory */
1440     err = vkAllocateMemory(demo->device, &demo->depth.mem_alloc, NULL, &demo->depth.mem);
1441     assert(!err);
1442
1443     /* bind memory */
1444     err = vkBindImageMemory(demo->device, demo->depth.image, demo->depth.mem, 0);
1445     assert(!err);
1446
1447     /* create image view */
1448     view.image = demo->depth.image;
1449     err = vkCreateImageView(demo->device, &view, NULL, &demo->depth.view);
1450     assert(!err);
1451 }
1452
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;
1457 #endif
1458
1459 #ifdef __ANDROID__
1460 #include <lunarg.ppm.h>
1461     char *cPtr;
1462     cPtr = (char *)lunarg_ppm;
1463     if ((unsigned char *)cPtr >= (lunarg_ppm + lunarg_ppm_len) || strncmp(cPtr, "P6\n", 3)) {
1464         return false;
1465     }
1466     while (strncmp(cPtr++, "\n", 1))
1467         ;
1468     sscanf(cPtr, "%u %u", width, height);
1469     if (rgba_data == NULL) {
1470         return true;
1471     }
1472     while (strncmp(cPtr++, "\n", 1))
1473         ;
1474     if ((unsigned char *)cPtr >= (lunarg_ppm + lunarg_ppm_len) || strncmp(cPtr, "255\n", 4)) {
1475         return false;
1476     }
1477     while (strncmp(cPtr++, "\n", 1))
1478         ;
1479
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 */
1485             rowPtr += 4;
1486             cPtr += 3;
1487         }
1488         rgba_data += layout->rowPitch;
1489     }
1490
1491     return true;
1492 #else
1493     FILE *fPtr = fopen(filename, "rb");
1494     char header[256], *cPtr, *tmp;
1495
1496     if (!fPtr) return false;
1497
1498     cPtr = fgets(header, 256, fPtr);  // P6
1499     if (cPtr == NULL || strncmp(header, "P6\n", 3)) {
1500         fclose(fPtr);
1501         return false;
1502     }
1503
1504     do {
1505         cPtr = fgets(header, 256, fPtr);
1506         if (cPtr == NULL) {
1507             fclose(fPtr);
1508             return false;
1509         }
1510     } while (!strncmp(header, "#", 1));
1511
1512     sscanf(header, "%u %u", width, height);
1513     if (rgba_data == NULL) {
1514         fclose(fPtr);
1515         return true;
1516     }
1517     tmp = fgets(header, 256, fPtr);  // Format
1518     (void)tmp;
1519     if (cPtr == NULL || strncmp(header, "255\n", 3)) {
1520         fclose(fPtr);
1521         return false;
1522     }
1523
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);
1528             (void)s;
1529             rowPtr[3] = 255; /* Alpha of 1 */
1530             rowPtr += 4;
1531         }
1532         rgba_data += layout->rowPitch;
1533     }
1534     fclose(fPtr);
1535     return true;
1536 #endif
1537 }
1538
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;
1542     int32_t tex_width;
1543     int32_t tex_height;
1544     VkResult U_ASSERT_ONLY err;
1545     bool U_ASSERT_ONLY pass;
1546
1547     if (!loadTexture(filename, NULL, NULL, &tex_width, &tex_height)) {
1548         ERR_EXIT("Failed to load textures", "Load Texture Failure");
1549     }
1550
1551     tex_obj->tex_width = tex_width;
1552     tex_obj->tex_height = tex_height;
1553
1554     const VkImageCreateInfo image_create_info = {
1555         .sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,
1556         .pNext = NULL,
1557         .imageType = VK_IMAGE_TYPE_2D,
1558         .format = tex_format,
1559         .extent = {tex_width, tex_height, 1},
1560         .mipLevels = 1,
1561         .arrayLayers = 1,
1562         .samples = VK_SAMPLE_COUNT_1_BIT,
1563         .tiling = tiling,
1564         .usage = usage,
1565         .flags = 0,
1566         .initialLayout = VK_IMAGE_LAYOUT_PREINITIALIZED,
1567     };
1568
1569     VkMemoryRequirements mem_reqs;
1570
1571     err = vkCreateImage(demo->device, &image_create_info, NULL, &tex_obj->image);
1572     assert(!err);
1573
1574     vkGetImageMemoryRequirements(demo->device, tex_obj->image, &mem_reqs);
1575
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;
1580
1581     pass = memory_type_from_properties(demo, mem_reqs.memoryTypeBits, required_props, &tex_obj->mem_alloc.memoryTypeIndex);
1582     assert(pass);
1583
1584     /* allocate memory */
1585     err = vkAllocateMemory(demo->device, &tex_obj->mem_alloc, NULL, &(tex_obj->mem));
1586     assert(!err);
1587
1588     /* bind memory */
1589     err = vkBindImageMemory(demo->device, tex_obj->image, tex_obj->mem, 0);
1590     assert(!err);
1591
1592     if (required_props & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) {
1593         const VkImageSubresource subres = {
1594             .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
1595             .mipLevel = 0,
1596             .arrayLayer = 0,
1597         };
1598         VkSubresourceLayout layout;
1599         void *data;
1600
1601         vkGetImageSubresourceLayout(demo->device, tex_obj->image, &subres, &layout);
1602
1603         err = vkMapMemory(demo->device, tex_obj->mem, 0, tex_obj->mem_alloc.allocationSize, 0, &data);
1604         assert(!err);
1605
1606         if (!loadTexture(filename, data, &layout, &tex_width, &tex_height)) {
1607             fprintf(stderr, "Error loading texture: %s\n", filename);
1608         }
1609
1610         vkUnmapMemory(demo->device, tex_obj->mem);
1611     }
1612
1613     tex_obj->imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
1614 }
1615
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);
1620 }
1621
1622 static void demo_prepare_textures(struct demo *demo) {
1623     const VkFormat tex_format = VK_FORMAT_R8G8B8A8_UNORM;
1624     VkFormatProperties props;
1625     uint32_t i;
1626
1627     vkGetPhysicalDeviceFormatProperties(demo->gpu, tex_format, &props);
1628
1629     for (i = 0; i < DEMO_TEXTURE_COUNT; i++) {
1630         VkResult U_ASSERT_ONLY err;
1631
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 */
1644
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);
1649
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);
1653
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);
1657
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);
1661
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},
1668             };
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, &copy_region);
1671
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);
1675
1676         } else {
1677             /* Can't support VK_FORMAT_R8G8B8A8_UNORM !? */
1678             assert(!"No support for R8G8B8A8_UNORM as texture image format");
1679         }
1680
1681         const VkSamplerCreateInfo sampler = {
1682             .sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO,
1683             .pNext = NULL,
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,
1690             .mipLodBias = 0.0f,
1691             .anisotropyEnable = VK_FALSE,
1692             .maxAnisotropy = 1,
1693             .compareOp = VK_COMPARE_OP_NEVER,
1694             .minLod = 0.0f,
1695             .maxLod = 0.0f,
1696             .borderColor = VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE,
1697             .unnormalizedCoordinates = VK_FALSE,
1698         };
1699
1700         VkImageViewCreateInfo view = {
1701             .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
1702             .pNext = NULL,
1703             .image = VK_NULL_HANDLE,
1704             .viewType = VK_IMAGE_VIEW_TYPE_2D,
1705             .format = tex_format,
1706             .components =
1707                 {
1708                     VK_COMPONENT_SWIZZLE_R,
1709                     VK_COMPONENT_SWIZZLE_G,
1710                     VK_COMPONENT_SWIZZLE_B,
1711                     VK_COMPONENT_SWIZZLE_A,
1712                 },
1713             .subresourceRange = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1},
1714             .flags = 0,
1715         };
1716
1717         /* create sampler */
1718         err = vkCreateSampler(demo->device, &sampler, NULL, &demo->textures[i].sampler);
1719         assert(!err);
1720
1721         /* create image view */
1722         view.image = demo->textures[i].image;
1723         err = vkCreateImageView(demo->device, &view, NULL, &demo->textures[i].view);
1724         assert(!err);
1725     }
1726 }
1727
1728 void demo_prepare_cube_data_buffers(struct demo *demo) {
1729     VkBufferCreateInfo buf_info;
1730     VkMemoryRequirements mem_reqs;
1731     VkMemoryAllocateInfo mem_alloc;
1732     uint8_t *pData;
1733     mat4x4 MVP, VP;
1734     VkResult U_ASSERT_ONLY err;
1735     bool U_ASSERT_ONLY pass;
1736     struct vktexcube_vs_uniform data;
1737
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);
1742
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;
1752     }
1753
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);
1758
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);
1761         assert(!err);
1762
1763         vkGetBufferMemoryRequirements(demo->device, demo->swapchain_image_resources[i].uniform_buffer, &mem_reqs);
1764
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;
1769
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);
1773         assert(pass);
1774
1775         err = vkAllocateMemory(demo->device, &mem_alloc, NULL, &demo->swapchain_image_resources[i].uniform_memory);
1776         assert(!err);
1777
1778         err = vkMapMemory(demo->device, demo->swapchain_image_resources[i].uniform_memory, 0, VK_WHOLE_SIZE, 0, (void **)&pData);
1779         assert(!err);
1780
1781         memcpy(pData, &data, sizeof data);
1782
1783         vkUnmapMemory(demo->device, demo->swapchain_image_resources[i].uniform_memory);
1784
1785         err = vkBindBufferMemory(demo->device, demo->swapchain_image_resources[i].uniform_buffer,
1786                                  demo->swapchain_image_resources[i].uniform_memory, 0);
1787         assert(!err);
1788     }
1789 }
1790
1791 static void demo_prepare_descriptor_layout(struct demo *demo) {
1792     const VkDescriptorSetLayoutBinding layout_bindings[2] = {
1793         [0] =
1794             {
1795                 .binding = 0,
1796                 .descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
1797                 .descriptorCount = 1,
1798                 .stageFlags = VK_SHADER_STAGE_VERTEX_BIT,
1799                 .pImmutableSamplers = NULL,
1800             },
1801         [1] =
1802             {
1803                 .binding = 1,
1804                 .descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
1805                 .descriptorCount = DEMO_TEXTURE_COUNT,
1806                 .stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT,
1807                 .pImmutableSamplers = NULL,
1808             },
1809     };
1810     const VkDescriptorSetLayoutCreateInfo descriptor_layout = {
1811         .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO,
1812         .pNext = NULL,
1813         .bindingCount = 2,
1814         .pBindings = layout_bindings,
1815     };
1816     VkResult U_ASSERT_ONLY err;
1817
1818     err = vkCreateDescriptorSetLayout(demo->device, &descriptor_layout, NULL, &demo->desc_layout);
1819     assert(!err);
1820
1821     const VkPipelineLayoutCreateInfo pPipelineLayoutCreateInfo = {
1822         .sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,
1823         .pNext = NULL,
1824         .setLayoutCount = 1,
1825         .pSetLayouts = &demo->desc_layout,
1826     };
1827
1828     err = vkCreatePipelineLayout(demo->device, &pPipelineLayoutCreateInfo, NULL, &demo->pipeline_layout);
1829     assert(!err);
1830 }
1831
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] = {
1842         [0] =
1843             {
1844                 .format = demo->format,
1845                 .flags = 0,
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,
1853             },
1854         [1] =
1855             {
1856                 .format = demo->depth.format,
1857                 .flags = 0,
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,
1865             },
1866     };
1867     const VkAttachmentReference color_reference = {
1868         .attachment = 0,
1869         .layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
1870     };
1871     const VkAttachmentReference depth_reference = {
1872         .attachment = 1,
1873         .layout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
1874     };
1875     const VkSubpassDescription subpass = {
1876         .pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS,
1877         .flags = 0,
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,
1886     };
1887     const VkRenderPassCreateInfo rp_info = {
1888         .sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO,
1889         .pNext = NULL,
1890         .flags = 0,
1891         .attachmentCount = 2,
1892         .pAttachments = attachments,
1893         .subpassCount = 1,
1894         .pSubpasses = &subpass,
1895         .dependencyCount = 0,
1896         .pDependencies = NULL,
1897     };
1898     VkResult U_ASSERT_ONLY err;
1899
1900     err = vkCreateRenderPass(demo->device, &rp_info, NULL, &demo->render_pass);
1901     assert(!err);
1902 }
1903
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;
1908
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;
1914
1915     err = vkCreateShaderModule(demo->device, &moduleCreateInfo, NULL, &module);
1916     assert(!err);
1917
1918     return module;
1919 }
1920
1921 static void demo_prepare_vs(struct demo *demo) {
1922     const uint32_t vs_code[] = {
1923 #include "cube.vert.inc"
1924     };
1925     demo->vert_shader_module = demo_prepare_shader_module(demo, vs_code, sizeof(vs_code));
1926 }
1927
1928 static void demo_prepare_fs(struct demo *demo) {
1929     const uint32_t fs_code[] = {
1930 #include "cube.frag.inc"
1931     };
1932     demo->frag_shader_module = demo_prepare_shader_module(demo, fs_code, sizeof(fs_code));
1933 }
1934
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;
1948
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;
1953
1954     memset(&pipeline, 0, sizeof(pipeline));
1955     pipeline.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO;
1956     pipeline.layout = demo->pipeline_layout;
1957
1958     memset(&vi, 0, sizeof(vi));
1959     vi.sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO;
1960
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;
1964
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;
1974
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;
1983
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;
1990
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;
2001     ds.front = ds.back;
2002
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;
2007
2008     demo_prepare_vs(demo);
2009     demo_prepare_fs(demo);
2010
2011     // Two stages: vs and fs
2012     VkPipelineShaderStageCreateInfo shaderStages[2];
2013     memset(&shaderStages, 0, 2 * sizeof(VkPipelineShaderStageCreateInfo));
2014
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";
2019
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";
2024
2025     memset(&pipelineCache, 0, sizeof(pipelineCache));
2026     pipelineCache.sType = VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO;
2027
2028     err = vkCreatePipelineCache(demo->device, &pipelineCache, NULL, &demo->pipelineCache);
2029     assert(!err);
2030
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;
2042
2043     pipeline.renderPass = demo->render_pass;
2044
2045     err = vkCreateGraphicsPipelines(demo->device, demo->pipelineCache, 1, &pipeline, NULL, &demo->pipeline);
2046     assert(!err);
2047
2048     vkDestroyShaderModule(demo->device, demo->frag_shader_module, NULL);
2049     vkDestroyShaderModule(demo->device, demo->vert_shader_module, NULL);
2050 }
2051
2052 static void demo_prepare_descriptor_pool(struct demo *demo) {
2053     const VkDescriptorPoolSize type_counts[2] = {
2054         [0] =
2055             {
2056                 .type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
2057                 .descriptorCount = demo->swapchainImageCount,
2058             },
2059         [1] =
2060             {
2061                 .type = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
2062                 .descriptorCount = demo->swapchainImageCount * DEMO_TEXTURE_COUNT,
2063             },
2064     };
2065     const VkDescriptorPoolCreateInfo descriptor_pool = {
2066         .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO,
2067         .pNext = NULL,
2068         .maxSets = demo->swapchainImageCount,
2069         .poolSizeCount = 2,
2070         .pPoolSizes = type_counts,
2071     };
2072     VkResult U_ASSERT_ONLY err;
2073
2074     err = vkCreateDescriptorPool(demo->device, &descriptor_pool, NULL, &demo->desc_pool);
2075     assert(!err);
2076 }
2077
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;
2082
2083     VkDescriptorSetAllocateInfo alloc_info = {.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO,
2084                                               .pNext = NULL,
2085                                               .descriptorPool = demo->desc_pool,
2086                                               .descriptorSetCount = 1,
2087                                               .pSetLayouts = &demo->desc_layout};
2088
2089     VkDescriptorBufferInfo buffer_info;
2090     buffer_info.offset = 0;
2091     buffer_info.range = sizeof(struct vktexcube_vs_uniform);
2092
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;
2098     }
2099
2100     memset(&writes, 0, sizeof(writes));
2101
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;
2106
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;
2112
2113     for (unsigned int i = 0; i < demo->swapchainImageCount; i++) {
2114         err = vkAllocateDescriptorSets(demo->device, &alloc_info, &demo->swapchain_image_resources[i].descriptor_set);
2115         assert(!err);
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);
2120     }
2121 }
2122
2123 static void demo_prepare_framebuffers(struct demo *demo) {
2124     VkImageView attachments[2];
2125     attachments[1] = demo->depth.view;
2126
2127     const VkFramebufferCreateInfo fb_info = {
2128         .sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO,
2129         .pNext = NULL,
2130         .renderPass = demo->render_pass,
2131         .attachmentCount = 2,
2132         .pAttachments = attachments,
2133         .width = demo->width,
2134         .height = demo->height,
2135         .layers = 1,
2136     };
2137     VkResult U_ASSERT_ONLY err;
2138     uint32_t i;
2139
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);
2143         assert(!err);
2144     }
2145 }
2146
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,
2152             .pNext = NULL,
2153             .queueFamilyIndex = demo->graphics_queue_family_index,
2154             .flags = 0,
2155         };
2156         err = vkCreateCommandPool(demo->device, &cmd_pool_info, NULL, &demo->cmd_pool);
2157         assert(!err);
2158     }
2159
2160     const VkCommandBufferAllocateInfo cmd = {
2161         .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,
2162         .pNext = NULL,
2163         .commandPool = demo->cmd_pool,
2164         .level = VK_COMMAND_BUFFER_LEVEL_PRIMARY,
2165         .commandBufferCount = 1,
2166     };
2167     err = vkAllocateCommandBuffers(demo->device, &cmd, &demo->cmd);
2168     assert(!err);
2169     VkCommandBufferBeginInfo cmd_buf_info = {
2170         .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
2171         .pNext = NULL,
2172         .flags = 0,
2173         .pInheritanceInfo = NULL,
2174     };
2175     err = vkBeginCommandBuffer(demo->cmd, &cmd_buf_info);
2176     assert(!err);
2177
2178     demo_prepare_buffers(demo);
2179
2180     if (demo->is_minimized) {
2181         demo->prepared = false;
2182         return;
2183     }
2184
2185     demo_prepare_depth(demo);
2186     demo_prepare_textures(demo);
2187     demo_prepare_cube_data_buffers(demo);
2188
2189     demo_prepare_descriptor_layout(demo);
2190     demo_prepare_render_pass(demo);
2191     demo_prepare_pipeline(demo);
2192
2193     for (uint32_t i = 0; i < demo->swapchainImageCount; i++) {
2194         err = vkAllocateCommandBuffers(demo->device, &cmd, &demo->swapchain_image_resources[i].cmd);
2195         assert(!err);
2196     }
2197
2198     if (demo->separate_present_queue) {
2199         const VkCommandPoolCreateInfo present_cmd_pool_info = {
2200             .sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,
2201             .pNext = NULL,
2202             .queueFamilyIndex = demo->present_queue_family_index,
2203             .flags = 0,
2204         };
2205         err = vkCreateCommandPool(demo->device, &present_cmd_pool_info, NULL, &demo->present_cmd_pool);
2206         assert(!err);
2207         const VkCommandBufferAllocateInfo present_cmd_info = {
2208             .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,
2209             .pNext = NULL,
2210             .commandPool = demo->present_cmd_pool,
2211             .level = VK_COMMAND_BUFFER_LEVEL_PRIMARY,
2212             .commandBufferCount = 1,
2213         };
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);
2217             assert(!err);
2218             demo_build_image_ownership_cmd(demo, i);
2219         }
2220     }
2221
2222     demo_prepare_descriptor_pool(demo);
2223     demo_prepare_descriptor_set(demo);
2224
2225     demo_prepare_framebuffers(demo);
2226
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);
2230     }
2231
2232     /*
2233      * Prepare functions above may generate pipeline commands
2234      * that need to be flushed before beginning the render loop.
2235      */
2236     demo_flush_init_cmd(demo);
2237     if (demo->staging_texture.image) {
2238         demo_destroy_texture_image(demo, &demo->staging_texture);
2239     }
2240
2241     demo->current_buffer = 0;
2242     demo->prepared = true;
2243 }
2244
2245 static void demo_cleanup(struct demo *demo) {
2246     uint32_t i;
2247
2248     demo->prepared = false;
2249     vkDeviceWaitIdle(demo->device);
2250
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);
2259         }
2260     }
2261
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);
2266         }
2267         vkDestroyDescriptorPool(demo->device, demo->desc_pool, NULL);
2268
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);
2274
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);
2280         }
2281         demo->fpDestroySwapchainKHR(demo->device, demo->swapchain, NULL);
2282
2283         vkDestroyImageView(demo->device, demo->depth.view, NULL);
2284         vkDestroyImage(demo->device, demo->depth.image, NULL);
2285         vkFreeMemory(demo->device, demo->depth.mem, NULL);
2286
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);
2292         }
2293         free(demo->swapchain_image_resources);
2294         free(demo->queue_props);
2295         vkDestroyCommandPool(demo->device, demo->cmd_pool, NULL);
2296
2297         if (demo->separate_present_queue) {
2298             vkDestroyCommandPool(demo->device, demo->present_cmd_pool, NULL);
2299         }
2300     }
2301     vkDeviceWaitIdle(demo->device);
2302     vkDestroyDevice(demo->device, NULL);
2303     if (demo->validate) {
2304         demo->DestroyDebugUtilsMessengerEXT(demo->inst, demo->dbg_messenger, NULL);
2305     }
2306     vkDestroySurfaceKHR(demo->inst, demo->surface, NULL);
2307
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)
2326 #endif
2327
2328     vkDestroyInstance(demo->inst, NULL);
2329 }
2330
2331 static void demo_resize(struct demo *demo) {
2332     uint32_t i;
2333
2334     // Don't react to resize until after first initialization.
2335     if (!demo->prepared) {
2336         if (demo->is_minimized) {
2337             demo_prepare(demo);
2338         }
2339         return;
2340     }
2341     // In order to properly resize the window, we must re-create the swapchain
2342     // AND redo the command buffers, etc.
2343     //
2344     // First, perform part of the demo_cleanup() function:
2345     demo->prepared = false;
2346     vkDeviceWaitIdle(demo->device);
2347
2348     for (i = 0; i < demo->swapchainImageCount; i++) {
2349         vkDestroyFramebuffer(demo->device, demo->swapchain_image_resources[i].framebuffer, NULL);
2350     }
2351     vkDestroyDescriptorPool(demo->device, demo->desc_pool, NULL);
2352
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);
2358
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);
2364     }
2365
2366     vkDestroyImageView(demo->device, demo->depth.view, NULL);
2367     vkDestroyImage(demo->device, demo->depth.image, NULL);
2368     vkFreeMemory(demo->device, demo->depth.mem, NULL);
2369
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);
2375     }
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);
2380     }
2381     free(demo->swapchain_image_resources);
2382
2383     // Second, re-perform the demo_prepare() function, which will re-create the
2384     // swapchain:
2385     demo_prepare(demo);
2386 }
2387
2388 // On MS-Windows, make this a global, so it's available to WndProc()
2389 struct demo demo;
2390
2391 #if defined(VK_USE_PLATFORM_WIN32_KHR)
2392 static void demo_run(struct demo *demo) {
2393     if (!demo->prepared) return;
2394
2395     demo_draw(demo);
2396     demo->curFrame++;
2397     if (demo->frameCount != INT_MAX && demo->curFrame == demo->frameCount) {
2398         PostQuitMessage(validation_error);
2399     }
2400 }
2401
2402 // MS-Windows event handling function:
2403 LRESULT CALLBACK WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam) {
2404     switch (uMsg) {
2405         case WM_CLOSE:
2406             PostQuitMessage(validation_error);
2407             break;
2408         case WM_PAINT:
2409             // The validation callback calls MessageBox which can generate paint
2410             // events - don't make more Vulkan calls if we got here from the
2411             // callback
2412             if (!in_callback) {
2413                 demo_run(&demo);
2414             }
2415             break;
2416         case WM_GETMINMAXINFO:  // set window's minimum size
2417             ((MINMAXINFO *)lParam)->ptMinTrackSize = demo.minsize;
2418             return 0;
2419         case WM_SIZE:
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;
2426                 demo_resize(&demo);
2427             }
2428             break;
2429         default:
2430             break;
2431     }
2432     return (DefWindowProc(hWnd, uMsg, wParam, lParam));
2433 }
2434
2435 static void demo_create_window(struct demo *demo) {
2436     WNDCLASSEX win_class;
2437
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");
2455         fflush(stdout);
2456         exit(1);
2457     }
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");
2476         fflush(stdout);
2477         exit(1);
2478     }
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;
2482 }
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");
2488         fflush(stdout);
2489         exit(1);
2490     }
2491
2492     XInitThreads();
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);
2499
2500     Colormap colormap =
2501         XCreateColormap(demo->display, RootWindow(demo->display, vInfoTemplate.screen), visualInfo->visual, AllocNone);
2502
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;
2508
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);
2512
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);
2517 }
2518 static void demo_handle_xlib_event(struct demo *demo, const XEvent *event) {
2519     switch (event->type) {
2520         case ClientMessage:
2521             if ((Atom)event->xclient.data.l[0] == demo->xlib_wm_delete_window) demo->quit = true;
2522             break;
2523         case KeyPress:
2524             switch (event->xkey.keycode) {
2525                 case 0x9:  // Escape
2526                     demo->quit = true;
2527                     break;
2528                 case 0x71:  // left arrow key
2529                     demo->spin_angle -= demo->spin_increment;
2530                     break;
2531                 case 0x72:  // right arrow key
2532                     demo->spin_angle += demo->spin_increment;
2533                     break;
2534                 case 0x41:  // space bar
2535                     demo->pause = !demo->pause;
2536                     break;
2537             }
2538             break;
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;
2543                 demo_resize(demo);
2544             }
2545             break;
2546         default:
2547             break;
2548     }
2549 }
2550
2551 static void demo_run_xlib(struct demo *demo) {
2552     while (!demo->quit) {
2553         XEvent event;
2554
2555         if (demo->pause) {
2556             XNextEvent(demo->display, &event);
2557             demo_handle_xlib_event(demo, &event);
2558         }
2559         while (XPending(demo->display) > 0) {
2560             XNextEvent(demo->display, &event);
2561             demo_handle_xlib_event(demo, &event);
2562         }
2563
2564         demo_draw(demo);
2565         demo->curFrame++;
2566         if (demo->frameCount != INT32_MAX && demo->curFrame == demo->frameCount) demo->quit = true;
2567     }
2568 }
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) {
2573         case XCB_EXPOSE:
2574             // TODO: Resize window
2575             break;
2576         case XCB_CLIENT_MESSAGE:
2577             if ((*(xcb_client_message_event_t *)event).data.data32[0] == (*demo->atom_wm_delete_window).atom) {
2578                 demo->quit = true;
2579             }
2580             break;
2581         case XCB_KEY_RELEASE: {
2582             const xcb_key_release_event_t *key = (const xcb_key_release_event_t *)event;
2583
2584             switch (key->detail) {
2585                 case 0x9:  // Escape
2586                     demo->quit = true;
2587                     break;
2588                 case 0x71:  // left arrow key
2589                     demo->spin_angle -= demo->spin_increment;
2590                     break;
2591                 case 0x72:  // right arrow key
2592                     demo->spin_angle += demo->spin_increment;
2593                     break;
2594                 case 0x41:  // space bar
2595                     demo->pause = !demo->pause;
2596                     break;
2597             }
2598         } break;
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;
2604                 demo_resize(demo);
2605             }
2606         } break;
2607         default:
2608             break;
2609     }
2610 }
2611
2612 static void demo_run_xcb(struct demo *demo) {
2613     xcb_flush(demo->connection);
2614
2615     while (!demo->quit) {
2616         xcb_generic_event_t *event;
2617
2618         if (demo->pause) {
2619             event = xcb_wait_for_event(demo->connection);
2620         } else {
2621             event = xcb_poll_for_event(demo->connection);
2622         }
2623         while (event) {
2624             demo_handle_xcb_event(demo, event);
2625             free(event);
2626             event = xcb_poll_for_event(demo->connection);
2627         }
2628
2629         demo_draw(demo);
2630         demo->curFrame++;
2631         if (demo->frameCount != INT32_MAX && demo->curFrame == demo->frameCount) demo->quit = true;
2632     }
2633 }
2634
2635 static void demo_create_xcb_window(struct demo *demo) {
2636     uint32_t value_mask, value_list[32];
2637
2638     demo->xcb_window = xcb_generate_id(demo->connection);
2639
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;
2643
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);
2646
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);
2650
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);
2653
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);
2656     free(reply);
2657
2658     xcb_map_window(demo->connection, demo->xcb_window);
2659
2660     // Force the x/y coordinates to 100,100 results are identical in consecutive
2661     // runs
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);
2664 }
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) {
2669         if (demo->pause) {
2670             wl_display_dispatch(demo->display);  // block and wait for input
2671         } else {
2672             wl_display_dispatch_pending(demo->display);  // don't block
2673             demo_draw(demo);
2674             demo->curFrame++;
2675             if (demo->frameCount != INT32_MAX && demo->curFrame == demo->frameCount) demo->quit = true;
2676         }
2677     }
2678 }
2679
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);
2682 }
2683
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) {}
2686
2687 static void handle_popup_done(void *data UNUSED, struct wl_shell_surface *shell_surface UNUSED) {}
2688
2689 static const struct wl_shell_surface_listener shell_surface_listener = {handle_ping, handle_configure, handle_popup_done};
2690
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");
2695         fflush(stdout);
2696         exit(1);
2697     }
2698
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");
2702         fflush(stdout);
2703         exit(1);
2704     }
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);
2708 }
2709 #elif defined(VK_USE_PLATFORM_ANDROID_KHR)
2710 static void demo_run(struct demo *demo) {
2711     if (!demo->prepared) return;
2712
2713     demo_draw(demo);
2714     demo->curFrame++;
2715 }
2716 #elif defined(VK_USE_PLATFORM_MACOS_MVK)
2717 static void demo_run(struct demo *demo) {
2718     demo_draw(demo);
2719     demo->curFrame++;
2720     if (demo->frameCount != INT32_MAX && demo->curFrame == demo->frameCount) {
2721         demo->quit = TRUE;
2722     }
2723 }
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;
2739
2740     // Get the first display
2741     err = vkGetPhysicalDeviceDisplayPropertiesKHR(demo->gpu, &display_count, NULL);
2742     assert(!err);
2743
2744     if (display_count == 0) {
2745         printf("Cannot find any display!\n");
2746         fflush(stdout);
2747         exit(1);
2748     }
2749
2750     display_count = 1;
2751     err = vkGetPhysicalDeviceDisplayPropertiesKHR(demo->gpu, &display_count, &display_props);
2752     assert(!err || (err == VK_INCOMPLETE));
2753
2754     display = display_props.display;
2755
2756     // Get the first mode of the display
2757     err = vkGetDisplayModePropertiesKHR(demo->gpu, display, &mode_count, NULL);
2758     assert(!err);
2759
2760     if (mode_count == 0) {
2761         printf("Cannot find any mode for the display!\n");
2762         fflush(stdout);
2763         exit(1);
2764     }
2765
2766     mode_count = 1;
2767     err = vkGetDisplayModePropertiesKHR(demo->gpu, display, &mode_count, &mode_props);
2768     assert(!err || (err == VK_INCOMPLETE));
2769
2770     // Get the list of planes
2771     err = vkGetPhysicalDeviceDisplayPlanePropertiesKHR(demo->gpu, &plane_count, NULL);
2772     assert(!err);
2773
2774     if (plane_count == 0) {
2775         printf("Cannot find any plane!\n");
2776         fflush(stdout);
2777         exit(1);
2778     }
2779
2780     plane_props = malloc(sizeof(VkDisplayPlanePropertiesKHR) * plane_count);
2781     assert(plane_props);
2782
2783     err = vkGetPhysicalDeviceDisplayPlanePropertiesKHR(demo->gpu, &plane_count, plane_props);
2784     assert(!err);
2785
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;
2790
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)) {
2793             continue;
2794         }
2795
2796         err = vkGetDisplayPlaneSupportedDisplaysKHR(demo->gpu, plane_index, &supported_count, NULL);
2797         assert(!err);
2798
2799         if (supported_count == 0) {
2800             continue;
2801         }
2802
2803         supported_displays = malloc(sizeof(VkDisplayKHR) * supported_count);
2804         assert(supported_displays);
2805
2806         err = vkGetDisplayPlaneSupportedDisplaysKHR(demo->gpu, plane_index, &supported_count, supported_displays);
2807         assert(!err);
2808
2809         for (uint32_t i = 0; i < supported_count; i++) {
2810             if (supported_displays[i] == display) {
2811                 found_plane = VK_TRUE;
2812                 break;
2813             }
2814         }
2815
2816         free(supported_displays);
2817
2818         if (found_plane) {
2819             break;
2820         }
2821     }
2822
2823     if (!found_plane) {
2824         printf("Cannot find a plane compatible with the display!\n");
2825         fflush(stdout);
2826         exit(1);
2827     }
2828
2829     free(plane_props);
2830
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,
2840     };
2841     for (uint32_t i = 0; i < sizeof(alphaModes); i++) {
2842         if (planeCaps.supportedAlpha & alphaModes[i]) {
2843             alphaMode = alphaModes[i];
2844             break;
2845         }
2846     }
2847     image_extent.width = mode_props.parameters.visibleRegion.width;
2848     image_extent.height = mode_props.parameters.visibleRegion.height;
2849
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;
2860
2861     return vkCreateDisplayPlaneSurfaceKHR(demo->inst, &create_info, NULL, &demo->surface);
2862 }
2863
2864 static void demo_run_display(struct demo *demo) {
2865     while (!demo->quit) {
2866         demo_draw(demo);
2867         demo->curFrame++;
2868
2869         if (demo->frameCount != INT32_MAX && demo->curFrame == demo->frameCount) {
2870             demo->quit = true;
2871         }
2872     }
2873 }
2874 #endif
2875
2876 /*
2877  * Return 1 (true) if all layer names specified in check_names
2878  * can be found in given layer properties.
2879  */
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++) {
2882         VkBool32 found = 0;
2883         for (uint32_t j = 0; j < layer_count; j++) {
2884             if (!strcmp(check_names[i], layers[j].layerName)) {
2885                 found = 1;
2886                 break;
2887             }
2888         }
2889         if (!found) {
2890             fprintf(stderr, "Cannot find layer: %s\n", check_names[i]);
2891             return 0;
2892         }
2893     }
2894     return 1;
2895 }
2896
2897 static void demo_init_vk(struct demo *demo) {
2898     VkResult err;
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;
2907
2908     char *instance_validation_layers_alt1[] = {"VK_LAYER_LUNARG_standard_validation"};
2909
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"};
2913
2914     /* Look for validation layers */
2915     VkBool32 validation_found = 0;
2916     if (demo->validate) {
2917         err = vkEnumerateInstanceLayerProperties(&instance_layer_count, NULL);
2918         assert(!err);
2919
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);
2924             assert(!err);
2925
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;
2932             } else {
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];
2941                 }
2942             }
2943             free(instance_layers);
2944         }
2945
2946         if (!validation_found) {
2947             ERR_EXIT(
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");
2951         }
2952     }
2953
2954     /* Look for instance extensions */
2955     VkBool32 surfaceExtFound = 0;
2956     VkBool32 platformSurfaceExtFound = 0;
2957     memset(demo->extension_names, 0, sizeof(demo->extension_names));
2958
2959     err = vkEnumerateInstanceExtensionProperties(NULL, &instance_extension_count, NULL);
2960     assert(!err);
2961
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);
2965         assert(!err);
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;
2970             }
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;
2975             }
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;
2980             }
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;
2985             }
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;
2990             }
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;
2996             }
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;
3001             }
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;
3006             }
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;
3011             }
3012 #endif
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;
3016                 }
3017             }
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;
3021                 }
3022             }
3023             assert(demo->enabled_extension_count < 64);
3024         }
3025
3026         free(instance_extensions);
3027     }
3028
3029     if (!surfaceExtFound) {
3030         ERR_EXIT("vkEnumerateInstanceExtensionProperties failed to find the " VK_KHR_SURFACE_EXTENSION_NAME
3031                  " extension.\n\n"
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");
3035     }
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
3039                  " extension.\n\n"
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
3045                  " extension.\n\n"
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
3051                  " extension.\n\n"
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
3057                  " extension.\n\n"
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
3063                  " extension.\n\n"
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
3070                  " extension.\n\n"
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
3076                  " extension.\n\n"
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
3082                  " extension.\n\n"
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");
3086 #endif
3087     }
3088     const VkApplicationInfo app = {
3089         .sType = VK_STRUCTURE_TYPE_APPLICATION_INFO,
3090         .pNext = NULL,
3091         .pApplicationName = APP_SHORT_NAME,
3092         .applicationVersion = 0,
3093         .pEngineName = APP_SHORT_NAME,
3094         .engineVersion = 0,
3095         .apiVersion = VK_API_VERSION_1_0,
3096     };
3097     VkInstanceCreateInfo inst_info = {
3098         .sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO,
3099         .pNext = NULL,
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,
3105     };
3106
3107     /*
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.
3111      */
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;
3126     }
3127
3128     uint32_t gpu_count;
3129
3130     err = vkCreateInstance(&inst_info, NULL, &demo->inst);
3131     if (err == VK_ERROR_INCOMPATIBLE_DRIVER) {
3132         ERR_EXIT(
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) {
3137         ERR_EXIT(
3138             "Cannot find a specified extension library.\n"
3139             "Make sure your layers path is set appropriately.\n",
3140             "vkCreateInstance Failure");
3141     } else if (err) {
3142         ERR_EXIT(
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");
3147     }
3148
3149     /* Make initial call to query gpu_count, then second call for gpu info*/
3150     err = vkEnumeratePhysicalDevices(demo->inst, &gpu_count, NULL);
3151     assert(!err);
3152
3153     if (gpu_count > 0) {
3154         VkPhysicalDevice *physical_devices = malloc(sizeof(VkPhysicalDevice) * gpu_count);
3155         err = vkEnumeratePhysicalDevices(demo->inst, &gpu_count, physical_devices);
3156         assert(!err);
3157         /* For cube demo we just grab the first physical device */
3158         demo->gpu = physical_devices[0];
3159         free(physical_devices);
3160     } else {
3161         ERR_EXIT(
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");
3166     }
3167
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));
3173
3174     err = vkEnumerateDeviceExtensionProperties(demo->gpu, NULL, &device_extension_count, NULL);
3175     assert(!err);
3176
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);
3180         assert(!err);
3181
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;
3186             }
3187             assert(demo->enabled_extension_count < 64);
3188         }
3189
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
3194             // enumerated.
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");
3201                 }
3202                 assert(demo->enabled_extension_count < 64);
3203             }
3204             if (!demo->VK_KHR_incremental_present_enabled) {
3205                 DbgMsg("VK_KHR_incremental_present extension NOT AVAILABLE\n");
3206             }
3207         }
3208
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
3213             // enumerated.
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");
3220                 }
3221                 assert(demo->enabled_extension_count < 64);
3222             }
3223             if (!demo->VK_GOOGLE_display_timing_enabled) {
3224                 DbgMsg("VK_GOOGLE_display_timing extension NOT AVAILABLE\n");
3225             }
3226         }
3227
3228         free(device_extensions);
3229     }
3230
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");
3236     }
3237
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");
3260         }
3261
3262         err = demo->CreateDebugUtilsMessengerEXT(demo->inst, &dbg_messenger_create_info, NULL, &demo->dbg_messenger);
3263         switch (err) {
3264             case VK_SUCCESS:
3265                 break;
3266             case VK_ERROR_OUT_OF_HOST_MEMORY:
3267                 ERR_EXIT("CreateDebugUtilsMessengerEXT: out of host memory\n", "CreateDebugUtilsMessengerEXT Failure");
3268                 break;
3269             default:
3270                 ERR_EXIT("CreateDebugUtilsMessengerEXT: unknown failure\n", "CreateDebugUtilsMessengerEXT Failure");
3271                 break;
3272         }
3273     }
3274     vkGetPhysicalDeviceProperties(demo->gpu, &demo->gpu_props);
3275
3276     /* Call with NULL data to get count */
3277     vkGetPhysicalDeviceQueueFamilyProperties(demo->gpu, &demo->queue_family_count, NULL);
3278     assert(demo->queue_family_count >= 1);
3279
3280     demo->queue_props = (VkQueueFamilyProperties *)malloc(demo->queue_family_count * sizeof(VkQueueFamilyProperties));
3281     vkGetPhysicalDeviceQueueFamilyProperties(demo->gpu, &demo->queue_family_count, demo->queue_props);
3282
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);
3288
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);
3294 }
3295
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;
3306
3307     VkDeviceCreateInfo device = {
3308         .sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO,
3309         .pNext = NULL,
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
3317     };
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;
3326     }
3327     err = vkCreateDevice(demo->gpu, &device, NULL, &demo->device);
3328     assert(!err);
3329 }
3330
3331 static void demo_init_vk_swapchain(struct demo *demo) {
3332     VkResult U_ASSERT_ONLY err;
3333
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;
3342
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;
3351
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);
3360
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;
3369
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;
3378
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;
3386     surface.flags = 0;
3387     surface.pView = demo->window;
3388
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;
3394     surface.flags = 0;
3395     surface.pView = demo->window;
3396
3397     err = vkCreateMacOSSurfaceMVK(demo->inst, &surface, NULL, &demo->surface);
3398 #endif
3399     assert(!err);
3400
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]);
3405     }
3406
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;
3415             }
3416
3417             if (supportsPresent[i] == VK_TRUE) {
3418                 graphicsQueueFamilyIndex = i;
3419                 presentQueueFamilyIndex = i;
3420                 break;
3421             }
3422         }
3423     }
3424
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;
3431                 break;
3432             }
3433         }
3434     }
3435
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");
3439     }
3440
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);
3445
3446     demo_create_device(demo);
3447
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);
3456     }
3457
3458     vkGetDeviceQueue(demo->device, demo->graphics_queue_family_index, 0, &demo->graphics_queue);
3459
3460     if (!demo->separate_present_queue) {
3461         demo->present_queue = demo->graphics_queue;
3462     } else {
3463         vkGetDeviceQueue(demo->device, demo->present_queue_family_index, 0, &demo->present_queue);
3464     }
3465
3466     // Get the list of VkFormat's that are supported:
3467     uint32_t formatCount;
3468     err = demo->fpGetPhysicalDeviceSurfaceFormatsKHR(demo->gpu, demo->surface, &formatCount, NULL);
3469     assert(!err);
3470     VkSurfaceFormatKHR *surfFormats = (VkSurfaceFormatKHR *)malloc(formatCount * sizeof(VkSurfaceFormatKHR));
3471     err = demo->fpGetPhysicalDeviceSurfaceFormatsKHR(demo->gpu, demo->surface, &formatCount, surfFormats);
3472     assert(!err);
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;
3478     } else {
3479         assert(formatCount >= 1);
3480         demo->format = surfFormats[0].format;
3481     }
3482     demo->color_space = surfFormats[0].colorSpace;
3483
3484     demo->quit = false;
3485     demo->curFrame = 0;
3486
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,
3491         .pNext = NULL,
3492         .flags = 0,
3493     };
3494
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]);
3501         assert(!err);
3502
3503         err = vkCreateSemaphore(demo->device, &semaphoreCreateInfo, NULL, &demo->image_acquired_semaphores[i]);
3504         assert(!err);
3505
3506         err = vkCreateSemaphore(demo->device, &semaphoreCreateInfo, NULL, &demo->draw_complete_semaphores[i]);
3507         assert(!err);
3508
3509         if (demo->separate_present_queue) {
3510             err = vkCreateSemaphore(demo->device, &semaphoreCreateInfo, NULL, &demo->image_ownership_semaphores[i]);
3511             assert(!err);
3512         }
3513     }
3514     demo->frame_index = 0;
3515
3516     // Get Memory information and properties
3517     vkGetPhysicalDeviceMemoryProperties(demo->gpu, &demo->memory_properties);
3518 }
3519
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,
3522                                  wl_fixed_t sy) {}
3523
3524 static void pointer_handle_leave(void *data, struct wl_pointer *pointer, uint32_t serial, struct wl_surface *surface) {}
3525
3526 static void pointer_handle_motion(void *data, struct wl_pointer *pointer, uint32_t time, wl_fixed_t sx, wl_fixed_t sy) {}
3527
3528 static void pointer_handle_button(void *data, struct wl_pointer *wl_pointer, uint32_t serial, uint32_t time, uint32_t button,
3529                                   uint32_t state) {
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);
3533     }
3534 }
3535
3536 static void pointer_handle_axis(void *data, struct wl_pointer *wl_pointer, uint32_t time, uint32_t axis, wl_fixed_t value) {}
3537
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,
3540 };
3541
3542 static void keyboard_handle_keymap(void *data, struct wl_keyboard *keyboard, uint32_t format, int fd, uint32_t size) {}
3543
3544 static void keyboard_handle_enter(void *data, struct wl_keyboard *keyboard, uint32_t serial, struct wl_surface *surface,
3545                                   struct wl_array *keys) {}
3546
3547 static void keyboard_handle_leave(void *data, struct wl_keyboard *keyboard, uint32_t serial, struct wl_surface *surface) {}
3548
3549 static void keyboard_handle_key(void *data, struct wl_keyboard *keyboard, uint32_t serial, uint32_t time, uint32_t key,
3550                                 uint32_t state) {
3551     if (state != WL_KEYBOARD_KEY_STATE_RELEASED) return;
3552     struct demo *demo = data;
3553     switch (key) {
3554         case KEY_ESC:  // Escape
3555             demo->quit = true;
3556             break;
3557         case KEY_LEFT:  // left arrow key
3558             demo->spin_angle -= demo->spin_increment;
3559             break;
3560         case KEY_RIGHT:  // right arrow key
3561             demo->spin_angle += demo->spin_increment;
3562             break;
3563         case KEY_SPACE:  // space bar
3564             demo->pause = !demo->pause;
3565             break;
3566     }
3567 }
3568
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) {}
3571
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,
3574 };
3575
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;
3585     }
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;
3593     }
3594 }
3595
3596 static const struct wl_seat_listener seat_listener = {
3597     seat_handle_capabilities,
3598 };
3599
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);
3611     }
3612 }
3613
3614 static void registry_handle_global_remove(void *data UNUSED, struct wl_registry *registry UNUSED, uint32_t name UNUSED) {}
3615
3616 static const struct wl_registry_listener registry_listener = {registry_handle_global, registry_handle_global_remove};
3617 #elif defined(VK_USE_PLATFORM_MIR_KHR)
3618 #endif
3619
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;
3624     int scr;
3625
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");
3629         fflush(stdout);
3630         exit(1);
3631     }
3632
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");
3636         fflush(stdout);
3637         exit(1);
3638     }
3639
3640     setup = xcb_get_setup(demo->connection);
3641     iter = xcb_setup_roots_iterator(setup);
3642     while (scr-- > 0) xcb_screen_next(&iter);
3643
3644     demo->screen = iter.data;
3645 #elif defined(VK_USE_PLATFORM_WAYLAND_KHR)
3646     demo->display = wl_display_connect(NULL);
3647
3648     if (demo->display == NULL) {
3649         printf("Cannot find a compatible Vulkan installable client driver (ICD).\nExiting ...\n");
3650         fflush(stdout);
3651         exit(1);
3652     }
3653
3654     demo->registry = wl_display_get_registry(demo->display);
3655     wl_registry_add_listener(demo->registry, &registry_listener, demo);
3656     wl_display_dispatch(demo->display);
3657 #elif defined(VK_USE_PLATFORM_MIR_KHR)
3658 #endif
3659 }
3660
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};
3665
3666     memset(demo, 0, sizeof(*demo));
3667     demo->presentMode = VK_PRESENT_MODE_FIFO_KHR;
3668     demo->frameCount = INT32_MAX;
3669
3670     for (int i = 1; i < argc; i++) {
3671         if (strcmp(argv[i], "--use_staging") == 0) {
3672             demo->use_staging_buffer = true;
3673             continue;
3674         }
3675         if ((strcmp(argv[i], "--present_mode") == 0) && (i < argc - 1)) {
3676             demo->presentMode = atoi(argv[i + 1]);
3677             i++;
3678             continue;
3679         }
3680         if (strcmp(argv[i], "--break") == 0) {
3681             demo->use_break = true;
3682             continue;
3683         }
3684         if (strcmp(argv[i], "--validate") == 0) {
3685             demo->validate = true;
3686             continue;
3687         }
3688         if (strcmp(argv[i], "--validate-checks-disabled") == 0) {
3689             demo->validate = true;
3690             demo->validate_checks_disabled = true;
3691             continue;
3692         }
3693         if (strcmp(argv[i], "--xlib") == 0) {
3694             fprintf(stderr, "--xlib is deprecated and no longer does anything");
3695             continue;
3696         }
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) {
3699             i++;
3700             continue;
3701         }
3702         if (strcmp(argv[i], "--suppress_popups") == 0) {
3703             demo->suppress_popups = true;
3704             continue;
3705         }
3706         if (strcmp(argv[i], "--display_timing") == 0) {
3707             demo->VK_GOOGLE_display_timing_enabled = true;
3708             continue;
3709         }
3710         if (strcmp(argv[i], "--incremental_present") == 0) {
3711             demo->VK_KHR_incremental_present_enabled = true;
3712             continue;
3713         }
3714
3715 #if defined(ANDROID)
3716         ERR_EXIT("Usage: cube [--validate]\n", "Usage");
3717 #else
3718         fprintf(stderr,
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);
3728         fflush(stderr);
3729         exit(1);
3730 #endif
3731     }
3732
3733     demo_init_connection(demo);
3734
3735     demo_init_vk(demo);
3736
3737     demo->width = 500;
3738     demo->height = 500;
3739
3740     demo->spin_angle = 4.0f;
3741     demo->spin_increment = 0.2f;
3742     demo->pause = false;
3743
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);
3747
3748     demo->projection_matrix[1][1] *= -1;  // Flip projection matrix from GL to Vulkan orientation.
3749 }
3750
3751 #if defined(VK_USE_PLATFORM_WIN32_KHR)
3752 // Include header required for parsing the command line options.
3753 #include <shellapi.h>
3754
3755 int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR pCmdLine, int nCmdShow) {
3756     MSG msg;    // message
3757     bool done;  // flag saying when app is complete
3758     int argc;
3759     char **argv;
3760
3761     // Ensure wParam is initialized.
3762     msg.wParam = 0;
3763
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) {
3772         argc = 0;
3773     }
3774
3775     if (argc > 0) {
3776         argv = (char **)malloc(sizeof(char *) * argc);
3777         if (argv == NULL) {
3778             argc = 0;
3779         } else {
3780             for (int iii = 0; iii < argc; iii++) {
3781                 size_t wideCharLen = wcslen(commandLineArgs[iii]);
3782                 size_t numConverted = 0;
3783
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);
3787                 }
3788             }
3789         }
3790     } else {
3791         argv = NULL;
3792     }
3793
3794     demo_init(&demo, argc, argv);
3795
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) {
3800                 free(argv[iii]);
3801             }
3802         }
3803         free(argv);
3804     }
3805
3806     demo.connection = hInstance;
3807     strncpy(demo.name, "cube", APP_NAME_STR_LEN);
3808     demo_create_window(&demo);
3809     demo_init_vk_swapchain(&demo);
3810
3811     demo_prepare(&demo);
3812
3813     done = false;  // initialize loop condition variable
3814
3815     // main message loop
3816     while (!done) {
3817         PeekMessage(&msg, NULL, 0, 0, PM_REMOVE);
3818         if (msg.message == WM_QUIT)  // check for a quit message
3819         {
3820             done = true;  // if found, quit app
3821         } else {
3822             /* Translate and dispatch to event queue*/
3823             TranslateMessage(&msg);
3824             DispatchMessage(&msg);
3825         }
3826         RedrawWindow(demo.window, NULL, NULL, RDW_INTERNALPAINT);
3827     }
3828
3829     demo_cleanup(&demo);
3830
3831     return (int)msg.wParam;
3832 }
3833
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[]) {
3836
3837     demo_init(demo, argc, (char **)argv);
3838     demo->window = view;
3839     demo_init_vk_swapchain(demo);
3840     demo_prepare(demo);
3841     demo->spin_angle = 0.4f;
3842 }
3843
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"
3848
3849 static bool initialized = false;
3850 static bool active = false;
3851 struct demo demo;
3852
3853 static int32_t processInput(struct android_app *app, AInputEvent *event) { return 0; }
3854
3855 static void processCommand(struct android_app *app, int32_t cmd) {
3856     switch (cmd) {
3857         case APP_CMD_INIT_WINDOW: {
3858             if (app->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
3868                 // the app)
3869                 if (demo.prepared) {
3870                     demo_cleanup(&demo);
3871                 }
3872
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;
3878                 int argc = 0;
3879                 char **argv = get_args(app, key, appTag, &argc);
3880
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]);
3883
3884                 demo_init(&demo, argc, argv);
3885
3886                 // Free the argv malloc'd by get_args
3887                 for (int i = 0; i < argc; i++) free(argv[i]);
3888
3889                 demo.window = (void *)app->window;
3890                 demo_init_vk_swapchain(&demo);
3891                 demo_prepare(&demo);
3892                 initialized = true;
3893             }
3894             break;
3895         }
3896         case APP_CMD_GAINED_FOCUS: {
3897             active = true;
3898             break;
3899         }
3900         case APP_CMD_LOST_FOCUS: {
3901             active = false;
3902             break;
3903         }
3904     }
3905 }
3906
3907 void android_main(struct android_app *app) {
3908 #ifdef ANDROID
3909     int vulkanSupport = InitVulkan();
3910     if (vulkanSupport == 0) return;
3911 #endif
3912
3913     demo.prepared = false;
3914
3915     app->onAppCmd = processCommand;
3916     app->onInputEvent = processInput;
3917
3918     while (1) {
3919         int events;
3920         struct android_poll_source *source;
3921         while (ALooper_pollAll(active ? 0 : -1, NULL, &events, (void **)&source) >= 0) {
3922             if (source) {
3923                 source->process(app, source);
3924             }
3925
3926             if (app->destroyRequested != 0) {
3927                 demo_cleanup(&demo);
3928                 return;
3929             }
3930         }
3931         if (initialized && active) {
3932             demo_run(&demo);
3933         }
3934     }
3935 }
3936 #else
3937 int main(int argc, char **argv) {
3938     struct demo demo;
3939
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)
3948 #endif
3949
3950     demo_init_vk_swapchain(&demo);
3951
3952     demo_prepare(&demo);
3953
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)
3959     demo_run(&demo);
3960 #elif defined(VK_USE_PLATFORM_MIR_KHR)
3961 #elif defined(VK_USE_PLATFORM_DISPLAY_KHR)
3962     demo_run_display(&demo);
3963 #endif
3964
3965     demo_cleanup(&demo);
3966
3967     return validation_error;
3968 }
3969 #endif