tests/vkrenderframework.cpp

   1 /*
   2  * Copyright (c) 2015-2017 The Khronos Group Inc.
   3  * Copyright (c) 2015-2017 Valve Corporation
   4  * Copyright (c) 2015-2017 LunarG, Inc.
   5  * Copyright (c) 2015-2017 Google, Inc.
   6  *
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *     http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  *
  19  * Author: Courtney Goeltzenleuchter <courtney@LunarG.com>
  20  * Author: Tony Barbour <tony@LunarG.com>
  21  * Author: Dave Houlton <daveh@lunarg.com>
  22  */
  23
  24 #include "vkrenderframework.h"
  25 #include "vk_format_utils.h"
  26
  27 #define ARRAY_SIZE(a) (sizeof(a) / sizeof(a[0]))
  28 #define GET_DEVICE_PROC_ADDR(dev, entrypoint)                                            \
  29     {                                                                                    \
  30         fp##entrypoint = (PFN_vk##entrypoint)vkGetDeviceProcAddr(dev, "vk" #entrypoint); \
  31         assert(fp##entrypoint != NULL);                                                  \
  32     }
  33
  34 VkRenderFramework::VkRenderFramework()
  35     : inst(VK_NULL_HANDLE),
  36       m_device(NULL),
  37       m_commandPool(VK_NULL_HANDLE),
  38       m_commandBuffer(NULL),
  39       m_renderPass(VK_NULL_HANDLE),
  40       m_framebuffer(VK_NULL_HANDLE),
  41       m_addRenderPassSelfDependency(false),
  42       m_width(256.0),   // default window width
  43       m_height(256.0),  // default window height
  44       m_render_target_fmt(VK_FORMAT_R8G8B8A8_UNORM),
  45       m_depth_stencil_fmt(VK_FORMAT_UNDEFINED),
  46       m_clear_via_load_op(true),
  47       m_depth_clear_color(1.0),
  48       m_stencil_clear_color(0),
  49       m_depthStencil(NULL),
  50       m_CreateDebugReportCallback(VK_NULL_HANDLE),
  51       m_DestroyDebugReportCallback(VK_NULL_HANDLE),
  52       m_globalMsgCallback(VK_NULL_HANDLE),
  53       m_devMsgCallback(VK_NULL_HANDLE) {
  54     memset(&m_renderPassBeginInfo, 0, sizeof(m_renderPassBeginInfo));
  55     m_renderPassBeginInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO;
  56
  57     // clear the back buffer to dark grey
  58     m_clear_color.float32[0] = 0.25f;
  59     m_clear_color.float32[1] = 0.25f;
  60     m_clear_color.float32[2] = 0.25f;
  61     m_clear_color.float32[3] = 0.0f;
  62 }
  63
  64 VkRenderFramework::~VkRenderFramework() {}
  65
  66 VkPhysicalDevice VkRenderFramework::gpu() {
  67     EXPECT_NE((VkInstance)0, inst);  // Invalid to request gpu before instance exists
  68     return objs[0];
  69 }
  70
  71 // Return true if layer name is found and spec+implementation values are >= requested values
  72 bool VkRenderFramework::InstanceLayerSupported(const char *name, uint32_t spec, uint32_t implementation) {
  73     uint32_t layer_count = 0;
  74     std::vector<VkLayerProperties> layer_props;
  75
  76     VkResult res = vkEnumerateInstanceLayerProperties(&layer_count, NULL);
  77     if (VK_SUCCESS != res) return false;
  78     if (0 == layer_count) return false;
  79
  80     layer_props.resize(layer_count);
  81     res = vkEnumerateInstanceLayerProperties(&layer_count, layer_props.data());
  82     if (VK_SUCCESS != res) return false;
  83
  84     for (auto &it : layer_props) {
  85         if (0 == strncmp(name, it.layerName, VK_MAX_EXTENSION_NAME_SIZE)) {
  86             return ((it.specVersion >= spec) && (it.implementationVersion >= implementation));
  87         }
  88     }
  89     return false;
  90 }
  91
  92 // Enable device profile as last layer on stack overriding devsim if there, or return if not available
  93 bool VkRenderFramework::EnableDeviceProfileLayer() {
  94     if (InstanceLayerSupported("VK_LAYER_LUNARG_device_profile_api")) {
  95         if (VkTestFramework::m_devsim_layer) {
  96             assert(0 == strcmp(m_instance_layer_names.back(), "VK_LAYER_LUNARG_device_simulation"));
  97             m_instance_layer_names.pop_back();
  98             m_instance_layer_names.push_back("VK_LAYER_LUNARG_device_profile_api");
  99         } else {
 100             m_instance_layer_names.push_back("VK_LAYER_LUNARG_device_profile_api");
 101         }
 102     } else {
 103         printf("             Did not find VK_LAYER_LUNARG_device_profile_api layer; skipped.\n");
 104         return false;
 105     }
 106     return true;
 107 }
 108
 109 // Return true if extension name is found and spec value is >= requested spec value
 110 bool VkRenderFramework::InstanceExtensionSupported(const char *ext_name, uint32_t spec) {
 111     uint32_t ext_count = 0;
 112     std::vector<VkExtensionProperties> ext_props;
 113     VkResult res = vkEnumerateInstanceExtensionProperties(nullptr, &ext_count, nullptr);
 114     if (VK_SUCCESS != res) return false;
 115     if (0 == ext_count) return false;
 116
 117     ext_props.resize(ext_count);
 118     res = vkEnumerateInstanceExtensionProperties(nullptr, &ext_count, ext_props.data());
 119     if (VK_SUCCESS != res) return false;
 120
 121     for (auto &it : ext_props) {
 122         if (0 == strncmp(ext_name, it.extensionName, VK_MAX_EXTENSION_NAME_SIZE)) {
 123             return (it.specVersion >= spec);
 124         }
 125     }
 126     return false;
 127 }
 128
 129 // Return true if instance exists and extension name is in the list
 130 bool VkRenderFramework::InstanceExtensionEnabled(const char *ext_name) {
 131     if (!inst) return false;
 132
 133     bool ext_found = false;
 134     for (auto ext : m_instance_extension_names) {
 135         if (!strcmp(ext, ext_name)) {
 136             ext_found = true;
 137             break;
 138         }
 139     }
 140     return ext_found;
 141 }
 142
 143 // Return true if extension name is found and spec value is >= requested spec value
 144 bool VkRenderFramework::DeviceExtensionSupported(VkPhysicalDevice dev, const char *layer, const char *ext_name, uint32_t spec) {
 145     if (!inst) {
 146         EXPECT_NE((VkInstance)0, inst);  // Complain, not cool without an instance
 147         return false;
 148     }
 149     uint32_t ext_count = 0;
 150     std::vector<VkExtensionProperties> ext_props;
 151     VkResult res = vkEnumerateDeviceExtensionProperties(dev, layer, &ext_count, nullptr);
 152     if (VK_SUCCESS != res) return false;
 153     if (0 == ext_count) return false;
 154
 155     ext_props.resize(ext_count);
 156     res = vkEnumerateDeviceExtensionProperties(dev, layer, &ext_count, ext_props.data());
 157     if (VK_SUCCESS != res) return false;
 158
 159     for (auto &it : ext_props) {
 160         if (0 == strncmp(ext_name, it.extensionName, VK_MAX_EXTENSION_NAME_SIZE)) {
 161             return (it.specVersion >= spec);
 162         }
 163     }
 164     return false;
 165 }
 166
 167 // Return true if device is created and extension name is found in the list
 168 bool VkRenderFramework::DeviceExtensionEnabled(const char *ext_name) {
 169     if (NULL == m_device) return false;
 170
 171     bool ext_found = false;
 172     for (auto ext : m_device_extension_names) {
 173         if (!strcmp(ext, ext_name)) {
 174             ext_found = true;
 175             break;
 176         }
 177     }
 178     return ext_found;
 179 }
 180
 181 void VkRenderFramework::InitFramework(PFN_vkDebugReportCallbackEXT dbgFunction, void *userData) {
 182     // Only enable device profile layer by default if devsim is not enabled
 183     if (!VkTestFramework::m_devsim_layer && InstanceLayerSupported("VK_LAYER_LUNARG_device_profile_api")) {
 184         m_instance_layer_names.push_back("VK_LAYER_LUNARG_device_profile_api");
 185     }
 186
 187     // Assert not already initialized
 188     ASSERT_EQ((VkInstance)0, inst);
 189
 190     // Remove any unsupported layer names from list
 191     for (auto layer = m_instance_layer_names.begin(); layer != m_instance_layer_names.end();) {
 192         if (!InstanceLayerSupported(*layer)) {
 193             ADD_FAILURE() << "InitFramework(): Requested layer " << *layer << " was not found. Disabled.";
 194             layer = m_instance_layer_names.erase(layer);
 195         } else {
 196             ++layer;
 197         }
 198     }
 199
 200     // Remove any unsupported instance extension names from list
 201     for (auto ext = m_instance_extension_names.begin(); ext != m_instance_extension_names.end();) {
 202         if (!InstanceExtensionSupported(*ext)) {
 203             ADD_FAILURE() << "InitFramework(): Requested extension " << *ext << " was not found. Disabled.";
 204             ext = m_instance_extension_names.erase(ext);
 205         } else {
 206             ++ext;
 207         }
 208     }
 209
 210     VkInstanceCreateInfo instInfo = {};
 211     VkResult U_ASSERT_ONLY err;
 212
 213     instInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
 214     instInfo.pNext = NULL;
 215     instInfo.pApplicationInfo = &app_info;
 216     instInfo.enabledLayerCount = m_instance_layer_names.size();
 217     instInfo.ppEnabledLayerNames = m_instance_layer_names.data();
 218     instInfo.enabledExtensionCount = m_instance_extension_names.size();
 219     instInfo.ppEnabledExtensionNames = m_instance_extension_names.data();
 220
 221     VkDebugReportCallbackCreateInfoEXT dbgCreateInfo;
 222     if (dbgFunction) {
 223         // Enable create time debug messages
 224         memset(&dbgCreateInfo, 0, sizeof(dbgCreateInfo));
 225         dbgCreateInfo.sType = VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT;
 226         dbgCreateInfo.flags =
 227             VK_DEBUG_REPORT_ERROR_BIT_EXT | VK_DEBUG_REPORT_WARNING_BIT_EXT | VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT;
 228         dbgCreateInfo.pfnCallback = dbgFunction;
 229         dbgCreateInfo.pUserData = userData;
 230
 231         dbgCreateInfo.pNext = instInfo.pNext;
 232         instInfo.pNext = &dbgCreateInfo;
 233     }
 234
 235     err = vkCreateInstance(&instInfo, NULL, &this->inst);
 236     ASSERT_VK_SUCCESS(err);
 237
 238     err = vkEnumeratePhysicalDevices(inst, &this->gpu_count, NULL);
 239     ASSERT_LE(this->gpu_count, ARRAY_SIZE(objs)) << "Too many gpus";
 240     ASSERT_VK_SUCCESS(err);
 241     err = vkEnumeratePhysicalDevices(inst, &this->gpu_count, objs);
 242     ASSERT_VK_SUCCESS(err);
 243     ASSERT_GE(this->gpu_count, (uint32_t)1) << "No GPU available";
 244     if (dbgFunction) {
 245         m_CreateDebugReportCallback =
 246             (PFN_vkCreateDebugReportCallbackEXT)vkGetInstanceProcAddr(this->inst, "vkCreateDebugReportCallbackEXT");
 247         ASSERT_NE(m_CreateDebugReportCallback, (PFN_vkCreateDebugReportCallbackEXT)NULL)
 248             << "Did not get function pointer for CreateDebugReportCallback";
 249         if (m_CreateDebugReportCallback) {
 250             dbgCreateInfo.pNext = nullptr;  // clean up from usage in CreateInstance above
 251             err = m_CreateDebugReportCallback(this->inst, &dbgCreateInfo, NULL, &m_globalMsgCallback);
 252             ASSERT_VK_SUCCESS(err);
 253
 254             m_DestroyDebugReportCallback =
 255                 (PFN_vkDestroyDebugReportCallbackEXT)vkGetInstanceProcAddr(this->inst, "vkDestroyDebugReportCallbackEXT");
 256             ASSERT_NE(m_DestroyDebugReportCallback, (PFN_vkDestroyDebugReportCallbackEXT)NULL)
 257                 << "Did not get function pointer for DestroyDebugReportCallback";
 258             m_DebugReportMessage = (PFN_vkDebugReportMessageEXT)vkGetInstanceProcAddr(this->inst, "vkDebugReportMessageEXT");
 259             ASSERT_NE(m_DebugReportMessage, (PFN_vkDebugReportMessageEXT)NULL)
 260                 << "Did not get function pointer for DebugReportMessage";
 261         }
 262     }
 263 }
 264
 265 void VkRenderFramework::ShutdownFramework() {
 266     // Nothing to shut down without a VkInstance
 267     if (!this->inst) return;
 268
 269     delete m_commandBuffer;
 270     delete m_commandPool;
 271     if (m_framebuffer) vkDestroyFramebuffer(device(), m_framebuffer, NULL);
 272     if (m_renderPass) vkDestroyRenderPass(device(), m_renderPass, NULL);
 273
 274     if (m_globalMsgCallback) m_DestroyDebugReportCallback(this->inst, m_globalMsgCallback, NULL);
 275     if (m_devMsgCallback) m_DestroyDebugReportCallback(this->inst, m_devMsgCallback, NULL);
 276
 277     m_renderTargets.clear();
 278
 279     delete m_depthStencil;
 280
 281     // reset the driver
 282     delete m_device;
 283     if (this->inst) vkDestroyInstance(this->inst, NULL);
 284     this->inst = (VkInstance)0;  // In case we want to re-initialize
 285 }
 286
 287 void VkRenderFramework::GetPhysicalDeviceFeatures(VkPhysicalDeviceFeatures *features) {
 288     if (NULL == m_device) {
 289         VkDeviceObj *temp_device = new VkDeviceObj(0, objs[0], m_device_extension_names);
 290         *features = temp_device->phy().features();
 291         delete (temp_device);
 292     } else {
 293         *features = m_device->phy().features();
 294     }
 295 }
 296
 297 void VkRenderFramework::InitState(VkPhysicalDeviceFeatures *features, const VkCommandPoolCreateFlags flags) {
 298     // Remove any unsupported device extension names from list
 299     for (auto ext = m_device_extension_names.begin(); ext != m_device_extension_names.end();) {
 300         if (!DeviceExtensionSupported(objs[0], nullptr, *ext)) {
 301             bool found = false;
 302             for (auto layer = m_instance_layer_names.begin(); layer != m_instance_layer_names.end();) {
 303                 if (!DeviceExtensionSupported(objs[0], *layer, *ext)) {
 304                     found = true;
 305                     break;
 306                 }
 307             }
 308             if (!found) {
 309                 ADD_FAILURE() << "InitState(): The requested device extension " << *ext << " was not found. Disabled.";
 310                 ext = m_device_extension_names.erase(ext);
 311             } else {
 312                 ++ext;
 313             }
 314         } else {
 315             ++ext;
 316         }
 317     }
 318
 319     m_device = new VkDeviceObj(0, objs[0], m_device_extension_names, features);
 320     m_device->SetDeviceQueue();
 321
 322     m_depthStencil = new VkDepthStencilObj(m_device);
 323
 324     m_render_target_fmt = VkTestFramework::GetFormat(inst, m_device);
 325
 326     m_lineWidth = 1.0f;
 327
 328     m_depthBiasConstantFactor = 0.0f;
 329     m_depthBiasClamp = 0.0f;
 330     m_depthBiasSlopeFactor = 0.0f;
 331
 332     m_blendConstants[0] = 1.0f;
 333     m_blendConstants[1] = 1.0f;
 334     m_blendConstants[2] = 1.0f;
 335     m_blendConstants[3] = 1.0f;
 336
 337     m_minDepthBounds = 0.f;
 338     m_maxDepthBounds = 1.f;
 339
 340     m_compareMask = 0xff;
 341     m_writeMask = 0xff;
 342     m_reference = 0;
 343
 344     m_commandPool = new VkCommandPoolObj(m_device, m_device->graphics_queue_node_index_, flags);
 345
 346     m_commandBuffer = new VkCommandBufferObj(m_device, m_commandPool);
 347 }
 348
 349 void VkRenderFramework::InitViewport(float width, float height) {
 350     VkViewport viewport;
 351     VkRect2D scissor;
 352     viewport.x = 0;
 353     viewport.y = 0;
 354     viewport.width = 1.f * width;
 355     viewport.height = 1.f * height;
 356     viewport.minDepth = 0.f;
 357     viewport.maxDepth = 1.f;
 358     m_viewports.push_back(viewport);
 359
 360     scissor.extent.width = (int32_t)width;
 361     scissor.extent.height = (int32_t)height;
 362     scissor.offset.x = 0;
 363     scissor.offset.y = 0;
 364     m_scissors.push_back(scissor);
 365
 366     m_width = width;
 367     m_height = height;
 368 }
 369
 370 void VkRenderFramework::InitViewport() { InitViewport(m_width, m_height); }
 371 void VkRenderFramework::InitRenderTarget() { InitRenderTarget(1); }
 372
 373 void VkRenderFramework::InitRenderTarget(uint32_t targets) { InitRenderTarget(targets, NULL); }
 374
 375 void VkRenderFramework::InitRenderTarget(VkImageView *dsBinding) { InitRenderTarget(1, dsBinding); }
 376
 377 void VkRenderFramework::InitRenderTarget(uint32_t targets, VkImageView *dsBinding) {
 378     std::vector<VkAttachmentDescription> attachments;
 379     std::vector<VkAttachmentReference> color_references;
 380     std::vector<VkImageView> bindings;
 381     attachments.reserve(targets + 1);  // +1 for dsBinding
 382     color_references.reserve(targets);
 383     bindings.reserve(targets + 1);  // +1 for dsBinding
 384
 385     VkAttachmentDescription att = {};
 386     att.format = m_render_target_fmt;
 387     att.samples = VK_SAMPLE_COUNT_1_BIT;
 388     att.loadOp = (m_clear_via_load_op) ? VK_ATTACHMENT_LOAD_OP_CLEAR : VK_ATTACHMENT_LOAD_OP_LOAD;
 389     att.storeOp = VK_ATTACHMENT_STORE_OP_STORE;
 390     att.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
 391     att.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
 392     att.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
 393     att.finalLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
 394
 395     VkAttachmentReference ref = {};
 396     ref.layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
 397
 398     m_renderPassClearValues.clear();
 399     VkClearValue clear = {};
 400     clear.color = m_clear_color;
 401
 402     for (uint32_t i = 0; i < targets; i++) {
 403         attachments.push_back(att);
 404
 405         ref.attachment = i;
 406         color_references.push_back(ref);
 407
 408         m_renderPassClearValues.push_back(clear);
 409
 410         std::unique_ptr<VkImageObj> img(new VkImageObj(m_device));
 411
 412         VkFormatProperties props;
 413
 414         vkGetPhysicalDeviceFormatProperties(m_device->phy().handle(), m_render_target_fmt, &props);
 415
 416         if (props.linearTilingFeatures & VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT) {
 417             img->Init((uint32_t)m_width, (uint32_t)m_height, 1, m_render_target_fmt,
 418                       VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT,
 419                       VK_IMAGE_TILING_LINEAR);
 420         } else if (props.optimalTilingFeatures & VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT) {
 421             img->Init((uint32_t)m_width, (uint32_t)m_height, 1, m_render_target_fmt,
 422                       VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT,
 423                       VK_IMAGE_TILING_OPTIMAL);
 424         } else {
 425             FAIL() << "Neither Linear nor Optimal allowed for render target";
 426         }
 427
 428         bindings.push_back(img->targetView(m_render_target_fmt));
 429         m_renderTargets.push_back(std::move(img));
 430     }
 431
 432     VkSubpassDescription subpass = {};
 433     subpass.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS;
 434     subpass.flags = 0;
 435     subpass.inputAttachmentCount = 0;
 436     subpass.pInputAttachments = NULL;
 437     subpass.colorAttachmentCount = targets;
 438     subpass.pColorAttachments = color_references.data();
 439     subpass.pResolveAttachments = NULL;
 440
 441     VkAttachmentReference ds_reference;
 442     if (dsBinding) {
 443         att.format = m_depth_stencil_fmt;
 444         att.loadOp = (m_clear_via_load_op) ? VK_ATTACHMENT_LOAD_OP_CLEAR : VK_ATTACHMENT_LOAD_OP_LOAD;
 445         ;
 446         att.storeOp = VK_ATTACHMENT_STORE_OP_STORE;
 447         att.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_LOAD;
 448         att.stencilStoreOp = VK_ATTACHMENT_STORE_OP_STORE;
 449         att.initialLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
 450         att.finalLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
 451         attachments.push_back(att);
 452
 453         clear.depthStencil.depth = m_depth_clear_color;
 454         clear.depthStencil.stencil = m_stencil_clear_color;
 455         m_renderPassClearValues.push_back(clear);
 456
 457         bindings.push_back(*dsBinding);
 458
 459         ds_reference.attachment = targets;
 460         ds_reference.layout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
 461         subpass.pDepthStencilAttachment = &ds_reference;
 462     } else {
 463         subpass.pDepthStencilAttachment = NULL;
 464     }
 465
 466     subpass.preserveAttachmentCount = 0;
 467     subpass.pPreserveAttachments = NULL;
 468
 469     VkRenderPassCreateInfo rp_info = {};
 470     rp_info.sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO;
 471     rp_info.attachmentCount = attachments.size();
 472     rp_info.pAttachments = attachments.data();
 473     rp_info.subpassCount = 1;
 474     rp_info.pSubpasses = &subpass;
 475     VkSubpassDependency subpass_dep = {};
 476     if (m_addRenderPassSelfDependency) {
 477         // Add a subpass self-dependency to subpass 0 of default renderPass
 478         subpass_dep.srcSubpass = 0;
 479         subpass_dep.dstSubpass = 0;
 480         // Just using all framebuffer-space pipeline stages in order to get a reasonably large
 481         //  set of bits that can be used for both src & dst
 482         subpass_dep.srcStageMask = VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT | VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT |
 483                                    VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT | VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
 484         subpass_dep.dstStageMask = VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT | VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT |
 485                                    VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT | VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
 486         // Add all of the gfx mem access bits that correlate to the fb-space pipeline stages
 487         subpass_dep.srcAccessMask = VK_ACCESS_UNIFORM_READ_BIT | VK_ACCESS_INPUT_ATTACHMENT_READ_BIT | VK_ACCESS_SHADER_READ_BIT |
 488                                     VK_ACCESS_SHADER_WRITE_BIT | VK_ACCESS_COLOR_ATTACHMENT_READ_BIT |
 489                                     VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT |
 490                                     VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
 491         subpass_dep.dstAccessMask = VK_ACCESS_UNIFORM_READ_BIT | VK_ACCESS_INPUT_ATTACHMENT_READ_BIT | VK_ACCESS_SHADER_READ_BIT |
 492                                     VK_ACCESS_SHADER_WRITE_BIT | VK_ACCESS_COLOR_ATTACHMENT_READ_BIT |
 493                                     VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT |
 494                                     VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
 495         // Must include dep_by_region bit when src & dst both include framebuffer-space stages
 496         subpass_dep.dependencyFlags = VK_DEPENDENCY_BY_REGION_BIT;
 497         rp_info.dependencyCount = 1;
 498         rp_info.pDependencies = &subpass_dep;
 499     }
 500
 501     vkCreateRenderPass(device(), &rp_info, NULL, &m_renderPass);
 502     renderPass_info_ = rp_info;  // Save away a copy for tests that need access to the render pass state
 503     // Create Framebuffer and RenderPass with color attachments and any
 504     // depth/stencil attachment
 505     VkFramebufferCreateInfo fb_info = {};
 506     fb_info.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO;
 507     fb_info.pNext = NULL;
 508     fb_info.renderPass = m_renderPass;
 509     fb_info.attachmentCount = bindings.size();
 510     fb_info.pAttachments = bindings.data();
 511     fb_info.width = (uint32_t)m_width;
 512     fb_info.height = (uint32_t)m_height;
 513     fb_info.layers = 1;
 514
 515     vkCreateFramebuffer(device(), &fb_info, NULL, &m_framebuffer);
 516
 517     m_renderPassBeginInfo.renderPass = m_renderPass;
 518     m_renderPassBeginInfo.framebuffer = m_framebuffer;
 519     m_renderPassBeginInfo.renderArea.extent.width = (int32_t)m_width;
 520     m_renderPassBeginInfo.renderArea.extent.height = (int32_t)m_height;
 521     m_renderPassBeginInfo.clearValueCount = m_renderPassClearValues.size();
 522     m_renderPassBeginInfo.pClearValues = m_renderPassClearValues.data();
 523 }
 524
 525 VkDeviceObj::VkDeviceObj(uint32_t id, VkPhysicalDevice obj) : vk_testing::Device(obj), id(id) {
 526     init();
 527
 528     props = phy().properties();
 529     queue_props = phy().queue_properties();
 530 }
 531
 532 VkDeviceObj::VkDeviceObj(uint32_t id, VkPhysicalDevice obj, std::vector<const char *> &extension_names,
 533                          VkPhysicalDeviceFeatures *features)
 534     : vk_testing::Device(obj), id(id) {
 535     init(extension_names, features);
 536
 537     props = phy().properties();
 538     queue_props = phy().queue_properties();
 539 }
 540
 541 uint32_t VkDeviceObj::QueueFamilyMatching(VkQueueFlags with, VkQueueFlags without, bool all_bits) {
 542     // Find a queue family with and without desired capabilities
 543     for (uint32_t i = 0; i < queue_props.size(); i++) {
 544         auto flags = queue_props[i].queueFlags;
 545         bool matches = all_bits ? (flags & with) == with : (flags & with) != 0;
 546         if (matches && ((flags & without) == 0) && (queue_props[i].queueCount > 0)) {
 547             return i;
 548         }
 549     }
 550     return UINT32_MAX;
 551 }
 552
 553 void VkDeviceObj::SetDeviceQueue() {
 554     ASSERT_NE(true, graphics_queues().empty());
 555     m_queue = graphics_queues()[0]->handle();
 556 }
 557
 558 VkQueueObj *VkDeviceObj::GetDefaultQueue() {
 559     if (graphics_queues().empty()) return nullptr;
 560     return graphics_queues()[0];
 561 }
 562 VkDescriptorSetLayoutObj::VkDescriptorSetLayoutObj(const VkDeviceObj *device,
 563                                                    const std::vector<VkDescriptorSetLayoutBinding> &descriptor_set_bindings,
 564                                                    VkDescriptorSetLayoutCreateFlags flags) {
 565     VkDescriptorSetLayoutCreateInfo dsl_ci = {};
 566     dsl_ci.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO;
 567     dsl_ci.flags = flags;
 568     dsl_ci.bindingCount = static_cast<uint32_t>(descriptor_set_bindings.size());
 569     dsl_ci.pBindings = descriptor_set_bindings.data();
 570
 571     init(*device, dsl_ci);
 572 }
 573
 574 VkDescriptorSetObj::VkDescriptorSetObj(VkDeviceObj *device) : m_device(device), m_nextSlot(0) {}
 575
 576 VkDescriptorSetObj::~VkDescriptorSetObj() {
 577     if (m_set) {
 578         delete m_set;
 579     }
 580 }
 581
 582 int VkDescriptorSetObj::AppendDummy() {
 583     /* request a descriptor but do not update it */
 584     VkDescriptorSetLayoutBinding binding = {};
 585     binding.descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;
 586     binding.descriptorCount = 1;
 587     binding.binding = m_layout_bindings.size();
 588     binding.stageFlags = VK_SHADER_STAGE_ALL;
 589     binding.pImmutableSamplers = NULL;
 590
 591     m_layout_bindings.push_back(binding);
 592     m_type_counts[VK_DESCRIPTOR_TYPE_STORAGE_BUFFER] += binding.descriptorCount;
 593
 594     return m_nextSlot++;
 595 }
 596
 597 int VkDescriptorSetObj::AppendBuffer(VkDescriptorType type, VkConstantBufferObj &constantBuffer) {
 598     assert(type == VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER || type == VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC ||
 599            type == VK_DESCRIPTOR_TYPE_STORAGE_BUFFER || type == VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC);
 600     VkDescriptorSetLayoutBinding binding = {};
 601     binding.descriptorType = type;
 602     binding.descriptorCount = 1;
 603     binding.binding = m_layout_bindings.size();
 604     binding.stageFlags = VK_SHADER_STAGE_ALL;
 605     binding.pImmutableSamplers = NULL;
 606
 607     m_layout_bindings.push_back(binding);
 608     m_type_counts[type] += binding.descriptorCount;
 609
 610     m_writes.push_back(vk_testing::Device::write_descriptor_set(vk_testing::DescriptorSet(), m_nextSlot, 0, type, 1,
 611                                                                 &constantBuffer.m_descriptorBufferInfo));
 612
 613     return m_nextSlot++;
 614 }
 615
 616 int VkDescriptorSetObj::AppendSamplerTexture(VkSamplerObj *sampler, VkTextureObj *texture) {
 617     VkDescriptorSetLayoutBinding binding = {};
 618     binding.descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
 619     binding.descriptorCount = 1;
 620     binding.binding = m_layout_bindings.size();
 621     binding.stageFlags = VK_SHADER_STAGE_ALL;
 622     binding.pImmutableSamplers = NULL;
 623
 624     m_layout_bindings.push_back(binding);
 625     m_type_counts[VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER] += binding.descriptorCount;
 626     VkDescriptorImageInfo tmp = texture->m_imageInfo;
 627     tmp.sampler = sampler->handle();
 628     m_imageSamplerDescriptors.push_back(tmp);
 629
 630     m_writes.push_back(vk_testing::Device::write_descriptor_set(vk_testing::DescriptorSet(), m_nextSlot, 0,
 631                                                                 VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 1, &tmp));
 632
 633     return m_nextSlot++;
 634 }
 635
 636 VkPipelineLayout VkDescriptorSetObj::GetPipelineLayout() const { return m_pipeline_layout.handle(); }
 637
 638 VkDescriptorSet VkDescriptorSetObj::GetDescriptorSetHandle() const {
 639     if (m_set)
 640         return m_set->handle();
 641     else
 642         return VK_NULL_HANDLE;
 643 }
 644
 645 void VkDescriptorSetObj::CreateVKDescriptorSet(VkCommandBufferObj *commandBuffer) {
 646     if (m_type_counts.size()) {
 647         // create VkDescriptorPool
 648         VkDescriptorPoolSize poolSize;
 649         vector<VkDescriptorPoolSize> sizes;
 650         for (auto it = m_type_counts.begin(); it != m_type_counts.end(); ++it) {
 651             poolSize.descriptorCount = it->second;
 652             poolSize.type = it->first;
 653             sizes.push_back(poolSize);
 654         }
 655         VkDescriptorPoolCreateInfo pool = {};
 656         pool.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
 657         pool.poolSizeCount = sizes.size();
 658         pool.maxSets = 1;
 659         pool.pPoolSizes = sizes.data();
 660         init(*m_device, pool);
 661     }
 662
 663     // create VkDescriptorSetLayout
 664     VkDescriptorSetLayoutCreateInfo layout = {};
 665     layout.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO;
 666     layout.bindingCount = m_layout_bindings.size();
 667     layout.pBindings = m_layout_bindings.data();
 668
 669     m_layout.init(*m_device, layout);
 670     vector<const vk_testing::DescriptorSetLayout *> layouts;
 671     layouts.push_back(&m_layout);
 672
 673     // create VkPipelineLayout
 674     VkPipelineLayoutCreateInfo pipeline_layout = {};
 675     pipeline_layout.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO;
 676     pipeline_layout.setLayoutCount = layouts.size();
 677     pipeline_layout.pSetLayouts = NULL;
 678
 679     m_pipeline_layout.init(*m_device, pipeline_layout, layouts);
 680
 681     if (m_type_counts.size()) {
 682         // create VkDescriptorSet
 683         m_set = alloc_sets(*m_device, m_layout);
 684
 685         // build the update array
 686         size_t imageSamplerCount = 0;
 687         for (std::vector<VkWriteDescriptorSet>::iterator it = m_writes.begin(); it != m_writes.end(); it++) {
 688             it->dstSet = m_set->handle();
 689             if (it->descriptorType == VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER)
 690                 it->pImageInfo = &m_imageSamplerDescriptors[imageSamplerCount++];
 691         }
 692
 693         // do the updates
 694         m_device->update_descriptor_sets(m_writes);
 695     }
 696 }
 697
 698 VkRenderpassObj::VkRenderpassObj(VkDeviceObj *dev) {
 699     // Create a renderPass with a single color attachment
 700     VkAttachmentReference attach = {};
 701     attach.layout = VK_IMAGE_LAYOUT_GENERAL;
 702
 703     VkSubpassDescription subpass = {};
 704     subpass.pColorAttachments = &attach;
 705     subpass.colorAttachmentCount = 1;
 706
 707     VkRenderPassCreateInfo rpci = {};
 708     rpci.subpassCount = 1;
 709     rpci.pSubpasses = &subpass;
 710     rpci.attachmentCount = 1;
 711
 712     VkAttachmentDescription attach_desc = {};
 713     attach_desc.format = VK_FORMAT_B8G8R8A8_UNORM;
 714     attach_desc.samples = VK_SAMPLE_COUNT_1_BIT;
 715     attach_desc.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
 716     attach_desc.finalLayout = VK_IMAGE_LAYOUT_GENERAL;
 717
 718     rpci.pAttachments = &attach_desc;
 719     rpci.sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO;
 720
 721     device = dev->device();
 722     vkCreateRenderPass(device, &rpci, NULL, &m_renderpass);
 723 }
 724
 725 VkRenderpassObj::~VkRenderpassObj() { vkDestroyRenderPass(device, m_renderpass, NULL); }
 726
 727 VkImageObj::VkImageObj(VkDeviceObj *dev) {
 728     m_device = dev;
 729     m_descriptorImageInfo.imageView = VK_NULL_HANDLE;
 730     m_descriptorImageInfo.imageLayout = VK_IMAGE_LAYOUT_GENERAL;
 731 }
 732
 733 // clang-format off
 734 void VkImageObj::ImageMemoryBarrier(VkCommandBufferObj *cmd_buf, VkImageAspectFlags aspect,
 735                                     VkFlags output_mask /*=
 736                                     VK_ACCESS_HOST_WRITE_BIT |
 737                                     VK_ACCESS_SHADER_WRITE_BIT |
 738                                     VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT |
 739                                     VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT |
 740                                     VK_MEMORY_OUTPUT_COPY_BIT*/,
 741                                     VkFlags input_mask /*=
 742                                     VK_ACCESS_HOST_READ_BIT |
 743                                     VK_ACCESS_INDIRECT_COMMAND_READ_BIT |
 744                                     VK_ACCESS_INDEX_READ_BIT |
 745                                     VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT |
 746                                     VK_ACCESS_UNIFORM_READ_BIT |
 747                                     VK_ACCESS_SHADER_READ_BIT |
 748                                     VK_ACCESS_COLOR_ATTACHMENT_READ_BIT |
 749                                     VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT |
 750                                     VK_MEMORY_INPUT_COPY_BIT*/, VkImageLayout image_layout) {
 751     // clang-format on
 752     // TODO: Mali device crashing with VK_REMAINING_MIP_LEVELS
 753     const VkImageSubresourceRange subresourceRange =
 754         subresource_range(aspect, 0, /*VK_REMAINING_MIP_LEVELS*/ 1, 0, 1 /*VK_REMAINING_ARRAY_LAYERS*/);
 755     VkImageMemoryBarrier barrier;
 756     barrier = image_memory_barrier(output_mask, input_mask, Layout(), image_layout, subresourceRange);
 757
 758     VkImageMemoryBarrier *pmemory_barrier = &barrier;
 759
 760     VkPipelineStageFlags src_stages = VK_PIPELINE_STAGE_ALL_COMMANDS_BIT;
 761     VkPipelineStageFlags dest_stages = VK_PIPELINE_STAGE_ALL_COMMANDS_BIT;
 762
 763     // write barrier to the command buffer
 764     vkCmdPipelineBarrier(cmd_buf->handle(), src_stages, dest_stages, 0, 0, NULL, 0, NULL, 1, pmemory_barrier);
 765 }
 766
 767 void VkImageObj::SetLayout(VkCommandBufferObj *cmd_buf, VkImageAspectFlags aspect, VkImageLayout image_layout) {
 768     VkFlags src_mask, dst_mask;
 769     const VkFlags all_cache_outputs = VK_ACCESS_HOST_WRITE_BIT | VK_ACCESS_SHADER_WRITE_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT |
 770                                       VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT | VK_ACCESS_TRANSFER_WRITE_BIT;
 771     const VkFlags all_cache_inputs = VK_ACCESS_HOST_READ_BIT | VK_ACCESS_INDIRECT_COMMAND_READ_BIT | VK_ACCESS_INDEX_READ_BIT |
 772                                      VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT | VK_ACCESS_UNIFORM_READ_BIT | VK_ACCESS_SHADER_READ_BIT |
 773                                      VK_ACCESS_COLOR_ATTACHMENT_READ_BIT | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT |
 774                                      VK_ACCESS_MEMORY_READ_BIT;
 775
 776     if (image_layout == m_descriptorImageInfo.imageLayout) {
 777         return;
 778     }
 779
 780     switch (image_layout) {
 781         case VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL:
 782             if (m_descriptorImageInfo.imageLayout == VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL)
 783                 src_mask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
 784             else
 785                 src_mask = VK_ACCESS_TRANSFER_WRITE_BIT;
 786             dst_mask = VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_TRANSFER_READ_BIT;
 787             break;
 788
 789         case VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL:
 790             if (m_descriptorImageInfo.imageLayout == VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL)
 791                 src_mask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
 792             else if (m_descriptorImageInfo.imageLayout == VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL)
 793                 src_mask = VK_ACCESS_INPUT_ATTACHMENT_READ_BIT;
 794             else
 795                 src_mask = VK_ACCESS_TRANSFER_WRITE_BIT;
 796             dst_mask = VK_ACCESS_TRANSFER_WRITE_BIT;
 797             break;
 798
 799         case VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL:
 800             if (m_descriptorImageInfo.imageLayout == VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL)
 801                 src_mask = VK_ACCESS_TRANSFER_WRITE_BIT;
 802             else
 803                 src_mask = VK_ACCESS_INPUT_ATTACHMENT_READ_BIT;
 804             dst_mask = VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_MEMORY_READ_BIT;
 805             break;
 806
 807         case VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL:
 808             if (m_descriptorImageInfo.imageLayout == VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL)
 809                 src_mask = VK_ACCESS_TRANSFER_READ_BIT;
 810             else
 811                 src_mask = 0;
 812             dst_mask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
 813             break;
 814
 815         case VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL:
 816             dst_mask = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
 817             src_mask = all_cache_outputs;
 818             break;
 819
 820         default:
 821             src_mask = all_cache_outputs;
 822             dst_mask = all_cache_inputs;
 823             break;
 824     }
 825
 826     if (m_descriptorImageInfo.imageLayout == VK_IMAGE_LAYOUT_UNDEFINED) src_mask = 0;
 827
 828     ImageMemoryBarrier(cmd_buf, aspect, src_mask, dst_mask, image_layout);
 829     m_descriptorImageInfo.imageLayout = image_layout;
 830 }
 831
 832 void VkImageObj::SetLayout(VkImageAspectFlags aspect, VkImageLayout image_layout) {
 833     if (image_layout == m_descriptorImageInfo.imageLayout) {
 834         return;
 835     }
 836
 837     VkCommandPoolObj pool(m_device, m_device->graphics_queue_node_index_);
 838     VkCommandBufferObj cmd_buf(m_device, &pool);
 839
 840     /* Build command buffer to set image layout in the driver */
 841     cmd_buf.begin();
 842     SetLayout(&cmd_buf, aspect, image_layout);
 843     cmd_buf.end();
 844
 845     cmd_buf.QueueCommandBuffer();
 846 }
 847
 848 bool VkImageObj::IsCompatible(const VkImageUsageFlags usages, const VkFormatFeatureFlags features) {
 849     VkFormatFeatureFlags all_feature_flags =
 850         VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT | VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT |
 851         VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT | VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT |
 852         VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT | VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT |
 853         VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT |
 854         VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT |
 855         VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT;
 856     if (m_device->IsEnbledExtension(VK_IMG_FILTER_CUBIC_EXTENSION_NAME)) {
 857         all_feature_flags |= VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG;
 858     }
 859
 860     if (m_device->IsEnbledExtension(VK_KHR_MAINTENANCE1_EXTENSION_NAME)) {
 861         all_feature_flags |= VK_FORMAT_FEATURE_TRANSFER_SRC_BIT_KHR | VK_FORMAT_FEATURE_TRANSFER_DST_BIT_KHR;
 862     }
 863
 864     if (m_device->IsEnbledExtension(VK_EXT_SAMPLER_FILTER_MINMAX_EXTENSION_NAME)) {
 865         all_feature_flags |= VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT_EXT;
 866     }
 867
 868     if (m_device->IsEnbledExtension(VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME)) {
 869         all_feature_flags |= VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT_KHR |
 870                              VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT_KHR |
 871                              VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT_KHR |
 872                              VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT_KHR |
 873                              VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT_KHR |
 874                              VK_FORMAT_FEATURE_DISJOINT_BIT_KHR | VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT_KHR;
 875     }
 876
 877     if ((features & all_feature_flags) == 0) return false;  // whole format unsupported
 878
 879     if ((usages & VK_IMAGE_USAGE_SAMPLED_BIT) && !(features & VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT)) return false;
 880     if ((usages & VK_IMAGE_USAGE_STORAGE_BIT) && !(features & VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT)) return false;
 881     if ((usages & VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT) && !(features & VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT)) return false;
 882     if ((usages & VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT) && !(features & VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT))
 883         return false;
 884
 885     if (m_device->IsEnbledExtension(VK_KHR_MAINTENANCE1_EXTENSION_NAME)) {
 886         // WORKAROUND: for DevSim not reporting extended enums, and possibly some drivers too
 887         const auto all_nontransfer_feature_flags =
 888             all_feature_flags ^ (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT_KHR | VK_FORMAT_FEATURE_TRANSFER_DST_BIT_KHR);
 889         const bool transfer_probably_supported_anyway = (features & all_nontransfer_feature_flags) > 0;
 890         if (!transfer_probably_supported_anyway) {
 891             if ((usages & VK_IMAGE_USAGE_TRANSFER_SRC_BIT) && !(features & VK_FORMAT_FEATURE_TRANSFER_SRC_BIT_KHR)) return false;
 892             if ((usages & VK_IMAGE_USAGE_TRANSFER_DST_BIT) && !(features & VK_FORMAT_FEATURE_TRANSFER_DST_BIT_KHR)) return false;
 893         }
 894     }
 895
 896     return true;
 897 }
 898
 899 void VkImageObj::InitNoLayout(uint32_t const width, uint32_t const height, uint32_t const mipLevels, VkFormat const format,
 900                               VkFlags const usage, VkImageTiling const requested_tiling, VkMemoryPropertyFlags const reqs,
 901                               const std::vector<uint32_t> *queue_families) {
 902     VkFormatProperties image_fmt;
 903     VkImageTiling tiling = VK_IMAGE_TILING_OPTIMAL;
 904
 905     vkGetPhysicalDeviceFormatProperties(m_device->phy().handle(), format, &image_fmt);
 906
 907     if (requested_tiling == VK_IMAGE_TILING_LINEAR) {
 908         if (IsCompatible(usage, image_fmt.linearTilingFeatures)) {
 909             tiling = VK_IMAGE_TILING_LINEAR;
 910         } else if (IsCompatible(usage, image_fmt.optimalTilingFeatures)) {
 911             tiling = VK_IMAGE_TILING_OPTIMAL;
 912         } else {
 913             FAIL() << "VkImageObj::init() error: unsupported tiling configuration. Usage: " << std::hex << std::showbase << usage
 914                    << ", supported linear features: " << image_fmt.linearTilingFeatures;
 915         }
 916     } else if (IsCompatible(usage, image_fmt.optimalTilingFeatures)) {
 917         tiling = VK_IMAGE_TILING_OPTIMAL;
 918     } else if (IsCompatible(usage, image_fmt.linearTilingFeatures)) {
 919         tiling = VK_IMAGE_TILING_LINEAR;
 920     } else {
 921         FAIL() << "VkImageObj::init() error: unsupported tiling configuration. Usage: " << std::hex << std::showbase << usage
 922                << ", supported optimal features: " << image_fmt.optimalTilingFeatures;
 923     }
 924
 925     VkImageCreateInfo imageCreateInfo = vk_testing::Image::create_info();
 926     imageCreateInfo.imageType = VK_IMAGE_TYPE_2D;
 927     imageCreateInfo.format = format;
 928     imageCreateInfo.extent.width = width;
 929     imageCreateInfo.extent.height = height;
 930     imageCreateInfo.mipLevels = mipLevels;
 931     imageCreateInfo.tiling = tiling;
 932     imageCreateInfo.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
 933
 934     // Automatically set sharing mode etc. based on queue family information
 935     if (queue_families && (queue_families->size() > 1)) {
 936         imageCreateInfo.sharingMode = VK_SHARING_MODE_CONCURRENT;
 937         imageCreateInfo.queueFamilyIndexCount = static_cast<uint32_t>(queue_families->size());
 938         imageCreateInfo.pQueueFamilyIndices = queue_families->data();
 939     }
 940
 941     Layout(imageCreateInfo.initialLayout);
 942     imageCreateInfo.usage = usage;
 943
 944     vk_testing::Image::init(*m_device, imageCreateInfo, reqs);
 945 }
 946
 947 void VkImageObj::Init(uint32_t const width, uint32_t const height, uint32_t const mipLevels, VkFormat const format,
 948                       VkFlags const usage, VkImageTiling const requested_tiling, VkMemoryPropertyFlags const reqs,
 949                       const std::vector<uint32_t> *queue_families) {
 950     InitNoLayout(width, height, mipLevels, format, usage, requested_tiling, reqs, queue_families);
 951
 952     VkImageLayout newLayout;
 953     if (usage & VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT)
 954         newLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
 955     else if (usage & VK_IMAGE_USAGE_SAMPLED_BIT)
 956         newLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
 957     else
 958         newLayout = m_descriptorImageInfo.imageLayout;
 959
 960     VkImageAspectFlags image_aspect = 0;
 961     if (FormatIsDepthAndStencil(format)) {
 962         image_aspect = VK_IMAGE_ASPECT_STENCIL_BIT | VK_IMAGE_ASPECT_DEPTH_BIT;
 963     } else if (FormatIsDepthOnly(format)) {
 964         image_aspect = VK_IMAGE_ASPECT_DEPTH_BIT;
 965     } else if (FormatIsStencilOnly(format)) {
 966         image_aspect = VK_IMAGE_ASPECT_STENCIL_BIT;
 967     } else {  // color
 968         image_aspect = VK_IMAGE_ASPECT_COLOR_BIT;
 969     }
 970     SetLayout(image_aspect, newLayout);
 971 }
 972
 973 void VkImageObj::init(const VkImageCreateInfo *create_info) {
 974     VkFormatProperties image_fmt;
 975     vkGetPhysicalDeviceFormatProperties(m_device->phy().handle(), create_info->format, &image_fmt);
 976
 977     switch (create_info->tiling) {
 978         case VK_IMAGE_TILING_OPTIMAL:
 979             if (!IsCompatible(create_info->usage, image_fmt.optimalTilingFeatures)) {
 980                 FAIL() << "VkImageObj::init() error: unsupported tiling configuration. Usage: " << std::hex << std::showbase
 981                        << create_info->usage << ", supported optimal features: " << image_fmt.optimalTilingFeatures;
 982             }
 983             break;
 984         case VK_IMAGE_TILING_LINEAR:
 985             if (!IsCompatible(create_info->usage, image_fmt.linearTilingFeatures)) {
 986                 FAIL() << "VkImageObj::init() error: unsupported tiling configuration. Usage: " << std::hex << std::showbase
 987                        << create_info->usage << ", supported linear features: " << image_fmt.linearTilingFeatures;
 988             }
 989             break;
 990         default:
 991             break;
 992     }
 993     Layout(create_info->initialLayout);
 994
 995     vk_testing::Image::init(*m_device, *create_info, 0);
 996
 997     VkImageAspectFlags image_aspect = 0;
 998     if (FormatIsDepthAndStencil(create_info->format)) {
 999         image_aspect = VK_IMAGE_ASPECT_STENCIL_BIT | VK_IMAGE_ASPECT_DEPTH_BIT;
1000     } else if (FormatIsDepthOnly(create_info->format)) {
1001         image_aspect = VK_IMAGE_ASPECT_DEPTH_BIT;
1002     } else if (FormatIsStencilOnly(create_info->format)) {
1003         image_aspect = VK_IMAGE_ASPECT_STENCIL_BIT;
1004     } else {  // color
1005         image_aspect = VK_IMAGE_ASPECT_COLOR_BIT;
1006     }
1007     SetLayout(image_aspect, VK_IMAGE_LAYOUT_GENERAL);
1008 }
1009
1010 VkResult VkImageObj::CopyImage(VkImageObj &src_image) {
1011     VkImageLayout src_image_layout, dest_image_layout;
1012
1013     VkCommandPoolObj pool(m_device, m_device->graphics_queue_node_index_);
1014     VkCommandBufferObj cmd_buf(m_device, &pool);
1015
1016     /* Build command buffer to copy staging texture to usable texture */
1017     cmd_buf.begin();
1018
1019     /* TODO: Can we determine image aspect from image object? */
1020     src_image_layout = src_image.Layout();
1021     src_image.SetLayout(&cmd_buf, VK_IMAGE_ASPECT_COLOR_BIT, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL);
1022
1023     dest_image_layout = (this->Layout() == VK_IMAGE_LAYOUT_UNDEFINED) ? VK_IMAGE_LAYOUT_GENERAL : this->Layout();
1024     this->SetLayout(&cmd_buf, VK_IMAGE_ASPECT_COLOR_BIT, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);
1025
1026     VkImageCopy copy_region = {};
1027     copy_region.srcSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
1028     copy_region.srcSubresource.baseArrayLayer = 0;
1029     copy_region.srcSubresource.mipLevel = 0;
1030     copy_region.srcSubresource.layerCount = 1;
1031     copy_region.srcOffset.x = 0;
1032     copy_region.srcOffset.y = 0;
1033     copy_region.srcOffset.z = 0;
1034     copy_region.dstSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
1035     copy_region.dstSubresource.baseArrayLayer = 0;
1036     copy_region.dstSubresource.mipLevel = 0;
1037     copy_region.dstSubresource.layerCount = 1;
1038     copy_region.dstOffset.x = 0;
1039     copy_region.dstOffset.y = 0;
1040     copy_region.dstOffset.z = 0;
1041     copy_region.extent = src_image.extent();
1042
1043     vkCmdCopyImage(cmd_buf.handle(), src_image.handle(), src_image.Layout(), handle(), Layout(), 1, &copy_region);
1044
1045     src_image.SetLayout(&cmd_buf, VK_IMAGE_ASPECT_COLOR_BIT, src_image_layout);
1046
1047     this->SetLayout(&cmd_buf, VK_IMAGE_ASPECT_COLOR_BIT, dest_image_layout);
1048
1049     cmd_buf.end();
1050
1051     cmd_buf.QueueCommandBuffer();
1052
1053     return VK_SUCCESS;
1054 }
1055
1056 VkTextureObj::VkTextureObj(VkDeviceObj *device, uint32_t *colors) : VkImageObj(device) {
1057     m_device = device;
1058     const VkFormat tex_format = VK_FORMAT_B8G8R8A8_UNORM;
1059     uint32_t tex_colors[2] = {0xffff0000, 0xff00ff00};
1060     void *data;
1061     uint32_t x, y;
1062     VkImageObj stagingImage(device);
1063     VkMemoryPropertyFlags reqs = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT;
1064
1065     stagingImage.Init(16, 16, 1, tex_format, VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT,
1066                       VK_IMAGE_TILING_LINEAR, reqs);
1067     VkSubresourceLayout layout = stagingImage.subresource_layout(subresource(VK_IMAGE_ASPECT_COLOR_BIT, 0, 0));
1068
1069     if (colors == NULL) colors = tex_colors;
1070
1071     memset(&m_imageInfo, 0, sizeof(m_imageInfo));
1072
1073     VkImageViewCreateInfo view = {};
1074     view.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
1075     view.pNext = NULL;
1076     view.image = VK_NULL_HANDLE;
1077     view.viewType = VK_IMAGE_VIEW_TYPE_2D;
1078     view.format = tex_format;
1079     view.components.r = VK_COMPONENT_SWIZZLE_R;
1080     view.components.g = VK_COMPONENT_SWIZZLE_G;
1081     view.components.b = VK_COMPONENT_SWIZZLE_B;
1082     view.components.a = VK_COMPONENT_SWIZZLE_A;
1083     view.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
1084     view.subresourceRange.baseMipLevel = 0;
1085     view.subresourceRange.levelCount = 1;
1086     view.subresourceRange.baseArrayLayer = 0;
1087     view.subresourceRange.layerCount = 1;
1088
1089     /* create image */
1090     Init(16, 16, 1, tex_format, VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT, VK_IMAGE_TILING_OPTIMAL);
1091     stagingImage.SetLayout(VK_IMAGE_ASPECT_COLOR_BIT, VK_IMAGE_LAYOUT_GENERAL);
1092
1093     /* create image view */
1094     view.image = handle();
1095     m_textureView.init(*m_device, view);
1096     m_imageInfo.imageView = m_textureView.handle();
1097
1098     data = stagingImage.MapMemory();
1099
1100     for (y = 0; y < extent().height; y++) {
1101         uint32_t *row = (uint32_t *)((char *)data + layout.rowPitch * y);
1102         for (x = 0; x < extent().width; x++) row[x] = colors[(x & 1) ^ (y & 1)];
1103     }
1104     stagingImage.UnmapMemory();
1105     stagingImage.SetLayout(VK_IMAGE_ASPECT_COLOR_BIT, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL);
1106     VkImageObj::CopyImage(stagingImage);
1107 }
1108
1109 VkSamplerObj::VkSamplerObj(VkDeviceObj *device) {
1110     m_device = device;
1111
1112     VkSamplerCreateInfo samplerCreateInfo;
1113     memset(&samplerCreateInfo, 0, sizeof(samplerCreateInfo));
1114     samplerCreateInfo.sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO;
1115     samplerCreateInfo.magFilter = VK_FILTER_NEAREST;
1116     samplerCreateInfo.minFilter = VK_FILTER_NEAREST;
1117     samplerCreateInfo.mipmapMode = VK_SAMPLER_MIPMAP_MODE_NEAREST;
1118     samplerCreateInfo.addressModeU = VK_SAMPLER_ADDRESS_MODE_REPEAT;
1119     samplerCreateInfo.addressModeV = VK_SAMPLER_ADDRESS_MODE_REPEAT;
1120     samplerCreateInfo.addressModeW = VK_SAMPLER_ADDRESS_MODE_REPEAT;
1121     samplerCreateInfo.mipLodBias = 0.0;
1122     samplerCreateInfo.anisotropyEnable = VK_FALSE;
1123     samplerCreateInfo.maxAnisotropy = 1;
1124     samplerCreateInfo.compareOp = VK_COMPARE_OP_NEVER;
1125     samplerCreateInfo.minLod = 0.0;
1126     samplerCreateInfo.maxLod = 0.0;
1127     samplerCreateInfo.borderColor = VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE;
1128     samplerCreateInfo.unnormalizedCoordinates = VK_FALSE;
1129
1130     init(*m_device, samplerCreateInfo);
1131 }
1132
1133 /*
1134  * Basic ConstantBuffer constructor. Then use create methods to fill in the
1135  * details.
1136  */
1137 VkConstantBufferObj::VkConstantBufferObj(VkDeviceObj *device, VkBufferUsageFlags usage) {
1138     m_device = device;
1139
1140     memset(&m_descriptorBufferInfo, 0, sizeof(m_descriptorBufferInfo));
1141
1142     // Special case for usages outside of original limits of framework
1143     if ((VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT) != usage) {
1144         init_no_mem(*m_device, create_info(0, usage));
1145     }
1146 }
1147
1148 VkConstantBufferObj::VkConstantBufferObj(VkDeviceObj *device, VkDeviceSize allocationSize, const void *data,
1149                                          VkBufferUsageFlags usage) {
1150     m_device = device;
1151
1152     memset(&m_descriptorBufferInfo, 0, sizeof(m_descriptorBufferInfo));
1153
1154     VkMemoryPropertyFlags reqs = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT;
1155
1156     if ((VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT) == usage) {
1157         init_as_src_and_dst(*m_device, allocationSize, reqs);
1158     } else {
1159         init(*m_device, create_info(allocationSize, usage), reqs);
1160     }
1161
1162     void *pData = memory().map();
1163     memcpy(pData, data, static_cast<size_t>(allocationSize));
1164     memory().unmap();
1165
1166     /*
1167      * Constant buffers are going to be used as vertex input buffers
1168      * or as shader uniform buffers. So, we'll create the shaderbuffer
1169      * descriptor here so it's ready if needed.
1170      */
1171     this->m_descriptorBufferInfo.buffer = handle();
1172     this->m_descriptorBufferInfo.offset = 0;
1173     this->m_descriptorBufferInfo.range = allocationSize;
1174 }
1175
1176 VkPipelineShaderStageCreateInfo const &VkShaderObj::GetStageCreateInfo() const { return m_stage_info; }
1177
1178 VkShaderObj::VkShaderObj(VkDeviceObj *device, const char *shader_code, VkShaderStageFlagBits stage, VkRenderFramework *framework,
1179                          char const *name) {
1180     VkResult U_ASSERT_ONLY err = VK_SUCCESS;
1181     std::vector<unsigned int> spv;
1182     VkShaderModuleCreateInfo moduleCreateInfo;
1183
1184     m_device = device;
1185     m_stage_info.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
1186     m_stage_info.pNext = nullptr;
1187     m_stage_info.flags = 0;
1188     m_stage_info.stage = stage;
1189     m_stage_info.module = VK_NULL_HANDLE;
1190     m_stage_info.pName = name;
1191     m_stage_info.pSpecializationInfo = nullptr;
1192
1193     moduleCreateInfo.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
1194     moduleCreateInfo.pNext = nullptr;
1195
1196     framework->GLSLtoSPV(stage, shader_code, spv);
1197     moduleCreateInfo.pCode = spv.data();
1198     moduleCreateInfo.codeSize = spv.size() * sizeof(unsigned int);
1199     moduleCreateInfo.flags = 0;
1200
1201     err = init_try(*m_device, moduleCreateInfo);
1202     m_stage_info.module = handle();
1203     assert(VK_SUCCESS == err);
1204 }
1205
1206 VkPipelineLayoutObj::VkPipelineLayoutObj(VkDeviceObj *device,
1207                                          const std::vector<const VkDescriptorSetLayoutObj *> &descriptor_layouts,
1208                                          const std::vector<VkPushConstantRange> &push_constant_ranges) {
1209     VkPipelineLayoutCreateInfo pl_ci = {};
1210     pl_ci.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO;
1211     pl_ci.pushConstantRangeCount = static_cast<uint32_t>(push_constant_ranges.size());
1212     pl_ci.pPushConstantRanges = push_constant_ranges.data();
1213
1214     auto descriptor_layouts_unwrapped = MakeTestbindingHandles<const vk_testing::DescriptorSetLayout>(descriptor_layouts);
1215
1216     init(*device, pl_ci, descriptor_layouts_unwrapped);
1217 }
1218
1219 void VkPipelineLayoutObj::Reset() { *this = VkPipelineLayoutObj(); }
1220
1221 VkPipelineObj::VkPipelineObj(VkDeviceObj *device) {
1222     m_device = device;
1223
1224     m_vi_state.sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO;
1225     m_vi_state.pNext = nullptr;
1226     m_vi_state.flags = 0;
1227     m_vi_state.vertexBindingDescriptionCount = 0;
1228     m_vi_state.pVertexBindingDescriptions = nullptr;
1229     m_vi_state.vertexAttributeDescriptionCount = 0;
1230     m_vi_state.pVertexAttributeDescriptions = nullptr;
1231
1232     m_ia_state.sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO;
1233     m_ia_state.pNext = nullptr;
1234     m_ia_state.flags = 0;
1235     m_ia_state.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
1236     m_ia_state.primitiveRestartEnable = VK_FALSE;
1237
1238     m_te_state = nullptr;
1239
1240     m_vp_state.sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO;
1241     m_vp_state.pNext = VK_NULL_HANDLE;
1242     m_vp_state.flags = 0;
1243     m_vp_state.viewportCount = 1;
1244     m_vp_state.scissorCount = 1;
1245     m_vp_state.pViewports = nullptr;
1246     m_vp_state.pScissors = nullptr;
1247
1248     m_rs_state.sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO;
1249     m_rs_state.pNext = nullptr;
1250     m_rs_state.flags = 0;
1251     m_rs_state.depthClampEnable = VK_FALSE;
1252     m_rs_state.rasterizerDiscardEnable = VK_FALSE;
1253     m_rs_state.polygonMode = VK_POLYGON_MODE_FILL;
1254     m_rs_state.cullMode = VK_CULL_MODE_BACK_BIT;
1255     m_rs_state.frontFace = VK_FRONT_FACE_CLOCKWISE;
1256     m_rs_state.depthBiasEnable = VK_FALSE;
1257     m_rs_state.depthBiasConstantFactor = 0.0f;
1258     m_rs_state.depthBiasClamp = 0.0f;
1259     m_rs_state.depthBiasSlopeFactor = 0.0f;
1260     m_rs_state.lineWidth = 1.0f;
1261
1262     m_ms_state.sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO;
1263     m_ms_state.pNext = nullptr;
1264     m_ms_state.flags = 0;
1265     m_ms_state.rasterizationSamples = VK_SAMPLE_COUNT_1_BIT;
1266     m_ms_state.sampleShadingEnable = VK_FALSE;
1267     m_ms_state.minSampleShading = 0.0f;
1268     m_ms_state.pSampleMask = nullptr;
1269     m_ms_state.alphaToCoverageEnable = VK_FALSE;
1270     m_ms_state.alphaToOneEnable = VK_FALSE;
1271
1272     m_ds_state = nullptr;
1273
1274     memset(&m_cb_state, 0, sizeof(m_cb_state));
1275     m_cb_state.sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO;
1276     m_cb_state.blendConstants[0] = 1.0f;
1277     m_cb_state.blendConstants[1] = 1.0f;
1278     m_cb_state.blendConstants[2] = 1.0f;
1279     m_cb_state.blendConstants[3] = 1.0f;
1280
1281     memset(&m_pd_state, 0, sizeof(m_pd_state));
1282 }
1283
1284 void VkPipelineObj::AddShader(VkShaderObj *shader) { m_shaderStages.push_back(shader->GetStageCreateInfo()); }
1285
1286 void VkPipelineObj::AddShader(VkPipelineShaderStageCreateInfo const &createInfo) { m_shaderStages.push_back(createInfo); }
1287
1288 void VkPipelineObj::AddVertexInputAttribs(VkVertexInputAttributeDescription *vi_attrib, uint32_t count) {
1289     m_vi_state.pVertexAttributeDescriptions = vi_attrib;
1290     m_vi_state.vertexAttributeDescriptionCount = count;
1291 }
1292
1293 void VkPipelineObj::AddVertexInputBindings(VkVertexInputBindingDescription *vi_binding, uint32_t count) {
1294     m_vi_state.pVertexBindingDescriptions = vi_binding;
1295     m_vi_state.vertexBindingDescriptionCount = count;
1296 }
1297
1298 void VkPipelineObj::AddColorAttachment(uint32_t binding, const VkPipelineColorBlendAttachmentState &att) {
1299     if (binding + 1 > m_colorAttachments.size()) {
1300         m_colorAttachments.resize(binding + 1);
1301     }
1302     m_colorAttachments[binding] = att;
1303 }
1304
1305 void VkPipelineObj::SetDepthStencil(const VkPipelineDepthStencilStateCreateInfo *ds_state) { m_ds_state = ds_state; }
1306
1307 void VkPipelineObj::SetViewport(const vector<VkViewport> viewports) {
1308     m_viewports = viewports;
1309     // If we explicitly set a null viewport, pass it through to create info
1310     // but preserve viewportCount because it musn't change
1311     if (m_viewports.size() == 0) {
1312         m_vp_state.pViewports = nullptr;
1313     }
1314 }
1315
1316 void VkPipelineObj::SetScissor(const vector<VkRect2D> scissors) {
1317     m_scissors = scissors;
1318     // If we explicitly set a null scissor, pass it through to create info
1319     // but preserve scissorCount because it musn't change
1320     if (m_scissors.size() == 0) {
1321         m_vp_state.pScissors = nullptr;
1322     }
1323 }
1324
1325 void VkPipelineObj::MakeDynamic(VkDynamicState state) {
1326     /* Only add a state once */
1327     for (auto it = m_dynamic_state_enables.begin(); it != m_dynamic_state_enables.end(); it++) {
1328         if ((*it) == state) return;
1329     }
1330     m_dynamic_state_enables.push_back(state);
1331 }
1332
1333 void VkPipelineObj::SetMSAA(const VkPipelineMultisampleStateCreateInfo *ms_state) { m_ms_state = *ms_state; }
1334
1335 void VkPipelineObj::SetInputAssembly(const VkPipelineInputAssemblyStateCreateInfo *ia_state) { m_ia_state = *ia_state; }
1336
1337 void VkPipelineObj::SetRasterization(const VkPipelineRasterizationStateCreateInfo *rs_state) { m_rs_state = *rs_state; }
1338
1339 void VkPipelineObj::SetTessellation(const VkPipelineTessellationStateCreateInfo *te_state) { m_te_state = te_state; }
1340
1341 void VkPipelineObj::InitGraphicsPipelineCreateInfo(VkGraphicsPipelineCreateInfo *gp_ci) {
1342     gp_ci->stageCount = m_shaderStages.size();
1343     gp_ci->pStages = m_shaderStages.size() ? m_shaderStages.data() : nullptr;
1344
1345     m_vi_state.sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO;
1346     gp_ci->pVertexInputState = &m_vi_state;
1347
1348     m_ia_state.sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO;
1349     gp_ci->pInputAssemblyState = &m_ia_state;
1350
1351     gp_ci->sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO;
1352     gp_ci->pNext = NULL;
1353     gp_ci->flags = 0;
1354
1355     m_cb_state.attachmentCount = m_colorAttachments.size();
1356     m_cb_state.pAttachments = m_colorAttachments.data();
1357
1358     if (m_viewports.size() > 0) {
1359         m_vp_state.viewportCount = m_viewports.size();
1360         m_vp_state.pViewports = m_viewports.data();
1361     } else {
1362         MakeDynamic(VK_DYNAMIC_STATE_VIEWPORT);
1363     }
1364
1365     if (m_scissors.size() > 0) {
1366         m_vp_state.scissorCount = m_scissors.size();
1367         m_vp_state.pScissors = m_scissors.data();
1368     } else {
1369         MakeDynamic(VK_DYNAMIC_STATE_SCISSOR);
1370     }
1371
1372     memset(&m_pd_state, 0, sizeof(m_pd_state));
1373     if (m_dynamic_state_enables.size() > 0) {
1374         m_pd_state.sType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO;
1375         m_pd_state.dynamicStateCount = m_dynamic_state_enables.size();
1376         m_pd_state.pDynamicStates = m_dynamic_state_enables.data();
1377         gp_ci->pDynamicState = &m_pd_state;
1378     }
1379
1380     gp_ci->subpass = 0;
1381     gp_ci->pViewportState = &m_vp_state;
1382     gp_ci->pRasterizationState = &m_rs_state;
1383     gp_ci->pMultisampleState = &m_ms_state;
1384     gp_ci->pDepthStencilState = m_ds_state;
1385     gp_ci->pColorBlendState = &m_cb_state;
1386     gp_ci->pTessellationState = m_te_state;
1387 }
1388
1389 VkResult VkPipelineObj::CreateVKPipeline(VkPipelineLayout layout, VkRenderPass render_pass, VkGraphicsPipelineCreateInfo *gp_ci) {
1390     VkGraphicsPipelineCreateInfo info = {};
1391
1392     // if not given a CreateInfo, create and initialize a local one.
1393     if (gp_ci == nullptr) {
1394         gp_ci = &info;
1395         InitGraphicsPipelineCreateInfo(gp_ci);
1396     }
1397
1398     gp_ci->layout = layout;
1399     gp_ci->renderPass = render_pass;
1400
1401     return init_try(*m_device, *gp_ci);
1402 }
1403
1404 VkCommandBufferObj::VkCommandBufferObj(VkDeviceObj *device, VkCommandPoolObj *pool, VkCommandBufferLevel level, VkQueueObj *queue) {
1405     m_device = device;
1406     if (queue) {
1407         m_queue = queue;
1408     } else {
1409         m_queue = m_device->GetDefaultQueue();
1410     }
1411     assert(m_queue);
1412
1413     auto create_info = vk_testing::CommandBuffer::create_info(pool->handle());
1414     create_info.level = level;
1415     init(*device, create_info);
1416 }
1417
1418 void VkCommandBufferObj::PipelineBarrier(VkPipelineStageFlags src_stages, VkPipelineStageFlags dest_stages,
1419                                          VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount,
1420                                          const VkMemoryBarrier *pMemoryBarriers, uint32_t bufferMemoryBarrierCount,
1421                                          const VkBufferMemoryBarrier *pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount,
1422                                          const VkImageMemoryBarrier *pImageMemoryBarriers) {
1423     vkCmdPipelineBarrier(handle(), src_stages, dest_stages, dependencyFlags, memoryBarrierCount, pMemoryBarriers,
1424                          bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
1425 }
1426
1427 void VkCommandBufferObj::ClearAllBuffers(const vector<std::unique_ptr<VkImageObj>> &color_objs, VkClearColorValue clear_color,
1428                                          VkDepthStencilObj *depth_stencil_obj, float depth_clear_value,
1429                                          uint32_t stencil_clear_value) {
1430     // whatever we want to do, we do it to the whole buffer
1431     VkImageSubresourceRange subrange = {};
1432     // srRange.aspectMask to be set later
1433     subrange.baseMipLevel = 0;
1434     // TODO: Mali device crashing with VK_REMAINING_MIP_LEVELS
1435     subrange.levelCount = 1;  // VK_REMAINING_MIP_LEVELS;
1436     subrange.baseArrayLayer = 0;
1437     // TODO: Mesa crashing with VK_REMAINING_ARRAY_LAYERS
1438     subrange.layerCount = 1;  // VK_REMAINING_ARRAY_LAYERS;
1439
1440     const VkImageLayout clear_layout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
1441
1442     for (const auto &color_obj : color_objs) {
1443         subrange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
1444         color_obj->Layout(VK_IMAGE_LAYOUT_UNDEFINED);
1445         color_obj->SetLayout(this, subrange.aspectMask, clear_layout);
1446         ClearColorImage(color_obj->image(), clear_layout, &clear_color, 1, &subrange);
1447     }
1448
1449     if (depth_stencil_obj && depth_stencil_obj->Initialized()) {
1450         subrange.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT;
1451         if (FormatIsDepthOnly(depth_stencil_obj->format())) subrange.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT;
1452         if (FormatIsStencilOnly(depth_stencil_obj->format())) subrange.aspectMask = VK_IMAGE_ASPECT_STENCIL_BIT;
1453
1454         depth_stencil_obj->Layout(VK_IMAGE_LAYOUT_UNDEFINED);
1455         depth_stencil_obj->SetLayout(this, subrange.aspectMask, clear_layout);
1456
1457         VkClearDepthStencilValue clear_value = {depth_clear_value, stencil_clear_value};
1458         ClearDepthStencilImage(depth_stencil_obj->handle(), clear_layout, &clear_value, 1, &subrange);
1459     }
1460 }
1461
1462 void VkCommandBufferObj::FillBuffer(VkBuffer buffer, VkDeviceSize offset, VkDeviceSize fill_size, uint32_t data) {
1463     vkCmdFillBuffer(handle(), buffer, offset, fill_size, data);
1464 }
1465
1466 void VkCommandBufferObj::UpdateBuffer(VkBuffer buffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void *pData) {
1467     vkCmdUpdateBuffer(handle(), buffer, dstOffset, dataSize, pData);
1468 }
1469
1470 void VkCommandBufferObj::CopyImage(VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout,
1471                                    uint32_t regionCount, const VkImageCopy *pRegions) {
1472     vkCmdCopyImage(handle(), srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
1473 }
1474
1475 void VkCommandBufferObj::ResolveImage(VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage,
1476                                       VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve *pRegions) {
1477     vkCmdResolveImage(handle(), srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
1478 }
1479
1480 void VkCommandBufferObj::ClearColorImage(VkImage image, VkImageLayout imageLayout, const VkClearColorValue *pColor,
1481                                          uint32_t rangeCount, const VkImageSubresourceRange *pRanges) {
1482     vkCmdClearColorImage(handle(), image, imageLayout, pColor, rangeCount, pRanges);
1483 }
1484
1485 void VkCommandBufferObj::ClearDepthStencilImage(VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue *pColor,
1486                                                 uint32_t rangeCount, const VkImageSubresourceRange *pRanges) {
1487     vkCmdClearDepthStencilImage(handle(), image, imageLayout, pColor, rangeCount, pRanges);
1488 }
1489
1490 void VkCommandBufferObj::PrepareAttachments(const vector<std::unique_ptr<VkImageObj>> &color_atts,
1491                                             VkDepthStencilObj *depth_stencil_att) {
1492     for (const auto &color_att : color_atts) {
1493         color_att->SetLayout(this, VK_IMAGE_ASPECT_COLOR_BIT, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL);
1494     }
1495
1496     if (depth_stencil_att && depth_stencil_att->Initialized()) {
1497         VkImageAspectFlags aspect = VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT;
1498         if (FormatIsDepthOnly(depth_stencil_att->Format())) aspect = VK_IMAGE_ASPECT_DEPTH_BIT;
1499         if (FormatIsStencilOnly(depth_stencil_att->Format())) aspect = VK_IMAGE_ASPECT_STENCIL_BIT;
1500
1501         depth_stencil_att->SetLayout(this, aspect, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL);
1502     }
1503 }
1504
1505 void VkCommandBufferObj::BeginRenderPass(const VkRenderPassBeginInfo &info) {
1506     vkCmdBeginRenderPass(handle(), &info, VK_SUBPASS_CONTENTS_INLINE);
1507 }
1508
1509 void VkCommandBufferObj::EndRenderPass() { vkCmdEndRenderPass(handle()); }
1510
1511 void VkCommandBufferObj::SetViewport(uint32_t firstViewport, uint32_t viewportCount, const VkViewport *pViewports) {
1512     vkCmdSetViewport(handle(), firstViewport, viewportCount, pViewports);
1513 }
1514
1515 void VkCommandBufferObj::SetStencilReference(VkStencilFaceFlags faceMask, uint32_t reference) {
1516     vkCmdSetStencilReference(handle(), faceMask, reference);
1517 }
1518
1519 void VkCommandBufferObj::DrawIndexed(uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset,
1520                                      uint32_t firstInstance) {
1521     vkCmdDrawIndexed(handle(), indexCount, instanceCount, firstIndex, vertexOffset, firstInstance);
1522 }
1523
1524 void VkCommandBufferObj::Draw(uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance) {
1525     vkCmdDraw(handle(), vertexCount, instanceCount, firstVertex, firstInstance);
1526 }
1527
1528 void VkCommandBufferObj::QueueCommandBuffer(bool checkSuccess) {
1529     VkFenceObj nullFence;
1530     QueueCommandBuffer(nullFence, checkSuccess);
1531 }
1532
1533 void VkCommandBufferObj::QueueCommandBuffer(const VkFenceObj &fence, bool checkSuccess) {
1534     VkResult err = VK_SUCCESS;
1535
1536     err = m_queue->submit(*this, fence, checkSuccess);
1537     if (checkSuccess) {
1538         ASSERT_VK_SUCCESS(err);
1539     }
1540
1541     err = m_queue->wait();
1542     if (checkSuccess) {
1543         ASSERT_VK_SUCCESS(err);
1544     }
1545
1546     // TODO: Determine if we really want this serialization here
1547     // Wait for work to finish before cleaning up.
1548     vkDeviceWaitIdle(m_device->device());
1549 }
1550
1551 void VkCommandBufferObj::BindDescriptorSet(VkDescriptorSetObj &descriptorSet) {
1552     VkDescriptorSet set_obj = descriptorSet.GetDescriptorSetHandle();
1553
1554     // bind pipeline, vertex buffer (descriptor set) and WVP (dynamic buffer view)
1555     if (set_obj) {
1556         vkCmdBindDescriptorSets(handle(), VK_PIPELINE_BIND_POINT_GRAPHICS, descriptorSet.GetPipelineLayout(), 0, 1, &set_obj, 0,
1557                                 NULL);
1558     }
1559 }
1560
1561 void VkCommandBufferObj::BindVertexBuffer(VkConstantBufferObj *vertexBuffer, VkDeviceSize offset, uint32_t binding) {
1562     vkCmdBindVertexBuffers(handle(), binding, 1, &vertexBuffer->handle(), &offset);
1563 }
1564
1565 VkCommandPoolObj::VkCommandPoolObj(VkDeviceObj *device, uint32_t queue_family_index, VkCommandPoolCreateFlags flags) {
1566     init(*device, vk_testing::CommandPool::create_info(queue_family_index, flags));
1567 }
1568
1569 bool VkDepthStencilObj::Initialized() { return m_initialized; }
1570 VkDepthStencilObj::VkDepthStencilObj(VkDeviceObj *device) : VkImageObj(device) { m_initialized = false; }
1571
1572 VkImageView *VkDepthStencilObj::BindInfo() { return &m_attachmentBindInfo; }
1573
1574 VkFormat VkDepthStencilObj::Format() const { return this->m_depth_stencil_fmt; }
1575
1576 void VkDepthStencilObj::Init(VkDeviceObj *device, int32_t width, int32_t height, VkFormat format, VkImageUsageFlags usage) {
1577     VkImageViewCreateInfo view_info = {};
1578
1579     m_device = device;
1580     m_initialized = true;
1581     m_depth_stencil_fmt = format;
1582
1583     /* create image */
1584     VkImageObj::Init(width, height, 1, m_depth_stencil_fmt, usage, VK_IMAGE_TILING_OPTIMAL);
1585
1586     VkImageAspectFlags aspect = VK_IMAGE_ASPECT_STENCIL_BIT | VK_IMAGE_ASPECT_DEPTH_BIT;
1587     if (FormatIsDepthOnly(format))
1588         aspect = VK_IMAGE_ASPECT_DEPTH_BIT;
1589     else if (FormatIsStencilOnly(format))
1590         aspect = VK_IMAGE_ASPECT_STENCIL_BIT;
1591
1592     SetLayout(aspect, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL);
1593
1594     view_info.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
1595     view_info.pNext = NULL;
1596     view_info.image = VK_NULL_HANDLE;
1597     view_info.subresourceRange.aspectMask = aspect;
1598     view_info.subresourceRange.baseMipLevel = 0;
1599     view_info.subresourceRange.levelCount = 1;
1600     view_info.subresourceRange.baseArrayLayer = 0;
1601     view_info.subresourceRange.layerCount = 1;
1602     view_info.flags = 0;
1603     view_info.format = m_depth_stencil_fmt;
1604     view_info.image = handle();
1605     view_info.viewType = VK_IMAGE_VIEW_TYPE_2D;
1606     m_imageView.init(*m_device, view_info);
1607
1608     m_attachmentBindInfo = m_imageView.handle();
1609 }