eleni.mutantstargoat.com Git - vkrt/blob - src/vk.c

   1 #include <assert.h>
   2 #include <stdio.h>
   3 #include <stdlib.h>
   4 #include <string.h>
   5
   6 #include "vk.h"
   7
   8 /* static variables */
   9
  10 static VkViewport viewport;
  11 static VkRect2D scissor;
  12 static VkPipelineCache pipeline_cache;
  13
  14 /* when I extend the program to use more than one buffers
  15  * I might need to store them in this list and access it
  16  * using multiple threads
  17  *
  18  * man realloc
  19  */
  20 #if 0
  21 static VkCommandBuffer *command_buffers;
  22 static uint32_t num_command_buffers;
  23 #endif
  24
  25 /* static functions */
  26
  27 static VkSampleCountFlagBits
  28 get_num_samples(uint32_t num_samples)
  29 {
  30     switch(num_samples) {
  31     case 64:
  32         return VK_SAMPLE_COUNT_64_BIT;
  33     case 32:
  34         return VK_SAMPLE_COUNT_32_BIT;
  35     case 16:
  36         return VK_SAMPLE_COUNT_16_BIT;
  37     case 8:
  38         return VK_SAMPLE_COUNT_8_BIT;
  39     case 4:
  40         return VK_SAMPLE_COUNT_4_BIT;
  41     case 2:
  42         return VK_SAMPLE_COUNT_2_BIT;
  43     case 1:
  44         break;
  45     default:
  46         fprintf(stderr, "Invalid number of samples in VkSampleCountFlagBits. Using one sample.\n");
  47         break;
  48     }
  49     return VK_SAMPLE_COUNT_1_BIT;
  50 }
  51
  52 static VkAccessFlagBits
  53 get_access_mask(const VkImageLayout layout)
  54 {
  55     /* dstAccessMask of barriers must be supported from the pipeline
  56      * stage, see also access scopes and this table:
  57      * https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#synchronization-access-types-supported
  58      */
  59     switch (layout) {
  60     case VK_IMAGE_LAYOUT_UNDEFINED:
  61         return 0;
  62     case VK_IMAGE_LAYOUT_GENERAL:
  63         return VK_ACCESS_MEMORY_READ_BIT | VK_ACCESS_MEMORY_WRITE_BIT;
  64     case VK_IMAGE_LAYOUT_PREINITIALIZED:
  65         return VK_ACCESS_HOST_WRITE_BIT;
  66     case VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL:
  67         return VK_ACCESS_COLOR_ATTACHMENT_READ_BIT |
  68                VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
  69     case VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL:
  70         return VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_INPUT_ATTACHMENT_READ_BIT;
  71     case VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL:
  72         return VK_ACCESS_TRANSFER_READ_BIT;
  73     case VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL:
  74         return VK_ACCESS_TRANSFER_WRITE_BIT;
  75     case VK_IMAGE_LAYOUT_PRESENT_SRC_KHR:
  76         return 0;
  77     default:
  78         return 0;
  79     };
  80
  81     return 0;
  82 }
  83
  84 static void
  85 enable_validation_layers(VkInstanceCreateInfo *info)
  86 {
  87     int i;
  88     uint32_t num_layers;
  89     VkLayerProperties *layers;
  90     static const char *layer_names[] = {
  91         "VK_LAYER_KHRONOS_validation",
  92     };
  93
  94     vkEnumerateInstanceLayerProperties(&num_layers, 0);
  95     layers = alloca(num_layers * sizeof *layers);
  96     vkEnumerateInstanceLayerProperties(&num_layers, layers);
  97
  98     if (num_layers) {
  99         printf("Available validation layers:\n");
 100         for(i = 0; i < (int)num_layers; i++) {
 101             printf(" %s\n", layers[i].layerName);
 102         }
 103
 104         info->ppEnabledLayerNames = layer_names;
 105         info->enabledLayerCount = sizeof layer_names / sizeof *layer_names;
 106     } else {
 107         fprintf(stderr, "Vulkan validation layers not found.\n");
 108     }
 109 }
 110
 111 static void
 112 enable_extensions(VkInstanceCreateInfo *info)
 113 {
 114     static const char *ext_names[] = {
 115         "VK_KHR_xcb_surface",
 116         "VK_KHR_surface"
 117     };
 118
 119     uint32_t num_extensions;
 120     VkExtensionProperties *extensions;
 121     int i;
 122
 123     vkEnumerateInstanceExtensionProperties(0, &num_extensions, 0);
 124     if (!num_extensions) {
 125         fprintf(stderr, "No instance extensions found.\n");
 126         return;
 127     }
 128
 129     extensions = alloca(num_extensions * sizeof *extensions);
 130     vkEnumerateInstanceExtensionProperties(0, &num_extensions, extensions);
 131
 132     printf("Available extensions:\n");
 133     for (i = 0; i < num_extensions; i++) {
 134        printf(" %s\n", extensions[i].extensionName);
 135     }
 136
 137     info->ppEnabledExtensionNames = ext_names;
 138     info->enabledExtensionCount = ARRAY_SIZE(ext_names);
 139 }
 140
 141 static VkInstance
 142 create_instance(bool enable_layers)
 143 {
 144     VkApplicationInfo app_info;
 145     VkInstanceCreateInfo inst_info;
 146     VkInstance inst;
 147
 148     /* VkApplicationInfo */
 149     memset(&app_info, 0, sizeof app_info);
 150     app_info.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
 151     app_info.pApplicationName = "vktest";
 152     app_info.apiVersion = VK_API_VERSION_1_1;
 153
 154     /* VkInstanceCreateInfo */
 155     memset(&inst_info, 0, sizeof inst_info);
 156     inst_info.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
 157     inst_info.pApplicationInfo = &app_info;
 158
 159     enable_extensions(&inst_info);
 160     if (enable_layers) {
 161         enable_validation_layers(&inst_info);
 162     }
 163
 164     if (vkCreateInstance(&inst_info, 0, &inst) != VK_SUCCESS)
 165         return 0;
 166
 167     return inst;
 168 }
 169
 170 static VkPhysicalDevice
 171 select_physical_device(VkInstance inst)
 172 {
 173     VkResult res = VK_SUCCESS;
 174     uint32_t dev_count = 0;
 175     VkPhysicalDevice *pdevices;
 176     VkPhysicalDevice pdevice0;
 177
 178     if ((res =
 179          vkEnumeratePhysicalDevices(inst, &dev_count, 0)) != VK_SUCCESS)
 180         return 0;
 181
 182     pdevices = malloc(dev_count * sizeof(VkPhysicalDevice));
 183     if (vkEnumeratePhysicalDevices(inst, &dev_count, pdevices) !=
 184         VK_SUCCESS)
 185         return 0;
 186
 187     pdevice0 = pdevices[0];
 188     free(pdevices);
 189
 190     return pdevice0;
 191 }
 192
 193 static VkDevice
 194 create_device(struct vk_ctx *ctx, VkPhysicalDevice pdev)
 195 {
 196     const char *deviceExtensions[] = { "VK_KHR_swapchain" };
 197     VkDeviceQueueCreateInfo dev_queue_info;
 198     VkDeviceCreateInfo dev_info;
 199     VkDevice dev;
 200     uint32_t prop_count;
 201     VkQueueFamilyProperties *fam_props;
 202     uint32_t i;
 203     float qprio = 0;
 204
 205     ctx->qfam_idx = -1;
 206     vkGetPhysicalDeviceQueueFamilyProperties(pdev, &prop_count, 0);
 207     if (prop_count < 0) {
 208         fprintf(stderr, "Invalid queue family properties.\n");
 209         return 0;
 210     }
 211
 212     fam_props = malloc(prop_count * sizeof *fam_props);
 213     vkGetPhysicalDeviceQueueFamilyProperties(pdev, &prop_count, fam_props);
 214
 215     for (i = 0; i < prop_count; i++) {
 216         if (fam_props[i].queueFlags & VK_QUEUE_GRAPHICS_BIT) {
 217             ctx->qfam_idx = i;
 218             break;
 219         }
 220     }
 221     free(fam_props);
 222
 223     memset(&dev_queue_info, 0, sizeof dev_queue_info);
 224     dev_queue_info.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
 225     dev_queue_info.queueFamilyIndex = ctx->qfam_idx;
 226     dev_queue_info.queueCount = 1;
 227     dev_queue_info.pQueuePriorities = &qprio;
 228
 229     memset(&dev_info, 0, sizeof dev_info);
 230     dev_info.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
 231     dev_info.queueCreateInfoCount = 1;
 232     dev_info.pQueueCreateInfos = &dev_queue_info;
 233     dev_info.enabledExtensionCount = ARRAY_SIZE(deviceExtensions);
 234     dev_info.ppEnabledExtensionNames = deviceExtensions;
 235
 236     if (vkCreateDevice(pdev, &dev_info, 0, &dev) != VK_SUCCESS)
 237         return 0;
 238
 239     return dev;
 240 }
 241
 242 static void
 243 fill_uuid(VkPhysicalDevice pdev, uint8_t *deviceUUID, uint8_t *driverUUID)
 244 {
 245     VkPhysicalDeviceIDProperties devProp;
 246     VkPhysicalDeviceProperties2 prop2;
 247
 248     memset(&devProp, 0, sizeof devProp);
 249     devProp.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES;
 250
 251     memset(&prop2, 0, sizeof prop2);
 252     prop2.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2;
 253     prop2.pNext = &devProp;
 254
 255     vkGetPhysicalDeviceProperties2(pdev, &prop2);
 256     memcpy(deviceUUID, devProp.deviceUUID, VK_UUID_SIZE);
 257     memcpy(driverUUID, devProp.driverUUID, VK_UUID_SIZE);
 258 }
 259
 260 static VkCommandPool
 261 create_cmd_pool(struct vk_ctx *ctx)
 262 {
 263     VkCommandPoolCreateInfo cmd_pool_info;
 264     VkCommandPool cmd_pool;
 265
 266     memset(&cmd_pool_info, 0, sizeof cmd_pool_info);
 267     cmd_pool_info.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
 268     cmd_pool_info.queueFamilyIndex = ctx->qfam_idx;
 269     cmd_pool_info.flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT;
 270
 271     if (vkCreateCommandPool(ctx->dev, &cmd_pool_info, 0, &cmd_pool) != VK_SUCCESS)
 272         return 0;
 273
 274     return cmd_pool;
 275 }
 276
 277 static VkPipelineCache
 278 create_pipeline_cache(struct vk_ctx *ctx)
 279 {
 280     VkPipelineCacheCreateInfo pc_info;
 281     VkPipelineCache pcache;
 282
 283     memset(&pc_info, 0, sizeof pc_info);
 284     pc_info.sType = VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO;
 285
 286     if (vkCreatePipelineCache(ctx->dev, &pc_info, 0, &pcache) != VK_SUCCESS) {
 287         fprintf(stderr, "Failed to create a pipeline cache.\n");
 288         return VK_NULL_HANDLE;
 289     }
 290
 291     return pcache;
 292 }
 293
 294 static VkRenderPass
 295 create_renderpass(struct vk_ctx *ctx,
 296                   uint32_t num_color_atts,
 297                   struct vk_attachment *color_atts,
 298                   struct vk_attachment *depth_att)
 299 {
 300     VkAttachmentDescription *att_dsc;
 301     VkAttachmentReference *att_rfc;
 302
 303     /* one subpass for the moment: */
 304     VkSubpassDescription subpass_dsc[1];
 305     VkRenderPassCreateInfo rpass_info;
 306
 307     int i;
 308     uint32_t num_atts = num_color_atts + 1;
 309     bool has_layout = depth_att->props.in_layout !=
 310                       VK_IMAGE_LAYOUT_UNDEFINED;
 311
 312     att_dsc = malloc(num_atts * sizeof att_dsc[0]);
 313     att_rfc = malloc(num_atts * sizeof att_rfc[0]);
 314
 315     memset(att_dsc, 0, num_atts * sizeof att_dsc[0]);
 316     memset(att_rfc, 0, num_atts * sizeof att_rfc[0]);
 317
 318     /* color attachments description (we can have many) */
 319     for (i = 0; i < num_color_atts; i++) {
 320         att_dsc[i].samples = get_num_samples(color_atts[i].props.num_samples);
 321         att_dsc[i].initialLayout = color_atts[i].props.in_layout;
 322         att_dsc[i].finalLayout = color_atts[i].props.end_layout;
 323         att_dsc[i].format = color_atts[i].props.format;
 324
 325         att_dsc[i].loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
 326         att_dsc[i].storeOp = VK_ATTACHMENT_STORE_OP_STORE;
 327         att_dsc[i].stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
 328         att_dsc[i].stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
 329
 330         att_rfc[i].attachment = i;
 331         att_rfc[i].layout = color_atts[i].props.tiling != VK_IMAGE_TILING_OPTIMAL ?
 332                             VK_IMAGE_LAYOUT_GENERAL :
 333                             VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
 334
 335     }
 336
 337     /* depth attachment description (we can have only one) */
 338     att_dsc[num_color_atts].samples = get_num_samples(depth_att->props.num_samples);
 339     att_dsc[num_color_atts].initialLayout = depth_att->props.in_layout;
 340     att_dsc[num_color_atts].finalLayout = depth_att->props.end_layout;
 341     att_dsc[num_color_atts].format = depth_att->props.format;
 342     /* we might want to reuse the depth buffer when it's filled */
 343     att_dsc[num_color_atts].loadOp = has_layout ?
 344                                VK_ATTACHMENT_LOAD_OP_LOAD :
 345                                VK_ATTACHMENT_LOAD_OP_CLEAR;
 346     att_dsc[num_color_atts].stencilLoadOp = has_layout ?
 347                                       VK_ATTACHMENT_LOAD_OP_LOAD :
 348                                       VK_ATTACHMENT_LOAD_OP_CLEAR;
 349     att_dsc[num_color_atts].stencilStoreOp = VK_ATTACHMENT_STORE_OP_STORE;
 350     att_rfc[num_color_atts].layout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
 351     att_rfc[num_color_atts].attachment = num_color_atts;
 352
 353     /* VkSubpassDescription */
 354     memset(&subpass_dsc, 0, sizeof subpass_dsc);
 355     subpass_dsc[0].pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS;
 356     subpass_dsc[0].colorAttachmentCount = num_color_atts;
 357     subpass_dsc[0].pColorAttachments = &att_rfc[0];
 358     subpass_dsc[0].pDepthStencilAttachment = &att_rfc[num_color_atts];
 359
 360     /* VkRenderPassCreateInfo */
 361     memset(&rpass_info, 0, sizeof rpass_info);
 362     rpass_info.sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO;
 363     rpass_info.attachmentCount = num_atts;
 364     rpass_info.pAttachments = att_dsc;
 365     rpass_info.subpassCount = 1;
 366     rpass_info.pSubpasses = subpass_dsc;
 367
 368     VkRenderPass rpass;
 369     if (vkCreateRenderPass(ctx->dev, &rpass_info, 0, &rpass) != VK_SUCCESS) {
 370         fprintf(stderr, "Failed to create renderpass.\n");
 371         rpass = VK_NULL_HANDLE;
 372     }
 373
 374     free(att_dsc);
 375     free(att_rfc);
 376
 377     return rpass;
 378 }
 379
 380 static inline VkImageType
 381 get_image_type(uint32_t h, uint32_t d)
 382 {
 383     if (h == 1)
 384         return VK_IMAGE_TYPE_1D;
 385
 386     if (d > 1)
 387         return VK_IMAGE_TYPE_3D;
 388
 389     return VK_IMAGE_TYPE_2D;
 390 }
 391
 392 #if 0
 393 static VkImageViewType
 394 get_image_view_type(struct vk_att_props *props)
 395 {
 396     VkImageType type = get_image_type(props->h, props->depth);
 397     switch(type) {
 398         case VK_IMAGE_TYPE_1D:
 399             return props->num_layers > 1 ?
 400                 VK_IMAGE_VIEW_TYPE_1D_ARRAY :
 401                 VK_IMAGE_VIEW_TYPE_1D;
 402         case VK_IMAGE_TYPE_2D:
 403             if (props->num_layers == 1)
 404                 return VK_IMAGE_VIEW_TYPE_2D;
 405             if (props->num_layers == 6)
 406                 return VK_IMAGE_VIEW_TYPE_CUBE;
 407             if (props->num_layers % 6 == 0)
 408                 return VK_IMAGE_VIEW_TYPE_CUBE_ARRAY;
 409             if (props->num_layers > 1)
 410                 return VK_IMAGE_VIEW_TYPE_2D_ARRAY;
 411         case VK_IMAGE_TYPE_3D:
 412             if (props->num_layers == 1)
 413                 return VK_IMAGE_VIEW_TYPE_3D;
 414             if ((props->num_layers == 1) &&
 415                 (props->num_levels == 1))
 416                 return VK_IMAGE_VIEW_TYPE_2D;
 417             if ((props->num_levels == 1) &&
 418                 (props->num_layers > 1))
 419                 return VK_IMAGE_VIEW_TYPE_2D_ARRAY;
 420         default:
 421             return VK_IMAGE_VIEW_TYPE_2D;
 422     }
 423 }
 424 #endif
 425
 426 static VkImageAspectFlagBits
 427 get_aspect_from_depth_format(VkFormat depth_format)
 428 {
 429     switch (depth_format) {
 430     case VK_FORMAT_D16_UNORM:
 431     case VK_FORMAT_X8_D24_UNORM_PACK32:
 432     case VK_FORMAT_D32_SFLOAT:
 433         return VK_IMAGE_ASPECT_DEPTH_BIT;
 434     case VK_FORMAT_S8_UINT:
 435         return VK_IMAGE_ASPECT_STENCIL_BIT;
 436     case VK_FORMAT_D16_UNORM_S8_UINT:
 437     case VK_FORMAT_D24_UNORM_S8_UINT:
 438     case VK_FORMAT_D32_SFLOAT_S8_UINT:
 439         return VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT;
 440     default:
 441         break;
 442     }
 443     return 0;
 444 }
 445
 446 static VkPipelineStageFlags
 447 get_pipeline_stage_flags(const VkImageLayout layout)
 448 {
 449     switch (layout) {
 450     case VK_IMAGE_LAYOUT_UNDEFINED:
 451         return VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT;
 452     case VK_IMAGE_LAYOUT_GENERAL:
 453         return VK_PIPELINE_STAGE_ALL_COMMANDS_BIT;
 454     case VK_IMAGE_LAYOUT_PREINITIALIZED:
 455         return VK_PIPELINE_STAGE_HOST_BIT;
 456     case VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL:
 457     case VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL:
 458         return VK_PIPELINE_STAGE_TRANSFER_BIT;
 459     case VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL:
 460         return VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
 461     case VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL:
 462         return VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT |
 463                VK_PIPELINE_STAGE_VERTEX_SHADER_BIT;
 464     case VK_IMAGE_LAYOUT_PRESENT_SRC_KHR:
 465         return VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT;
 466     default:
 467         break;
 468     }
 469     return 0;
 470 }
 471
 472 static bool
 473 create_image_view(struct vk_ctx *ctx,
 474                   VkImage image,
 475                   VkImageViewType view_type,
 476                   VkFormat format,
 477                   VkImageSubresourceRange sr,
 478                   bool is_swapchain,
 479                   VkImageView *image_view)
 480 {
 481     VkImageViewCreateInfo info;
 482
 483     memset(&info, 0, sizeof info);
 484     info.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
 485     info.image = image;
 486     info.viewType = view_type;
 487     info.viewType = VK_IMAGE_VIEW_TYPE_2D;
 488     info.format = format;
 489     info.subresourceRange = sr;
 490
 491     if (is_swapchain) {
 492         info.components.r = VK_COMPONENT_SWIZZLE_R;
 493         info.components.g = VK_COMPONENT_SWIZZLE_G;
 494         info.components.b = VK_COMPONENT_SWIZZLE_B;
 495         info.components.a = VK_COMPONENT_SWIZZLE_A;
 496     }
 497
 498     if (vkCreateImageView(ctx->dev, &info, 0, image_view) != VK_SUCCESS) {
 499         fprintf(stderr, "Failed to create image view.\n");
 500         image_view = VK_NULL_HANDLE;
 501
 502         return false;
 503     }
 504
 505     return true;
 506 }
 507
 508 static bool
 509 create_attachment_views(struct vk_ctx *ctx, int num_color_att,
 510                         struct vk_attachment *color_att,
 511                         struct vk_attachment *depth_att)
 512 {
 513     VkImageSubresourceRange sr;
 514     int i;
 515
 516     /* depth attachments */
 517     memset(&sr, 0, sizeof sr);
 518     sr.aspectMask = get_aspect_from_depth_format(depth_att->props.format);
 519     sr.baseMipLevel = 0;
 520     sr.levelCount = 1;
 521     sr.baseArrayLayer = 0;
 522     sr.layerCount = 1;
 523
 524     create_image_view(ctx, depth_att->obj.img, VK_IMAGE_VIEW_TYPE_2D,
 525                       depth_att->props.format, sr, false,
 526                       &depth_att->obj.img_view);
 527
 528     memset(&sr, 0, sizeof sr);
 529     sr.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
 530
 531     for (i = 0; i < num_color_att; i++) {
 532         /* FIXME: in case of mipmaps */
 533         sr.baseMipLevel = 0;
 534         sr.levelCount = color_att[i].props.num_levels;
 535         sr.baseArrayLayer = 0;
 536         sr.layerCount = color_att[i].props.num_layers;
 537
 538         create_image_view(ctx, color_att[i].obj.img, VK_IMAGE_VIEW_TYPE_2D,
 539                           color_att[i].props.format, sr, color_att[i].props.is_swapchain,
 540                           &color_att[i].obj.img_view);
 541     }
 542
 543     return true;
 544 }
 545
 546 static void
 547 create_framebuffer(struct vk_ctx *ctx,
 548                    int width, int height,
 549                    int num_color_atts,
 550                    struct vk_attachment *color_att,
 551                    struct vk_attachment *depth_att,
 552                    struct vk_renderer *renderer)
 553 {
 554     VkFramebufferCreateInfo fb_info;
 555     VkImageView *atts;
 556     int i;
 557     int num_atts = num_color_atts + 1;
 558
 559     atts = malloc(num_atts * sizeof atts[0]);
 560
 561     for (i = 0; i < num_color_atts; i++) {
 562         atts[i] = color_att[i].obj.img_view;
 563     }
 564     atts[num_color_atts] = depth_att->obj.img_view;
 565
 566     memset(&fb_info, 0, sizeof fb_info);
 567     fb_info.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO;
 568     fb_info.renderPass = renderer->renderpass;
 569     fb_info.width = width;
 570     fb_info.height = height;
 571     fb_info.layers = 1;
 572     fb_info.attachmentCount = num_atts;
 573     fb_info.pAttachments = atts;
 574
 575     if (vkCreateFramebuffer(ctx->dev, &fb_info, 0, &renderer->fb) != VK_SUCCESS)
 576         goto fail;
 577
 578     free(atts);
 579     return;
 580
 581 fail:
 582     fprintf(stderr, "Failed to create framebuffer.\n");
 583     free(atts);
 584     renderer->fb = VK_NULL_HANDLE;
 585 }
 586
 587 static VkShaderModule
 588 create_shader_module(struct vk_ctx *ctx,
 589              const char *src,
 590              unsigned int size)
 591 {
 592     VkShaderModuleCreateInfo sm_info;
 593     VkShaderModule sm;
 594
 595     /* VkShaderModuleCreateInfo */
 596     memset(&sm_info, 0, sizeof sm_info);
 597     sm_info.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
 598     sm_info.codeSize = size;
 599     sm_info.pCode = (void*)src;
 600
 601     if (vkCreateShaderModule(ctx->dev, &sm_info, 0, &sm) != VK_SUCCESS) {
 602         fprintf(stderr, "Failed to create shader module.\n");
 603         sm = VK_NULL_HANDLE;
 604     }
 605
 606     return sm;
 607 }
 608
 609 static bool
 610 create_graphics_pipeline(struct vk_ctx *ctx,
 611                          uint32_t width,
 612                          uint32_t height,
 613                          uint32_t num_samples,
 614                          uint32_t num_color_atts,
 615                          bool enable_depth,
 616                          bool enable_stencil,
 617                          struct vk_renderer *renderer)
 618 {
 619     VkVertexInputBindingDescription vert_bind_dsc[1];
 620     VkVertexInputAttributeDescription vert_att_dsc[1];
 621
 622     VkPipelineColorBlendAttachmentState *cb_att_state;
 623     VkPipelineVertexInputStateCreateInfo vert_input_info;
 624     VkPipelineInputAssemblyStateCreateInfo asm_info;
 625     VkPipelineViewportStateCreateInfo viewport_info;
 626     VkPipelineRasterizationStateCreateInfo rs_info;
 627     VkPipelineMultisampleStateCreateInfo ms_info;
 628     VkPipelineDepthStencilStateCreateInfo ds_info;
 629     VkPipelineColorBlendStateCreateInfo cb_info;
 630     VkPipelineShaderStageCreateInfo sdr_stages[2];
 631     VkPipelineLayoutCreateInfo layout_info;
 632     VkGraphicsPipelineCreateInfo pipeline_info;
 633     VkFormat format;
 634     VkFormatProperties fmt_props;
 635     VkPushConstantRange pc_range[1];
 636
 637     VkStencilOpState front;
 638     VkStencilOpState back;
 639     int i;
 640     VkPipelineLayout pipeline_layout;
 641     uint32_t stride;
 642
 643     /* format of vertex attributes:
 644      * we have 2D vectors so we need a RG format:
 645      * R for x, G for y
 646      * the stride (distance between 2 consecutive elements)
 647      * must be 8 because we use 32 bit floats and
 648      * 32bits = 8bytes */
 649     format = VK_FORMAT_R32G32_SFLOAT;
 650     vkGetPhysicalDeviceFormatProperties(ctx->pdev, format, &fmt_props);
 651     assert(fmt_props.bufferFeatures & VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT);
 652     stride = 8;
 653
 654     /* VkVertexInputAttributeDescription */
 655     memset(&vert_att_dsc, 0, sizeof vert_att_dsc);
 656     vert_att_dsc[0].location = 0;
 657     vert_att_dsc[0].binding = 0;
 658     vert_att_dsc[0].format = format; /* see comment */
 659     vert_att_dsc[0].offset = 0;
 660
 661     /* VkVertexInputBindingDescription */
 662     memset(&vert_bind_dsc, 0, sizeof vert_bind_dsc);
 663     vert_bind_dsc[0].binding = 0;
 664     vert_bind_dsc[0].stride = stride;
 665     vert_bind_dsc[0].inputRate = VK_VERTEX_INPUT_RATE_VERTEX;
 666
 667     /* If using vbo, we have setup vertex_info in the renderer. */
 668     bool use_vbo = renderer->vertex_info.num_verts > 0;
 669
 670     /* VkPipelineVertexInputStateCreateInfo */
 671     memset(&vert_input_info, 0, sizeof vert_input_info);
 672     vert_input_info.sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO;
 673     vert_input_info.vertexBindingDescriptionCount = use_vbo ? 1 : 0;
 674     vert_input_info.pVertexBindingDescriptions = vert_bind_dsc;
 675     vert_input_info.vertexAttributeDescriptionCount = use_vbo ? 1 : 0;
 676     vert_input_info.pVertexAttributeDescriptions = vert_att_dsc;
 677
 678     /* VkPipelineInputAssemblyStateCreateInfo */
 679     memset(&asm_info, 0, sizeof asm_info);
 680     asm_info.sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO;
 681     asm_info.topology = renderer->vertex_info.topology ?
 682                         renderer->vertex_info.topology
 683                         : VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP;
 684     asm_info.primitiveRestartEnable = false;
 685
 686     /* VkViewport */
 687     viewport.x = viewport.y = 0;
 688     viewport.width = width;
 689     viewport.height = height;
 690     viewport.minDepth = 0;
 691     viewport.maxDepth = 1;
 692
 693     /* VkRect2D scissor */
 694     scissor.offset.x = scissor.offset.y = 0;
 695     scissor.extent.width = width;
 696     scissor.extent.height = height;
 697
 698     /* VkPipelineViewportStateCreateInfo */
 699     memset(&viewport_info, 0, sizeof viewport_info);
 700     viewport_info.sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO;
 701     viewport_info.viewportCount = 1;
 702     viewport_info.pViewports = &viewport;
 703     viewport_info.scissorCount = 1;
 704     viewport_info.pScissors = &scissor;
 705
 706     /* VkPipelineRasterizationStateCreateInfo */
 707     memset(&rs_info, 0, sizeof rs_info);
 708     rs_info.sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO;
 709     rs_info.polygonMode = VK_POLYGON_MODE_FILL;
 710     rs_info.cullMode = VK_CULL_MODE_NONE;
 711     rs_info.frontFace = VK_FRONT_FACE_COUNTER_CLOCKWISE;
 712     rs_info.lineWidth = 1.0;
 713
 714     /* VkPipelineMultisampleStateCreateInfo */
 715     memset(&ms_info, 0, sizeof ms_info);
 716     ms_info.sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO;
 717     ms_info.rasterizationSamples = get_num_samples(num_samples);
 718
 719     /* VkStencilOpState */
 720     /* The default values for ES are taken by Topi Pohjolainen's code */
 721     /* defaults in OpenGL ES 3.1 */
 722     memset(&front, 0, sizeof front);
 723     front.compareMask = ~0;
 724     front.writeMask = ~0;
 725     front.reference = 0;
 726
 727     memset(&back, 0, sizeof back);
 728     back.compareMask = ~0;
 729     back.writeMask = ~0;
 730     back.reference = 0;
 731
 732     /* VkPipelineDepthStencilStateCreateInfo */
 733     memset(&ds_info, 0, sizeof ds_info);
 734     ds_info.sType = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO;
 735     ds_info.front = front;
 736     ds_info.back = back;
 737     /* defaults in OpenGL ES 3.1 */
 738     ds_info.minDepthBounds = 0;
 739     ds_info.maxDepthBounds = 1;
 740     /* z buffer, stencil buffer */
 741     if (enable_depth) {
 742         ds_info.depthTestEnable = VK_TRUE;
 743         ds_info.depthWriteEnable = VK_TRUE;
 744         ds_info.depthCompareOp = VK_COMPARE_OP_LESS;
 745     }
 746     if (enable_stencil) {
 747         ds_info.stencilTestEnable = VK_TRUE;
 748         ds_info.depthTestEnable = VK_FALSE;
 749         ds_info.depthWriteEnable = VK_TRUE;
 750     }
 751
 752     /* we only care about the passOp here */
 753     ds_info.back.compareOp = VK_COMPARE_OP_ALWAYS;
 754     ds_info.back.failOp = VK_STENCIL_OP_REPLACE;
 755     ds_info.back.depthFailOp = VK_STENCIL_OP_REPLACE;
 756     ds_info.back.passOp = VK_STENCIL_OP_REPLACE;
 757     ds_info.back.compareMask = 0xffffffff;
 758     ds_info.back.writeMask = 0xffffffff;
 759     ds_info.back.reference = 1;
 760     ds_info.front = ds_info.back;
 761
 762     /* VkPipelineColorBlendAttachmentState */
 763     cb_att_state = malloc(num_color_atts * sizeof cb_att_state[0]);
 764     if (!cb_att_state) {
 765         fprintf(stderr, "Failed to allocate color blend attachment state for each attachment.\n");
 766         goto fail;
 767     }
 768     memset(cb_att_state, 0, num_color_atts * sizeof cb_att_state[0]);
 769     for (i = 0; i < num_color_atts; i++) {
 770         cb_att_state[i].colorWriteMask = (VK_COLOR_COMPONENT_R_BIT |
 771                                           VK_COLOR_COMPONENT_G_BIT |
 772                                           VK_COLOR_COMPONENT_B_BIT |
 773                                           VK_COLOR_COMPONENT_A_BIT);
 774     }
 775
 776     /* VkPipelineColorBlendStateCreateInfo */
 777     memset(&cb_info, 0, sizeof cb_info);
 778     cb_info.sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO;
 779     cb_info.attachmentCount = num_color_atts;
 780     cb_info.pAttachments = cb_att_state;
 781     /* default in ES 3.1 */
 782     for (i = 0; i < 4; i++) {
 783         cb_info.blendConstants[i] = 0.0f;
 784     }
 785
 786     /* VkPipelineShaderStageCreateInfo */
 787     memset(sdr_stages, 0, 2 * sizeof sdr_stages[0]);
 788
 789     sdr_stages[0].sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
 790     sdr_stages[0].stage = VK_SHADER_STAGE_VERTEX_BIT;
 791     sdr_stages[0].module = renderer->vs;
 792     sdr_stages[0].pName = "main";
 793
 794     sdr_stages[1].sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
 795     sdr_stages[1].stage = VK_SHADER_STAGE_FRAGMENT_BIT;
 796     sdr_stages[1].module = renderer->fs;
 797     sdr_stages[1].pName = "main";
 798
 799     /* VkPushConstantRange */
 800     memset(pc_range, 0, sizeof pc_range[0]);
 801     pc_range[0].stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT;
 802     pc_range[0].size = sizeof (struct vk_dims); /* w, h */
 803
 804     /* VkPipelineLayoutCreateInfo */
 805     memset(&layout_info, 0, sizeof layout_info);
 806     layout_info.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO;
 807     layout_info.pushConstantRangeCount = 1;
 808     layout_info.pPushConstantRanges = pc_range;
 809
 810     if (vkCreatePipelineLayout(ctx->dev, &layout_info, 0, &pipeline_layout) != VK_SUCCESS) {
 811         fprintf(stderr, "Failed to create pipeline layout\n");
 812         renderer->pipeline = VK_NULL_HANDLE;
 813         goto fail;
 814     }
 815
 816     renderer->pipeline_layout = pipeline_layout;
 817
 818     /* VkGraphicsPipelineCreateInfo */
 819     memset(&pipeline_info, 0, sizeof pipeline_info);
 820     pipeline_info.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO;
 821     pipeline_info.layout = pipeline_layout;
 822     pipeline_info.renderPass = renderer->renderpass;
 823     pipeline_info.pVertexInputState = &vert_input_info;
 824     pipeline_info.pInputAssemblyState = &asm_info;
 825     pipeline_info.pViewportState = &viewport_info;
 826     pipeline_info.pRasterizationState = &rs_info;
 827     pipeline_info.pMultisampleState = &ms_info;
 828     pipeline_info.pDepthStencilState = &ds_info;
 829     pipeline_info.pColorBlendState = &cb_info;
 830     pipeline_info.stageCount = 2;
 831     pipeline_info.pStages = sdr_stages;
 832
 833     if (vkCreateGraphicsPipelines(ctx->dev, 0, 1,
 834                                   &pipeline_info, 0,
 835                                   &renderer->pipeline) != VK_SUCCESS) {
 836         fprintf(stderr, "Failed to create graphics pipeline.\n");
 837         renderer->pipeline = VK_NULL_HANDLE;
 838         goto fail;
 839     }
 840
 841     free(cb_att_state);
 842     return true;
 843
 844 fail:
 845     free(cb_att_state);
 846     return false;
 847 }
 848
 849 static uint32_t
 850 get_memory_type_idx(VkPhysicalDevice pdev,
 851             const VkMemoryRequirements *mem_reqs,
 852             VkMemoryPropertyFlagBits prop_flags)
 853 {
 854     VkPhysicalDeviceMemoryProperties pdev_mem_props;
 855     uint32_t i;
 856
 857     vkGetPhysicalDeviceMemoryProperties(pdev, &pdev_mem_props);
 858
 859     for (i = 0; i < pdev_mem_props.memoryTypeCount; i++) {
 860         const VkMemoryType *type = &pdev_mem_props.memoryTypes[i];
 861
 862         if ((mem_reqs->memoryTypeBits & (1 << i)) &&
 863             (type->propertyFlags & prop_flags) == prop_flags) {
 864             return i;
 865             break;
 866         }
 867     }
 868     return UINT32_MAX;
 869 }
 870
 871 static VkDeviceMemory
 872 alloc_memory(struct vk_ctx *ctx,
 873              bool is_external,
 874              const VkMemoryRequirements *mem_reqs,
 875              VkImage image,
 876              VkBuffer buffer,
 877              VkMemoryPropertyFlagBits prop_flags)
 878 {
 879     VkExportMemoryAllocateInfo exp_mem_info;
 880     VkMemoryAllocateInfo mem_alloc_info;
 881     VkDeviceMemory mem;
 882     VkMemoryDedicatedAllocateInfoKHR ded_info;
 883
 884     if (is_external) {
 885         memset(&exp_mem_info, 0, sizeof exp_mem_info);
 886         exp_mem_info.sType = VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO;
 887         exp_mem_info.handleTypes =
 888             VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT;
 889     }
 890
 891     memset(&mem_alloc_info, 0, sizeof mem_alloc_info);
 892     mem_alloc_info.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
 893     mem_alloc_info.pNext = is_external ? &exp_mem_info : VK_NULL_HANDLE;
 894     mem_alloc_info.allocationSize = mem_reqs->size;
 895     mem_alloc_info.memoryTypeIndex =
 896         get_memory_type_idx(ctx->pdev, mem_reqs, prop_flags);
 897
 898     if (mem_alloc_info.memoryTypeIndex == UINT32_MAX) {
 899         fprintf(stderr, "No suitable memory type index found.\n");
 900         return 0;
 901     }
 902
 903     if (image || buffer) {
 904         memset(&ded_info, 0, sizeof ded_info);
 905         ded_info.sType = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO;
 906         ded_info.image = image;
 907         ded_info.buffer = buffer;
 908
 909         exp_mem_info.pNext = &ded_info;
 910     }
 911
 912     if (vkAllocateMemory(ctx->dev, &mem_alloc_info, 0, &mem) !=
 913         VK_SUCCESS)
 914         return 0;
 915
 916     return mem;
 917 }
 918
 919 static bool
 920 alloc_image_memory(struct vk_ctx *ctx, bool is_external, struct vk_image_obj *img_obj)
 921 {
 922     VkMemoryDedicatedRequirements ded_reqs;
 923     VkImageMemoryRequirementsInfo2 req_info2;
 924     VkMemoryRequirements2 mem_reqs2;
 925
 926     memset(&ded_reqs, 0, sizeof ded_reqs);
 927     ded_reqs.sType = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS;
 928
 929     /* VkImageMemoryRequirementsInfo2 */
 930     memset(&req_info2, 0, sizeof req_info2);
 931     req_info2.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2;
 932     req_info2.image = img_obj->img;
 933
 934     /* VkMemoryRequirements2 */
 935     memset(&mem_reqs2, 0, sizeof mem_reqs2);
 936     mem_reqs2.sType = VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2;
 937     mem_reqs2.pNext = &ded_reqs;
 938
 939     vkGetImageMemoryRequirements2(ctx->dev, &req_info2, &mem_reqs2);
 940     img_obj->mobj.mem = alloc_memory(ctx,
 941                                      is_external,
 942                                      &mem_reqs2.memoryRequirements,
 943                                      ded_reqs.requiresDedicatedAllocation ?
 944                                         img_obj->img : VK_NULL_HANDLE,
 945                                      VK_NULL_HANDLE,
 946                                      mem_reqs2.memoryRequirements.memoryTypeBits &
 947                                      VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
 948
 949     img_obj->mobj.mem_sz = mem_reqs2.memoryRequirements.size;
 950     img_obj->mobj.dedicated = ded_reqs.requiresDedicatedAllocation;
 951     if (img_obj->mobj.mem == VK_NULL_HANDLE) {
 952         fprintf(stderr, "Failed to allocate image memory.\n");
 953         return false;
 954     }
 955
 956     if (vkBindImageMemory(ctx->dev, img_obj->img, img_obj->mobj.mem, 0) !=
 957             VK_SUCCESS) {
 958         fprintf(stderr, "Failed to bind image memory.\n");
 959         return false;
 960     }
 961
 962     return true;
 963 }
 964
 965 static bool
 966 are_props_supported(struct vk_ctx *ctx, struct vk_att_props *props)
 967 {
 968     VkPhysicalDeviceExternalImageFormatInfo ext_img_fmt_info;
 969     VkExternalImageFormatProperties ext_img_fmt_props;
 970
 971     int i;
 972     VkPhysicalDeviceImageFormatInfo2 img_fmt_info;
 973     VkImageFormatProperties2 img_fmt_props;
 974
 975     VkImageUsageFlagBits all_flags[] = {
 976         VK_IMAGE_USAGE_TRANSFER_SRC_BIT,
 977         VK_IMAGE_USAGE_TRANSFER_DST_BIT,
 978         VK_IMAGE_USAGE_SAMPLED_BIT,
 979         VK_IMAGE_USAGE_STORAGE_BIT,
 980         VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT,
 981         VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT,
 982         VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT,
 983         /* Shouldn't be used together with COLOR, DEPTH_STENCIL
 984          * attachment bits:
 985          * VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT,
 986          * Provided by VK_EXT_fragment_density_map
 987          * VK_IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT,
 988          * Provided by VK_NV_shading_rate_image
 989          * VK_IMAGE_USAGE_SHADING_RATE_IMAGE_BIT_NV,
 990          * Provided by VK_KHR_fragment_shading_rate
 991          * VK_IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR,
 992          */
 993     };
 994     VkImageUsageFlagBits flags = 0;
 995
 996     VkExternalMemoryFeatureFlagBits export_feature_flags = props->need_export ?
 997         VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT : 0;
 998     VkExternalMemoryHandleTypeFlagBits handle_type = props->need_export ?
 999         VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR : 0;
1000
1001     if (props->need_export) {
1002         memset(&ext_img_fmt_info, 0, sizeof ext_img_fmt_info);
1003         ext_img_fmt_info.sType =
1004             VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO;
1005         ext_img_fmt_info.handleType = handle_type;
1006
1007         memset(&ext_img_fmt_props, 0, sizeof ext_img_fmt_props);
1008         ext_img_fmt_props.sType =
1009             VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES;
1010     }
1011
1012     memset(&img_fmt_props, 0, sizeof img_fmt_props);
1013     img_fmt_props.sType = VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2;
1014     img_fmt_props.pNext = props->need_export ? &ext_img_fmt_props : 0;
1015
1016     memset(&img_fmt_info, 0, sizeof img_fmt_info);
1017     img_fmt_info.sType =
1018         VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2;
1019     img_fmt_info.pNext = props->need_export ? &ext_img_fmt_info : 0;
1020     img_fmt_info.format = props->format;
1021     img_fmt_info.type = get_image_type(props->h, props->depth);
1022     img_fmt_info.tiling = props->tiling;
1023
1024     for (i = 0; i < ARRAY_SIZE(all_flags); i++) {
1025         img_fmt_info.usage = all_flags[i];
1026         if (vkGetPhysicalDeviceImageFormatProperties2(ctx->pdev,
1027                                                       &img_fmt_info,
1028                                                       &img_fmt_props) == VK_SUCCESS) {
1029             flags |= all_flags[i];
1030         }
1031     }
1032
1033     /* usage can't be null */
1034     if (flags) {
1035         img_fmt_info.usage = flags;
1036     }
1037     else {
1038         if (!props->is_swapchain) {
1039             fprintf(stderr, "Unsupported Vulkan format properties: usage.\n");
1040             return false;
1041         }
1042         img_fmt_info.usage = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
1043     }
1044
1045     if (vkGetPhysicalDeviceImageFormatProperties2
1046         (ctx->pdev, &img_fmt_info, &img_fmt_props) != VK_SUCCESS) {
1047         fprintf(stderr,
1048             "Unsupported Vulkan format properties.\n");
1049         return false;
1050     }
1051     props->usage = flags;
1052
1053     if (props->need_export &&
1054         !(ext_img_fmt_props.externalMemoryProperties.externalMemoryFeatures
1055             & export_feature_flags)) {
1056         fprintf(stderr, "Unsupported Vulkan external memory features.\n");
1057         return false;
1058     }
1059
1060     return true;
1061 }
1062
1063 /* static swapchain / surf related functions */
1064
1065 static bool
1066 sc_validate_surface(struct vk_ctx *ctx,
1067                     VkSurfaceKHR surf)
1068 {
1069     VkBool32 supported;
1070     if (!surf) {
1071         fprintf(stderr, "No surface!\n");
1072         return false;
1073     }
1074
1075     if(vkGetPhysicalDeviceSurfaceSupportKHR(ctx->pdev, ctx->qfam_idx, surf, &supported) != VK_SUCCESS) {
1076         fprintf(stderr, "Failed to validate surface.\n");
1077         return false;
1078     }
1079
1080     if (!supported) {
1081         fprintf(stderr, "Invalid surface! Check if the surface with queue family index: %d supports presentation.\n", (int)ctx->qfam_idx);
1082         return false;
1083     }
1084
1085     return true;
1086 }
1087
1088 static bool
1089 sc_select_format(struct vk_ctx *ctx,
1090                  VkSurfaceKHR surf,
1091                  VkSwapchainCreateInfoKHR *s_info)
1092 {
1093     VkSurfaceFormatKHR *formats;
1094     uint32_t num_formats;
1095
1096     if (vkGetPhysicalDeviceSurfaceFormatsKHR(ctx->pdev, surf, &num_formats, 0) != VK_SUCCESS) {
1097         fprintf(stderr, "Failed to get the number of surface formats.\n");
1098         return false;
1099     }
1100
1101     if (!num_formats) {
1102         fprintf(stderr, "No surface formats found.\n");
1103         return false;
1104     }
1105
1106     formats = malloc(num_formats * sizeof *formats);
1107
1108     if (vkGetPhysicalDeviceSurfaceFormatsKHR(ctx->pdev, surf, &num_formats, formats) != VK_SUCCESS) {
1109         fprintf(stderr, "Failed to get the supported surface formats.\n");
1110         return false;
1111     }
1112
1113     if ((num_formats == 1) && (formats[0].format == VK_FORMAT_UNDEFINED)) {
1114         s_info->imageFormat = VK_FORMAT_B8G8R8A8_UNORM;
1115         s_info->imageColorSpace = VK_COLORSPACE_SRGB_NONLINEAR_KHR;
1116     } else {
1117         s_info->imageFormat = formats[0].format;
1118         s_info->imageColorSpace = formats[0].colorSpace;
1119     }
1120     free(formats);
1121
1122     return true;
1123 }
1124
1125 static bool
1126 sc_select_supported_present_modes(struct vk_ctx *ctx,
1127                                   VkSurfaceKHR surf,
1128                                   bool has_vsync,
1129                                   VkSwapchainCreateInfoKHR *s_info)
1130 {
1131     VkPresentModeKHR *present_modes;
1132     uint32_t num_present_modes;
1133     int i;
1134
1135     /* find supported present modes */
1136     if (vkGetPhysicalDeviceSurfacePresentModesKHR(ctx->pdev, surf, &num_present_modes, 0) != VK_SUCCESS || !num_present_modes) {
1137         fprintf(stderr, "Failed to get the number of the supported presentation modes.\n");
1138         return false;
1139     }
1140
1141     present_modes = malloc(num_present_modes * sizeof *present_modes);
1142     if (vkGetPhysicalDeviceSurfacePresentModesKHR(ctx->pdev, surf, &num_present_modes, present_modes) != VK_SUCCESS) {
1143         fprintf(stderr, "Failed to get the number of supported presentation modes.\n");
1144         return false;
1145     }
1146     if (vkGetPhysicalDeviceSurfacePresentModesKHR(ctx->pdev, surf, &num_present_modes,
1147                                                   present_modes) != VK_SUCCESS) {
1148         fprintf(stderr, "Failed to get the supported presentation modes.\n");
1149         return false;
1150     }
1151
1152     s_info->presentMode = VK_PRESENT_MODE_FIFO_KHR;
1153     if (!has_vsync) {
1154         for (i = 0; i < num_present_modes; i++) {
1155             if (present_modes[i] == VK_PRESENT_MODE_MAILBOX_KHR) {
1156                 s_info->presentMode = present_modes[i];
1157                 goto success;
1158             }
1159             if (present_modes[i] == VK_PRESENT_MODE_IMMEDIATE_KHR) {
1160                 s_info->presentMode = present_modes[i];
1161                 goto success;
1162             }
1163         }
1164     }
1165
1166 success:
1167     free(present_modes);
1168     return true;
1169 }
1170
1171 /* end of static functions */
1172
1173 /* exposed Vulkan functions */
1174
1175 bool
1176 vk_init_ctx(struct vk_ctx *ctx,
1177             bool enable_layers)
1178 {
1179     if ((ctx->inst = create_instance(enable_layers)) == VK_NULL_HANDLE) {
1180         fprintf(stderr, "Failed to create Vulkan instance.\n");
1181         goto fail;
1182     }
1183
1184     if ((ctx->pdev = select_physical_device(ctx->inst)) == VK_NULL_HANDLE) {
1185         fprintf(stderr, "Failed to find suitable physical device.\n");
1186         goto fail;
1187     }
1188
1189     if ((ctx->dev = create_device(ctx, ctx->pdev)) == VK_NULL_HANDLE) {
1190         fprintf(stderr, "Failed to create Vulkan device.\n");
1191         goto fail;
1192     }
1193
1194     fill_uuid(ctx->pdev, ctx->deviceUUID, ctx->driverUUID);
1195     return true;
1196
1197 fail:
1198     vk_cleanup_ctx(ctx, enable_layers);
1199     return false;
1200 }
1201
1202 bool
1203 vk_init_ctx_for_rendering(struct vk_ctx *ctx,
1204                           bool enable_cache,
1205                           bool enable_layers)
1206 {
1207     if (!vk_init_ctx(ctx, enable_layers)) {
1208         fprintf(stderr, "Failed to initialize Vulkan.\n");
1209         return false;
1210     }
1211
1212     if ((ctx->cmd_pool = create_cmd_pool(ctx)) == VK_NULL_HANDLE) {
1213         fprintf(stderr, "Failed to create command pool.\n");
1214         goto fail;
1215     }
1216
1217     vkGetDeviceQueue(ctx->dev, ctx->qfam_idx, 0, &ctx->queue);
1218     if (!ctx->queue) {
1219         fprintf(stderr, "Failed to get command queue.\n");
1220         goto fail;
1221     }
1222
1223     if (enable_cache) {
1224         if (!(pipeline_cache = create_pipeline_cache(ctx))) {
1225             fprintf(stderr, "Failed to create pipeline cache.\n");
1226             goto fail;
1227         }
1228     }
1229
1230     return true;
1231
1232 fail:
1233     vk_cleanup_ctx(ctx, enable_layers);
1234     return false;
1235 }
1236
1237 void
1238 vk_destroy_cmd_bufs(struct vk_ctx *ctx,
1239                     uint32_t num_buffers,
1240                     VkCommandBuffer *buffers)
1241 {
1242     int i;
1243     for (i = 0; i < num_buffers; i++) {
1244         vkResetCommandBuffer(buffers[i],
1245                              VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT);
1246     }
1247     vkFreeCommandBuffers(ctx->dev, ctx->cmd_pool, num_buffers, &buffers[i]);
1248 }
1249
1250 void
1251 vk_cleanup_ctx(struct vk_ctx *ctx,
1252                bool enable_layers)
1253 {
1254     if (enable_layers) {
1255         return;
1256     }
1257
1258     if (ctx->cmd_pool != VK_NULL_HANDLE) {
1259         vkResetCommandPool(ctx->dev, ctx->cmd_pool,
1260                            VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT);
1261         vkDestroyCommandPool(ctx->dev, ctx->cmd_pool, 0);
1262         ctx->cmd_pool = VK_NULL_HANDLE;
1263     }
1264
1265     if (pipeline_cache != VK_NULL_HANDLE) {
1266         vkDestroyPipelineCache(ctx->dev, pipeline_cache, 0);
1267         pipeline_cache = VK_NULL_HANDLE;
1268     }
1269
1270     if (ctx->dev != VK_NULL_HANDLE) {
1271         vkDestroyDevice(ctx->dev, 0);
1272         ctx->dev = VK_NULL_HANDLE;
1273     }
1274
1275     if (ctx->inst != VK_NULL_HANDLE) {
1276         vkDestroyInstance(ctx->inst, 0);
1277         ctx->inst = VK_NULL_HANDLE;
1278     }
1279 }
1280
1281 bool
1282 vk_create_image(struct vk_ctx *ctx,
1283                 struct vk_att_props *props,
1284                 struct vk_image_obj *img)
1285 {
1286     VkImageCreateInfo img_info;
1287
1288     memset(&img_info, 0, sizeof img_info);
1289     img_info.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
1290     img_info.pNext = 0; /* do something if external */
1291     img_info.imageType = get_image_type(props->h, props->depth);
1292     img_info.format = props->format;
1293     img_info.extent.width = props->w;
1294     img_info.extent.height = props->h;
1295     img_info.extent.depth = props->depth;
1296     img_info.mipLevels = props->num_levels ? props->num_levels : 1;
1297     img_info.arrayLayers = props->num_layers ?
1298                            props->num_layers : VK_SAMPLE_COUNT_1_BIT;
1299     img_info.samples = get_num_samples(props->num_samples);
1300     img_info.tiling = props->tiling;
1301     img_info.usage = props->usage ?
1302                      props->usage : VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
1303     img_info.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
1304     img_info.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
1305
1306     if (vkCreateImage(ctx->dev, &img_info, 0, &img->img) != VK_SUCCESS)
1307         goto fail;
1308
1309     if(!alloc_image_memory(ctx, props->need_export, img))
1310         goto fail;
1311
1312     return true;
1313
1314 fail:
1315     fprintf(stderr, "Failed to create external image.\n");
1316     vk_destroy_image(ctx, img);
1317     img->img = VK_NULL_HANDLE;
1318     img->mobj.mem = VK_NULL_HANDLE;
1319     return false;
1320 }
1321
1322 void
1323 vk_destroy_image(struct vk_ctx *ctx, struct vk_image_obj *img_obj)
1324 {
1325     if (img_obj->img != VK_NULL_HANDLE) {
1326         vkDestroyImage(ctx->dev, img_obj->img, 0);
1327         img_obj->img = VK_NULL_HANDLE;
1328     }
1329
1330     if (img_obj->mobj.mem != VK_NULL_HANDLE) {
1331         vkFreeMemory(ctx->dev, img_obj->mobj.mem, 0);
1332         img_obj->mobj.mem = VK_NULL_HANDLE;
1333     }
1334 }
1335
1336 bool
1337 vk_create_ext_image(struct vk_ctx *ctx,
1338                     struct vk_att_props *props, struct vk_image_obj *img)
1339 {
1340     VkExternalMemoryImageCreateInfo ext_img_info;
1341     VkImageCreateInfo img_info;
1342
1343     memset(&ext_img_info, 0, sizeof ext_img_info);
1344     ext_img_info.sType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO;
1345     ext_img_info.handleTypes = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR;
1346
1347     memset(&img_info, 0, sizeof img_info);
1348     img_info.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
1349     img_info.pNext = &ext_img_info;
1350     img_info.imageType = get_image_type(props->h, props->depth);
1351     img_info.format = props->format;
1352     img_info.extent.width = props->w;
1353     img_info.extent.height = props->h;
1354     img_info.extent.depth = props->depth;
1355     img_info.mipLevels = props->num_levels ? props->num_levels : 1;
1356     img_info.arrayLayers = props->num_layers ? props->num_layers : VK_SAMPLE_COUNT_1_BIT;
1357     img_info.samples = get_num_samples(props->num_samples);
1358     img_info.tiling = props->tiling;
1359     img_info.usage = props->usage;
1360     img_info.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
1361     img_info.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
1362     /* issue 17 of EXT_external_objects
1363      * Required in OpenGL implementations that support
1364      * ARB_texture_view, OES_texture_view, EXT_texture_view,
1365      * or OpenGL 4.3 and above.
1366      */
1367     img_info.flags = VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT;
1368
1369     if (vkCreateImage(ctx->dev, &img_info, 0, &img->img) != VK_SUCCESS)
1370         goto fail;
1371
1372     if(!alloc_image_memory(ctx, true, img))
1373         goto fail;
1374
1375     return true;
1376
1377 fail:
1378     fprintf(stderr, "Failed to create external image.\n");
1379     vk_destroy_image(ctx, img);
1380     img->img = VK_NULL_HANDLE;
1381     img->mobj.mem = VK_NULL_HANDLE;
1382     return false;
1383 }
1384
1385 bool
1386 vk_fill_image_props(struct vk_ctx *ctx,
1387                     uint32_t w,
1388                     uint32_t h,
1389                     uint32_t d,
1390                     uint32_t num_samples,
1391                     uint32_t num_levels,
1392                     uint32_t num_layers,
1393                     VkFormat format,
1394                     VkImageTiling tiling,
1395                     VkImageLayout in_layout,
1396                     VkImageLayout end_layout,
1397                     bool is_swapchain,
1398                     bool is_depth,
1399                     bool need_export,
1400                     struct vk_att_props *props)
1401 {
1402     props->w = w;
1403     props->h = h;
1404     props->depth = d;
1405
1406     props->num_samples = num_samples;
1407     props->num_levels = num_levels;
1408     props->num_layers = num_layers;
1409
1410     props->format = format;
1411     props->tiling = tiling;
1412
1413     props->in_layout = in_layout;
1414     props->end_layout = end_layout;
1415
1416     props->is_swapchain = is_swapchain;
1417     props->is_depth = is_depth;
1418     props->need_export = need_export;
1419
1420     if (!are_props_supported(ctx, props))
1421         return false;
1422
1423     return true;
1424 }
1425
1426 bool
1427 vk_create_renderer(struct vk_ctx *ctx,
1428                    const char *vs_src,
1429                    unsigned int vs_size,
1430                    const char *fs_src,
1431                    unsigned int fs_size,
1432                    int w, int h,
1433                    uint32_t num_samples,
1434                    bool enable_depth,
1435                    bool enable_stencil,
1436                    int num_color_att,
1437                    struct vk_attachment *color_att,
1438                    struct vk_attachment *depth_att,
1439                    struct vk_vertex_info *vert_info,
1440                    struct vk_renderer *renderer)
1441 {
1442     memset(&renderer->vertex_info, 0, sizeof renderer->vertex_info);
1443     if (vert_info)
1444         renderer->vertex_info = *vert_info;
1445
1446     /* create image views for each attachment */
1447     if (!create_attachment_views(ctx, num_color_att, color_att, depth_att))
1448         goto fail;
1449
1450     renderer->renderpass = create_renderpass(ctx,
1451                                              num_color_att,
1452                                              color_att,
1453                                              depth_att);
1454
1455     if (renderer->renderpass == VK_NULL_HANDLE)
1456         goto fail;
1457
1458     create_framebuffer(ctx,
1459                        w, h,
1460                        num_color_att, color_att,
1461                        depth_att, renderer);
1462     if (renderer->fb == VK_NULL_HANDLE)
1463         goto fail;
1464
1465     renderer->vs = create_shader_module(ctx, vs_src, vs_size);
1466     if (renderer->vs == VK_NULL_HANDLE)
1467         goto fail;
1468
1469     renderer->fs = create_shader_module(ctx, fs_src, fs_size);
1470     if (renderer->fs == VK_NULL_HANDLE)
1471         goto fail;
1472
1473     /* FIXME this is only for graphics atm */
1474     if(!create_graphics_pipeline(ctx, w, h,
1475                                  num_samples,
1476                                  num_color_att,
1477                                  enable_depth,
1478                                  enable_stencil, renderer))
1479         goto fail;
1480
1481     if (renderer->pipeline == VK_NULL_HANDLE)
1482         goto fail;
1483
1484     return true;
1485
1486 fail:
1487     fprintf(stderr, "Failed to create renderer.\n");
1488     vk_destroy_renderer(ctx, renderer);
1489     return false;
1490 }
1491
1492 void
1493 vk_destroy_renderer(struct vk_ctx *ctx,
1494                     struct vk_renderer *renderer)
1495 {
1496     if (renderer->renderpass != VK_NULL_HANDLE) {
1497         vkDestroyRenderPass(ctx->dev, renderer->renderpass, 0);
1498         renderer->renderpass = VK_NULL_HANDLE;
1499     }
1500
1501     if (renderer->vs != VK_NULL_HANDLE) {
1502         vkDestroyShaderModule(ctx->dev, renderer->vs, 0);
1503         renderer->vs = VK_NULL_HANDLE;
1504     }
1505
1506     if (renderer->fs != VK_NULL_HANDLE) {
1507         vkDestroyShaderModule(ctx->dev, renderer->fs, 0);
1508         renderer->fs = VK_NULL_HANDLE;
1509     }
1510
1511     if (renderer->fb != VK_NULL_HANDLE) {
1512         vkDestroyFramebuffer(ctx->dev, renderer->fb, 0);
1513         renderer->fb = VK_NULL_HANDLE;
1514     }
1515
1516     if (renderer->pipeline != VK_NULL_HANDLE) {
1517         vkDestroyPipeline(ctx->dev, renderer->pipeline, 0);
1518         renderer->pipeline = VK_NULL_HANDLE;
1519     }
1520
1521     if (renderer->pipeline_layout != VK_NULL_HANDLE) {
1522         vkDestroyPipelineLayout(ctx->dev, renderer->pipeline_layout, 0);
1523         renderer->pipeline_layout = VK_NULL_HANDLE;
1524     }
1525 }
1526
1527 bool
1528 vk_create_ext_buffer(struct vk_ctx *ctx,
1529                      uint32_t sz,
1530                      VkBufferUsageFlagBits usage,
1531                      struct vk_buf *bo)
1532 {
1533     VkExternalMemoryBufferCreateInfo ext_bo_info;
1534
1535     memset(&ext_bo_info, 0, sizeof ext_bo_info);
1536     ext_bo_info.sType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO;
1537     ext_bo_info.handleTypes = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR;
1538
1539     if (!vk_create_buffer(ctx, true, sz, usage, &ext_bo_info, bo)) {
1540         fprintf(stderr, "Failed to allocate external buffer.\n");
1541         return false;
1542     }
1543
1544     return true;
1545 }
1546
1547 bool
1548 vk_create_buffer(struct vk_ctx *ctx,
1549                  bool is_external,
1550                  uint32_t sz,
1551                  VkBufferUsageFlagBits usage,
1552                  void *pnext,
1553                  struct vk_buf *bo)
1554 {
1555     VkBufferCreateInfo buf_info;
1556     VkMemoryRequirements mem_reqs;
1557
1558     bo->mobj.mem = VK_NULL_HANDLE;
1559     bo->buf = VK_NULL_HANDLE;
1560
1561     /* VkBufferCreateInfo */
1562     memset(&buf_info, 0, sizeof buf_info);
1563     buf_info.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
1564     buf_info.size = sz;
1565     buf_info.usage = usage;
1566     buf_info.pNext = pnext;
1567     buf_info.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
1568
1569     if (vkCreateBuffer(ctx->dev, &buf_info, 0, &bo->buf) != VK_SUCCESS)
1570         goto fail;
1571
1572     /* allocate buffer */
1573     vkGetBufferMemoryRequirements(ctx->dev, bo->buf, &mem_reqs);
1574     /* VK_MEMORY_PROPERTY_HOST_COHERENT_BIT bit specifies that the
1575      * host cache management commands vkFlushMappedMemoryRanges and
1576      * vkInvalidateMappedMemoryRanges are not needed to flush host
1577      * writes to the device or make device writes visible to the
1578      * host, respectively. */
1579     bo->mobj.mem = alloc_memory(ctx, is_external, &mem_reqs, VK_NULL_HANDLE,
1580                                 VK_NULL_HANDLE,
1581                                 VK_MEMORY_PROPERTY_HOST_COHERENT_BIT |
1582                                 VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT);
1583
1584     if (bo->mobj.mem == VK_NULL_HANDLE)
1585         goto fail;
1586
1587     bo->mobj.mem_sz = sz;
1588
1589     if (vkBindBufferMemory(ctx->dev, bo->buf, bo->mobj.mem, 0) != VK_SUCCESS) {
1590         fprintf(stderr, "Failed to bind buffer memory.\n");
1591         goto fail;
1592     }
1593
1594     return true;
1595
1596 fail:
1597     fprintf(stderr, "Failed to allocate buffer.\n");
1598     vk_destroy_buffer(ctx, bo);
1599     return false;
1600 }
1601
1602 bool
1603 vk_update_buffer_data(struct vk_ctx *ctx,
1604                       void *data,
1605                       uint32_t data_sz,
1606                       struct vk_buf *bo)
1607 {
1608     void *map;
1609
1610     if (vkMapMemory(ctx->dev, bo->mobj.mem, 0, data_sz, 0, &map) != VK_SUCCESS) {
1611         fprintf(stderr, "Failed to map buffer memory.\n");
1612         goto fail;
1613     }
1614
1615     memcpy(map, data, data_sz);
1616
1617     vkUnmapMemory(ctx->dev, bo->mobj.mem);
1618     return true;
1619
1620 fail:
1621     fprintf(stderr, "Failed to update buffer data. Destroying the buffer.\n");
1622     vk_destroy_buffer(ctx, bo);
1623
1624     return false;
1625 }
1626
1627 void
1628 vk_destroy_buffer(struct vk_ctx *ctx,
1629           struct vk_buf *bo)
1630 {
1631     if (bo->buf != VK_NULL_HANDLE)
1632         vkDestroyBuffer(ctx->dev, bo->buf, 0);
1633
1634     if (bo->mobj.mem != VK_NULL_HANDLE)
1635         vkFreeMemory(ctx->dev, bo->mobj.mem, 0);
1636
1637     bo->mobj.mem_sz = 0;
1638     bo->buf = VK_NULL_HANDLE;
1639     bo->mobj.mem = VK_NULL_HANDLE;
1640 }
1641
1642 VkCommandBuffer
1643 vk_create_cmd_buffer(struct vk_ctx *ctx)
1644 {
1645     VkCommandBuffer cmd_buf;
1646     VkCommandBufferAllocateInfo alloc_info;
1647
1648     memset(&alloc_info, 0, sizeof alloc_info);
1649     alloc_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
1650     alloc_info.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
1651     alloc_info.commandBufferCount = 1;
1652     alloc_info.commandPool = ctx->cmd_pool;
1653
1654     if (vkAllocateCommandBuffers(ctx->dev, &alloc_info, &cmd_buf) != VK_SUCCESS)
1655         return 0;
1656
1657     return cmd_buf;
1658 }
1659
1660 bool
1661 vk_record_cmd_buffer(struct vk_ctx *ctx,
1662                      VkCommandBuffer cmd_buf,
1663                      struct vk_renderer *renderer,
1664                      struct vk_buf *vbo,
1665                      uint32_t vk_fb_color_count,
1666                      float *vk_fb_color,
1667                      uint32_t num_atts,
1668                      struct vk_attachment *atts,
1669                      float x, float y,
1670                      float w, float h)
1671 {
1672     VkCommandBufferBeginInfo cmd_begin_info;
1673     VkRenderPassBeginInfo rp_begin_info;
1674     VkRect2D rp_area;
1675     VkClearValue *clear_values; int i;
1676     VkDeviceSize offsets[] = {0};
1677     int num_vertices;
1678     struct vk_dims img_size;
1679
1680     assert(vk_fb_color_count == 4);
1681
1682     /* if cmd_buf is null create it */
1683     if (!cmd_buf) {
1684         if ((cmd_buf = vk_create_cmd_buffer(ctx)) ==
1685                 VK_NULL_HANDLE) {
1686             fprintf(stderr, "Failed to create command buffer.\n");
1687             return false;
1688         }
1689     }
1690
1691     /* VkCommandBufferBeginInfo */
1692     memset(&cmd_begin_info, 0, sizeof cmd_begin_info);
1693     cmd_begin_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
1694     cmd_begin_info.flags = VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT;
1695
1696     /* VkRect2D render area */
1697     memset(&rp_area, 0, sizeof rp_area);
1698     rp_area.extent.width = (uint32_t)w;
1699     rp_area.extent.height = (uint32_t)h;
1700     rp_area.offset.x = x;
1701     rp_area.offset.y = y;
1702
1703     /* VkClearValue */
1704     clear_values = malloc(num_atts * sizeof clear_values[0]);
1705     memset(clear_values, 0, num_atts * sizeof clear_values[0]);
1706
1707     for (i = 0; i < num_atts - 1; i++) {
1708         clear_values[i].color.float32[0] = vk_fb_color[0];
1709         clear_values[i].color.float32[1] = vk_fb_color[1];
1710         clear_values[i].color.float32[2] = vk_fb_color[2];
1711         clear_values[i].color.float32[3] = vk_fb_color[3];
1712     }
1713     clear_values[num_atts - 1].depthStencil.depth = 1.0f;
1714     clear_values[num_atts - 1].depthStencil.stencil = 0;
1715
1716     /* VkRenderPassBeginInfo */
1717     memset(&rp_begin_info, 0, sizeof rp_begin_info);
1718     rp_begin_info.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO;
1719     rp_begin_info.renderPass = renderer->renderpass;
1720     rp_begin_info.framebuffer = renderer->fb;
1721     rp_begin_info.renderArea = rp_area;
1722     rp_begin_info.clearValueCount = num_atts;
1723     rp_begin_info.pClearValues = clear_values;
1724
1725     vkBeginCommandBuffer(cmd_buf, &cmd_begin_info);
1726     vkCmdBeginRenderPass(cmd_buf, &rp_begin_info, VK_SUBPASS_CONTENTS_INLINE);
1727
1728     viewport.x = x;
1729     viewport.y = y;
1730     viewport.width = w;
1731     viewport.height = h;
1732
1733     scissor.offset.x = x;
1734     scissor.offset.y = y;
1735     scissor.extent.width = w;
1736     scissor.extent.height = h;
1737
1738     vkCmdSetViewport(cmd_buf, 0, 1, &viewport);
1739     vkCmdSetScissor(cmd_buf, 0, 1, &scissor);
1740
1741     img_size.w = (float)w;
1742     img_size.h = (float)h;
1743     vkCmdPushConstants(cmd_buf,
1744                        renderer->pipeline_layout,
1745                        VK_SHADER_STAGE_FRAGMENT_BIT,
1746                        0, sizeof (struct vk_dims),
1747                        &img_size);
1748
1749     if (vbo) {
1750         vkCmdBindVertexBuffers(cmd_buf, 0, 1, &vbo->buf, offsets);
1751     }
1752
1753     vkCmdBindPipeline(cmd_buf, VK_PIPELINE_BIND_POINT_GRAPHICS, renderer->pipeline);
1754
1755     num_vertices = vbo ? renderer->vertex_info.num_verts : 4;
1756     vkCmdDraw(cmd_buf, num_vertices, 1, 0, 0);
1757     vkCmdEndRenderPass(cmd_buf);
1758
1759     free(clear_values);
1760 #if 0
1761     if (atts) {
1762         VkImageMemoryBarrier *barriers =
1763             calloc(num_atts, sizeof(VkImageMemoryBarrier));
1764         VkImageMemoryBarrier *barrier = barriers;
1765         for (uint32_t n = 0; n < num_atts; n++, barrier++) {
1766             struct vk_attachment *att = &atts[n];
1767             VkImageAspectFlagBits depth_stencil_flags =
1768                 get_aspect_from_depth_format(att->props.format);
1769             bool is_depth = (depth_stencil_flags != 0);
1770
1771             /* Insert barrier to mark ownership transfer. */
1772             barrier->sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
1773             barrier->oldLayout = is_depth ?
1774                 VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL :
1775                 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
1776             barrier->newLayout = VK_IMAGE_LAYOUT_GENERAL;
1777             barrier->srcAccessMask = get_access_mask(barrier->oldLayout);
1778             barrier->dstAccessMask = get_access_mask(barrier->newLayout);
1779             barrier->srcQueueFamilyIndex = ctx->qfam_idx;
1780             barrier->dstQueueFamilyIndex = VK_QUEUE_FAMILY_EXTERNAL;
1781             barrier->image = att->obj.img;
1782             barrier->subresourceRange.aspectMask = is_depth ?
1783                 depth_stencil_flags :
1784                 VK_IMAGE_ASPECT_COLOR_BIT;
1785             barrier->subresourceRange.baseMipLevel = 0;
1786             barrier->subresourceRange.levelCount = 1;
1787             barrier->subresourceRange.baseArrayLayer = 0;
1788             barrier->subresourceRange.layerCount = 1;
1789         }
1790
1791         vkCmdPipelineBarrier(cmd_buf,
1792                      VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT,
1793                      VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT,
1794                      0,
1795                      0, NULL,
1796                      0, NULL,
1797                      num_atts, barriers);
1798         free(barriers);
1799     }
1800 #endif
1801
1802     vkEndCommandBuffer(cmd_buf);
1803     return true;
1804 }
1805
1806 void
1807 vk_draw(struct vk_ctx *ctx,
1808         struct vk_semaphores *semaphores,
1809         uint32_t num_buffers,
1810         VkCommandBuffer *cmd_buf)
1811 {
1812     VkSubmitInfo submit_info;
1813     VkPipelineStageFlagBits stage_flags;
1814
1815     stage_flags = VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT;
1816
1817     /* VkSubmitInfo */
1818     memset(&submit_info, 0, sizeof submit_info);
1819     submit_info.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
1820     submit_info.commandBufferCount = num_buffers;
1821     submit_info.pCommandBuffers = cmd_buf;
1822
1823     /* semaphores */
1824     if (semaphores) {
1825         assert(semaphores->frame_ready);
1826         assert(semaphores->frame_done);
1827
1828         submit_info.pWaitDstStageMask = &stage_flags;
1829         submit_info.waitSemaphoreCount = 1;
1830         submit_info.pWaitSemaphores = &semaphores->frame_done;
1831
1832         submit_info.signalSemaphoreCount = 1;
1833         submit_info.pSignalSemaphores = &semaphores->frame_ready;
1834     }
1835
1836
1837     if (vkQueueSubmit(ctx->queue, 1, &submit_info, VK_NULL_HANDLE) != VK_SUCCESS) {
1838         fprintf(stderr, "Failed to submit queue.\n");
1839     }
1840
1841     vkQueueWaitIdle(ctx->queue);
1842 }
1843
1844 void
1845 vk_clear_color(struct vk_ctx *ctx,
1846                VkCommandBuffer cmd_buf,
1847                struct vk_buf *vbo,
1848                struct vk_renderer *renderer,
1849                float *vk_fb_color,
1850                uint32_t vk_fb_color_count,
1851                struct vk_semaphores *semaphores,
1852                bool has_wait, bool has_signal,
1853                struct vk_attachment *attachments,
1854                uint32_t n_attachments,
1855                float x, float y,
1856                float w, float h)
1857 {
1858     VkCommandBufferBeginInfo cmd_begin_info;
1859     VkRenderPassBeginInfo rp_begin_info;
1860     VkRect2D rp_area;
1861     VkClearValue clear_values[2];
1862     VkSubmitInfo submit_info;
1863     VkPipelineStageFlagBits stage_flags;
1864     VkImageSubresourceRange img_range;
1865
1866     assert(vk_fb_color_count == 4);
1867
1868     /* VkCommandBufferBeginInfo */
1869     memset(&cmd_begin_info, 0, sizeof cmd_begin_info);
1870     cmd_begin_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
1871     cmd_begin_info.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
1872
1873     /* VkRect2D render area */
1874     memset(&rp_area, 0, sizeof rp_area);
1875     rp_area.extent.width = (uint32_t)w;
1876     rp_area.extent.height = (uint32_t)h;
1877     rp_area.offset.x = x;
1878     rp_area.offset.y = y;
1879
1880     /* VkClearValue */
1881     memset(&clear_values[0], 0, sizeof clear_values[0]);
1882     clear_values[0].color.float32[0] = vk_fb_color[0]; /* red */
1883     clear_values[0].color.float32[1] = vk_fb_color[1]; /* green */
1884     clear_values[0].color.float32[2] = vk_fb_color[2]; /* blue */
1885     clear_values[0].color.float32[3] = vk_fb_color[3]; /* alpha */
1886
1887     memset(&clear_values[1], 0, sizeof clear_values[1]);
1888     clear_values[1].depthStencil.depth = 1.0;
1889     clear_values[1].depthStencil.stencil = 0;
1890
1891     /* VkRenderPassBeginInfo */
1892     memset(&rp_begin_info, 0, sizeof rp_begin_info);
1893     rp_begin_info.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO;
1894     rp_begin_info.renderPass = renderer->renderpass;
1895     rp_begin_info.framebuffer = renderer->fb;
1896     rp_begin_info.renderArea = rp_area;
1897     rp_begin_info.clearValueCount = 2;
1898     rp_begin_info.pClearValues = clear_values;
1899
1900     /* VkSubmitInfo */
1901     stage_flags = VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT;
1902
1903     memset(&submit_info, 0, sizeof submit_info);
1904     submit_info.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
1905     submit_info.commandBufferCount = 1;
1906     submit_info.pCommandBuffers = &cmd_buf;
1907
1908     /* FIXME */
1909     if (has_wait) {
1910         submit_info.pWaitDstStageMask = &stage_flags;
1911         submit_info.waitSemaphoreCount = 1;
1912         submit_info.pWaitSemaphores = &semaphores->frame_done;
1913     }
1914
1915     if (has_signal) {
1916         submit_info.signalSemaphoreCount = 1;
1917         submit_info.pSignalSemaphores = &semaphores->frame_ready;
1918     }
1919
1920     img_range.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
1921     img_range.baseMipLevel = 0;
1922     img_range.levelCount = 1;
1923     img_range.baseArrayLayer = 0;
1924     img_range.layerCount = 1;
1925
1926     vkBeginCommandBuffer(cmd_buf, &cmd_begin_info);
1927     vk_transition_image_layout(&attachments[0],
1928                                cmd_buf,
1929                                VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
1930                                VK_IMAGE_LAYOUT_GENERAL,
1931                                VK_QUEUE_FAMILY_EXTERNAL,
1932                                ctx->qfam_idx);
1933     vkCmdClearColorImage(cmd_buf,
1934                          attachments[0].obj.img,
1935                          VK_IMAGE_LAYOUT_GENERAL,
1936                          &clear_values[0].color,
1937                          1,
1938                          &img_range);
1939
1940     vkCmdBeginRenderPass(cmd_buf, &rp_begin_info, VK_SUBPASS_CONTENTS_INLINE);
1941
1942     viewport.x = x;
1943     viewport.y = y;
1944     viewport.width = w;
1945     viewport.height = h;
1946
1947     scissor.offset.x = x;
1948     scissor.offset.y = y;
1949     scissor.extent.width = w;
1950     scissor.extent.height = h;
1951
1952     vkCmdSetViewport(cmd_buf, 0, 1, &viewport);
1953     vkCmdSetScissor(cmd_buf, 0, 1, &scissor);
1954
1955     vkCmdBindPipeline(cmd_buf, VK_PIPELINE_BIND_POINT_GRAPHICS, renderer->pipeline);
1956
1957     vkCmdEndRenderPass(cmd_buf);
1958
1959     if (attachments) {
1960         VkImageMemoryBarrier *barriers =
1961             calloc(n_attachments, sizeof(VkImageMemoryBarrier));
1962         VkImageMemoryBarrier *barrier = barriers;
1963
1964         for (uint32_t n = 0; n < n_attachments; n++, barrier++) {
1965             struct vk_attachment *att = &attachments[n];
1966
1967             /* Insert barrier to mark ownership transfer. */
1968             barrier->sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
1969
1970             bool is_depth =
1971                 get_aspect_from_depth_format(att->props.format) != VK_NULL_HANDLE;
1972
1973             barrier->oldLayout = is_depth ?
1974                 VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL :
1975                 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
1976             barrier->newLayout = VK_IMAGE_LAYOUT_GENERAL;
1977             barrier->srcAccessMask = get_access_mask(barrier->oldLayout);
1978             barrier->dstAccessMask = get_access_mask(barrier->newLayout);
1979             barrier->srcQueueFamilyIndex = ctx->qfam_idx;
1980             barrier->dstQueueFamilyIndex = VK_QUEUE_FAMILY_EXTERNAL;
1981             barrier->image = att->obj.img;
1982             barrier->subresourceRange.aspectMask = is_depth ?
1983                 VK_IMAGE_ASPECT_DEPTH_BIT :
1984                 VK_IMAGE_ASPECT_COLOR_BIT;
1985             barrier->subresourceRange.baseMipLevel = 0;
1986             barrier->subresourceRange.levelCount = 1;
1987             barrier->subresourceRange.baseArrayLayer = 0;
1988             barrier->subresourceRange.layerCount = 1;
1989         }
1990
1991         vkCmdPipelineBarrier(cmd_buf,
1992                      VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT,
1993                      VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT,
1994                      0,
1995                      0, NULL,
1996                      0, NULL,
1997                      n_attachments, barriers);
1998         free(barriers);
1999     }
2000
2001     vkEndCommandBuffer(cmd_buf);
2002
2003     if (vkQueueSubmit(ctx->queue, 1, &submit_info, VK_NULL_HANDLE) != VK_SUCCESS) {
2004         fprintf(stderr, "Failed to submit queue.\n");
2005     }
2006
2007     if (!semaphores && !has_wait && !has_signal)
2008         vkQueueWaitIdle(ctx->queue);
2009 }
2010
2011 bool
2012 vk_create_swapchain(struct vk_ctx *ctx,
2013                     int width, int height,
2014                     bool has_vsync,
2015                     VkSurfaceKHR surf,
2016                     struct vk_swapchain *old_swapchain,
2017                     struct vk_swapchain *swapchain)
2018 {
2019     VkSurfaceCapabilitiesKHR surf_cap;
2020     VkSwapchainCreateInfoKHR s_info;
2021     VkExtent2D extent;
2022     VkImageSubresourceRange sr;
2023     VkImage *s_images;
2024     int i;
2025
2026     if (!sc_validate_surface(ctx, surf)) {
2027         fprintf(stderr, "Failed to validate surface!\n");
2028         return false;
2029     }
2030
2031     /* get pdevice capabilities
2032      * will need that to determine the swapchain number of images
2033      */
2034     if (vkGetPhysicalDeviceSurfaceCapabilitiesKHR(ctx->pdev, surf, &surf_cap) != VK_SUCCESS) {
2035         fprintf(stderr, "Failed to query surface capabilities.\n");
2036         return false;
2037     }
2038
2039     memset(swapchain, 0, sizeof *swapchain);
2040
2041     memset(&s_info, 0, sizeof s_info);
2042     s_info.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR;
2043     s_info.flags = 0;
2044     if (!sc_select_format(ctx, surf, &s_info)) {
2045         fprintf(stderr, "Failed to determine the surface format.\n");
2046         return false;
2047     }
2048     s_info.surface = surf;
2049     s_info.minImageCount = surf_cap.minImageCount;
2050     {
2051         extent.width = width;
2052         extent.height = height;
2053     }
2054     if (!sc_select_supported_present_modes(ctx, surf, has_vsync, &s_info)) {
2055         s_info.presentMode = VK_PRESENT_MODE_FIFO_KHR;
2056     }
2057     s_info.imageExtent = extent;
2058     s_info.imageArrayLayers = 1;
2059     {
2060         s_info.imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
2061         if (surf_cap.supportedUsageFlags & VK_IMAGE_USAGE_TRANSFER_SRC_BIT)
2062             s_info.imageUsage |= VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
2063         if (surf_cap.supportedUsageFlags & VK_IMAGE_USAGE_TRANSFER_DST_BIT)
2064             s_info.imageUsage |= VK_IMAGE_USAGE_TRANSFER_DST_BIT;
2065     }
2066     s_info.imageSharingMode = VK_SHARING_MODE_EXCLUSIVE;
2067     s_info.queueFamilyIndexCount = ctx->qfam_idx;
2068
2069     /* we might want to use this function when we recreate the swapchain too */
2070     s_info.preTransform = surf_cap.supportedTransforms &
2071                           VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR ?
2072                           VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR :
2073                           surf_cap.currentTransform;
2074
2075     /* we could also write a sc_select_supported_composite_alpha
2076      * later but VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR is universally
2077      * supported */
2078     s_info.compositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR;
2079     s_info.clipped = VK_TRUE;
2080
2081     if (vkCreateSwapchainKHR(ctx->dev, &s_info, 0,
2082                              &swapchain->swapchain) != VK_SUCCESS) {
2083         fprintf(stderr, "Failed to create a swapchain.\n");
2084         return false;
2085     }
2086
2087     if (!swapchain->swapchain) {
2088         fprintf(stderr, "The swapchain seems null\n");
2089         return false;
2090     }
2091
2092     /* get the number of swapchain images and the swapchain images
2093      * and store the new swapchain images
2094      */
2095     vkGetSwapchainImagesKHR(ctx->dev, swapchain->swapchain, &swapchain->num_atts, 0);
2096     printf("number of swapchain images: %d\n", swapchain->num_atts);
2097
2098     /* create images */
2099     s_images = malloc(swapchain->num_atts * sizeof(VkImage));
2100     if (!s_images) {
2101         fprintf(stderr, "Failed to allocate swapchain images.\n");
2102         return false;
2103     }
2104
2105     vkGetSwapchainImagesKHR(ctx->dev, swapchain->swapchain, &swapchain->num_atts, s_images);
2106
2107     swapchain->image_fmt = s_info.imageFormat;
2108     swapchain->atts = malloc(swapchain->num_atts * sizeof swapchain->atts[0]);
2109     if (!swapchain->atts) {
2110         fprintf(stderr, "Failed to allocate swapchain images.\n");
2111         goto fail;
2112     }
2113     memset(swapchain->atts, 0, sizeof swapchain->atts[0]);
2114
2115     memset(&sr, 0, sizeof sr);
2116     sr.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
2117     sr.levelCount = 1;
2118     sr.layerCount = 1;
2119
2120     for (i = 0; i < swapchain->num_atts; i++) {
2121         /* we store the image */
2122         swapchain->atts[i].obj.img = s_images[i];
2123
2124         /* filling attachment properties here where that info
2125          * is available */
2126
2127         vk_fill_image_props(ctx, width, height, 1,
2128                             1, 1, 1,
2129                             s_info.imageFormat,
2130                             0,
2131                             VK_IMAGE_LAYOUT_UNDEFINED,
2132                             VK_IMAGE_LAYOUT_PRESENT_SRC_KHR,
2133                             true, false, false,
2134                             &swapchain->atts[i].props);
2135         swapchain->atts[i].props.usage = s_info.imageUsage;
2136
2137         if (!create_image_view(ctx, s_images[i],
2138                                VK_IMAGE_VIEW_TYPE_2D,
2139                                s_info.imageFormat, sr, true,
2140                                &swapchain->atts[i].obj.img_view)) {
2141             fprintf(stderr, "Failed to create image view for image: %d\n", i);
2142             goto fail;
2143         }
2144     }
2145
2146     free(s_images);
2147     return true;
2148
2149 fail:
2150     free(s_images);
2151     return false;
2152 }
2153
2154 void
2155 vk_destroy_swapchain(struct vk_ctx *ctx,
2156                      struct vk_swapchain *swapchain)
2157 {
2158     vkDestroySwapchainKHR(ctx->dev, swapchain->swapchain, 0);
2159     swapchain = 0;
2160 }
2161
2162 bool
2163 vk_present_queue(struct vk_swapchain *swapchain,
2164                  VkQueue queue,
2165                  uint32_t image_idx,
2166                  VkSemaphore wait_sema)
2167 {
2168     VkPresentInfoKHR pinfo;
2169
2170     memset(&pinfo, 0, sizeof pinfo);
2171     pinfo.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR;
2172     pinfo.swapchainCount = 1;
2173     pinfo.pImageIndices = &image_idx;
2174
2175     if (wait_sema != VK_NULL_HANDLE) {
2176         pinfo.pWaitSemaphores = &wait_sema;
2177         pinfo.waitSemaphoreCount = 1;
2178     }
2179
2180     if (vkQueuePresentKHR(queue, &pinfo) != VK_SUCCESS) {
2181         fprintf(stderr, "Failed to present queue.\n");
2182         return false;
2183     }
2184
2185     return true;
2186 }
2187
2188 void
2189 vk_copy_image_to_buffer(struct vk_ctx *ctx,
2190                         VkCommandBuffer cmd_buf,
2191                         struct vk_attachment *src_img,
2192                         struct vk_buf *dst_bo,
2193                         float w, float h)
2194 {
2195     VkCommandBufferBeginInfo cmd_begin_info;
2196     VkSubmitInfo submit_info;
2197     VkImageAspectFlagBits aspect_mask = get_aspect_from_depth_format(src_img->props.format);
2198
2199     /* VkCommandBufferBeginInfo */
2200     memset(&cmd_begin_info, 0, sizeof cmd_begin_info);
2201     cmd_begin_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
2202     cmd_begin_info.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
2203
2204     memset(&submit_info, 0, sizeof submit_info);
2205     submit_info.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
2206     submit_info.commandBufferCount = 1;
2207     submit_info.pCommandBuffers = &cmd_buf;
2208
2209     vkBeginCommandBuffer(cmd_buf, &cmd_begin_info);
2210     if (src_img->props.end_layout == VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL && dst_bo) {
2211         vk_transition_image_layout(src_img,
2212                                    cmd_buf,
2213                                    VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
2214                                    VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
2215                                    VK_QUEUE_FAMILY_EXTERNAL,
2216                                    ctx->qfam_idx);
2217
2218         /* copy image to buf */
2219         VkBufferImageCopy copy_region = {
2220             .bufferOffset = 0,
2221             .bufferRowLength = w,
2222             .bufferImageHeight = h,
2223             .imageSubresource = {
2224                 .aspectMask = aspect_mask ? aspect_mask
2225                               : VK_IMAGE_ASPECT_COLOR_BIT,
2226                 .mipLevel = 0,
2227                 .baseArrayLayer = 0,
2228                 .layerCount = 1,
2229             },
2230             .imageOffset = { 0, 0, 0 },
2231             .imageExtent = { w, h, 1 }
2232                 };
2233
2234         vkCmdCopyImageToBuffer(cmd_buf,
2235                                src_img->obj.img,
2236                                VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
2237                                dst_bo->buf, 1, &copy_region);
2238
2239         vk_transition_image_layout(src_img,
2240                                    cmd_buf,
2241                                    VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
2242                                    VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
2243                                    VK_QUEUE_FAMILY_EXTERNAL,
2244                                    ctx->qfam_idx);
2245
2246         VkBufferMemoryBarrier write_finish_buffer_memory_barrier = {
2247             .sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,
2248             .srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT,
2249             .dstAccessMask = VK_ACCESS_HOST_READ_BIT,
2250             .srcQueueFamilyIndex = VK_QUEUE_FAMILY_EXTERNAL,
2251             .dstQueueFamilyIndex = ctx->qfam_idx,
2252             .buffer = dst_bo->buf,
2253             .offset = 0,
2254             .size = VK_WHOLE_SIZE
2255         };
2256
2257         vkCmdPipelineBarrier(cmd_buf,
2258                              VK_PIPELINE_STAGE_TRANSFER_BIT,
2259                              VK_PIPELINE_STAGE_HOST_BIT,
2260                              (VkDependencyFlags) 0, 0, NULL,
2261                              1, &write_finish_buffer_memory_barrier,
2262                              0, NULL);
2263     }
2264     vkEndCommandBuffer(cmd_buf);
2265
2266     if (vkQueueSubmit(ctx->queue, 1, &submit_info, VK_NULL_HANDLE) != VK_SUCCESS) {
2267         fprintf(stderr, "Failed to submit queue.\n");
2268     }
2269     vkQueueWaitIdle(ctx->queue);
2270 }
2271
2272 bool
2273 vk_create_semaphores(struct vk_ctx *ctx,
2274                      bool is_external,
2275                      struct vk_semaphores *semaphores)
2276 {
2277     VkSemaphoreCreateInfo sema_info;
2278     VkExportSemaphoreCreateInfo exp_sema_info;
2279
2280     if (is_external) {
2281         /* VkExportSemaphoreCreateInfo */
2282         memset(&exp_sema_info, 0, sizeof exp_sema_info);
2283         exp_sema_info.sType = VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO;
2284         exp_sema_info.handleTypes = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT;
2285     }
2286
2287     /* VkSemaphoreCreateInfo */
2288     memset(&sema_info, 0, sizeof sema_info);
2289     sema_info.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO;
2290     sema_info.pNext = is_external ? &exp_sema_info : 0;
2291
2292     if (vkCreateSemaphore(ctx->dev, &sema_info, 0, &semaphores->frame_ready) != VK_SUCCESS) {
2293         fprintf(stderr, "Failed to create semaphore frame_ready.\n");
2294         return false;
2295     }
2296
2297     if (vkCreateSemaphore(ctx->dev, &sema_info, 0, &semaphores->frame_done) != VK_SUCCESS) {
2298         fprintf(stderr, "Failed to create semaphore frame_done.\n");
2299         return false;
2300     }
2301
2302     return true;
2303 }
2304
2305 void
2306 vk_destroy_semaphores(struct vk_ctx *ctx,
2307                       struct vk_semaphores *semaphores)
2308 {
2309     if (semaphores->frame_ready)
2310         vkDestroySemaphore(ctx->dev, semaphores->frame_ready, 0);
2311     if (semaphores->frame_done)
2312         vkDestroySemaphore(ctx->dev, semaphores->frame_done, 0);
2313 }
2314
2315 bool
2316 vk_create_fences(struct vk_ctx *ctx,
2317                  int num_cmd_buf,
2318                  VkFenceCreateFlagBits flags,
2319                  VkFence *fences)
2320 {
2321     VkFenceCreateInfo f_info;
2322     int i, j = -1;
2323
2324     memset(&f_info, 0, sizeof f_info);
2325     f_info.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
2326     f_info.flags = flags ? flags : VK_FENCE_CREATE_SIGNALED_BIT;
2327
2328
2329     fences = malloc(num_cmd_buf * sizeof(VkFence));
2330     for (i = 0; i < num_cmd_buf; i++) {
2331         if (vkCreateFence(ctx->dev, &f_info, 0, &fences[i]) != VK_SUCCESS) {
2332             fprintf(stderr, "Failed to create fence number: %d\n", (i + 1));
2333             j = i;
2334             break;
2335         }
2336     }
2337
2338     if (j == i) {
2339         for (i = 0; i < j; i++) {
2340             vkDestroyFence(ctx->dev, fences[i], 0);
2341         }
2342         return false;
2343     }
2344
2345     return true;
2346 }
2347
2348 void
2349 vk_destroy_fences(struct vk_ctx *ctx,
2350                   int num_fences,
2351                   VkFence *fences)
2352 {
2353     int i;
2354     for (i = 0; i < num_fences; i++) {
2355         vkDestroyFence(ctx->dev, fences[i], 0);
2356     }
2357 }
2358
2359 void
2360 vk_transition_image_layout(struct vk_attachment *img_att,
2361                            VkCommandBuffer cmd_buf,
2362                            VkImageLayout old_layout,
2363                            VkImageLayout new_layout,
2364                            uint32_t src_queue_fam_idx,
2365                            uint32_t dst_queue_fam_idx)
2366 {
2367     VkImageMemoryBarrier barrier;
2368     struct vk_att_props props = img_att->props;
2369     VkImageAspectFlagBits aspect_mask = get_aspect_from_depth_format(props.format);
2370
2371     memset(&barrier, 0, sizeof barrier);
2372     barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
2373     barrier.srcAccessMask = get_access_mask(old_layout);
2374     barrier.dstAccessMask = get_access_mask(new_layout);
2375     barrier.oldLayout = old_layout;
2376     barrier.newLayout = new_layout;
2377     barrier.srcQueueFamilyIndex = src_queue_fam_idx;
2378     barrier.dstQueueFamilyIndex = dst_queue_fam_idx;
2379     barrier.image = img_att->obj.img;
2380     barrier.subresourceRange.aspectMask = aspect_mask ? aspect_mask :
2381                                           VK_IMAGE_ASPECT_COLOR_BIT;
2382     barrier.subresourceRange.levelCount = 1;
2383     barrier.subresourceRange.layerCount = 1;
2384
2385     vkCmdPipelineBarrier(cmd_buf,
2386                          get_pipeline_stage_flags(old_layout),
2387                          get_pipeline_stage_flags(new_layout),
2388                          0, 0, VK_NULL_HANDLE, 0, VK_NULL_HANDLE, 1, &barrier);
2389 }