unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 1 | /* |
sfricke-samsung | 6d97e56 | 2020-01-07 22:01:00 -0800 | [diff] [blame] | 2 | * Copyright (c) 2015-2020 The Khronos Group Inc. |
| 3 | * Copyright (c) 2015-2020 Valve Corporation |
| 4 | * Copyright (c) 2015-2020 LunarG, Inc. |
| 5 | * Copyright (c) 2015-2020 Google, Inc. |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 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 | * Author: Chia-I Wu <olvaffe@gmail.com> |
| 14 | * Author: Chris Forbes <chrisf@ijw.co.nz> |
| 15 | * Author: Courtney Goeltzenleuchter <courtney@LunarG.com> |
| 16 | * Author: Mark Lobodzinski <mark@lunarg.com> |
| 17 | * Author: Mike Stroyan <mike@LunarG.com> |
| 18 | * Author: Tobin Ehlis <tobine@google.com> |
| 19 | * Author: Tony Barbour <tony@LunarG.com> |
| 20 | * Author: Cody Northrop <cnorthrop@google.com> |
| 21 | * Author: Dave Houlton <daveh@lunarg.com> |
| 22 | * Author: Jeremy Kniager <jeremyk@lunarg.com> |
| 23 | * Author: Shannon McPherson <shannon@lunarg.com> |
| 24 | * Author: John Zulauf <jzulauf@lunarg.com> |
| 25 | */ |
| 26 | |
| 27 | #include "cast_utils.h" |
| 28 | #include "layer_validation_tests.h" |
| 29 | |
| 30 | TEST_F(VkLayerTest, InvalidCommandPoolConsistency) { |
| 31 | TEST_DESCRIPTION("Allocate command buffers from one command pool and attempt to delete them from another."); |
| 32 | |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 33 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkFreeCommandBuffers-pCommandBuffers-parent"); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 34 | |
| 35 | ASSERT_NO_FATAL_FAILURE(Init()); |
| 36 | VkCommandPool command_pool_one; |
| 37 | VkCommandPool command_pool_two; |
| 38 | |
| 39 | VkCommandPoolCreateInfo pool_create_info{}; |
| 40 | pool_create_info.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO; |
| 41 | pool_create_info.queueFamilyIndex = m_device->graphics_queue_node_index_; |
| 42 | pool_create_info.flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT; |
| 43 | |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 44 | vk::CreateCommandPool(m_device->device(), &pool_create_info, nullptr, &command_pool_one); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 45 | |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 46 | vk::CreateCommandPool(m_device->device(), &pool_create_info, nullptr, &command_pool_two); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 47 | |
| 48 | VkCommandBuffer cb; |
| 49 | VkCommandBufferAllocateInfo command_buffer_allocate_info{}; |
| 50 | command_buffer_allocate_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO; |
| 51 | command_buffer_allocate_info.commandPool = command_pool_one; |
| 52 | command_buffer_allocate_info.commandBufferCount = 1; |
| 53 | command_buffer_allocate_info.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY; |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 54 | vk::AllocateCommandBuffers(m_device->device(), &command_buffer_allocate_info, &cb); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 55 | |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 56 | vk::FreeCommandBuffers(m_device->device(), command_pool_two, 1, &cb); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 57 | |
| 58 | m_errorMonitor->VerifyFound(); |
| 59 | |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 60 | vk::DestroyCommandPool(m_device->device(), command_pool_one, NULL); |
| 61 | vk::DestroyCommandPool(m_device->device(), command_pool_two, NULL); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 62 | } |
| 63 | |
| 64 | TEST_F(VkLayerTest, InvalidSecondaryCommandBufferBarrier) { |
| 65 | TEST_DESCRIPTION("Add an invalid image barrier in a secondary command buffer"); |
| 66 | ASSERT_NO_FATAL_FAILURE(Init()); |
| 67 | |
| 68 | // A renderpass with a single subpass that declared a self-dependency |
| 69 | VkAttachmentDescription attach[] = { |
| 70 | {0, VK_FORMAT_R8G8B8A8_UNORM, VK_SAMPLE_COUNT_1_BIT, VK_ATTACHMENT_LOAD_OP_DONT_CARE, VK_ATTACHMENT_STORE_OP_DONT_CARE, |
| 71 | VK_ATTACHMENT_LOAD_OP_DONT_CARE, VK_ATTACHMENT_STORE_OP_DONT_CARE, VK_IMAGE_LAYOUT_UNDEFINED, |
| 72 | VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL}, |
| 73 | }; |
| 74 | VkAttachmentReference ref = {0, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL}; |
| 75 | VkSubpassDescription subpasses[] = { |
| 76 | {0, VK_PIPELINE_BIND_POINT_GRAPHICS, 0, nullptr, 1, &ref, nullptr, nullptr, 0, nullptr}, |
| 77 | }; |
| 78 | VkSubpassDependency dep = {0, |
| 79 | 0, |
| 80 | VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, |
| 81 | VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, |
| 82 | VK_ACCESS_SHADER_WRITE_BIT, |
| 83 | VK_ACCESS_SHADER_WRITE_BIT, |
| 84 | VK_DEPENDENCY_BY_REGION_BIT}; |
| 85 | VkRenderPassCreateInfo rpci = {VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO, nullptr, 0, 1, attach, 1, subpasses, 1, &dep}; |
| 86 | VkRenderPass rp; |
| 87 | |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 88 | VkResult err = vk::CreateRenderPass(m_device->device(), &rpci, nullptr, &rp); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 89 | ASSERT_VK_SUCCESS(err); |
| 90 | |
| 91 | VkImageObj image(m_device); |
| 92 | image.Init(32, 32, 1, VK_FORMAT_R8G8B8A8_UNORM, VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, VK_IMAGE_TILING_OPTIMAL, 0); |
| 93 | VkImageView imageView = image.targetView(VK_FORMAT_R8G8B8A8_UNORM); |
| 94 | // Second image that img_barrier will incorrectly use |
| 95 | VkImageObj image2(m_device); |
| 96 | image2.Init(32, 32, 1, VK_FORMAT_R8G8B8A8_UNORM, VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, VK_IMAGE_TILING_OPTIMAL, 0); |
| 97 | |
| 98 | VkFramebufferCreateInfo fbci = {VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO, nullptr, 0, rp, 1, &imageView, 32, 32, 1}; |
| 99 | VkFramebuffer fb; |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 100 | err = vk::CreateFramebuffer(m_device->device(), &fbci, nullptr, &fb); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 101 | ASSERT_VK_SUCCESS(err); |
| 102 | |
| 103 | m_commandBuffer->begin(); |
| 104 | |
| 105 | VkRenderPassBeginInfo rpbi = {VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO, |
| 106 | nullptr, |
| 107 | rp, |
| 108 | fb, |
| 109 | {{ |
| 110 | 0, |
| 111 | 0, |
| 112 | }, |
| 113 | {32, 32}}, |
| 114 | 0, |
| 115 | nullptr}; |
| 116 | |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 117 | vk::CmdBeginRenderPass(m_commandBuffer->handle(), &rpbi, VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 118 | |
| 119 | VkCommandPoolObj pool(m_device, m_device->graphics_queue_node_index_, VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT); |
| 120 | VkCommandBufferObj secondary(m_device, &pool, VK_COMMAND_BUFFER_LEVEL_SECONDARY); |
| 121 | |
| 122 | VkCommandBufferInheritanceInfo cbii = {VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO, |
| 123 | nullptr, |
| 124 | rp, |
| 125 | 0, |
| 126 | VK_NULL_HANDLE, // Set to NULL FB handle intentionally to flesh out any errors |
| 127 | VK_FALSE, |
| 128 | 0, |
| 129 | 0}; |
| 130 | VkCommandBufferBeginInfo cbbi = {VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, nullptr, |
| 131 | VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT | VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT, |
| 132 | &cbii}; |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 133 | vk::BeginCommandBuffer(secondary.handle(), &cbbi); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 134 | VkImageMemoryBarrier img_barrier = {}; |
| 135 | img_barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER; |
| 136 | img_barrier.srcAccessMask = VK_ACCESS_SHADER_WRITE_BIT; |
| 137 | img_barrier.dstAccessMask = VK_ACCESS_SHADER_WRITE_BIT; |
| 138 | img_barrier.oldLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL; |
| 139 | img_barrier.newLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL; |
| 140 | img_barrier.image = image2.handle(); // Image mis-matches with FB image |
| 141 | img_barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED; |
| 142 | img_barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED; |
| 143 | img_barrier.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; |
| 144 | img_barrier.subresourceRange.baseArrayLayer = 0; |
| 145 | img_barrier.subresourceRange.baseMipLevel = 0; |
| 146 | img_barrier.subresourceRange.layerCount = 1; |
| 147 | img_barrier.subresourceRange.levelCount = 1; |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 148 | vk::CmdPipelineBarrier(secondary.handle(), VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, |
| 149 | VK_DEPENDENCY_BY_REGION_BIT, 0, nullptr, 0, nullptr, 1, &img_barrier); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 150 | secondary.end(); |
| 151 | |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 152 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdPipelineBarrier-image-02635"); |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 153 | vk::CmdExecuteCommands(m_commandBuffer->handle(), 1, &secondary.handle()); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 154 | m_errorMonitor->VerifyFound(); |
| 155 | |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 156 | vk::DestroyFramebuffer(m_device->device(), fb, nullptr); |
| 157 | vk::DestroyRenderPass(m_device->device(), rp, nullptr); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 158 | } |
| 159 | |
| 160 | TEST_F(VkLayerTest, DynamicDepthBiasNotBound) { |
| 161 | TEST_DESCRIPTION( |
| 162 | "Run a simple draw calls to validate failure when Depth Bias dynamic state is required but not correctly bound."); |
| 163 | |
| 164 | ASSERT_NO_FATAL_FAILURE(Init()); |
| 165 | // Dynamic depth bias |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 166 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "Dynamic depth bias state not set for this command buffer"); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 167 | VKTriangleTest(BsoFailDepthBias); |
| 168 | m_errorMonitor->VerifyFound(); |
| 169 | } |
| 170 | |
| 171 | TEST_F(VkLayerTest, DynamicLineWidthNotBound) { |
| 172 | TEST_DESCRIPTION( |
| 173 | "Run a simple draw calls to validate failure when Line Width dynamic state is required but not correctly bound."); |
| 174 | |
| 175 | ASSERT_NO_FATAL_FAILURE(Init()); |
| 176 | // Dynamic line width |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 177 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "Dynamic line width state not set for this command buffer"); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 178 | VKTriangleTest(BsoFailLineWidth); |
| 179 | m_errorMonitor->VerifyFound(); |
| 180 | } |
| 181 | |
Jeff Bolz | f390c6c | 2019-08-16 16:29:53 -0500 | [diff] [blame] | 182 | TEST_F(VkLayerTest, DynamicLineStippleNotBound) { |
| 183 | TEST_DESCRIPTION( |
| 184 | "Run a simple draw calls to validate failure when Line Stipple dynamic state is required but not correctly bound."); |
| 185 | |
| 186 | if (InstanceExtensionSupported(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME)) { |
| 187 | m_instance_extension_names.push_back(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME); |
| 188 | } else { |
| 189 | printf("%s Did not find required instance extension %s; skipped.\n", kSkipPrefix, |
| 190 | VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME); |
| 191 | return; |
| 192 | } |
Mark Lobodzinski | 09ce9c4 | 2020-03-06 10:02:44 -0700 | [diff] [blame] | 193 | ASSERT_NO_FATAL_FAILURE(InitFramework(m_errorMonitor)); |
Jeff Bolz | f390c6c | 2019-08-16 16:29:53 -0500 | [diff] [blame] | 194 | std::array<const char *, 1> required_device_extensions = {{VK_EXT_LINE_RASTERIZATION_EXTENSION_NAME}}; |
| 195 | for (auto device_extension : required_device_extensions) { |
| 196 | if (DeviceExtensionSupported(gpu(), nullptr, device_extension)) { |
| 197 | m_device_extension_names.push_back(device_extension); |
| 198 | } else { |
| 199 | printf("%s %s Extension not supported, skipping tests\n", kSkipPrefix, device_extension); |
| 200 | return; |
| 201 | } |
| 202 | } |
| 203 | |
| 204 | PFN_vkGetPhysicalDeviceFeatures2KHR vkGetPhysicalDeviceFeatures2KHR = |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 205 | (PFN_vkGetPhysicalDeviceFeatures2KHR)vk::GetInstanceProcAddr(instance(), "vkGetPhysicalDeviceFeatures2KHR"); |
Jeff Bolz | f390c6c | 2019-08-16 16:29:53 -0500 | [diff] [blame] | 206 | ASSERT_TRUE(vkGetPhysicalDeviceFeatures2KHR != nullptr); |
| 207 | |
| 208 | auto line_rasterization_features = lvl_init_struct<VkPhysicalDeviceLineRasterizationFeaturesEXT>(); |
| 209 | auto features2 = lvl_init_struct<VkPhysicalDeviceFeatures2KHR>(&line_rasterization_features); |
| 210 | vkGetPhysicalDeviceFeatures2KHR(gpu(), &features2); |
| 211 | |
| 212 | if (!line_rasterization_features.stippledBresenhamLines || !line_rasterization_features.bresenhamLines) { |
| 213 | printf("%sStipple Bresenham lines not supported; skipped.\n", kSkipPrefix); |
| 214 | return; |
| 215 | } |
| 216 | |
| 217 | ASSERT_NO_FATAL_FAILURE(InitState(nullptr, &features2, VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT)); |
| 218 | |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 219 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "Dynamic line stipple state not set for this command buffer"); |
Jeff Bolz | f390c6c | 2019-08-16 16:29:53 -0500 | [diff] [blame] | 220 | VKTriangleTest(BsoFailLineStipple); |
| 221 | m_errorMonitor->VerifyFound(); |
| 222 | } |
| 223 | |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 224 | TEST_F(VkLayerTest, DynamicViewportNotBound) { |
| 225 | TEST_DESCRIPTION( |
| 226 | "Run a simple draw calls to validate failure when Viewport dynamic state is required but not correctly bound."); |
| 227 | |
| 228 | ASSERT_NO_FATAL_FAILURE(Init()); |
| 229 | // Dynamic viewport state |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 230 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 231 | "Dynamic viewport(s) 0 are used by pipeline state object, but were not provided"); |
| 232 | VKTriangleTest(BsoFailViewport); |
| 233 | m_errorMonitor->VerifyFound(); |
| 234 | } |
| 235 | |
| 236 | TEST_F(VkLayerTest, DynamicScissorNotBound) { |
| 237 | TEST_DESCRIPTION("Run a simple draw calls to validate failure when Scissor dynamic state is required but not correctly bound."); |
| 238 | |
| 239 | ASSERT_NO_FATAL_FAILURE(Init()); |
| 240 | // Dynamic scissor state |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 241 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 242 | "Dynamic scissor(s) 0 are used by pipeline state object, but were not provided"); |
| 243 | VKTriangleTest(BsoFailScissor); |
| 244 | m_errorMonitor->VerifyFound(); |
| 245 | } |
| 246 | |
| 247 | TEST_F(VkLayerTest, DynamicBlendConstantsNotBound) { |
| 248 | TEST_DESCRIPTION( |
| 249 | "Run a simple draw calls to validate failure when Blend Constants dynamic state is required but not correctly bound."); |
| 250 | |
| 251 | ASSERT_NO_FATAL_FAILURE(Init()); |
| 252 | // Dynamic blend constant state |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 253 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "Dynamic blend constants state not set for this command buffer"); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 254 | VKTriangleTest(BsoFailBlend); |
| 255 | m_errorMonitor->VerifyFound(); |
| 256 | } |
| 257 | |
| 258 | TEST_F(VkLayerTest, DynamicDepthBoundsNotBound) { |
| 259 | TEST_DESCRIPTION( |
| 260 | "Run a simple draw calls to validate failure when Depth Bounds dynamic state is required but not correctly bound."); |
| 261 | |
| 262 | ASSERT_NO_FATAL_FAILURE(Init()); |
| 263 | if (!m_device->phy().features().depthBounds) { |
| 264 | printf("%s Device does not support depthBounds test; skipped.\n", kSkipPrefix); |
| 265 | return; |
| 266 | } |
| 267 | // Dynamic depth bounds |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 268 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "Dynamic depth bounds state not set for this command buffer"); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 269 | VKTriangleTest(BsoFailDepthBounds); |
| 270 | m_errorMonitor->VerifyFound(); |
| 271 | } |
| 272 | |
| 273 | TEST_F(VkLayerTest, DynamicStencilReadNotBound) { |
| 274 | TEST_DESCRIPTION( |
| 275 | "Run a simple draw calls to validate failure when Stencil Read dynamic state is required but not correctly bound."); |
| 276 | |
| 277 | ASSERT_NO_FATAL_FAILURE(Init()); |
| 278 | // Dynamic stencil read mask |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 279 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "Dynamic stencil read mask state not set for this command buffer"); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 280 | VKTriangleTest(BsoFailStencilReadMask); |
| 281 | m_errorMonitor->VerifyFound(); |
| 282 | } |
| 283 | |
| 284 | TEST_F(VkLayerTest, DynamicStencilWriteNotBound) { |
| 285 | TEST_DESCRIPTION( |
| 286 | "Run a simple draw calls to validate failure when Stencil Write dynamic state is required but not correctly bound."); |
| 287 | |
| 288 | ASSERT_NO_FATAL_FAILURE(Init()); |
| 289 | // Dynamic stencil write mask |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 290 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "Dynamic stencil write mask state not set for this command buffer"); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 291 | VKTriangleTest(BsoFailStencilWriteMask); |
| 292 | m_errorMonitor->VerifyFound(); |
| 293 | } |
| 294 | |
| 295 | TEST_F(VkLayerTest, DynamicStencilRefNotBound) { |
| 296 | TEST_DESCRIPTION( |
| 297 | "Run a simple draw calls to validate failure when Stencil Ref dynamic state is required but not correctly bound."); |
| 298 | |
| 299 | ASSERT_NO_FATAL_FAILURE(Init()); |
| 300 | // Dynamic stencil reference |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 301 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "Dynamic stencil reference state not set for this command buffer"); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 302 | VKTriangleTest(BsoFailStencilReference); |
| 303 | m_errorMonitor->VerifyFound(); |
| 304 | } |
| 305 | |
| 306 | TEST_F(VkLayerTest, IndexBufferNotBound) { |
| 307 | TEST_DESCRIPTION("Run an indexed draw call without an index buffer bound."); |
| 308 | |
| 309 | ASSERT_NO_FATAL_FAILURE(Init()); |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 310 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "Index buffer object not bound to this command buffer when Indexed "); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 311 | VKTriangleTest(BsoFailIndexBuffer); |
| 312 | m_errorMonitor->VerifyFound(); |
| 313 | } |
| 314 | |
| 315 | TEST_F(VkLayerTest, IndexBufferBadSize) { |
| 316 | TEST_DESCRIPTION("Run indexed draw call with bad index buffer size."); |
| 317 | |
| 318 | ASSERT_NO_FATAL_FAILURE(Init(nullptr, nullptr, VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT)); |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 319 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "vkCmdDrawIndexed() index size "); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 320 | VKTriangleTest(BsoFailIndexBufferBadSize); |
| 321 | m_errorMonitor->VerifyFound(); |
| 322 | } |
| 323 | |
| 324 | TEST_F(VkLayerTest, IndexBufferBadOffset) { |
| 325 | TEST_DESCRIPTION("Run indexed draw call with bad index buffer offset."); |
| 326 | |
| 327 | ASSERT_NO_FATAL_FAILURE(Init(nullptr, nullptr, VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT)); |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 328 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "vkCmdDrawIndexed() index size "); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 329 | VKTriangleTest(BsoFailIndexBufferBadOffset); |
| 330 | m_errorMonitor->VerifyFound(); |
| 331 | } |
| 332 | |
| 333 | TEST_F(VkLayerTest, IndexBufferBadBindSize) { |
| 334 | TEST_DESCRIPTION("Run bind index buffer with a size greater than the index buffer."); |
| 335 | |
| 336 | ASSERT_NO_FATAL_FAILURE(Init(nullptr, nullptr, VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT)); |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 337 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "vkCmdDrawIndexed() index size "); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 338 | VKTriangleTest(BsoFailIndexBufferBadMapSize); |
| 339 | m_errorMonitor->VerifyFound(); |
| 340 | } |
| 341 | |
| 342 | TEST_F(VkLayerTest, IndexBufferBadBindOffset) { |
| 343 | TEST_DESCRIPTION("Run bind index buffer with an offset greater than the size of the index buffer."); |
| 344 | |
| 345 | ASSERT_NO_FATAL_FAILURE(Init(nullptr, nullptr, VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT)); |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 346 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "vkCmdDrawIndexed() index size "); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 347 | VKTriangleTest(BsoFailIndexBufferBadMapOffset); |
| 348 | m_errorMonitor->VerifyFound(); |
| 349 | } |
| 350 | |
| 351 | TEST_F(VkLayerTest, MissingClearAttachment) { |
| 352 | TEST_DESCRIPTION("Points to a wrong colorAttachment index in a VkClearAttachment structure passed to vkCmdClearAttachments"); |
| 353 | ASSERT_NO_FATAL_FAILURE(Init()); |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 354 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdClearAttachments-aspectMask-02501"); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 355 | |
| 356 | VKTriangleTest(BsoFailCmdClearAttachments); |
| 357 | m_errorMonitor->VerifyFound(); |
| 358 | } |
| 359 | |
Mark Lobodzinski | cd0204c | 2019-11-11 16:59:18 -0700 | [diff] [blame] | 360 | TEST_F(VkLayerTest, SecondaryCommandbufferAsPrimary) { |
| 361 | TEST_DESCRIPTION("Create a secondary command buffer and pass it to QueueSubmit."); |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 362 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkSubmitInfo-pCommandBuffers-00075"); |
Mark Lobodzinski | cd0204c | 2019-11-11 16:59:18 -0700 | [diff] [blame] | 363 | |
| 364 | ASSERT_NO_FATAL_FAILURE(Init()); |
| 365 | |
| 366 | VkCommandBufferObj secondary(m_device, m_commandPool, VK_COMMAND_BUFFER_LEVEL_SECONDARY); |
| 367 | secondary.begin(); |
| 368 | secondary.ClearAllBuffers(m_renderTargets, m_clear_color, nullptr, m_depth_clear_color, m_stencil_clear_color); |
| 369 | secondary.end(); |
| 370 | |
| 371 | VkSubmitInfo submit_info; |
| 372 | submit_info.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO; |
| 373 | submit_info.pNext = NULL; |
| 374 | submit_info.waitSemaphoreCount = 0; |
| 375 | submit_info.pWaitSemaphores = NULL; |
| 376 | submit_info.pWaitDstStageMask = NULL; |
| 377 | submit_info.commandBufferCount = 1; |
| 378 | submit_info.pCommandBuffers = &secondary.handle(); |
| 379 | submit_info.signalSemaphoreCount = 0; |
| 380 | submit_info.pSignalSemaphores = NULL; |
| 381 | |
| 382 | vk::QueueSubmit(m_device->m_queue, 1, &submit_info, VK_NULL_HANDLE); |
| 383 | m_errorMonitor->VerifyFound(); |
| 384 | } |
| 385 | |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 386 | TEST_F(VkLayerTest, CommandBufferTwoSubmits) { |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 387 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 388 | "was begun w/ VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT set, but has been submitted"); |
| 389 | |
| 390 | ASSERT_NO_FATAL_FAILURE(Init()); |
| 391 | ASSERT_NO_FATAL_FAILURE(InitViewport()); |
| 392 | ASSERT_NO_FATAL_FAILURE(InitRenderTarget()); |
| 393 | |
| 394 | // We luck out b/c by default the framework creates CB w/ the |
| 395 | // VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT set |
| 396 | m_commandBuffer->begin(); |
| 397 | m_commandBuffer->ClearAllBuffers(m_renderTargets, m_clear_color, nullptr, m_depth_clear_color, m_stencil_clear_color); |
| 398 | m_commandBuffer->end(); |
| 399 | |
| 400 | // Bypass framework since it does the waits automatically |
| 401 | VkResult err = VK_SUCCESS; |
| 402 | VkSubmitInfo submit_info; |
| 403 | submit_info.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO; |
| 404 | submit_info.pNext = NULL; |
| 405 | submit_info.waitSemaphoreCount = 0; |
| 406 | submit_info.pWaitSemaphores = NULL; |
| 407 | submit_info.pWaitDstStageMask = NULL; |
| 408 | submit_info.commandBufferCount = 1; |
| 409 | submit_info.pCommandBuffers = &m_commandBuffer->handle(); |
| 410 | submit_info.signalSemaphoreCount = 0; |
| 411 | submit_info.pSignalSemaphores = NULL; |
| 412 | |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 413 | err = vk::QueueSubmit(m_device->m_queue, 1, &submit_info, VK_NULL_HANDLE); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 414 | ASSERT_VK_SUCCESS(err); |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 415 | vk::QueueWaitIdle(m_device->m_queue); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 416 | |
| 417 | // Cause validation error by re-submitting cmd buffer that should only be |
| 418 | // submitted once |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 419 | err = vk::QueueSubmit(m_device->m_queue, 1, &submit_info, VK_NULL_HANDLE); |
| 420 | vk::QueueWaitIdle(m_device->m_queue); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 421 | |
| 422 | m_errorMonitor->VerifyFound(); |
| 423 | } |
| 424 | |
| 425 | TEST_F(VkLayerTest, InvalidPushConstants) { |
| 426 | ASSERT_NO_FATAL_FAILURE(Init()); |
| 427 | ASSERT_NO_FATAL_FAILURE(InitViewport()); |
| 428 | ASSERT_NO_FATAL_FAILURE(InitRenderTarget()); |
| 429 | |
| 430 | VkPipelineLayout pipeline_layout; |
| 431 | VkPushConstantRange pc_range = {}; |
| 432 | VkPipelineLayoutCreateInfo pipeline_layout_ci = {}; |
| 433 | pipeline_layout_ci.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO; |
| 434 | pipeline_layout_ci.pushConstantRangeCount = 1; |
| 435 | pipeline_layout_ci.pPushConstantRanges = &pc_range; |
| 436 | |
| 437 | // |
| 438 | // Check for invalid push constant ranges in pipeline layouts. |
| 439 | // |
| 440 | struct PipelineLayoutTestCase { |
| 441 | VkPushConstantRange const range; |
| 442 | char const *msg; |
| 443 | }; |
| 444 | |
| 445 | const uint32_t too_big = m_device->props.limits.maxPushConstantsSize + 0x4; |
| 446 | const std::array<PipelineLayoutTestCase, 10> range_tests = {{ |
| 447 | {{VK_SHADER_STAGE_VERTEX_BIT, 0, 0}, "vkCreatePipelineLayout() call has push constants index 0 with size 0."}, |
| 448 | {{VK_SHADER_STAGE_VERTEX_BIT, 0, 1}, "vkCreatePipelineLayout() call has push constants index 0 with size 1."}, |
| 449 | {{VK_SHADER_STAGE_VERTEX_BIT, 4, 1}, "vkCreatePipelineLayout() call has push constants index 0 with size 1."}, |
| 450 | {{VK_SHADER_STAGE_VERTEX_BIT, 4, 0}, "vkCreatePipelineLayout() call has push constants index 0 with size 0."}, |
| 451 | {{VK_SHADER_STAGE_VERTEX_BIT, 1, 4}, "vkCreatePipelineLayout() call has push constants index 0 with offset 1. Offset must"}, |
| 452 | {{VK_SHADER_STAGE_VERTEX_BIT, 0, too_big}, "vkCreatePipelineLayout() call has push constants index 0 with offset "}, |
| 453 | {{VK_SHADER_STAGE_VERTEX_BIT, too_big, too_big}, "vkCreatePipelineLayout() call has push constants index 0 with offset "}, |
| 454 | {{VK_SHADER_STAGE_VERTEX_BIT, too_big, 4}, "vkCreatePipelineLayout() call has push constants index 0 with offset "}, |
| 455 | {{VK_SHADER_STAGE_VERTEX_BIT, 0xFFFFFFF0, 0x00000020}, |
| 456 | "vkCreatePipelineLayout() call has push constants index 0 with offset "}, |
| 457 | {{VK_SHADER_STAGE_VERTEX_BIT, 0x00000020, 0xFFFFFFF0}, |
| 458 | "vkCreatePipelineLayout() call has push constants index 0 with offset "}, |
| 459 | }}; |
| 460 | |
| 461 | // Check for invalid offset and size |
| 462 | for (const auto &iter : range_tests) { |
| 463 | pc_range = iter.range; |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 464 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, iter.msg); |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 465 | vk::CreatePipelineLayout(m_device->device(), &pipeline_layout_ci, NULL, &pipeline_layout); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 466 | m_errorMonitor->VerifyFound(); |
| 467 | } |
| 468 | |
| 469 | // Check for invalid stage flag |
| 470 | pc_range.offset = 0; |
| 471 | pc_range.size = 16; |
| 472 | pc_range.stageFlags = 0; |
| 473 | m_errorMonitor->SetDesiredFailureMsg( |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 474 | kErrorBit, "vkCreatePipelineLayout: value of pCreateInfo->pPushConstantRanges[0].stageFlags must not be 0"); |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 475 | vk::CreatePipelineLayout(m_device->device(), &pipeline_layout_ci, NULL, &pipeline_layout); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 476 | m_errorMonitor->VerifyFound(); |
| 477 | |
| 478 | // Check for duplicate stage flags in a list of push constant ranges. |
| 479 | // A shader can only have one push constant block and that block is mapped |
| 480 | // to the push constant range that has that shader's stage flag set. |
| 481 | // The shader's stage flag can only appear once in all the ranges, so the |
| 482 | // implementation can find the one and only range to map it to. |
| 483 | const uint32_t ranges_per_test = 5; |
| 484 | struct DuplicateStageFlagsTestCase { |
| 485 | VkPushConstantRange const ranges[ranges_per_test]; |
| 486 | std::vector<char const *> const msg; |
| 487 | }; |
| 488 | // Overlapping ranges are OK, but a stage flag can appear only once. |
| 489 | const std::array<DuplicateStageFlagsTestCase, 3> duplicate_stageFlags_tests = { |
| 490 | { |
| 491 | {{{VK_SHADER_STAGE_VERTEX_BIT, 0, 4}, |
| 492 | {VK_SHADER_STAGE_VERTEX_BIT, 0, 4}, |
| 493 | {VK_SHADER_STAGE_VERTEX_BIT, 0, 4}, |
| 494 | {VK_SHADER_STAGE_VERTEX_BIT, 0, 4}, |
| 495 | {VK_SHADER_STAGE_VERTEX_BIT, 0, 4}}, |
| 496 | { |
| 497 | "vkCreatePipelineLayout() Duplicate stage flags found in ranges 0 and 1.", |
| 498 | "vkCreatePipelineLayout() Duplicate stage flags found in ranges 0 and 2.", |
| 499 | "vkCreatePipelineLayout() Duplicate stage flags found in ranges 0 and 3.", |
| 500 | "vkCreatePipelineLayout() Duplicate stage flags found in ranges 0 and 4.", |
| 501 | "vkCreatePipelineLayout() Duplicate stage flags found in ranges 1 and 2.", |
| 502 | "vkCreatePipelineLayout() Duplicate stage flags found in ranges 1 and 3.", |
| 503 | "vkCreatePipelineLayout() Duplicate stage flags found in ranges 1 and 4.", |
| 504 | "vkCreatePipelineLayout() Duplicate stage flags found in ranges 2 and 3.", |
| 505 | "vkCreatePipelineLayout() Duplicate stage flags found in ranges 2 and 4.", |
| 506 | "vkCreatePipelineLayout() Duplicate stage flags found in ranges 3 and 4.", |
| 507 | }}, |
| 508 | {{{VK_SHADER_STAGE_VERTEX_BIT, 0, 4}, |
| 509 | {VK_SHADER_STAGE_GEOMETRY_BIT, 0, 4}, |
| 510 | {VK_SHADER_STAGE_FRAGMENT_BIT, 0, 4}, |
| 511 | {VK_SHADER_STAGE_VERTEX_BIT, 0, 4}, |
| 512 | {VK_SHADER_STAGE_GEOMETRY_BIT, 0, 4}}, |
| 513 | { |
| 514 | "vkCreatePipelineLayout() Duplicate stage flags found in ranges 0 and 3.", |
| 515 | "vkCreatePipelineLayout() Duplicate stage flags found in ranges 1 and 4.", |
| 516 | }}, |
| 517 | {{{VK_SHADER_STAGE_FRAGMENT_BIT, 0, 4}, |
| 518 | {VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT, 0, 4}, |
| 519 | {VK_SHADER_STAGE_VERTEX_BIT, 0, 4}, |
| 520 | {VK_SHADER_STAGE_VERTEX_BIT, 0, 4}, |
| 521 | {VK_SHADER_STAGE_GEOMETRY_BIT, 0, 4}}, |
| 522 | { |
| 523 | "vkCreatePipelineLayout() Duplicate stage flags found in ranges 2 and 3.", |
| 524 | }}, |
| 525 | }, |
| 526 | }; |
| 527 | |
| 528 | for (const auto &iter : duplicate_stageFlags_tests) { |
| 529 | pipeline_layout_ci.pPushConstantRanges = iter.ranges; |
| 530 | pipeline_layout_ci.pushConstantRangeCount = ranges_per_test; |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 531 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, iter.msg.begin(), iter.msg.end()); |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 532 | vk::CreatePipelineLayout(m_device->device(), &pipeline_layout_ci, NULL, &pipeline_layout); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 533 | m_errorMonitor->VerifyFound(); |
| 534 | } |
| 535 | |
| 536 | // |
| 537 | // CmdPushConstants tests |
| 538 | // |
| 539 | |
| 540 | // Setup a pipeline layout with ranges: [0,32) [16,80) |
| 541 | const std::vector<VkPushConstantRange> pc_range2 = {{VK_SHADER_STAGE_VERTEX_BIT, 16, 64}, |
| 542 | {VK_SHADER_STAGE_FRAGMENT_BIT, 0, 32}}; |
| 543 | const VkPipelineLayoutObj pipeline_layout_obj(m_device, {}, pc_range2); |
| 544 | |
| 545 | const uint8_t dummy_values[100] = {}; |
| 546 | |
| 547 | m_commandBuffer->begin(); |
| 548 | m_commandBuffer->BeginRenderPass(m_renderPassBeginInfo); |
| 549 | |
| 550 | // Check for invalid stage flag |
| 551 | // Note that VU 00996 isn't reached due to parameter validation |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 552 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "vkCmdPushConstants: value of stageFlags must not be 0"); |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 553 | vk::CmdPushConstants(m_commandBuffer->handle(), pipeline_layout_obj.handle(), 0, 0, 16, dummy_values); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 554 | m_errorMonitor->VerifyFound(); |
| 555 | |
| 556 | // Positive tests for the overlapping ranges |
| 557 | m_errorMonitor->ExpectSuccess(); |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 558 | vk::CmdPushConstants(m_commandBuffer->handle(), pipeline_layout_obj.handle(), VK_SHADER_STAGE_FRAGMENT_BIT, 0, 16, |
| 559 | dummy_values); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 560 | m_errorMonitor->VerifyNotFound(); |
| 561 | m_errorMonitor->ExpectSuccess(); |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 562 | vk::CmdPushConstants(m_commandBuffer->handle(), pipeline_layout_obj.handle(), VK_SHADER_STAGE_VERTEX_BIT, 32, 48, dummy_values); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 563 | m_errorMonitor->VerifyNotFound(); |
| 564 | m_errorMonitor->ExpectSuccess(); |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 565 | vk::CmdPushConstants(m_commandBuffer->handle(), pipeline_layout_obj.handle(), |
| 566 | VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT, 16, 16, dummy_values); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 567 | m_errorMonitor->VerifyNotFound(); |
| 568 | |
| 569 | // Wrong cmd stages for extant range |
| 570 | // No range for all cmd stages -- "VUID-vkCmdPushConstants-offset-01795" VUID-vkCmdPushConstants-offset-01795 |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 571 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdPushConstants-offset-01795"); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 572 | // Missing cmd stages for found overlapping range -- "VUID-vkCmdPushConstants-offset-01796" VUID-vkCmdPushConstants-offset-01796 |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 573 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdPushConstants-offset-01796"); |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 574 | vk::CmdPushConstants(m_commandBuffer->handle(), pipeline_layout_obj.handle(), VK_SHADER_STAGE_GEOMETRY_BIT, 0, 16, |
| 575 | dummy_values); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 576 | m_errorMonitor->VerifyFound(); |
| 577 | |
| 578 | // Wrong no extant range |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 579 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdPushConstants-offset-01795"); |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 580 | vk::CmdPushConstants(m_commandBuffer->handle(), pipeline_layout_obj.handle(), VK_SHADER_STAGE_FRAGMENT_BIT, 80, 4, |
| 581 | dummy_values); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 582 | m_errorMonitor->VerifyFound(); |
| 583 | |
| 584 | // Wrong overlapping extent |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 585 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdPushConstants-offset-01795"); |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 586 | vk::CmdPushConstants(m_commandBuffer->handle(), pipeline_layout_obj.handle(), |
| 587 | VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT, 0, 20, dummy_values); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 588 | m_errorMonitor->VerifyFound(); |
| 589 | |
| 590 | // Wrong stage flags for valid overlapping range |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 591 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdPushConstants-offset-01796"); |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 592 | vk::CmdPushConstants(m_commandBuffer->handle(), pipeline_layout_obj.handle(), VK_SHADER_STAGE_VERTEX_BIT, 16, 16, dummy_values); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 593 | m_errorMonitor->VerifyFound(); |
| 594 | |
| 595 | m_commandBuffer->EndRenderPass(); |
| 596 | m_commandBuffer->end(); |
| 597 | } |
| 598 | |
| 599 | TEST_F(VkLayerTest, NoBeginCommandBuffer) { |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 600 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "You must call vkBeginCommandBuffer() before this call to "); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 601 | |
| 602 | ASSERT_NO_FATAL_FAILURE(Init()); |
| 603 | VkCommandBufferObj commandBuffer(m_device, m_commandPool); |
| 604 | // Call EndCommandBuffer() w/o calling BeginCommandBuffer() |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 605 | vk::EndCommandBuffer(commandBuffer.handle()); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 606 | |
| 607 | m_errorMonitor->VerifyFound(); |
| 608 | } |
| 609 | |
| 610 | TEST_F(VkLayerTest, SecondaryCommandBufferNullRenderpass) { |
| 611 | ASSERT_NO_FATAL_FAILURE(Init()); |
| 612 | |
| 613 | VkCommandBufferObj cb(m_device, m_commandPool, VK_COMMAND_BUFFER_LEVEL_SECONDARY); |
| 614 | |
| 615 | // Force the failure by not setting the Renderpass and Framebuffer fields |
| 616 | VkCommandBufferInheritanceInfo cmd_buf_hinfo = {}; |
| 617 | cmd_buf_hinfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO; |
| 618 | |
| 619 | VkCommandBufferBeginInfo cmd_buf_info = {}; |
| 620 | cmd_buf_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO; |
| 621 | cmd_buf_info.pNext = NULL; |
| 622 | cmd_buf_info.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT | VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT; |
| 623 | cmd_buf_info.pInheritanceInfo = &cmd_buf_hinfo; |
| 624 | |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 625 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkCommandBufferBeginInfo-flags-00053"); |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 626 | vk::BeginCommandBuffer(cb.handle(), &cmd_buf_info); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 627 | m_errorMonitor->VerifyFound(); |
| 628 | } |
| 629 | |
| 630 | TEST_F(VkLayerTest, SecondaryCommandBufferRerecordedExplicitReset) { |
| 631 | ASSERT_NO_FATAL_FAILURE(Init()); |
| 632 | |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 633 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "was destroyed or rerecorded"); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 634 | |
| 635 | // A pool we can reset in. |
| 636 | VkCommandPoolObj pool(m_device, m_device->graphics_queue_node_index_, VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT); |
| 637 | VkCommandBufferObj secondary(m_device, &pool, VK_COMMAND_BUFFER_LEVEL_SECONDARY); |
| 638 | |
| 639 | secondary.begin(); |
| 640 | secondary.end(); |
| 641 | |
| 642 | m_commandBuffer->begin(); |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 643 | vk::CmdExecuteCommands(m_commandBuffer->handle(), 1, &secondary.handle()); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 644 | |
| 645 | // rerecording of secondary |
| 646 | secondary.reset(); // explicit reset here. |
| 647 | secondary.begin(); |
| 648 | secondary.end(); |
| 649 | |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 650 | vk::CmdExecuteCommands(m_commandBuffer->handle(), 1, &secondary.handle()); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 651 | m_errorMonitor->VerifyFound(); |
| 652 | } |
| 653 | |
| 654 | TEST_F(VkLayerTest, SecondaryCommandBufferRerecordedNoReset) { |
| 655 | ASSERT_NO_FATAL_FAILURE(Init()); |
| 656 | |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 657 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "was destroyed or rerecorded"); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 658 | |
| 659 | // A pool we can reset in. |
| 660 | VkCommandPoolObj pool(m_device, m_device->graphics_queue_node_index_, VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT); |
| 661 | VkCommandBufferObj secondary(m_device, &pool, VK_COMMAND_BUFFER_LEVEL_SECONDARY); |
| 662 | |
| 663 | secondary.begin(); |
| 664 | secondary.end(); |
| 665 | |
| 666 | m_commandBuffer->begin(); |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 667 | vk::CmdExecuteCommands(m_commandBuffer->handle(), 1, &secondary.handle()); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 668 | |
| 669 | // rerecording of secondary |
| 670 | secondary.begin(); // implicit reset in begin |
| 671 | secondary.end(); |
| 672 | |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 673 | vk::CmdExecuteCommands(m_commandBuffer->handle(), 1, &secondary.handle()); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 674 | m_errorMonitor->VerifyFound(); |
| 675 | } |
| 676 | |
| 677 | TEST_F(VkLayerTest, CascadedInvalidation) { |
| 678 | ASSERT_NO_FATAL_FAILURE(Init()); |
| 679 | |
| 680 | VkEventCreateInfo eci = {VK_STRUCTURE_TYPE_EVENT_CREATE_INFO, nullptr, 0}; |
| 681 | VkEvent event; |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 682 | vk::CreateEvent(m_device->device(), &eci, nullptr, &event); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 683 | |
| 684 | VkCommandBufferObj secondary(m_device, m_commandPool, VK_COMMAND_BUFFER_LEVEL_SECONDARY); |
| 685 | secondary.begin(); |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 686 | vk::CmdSetEvent(secondary.handle(), event, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 687 | secondary.end(); |
| 688 | |
| 689 | m_commandBuffer->begin(); |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 690 | vk::CmdExecuteCommands(m_commandBuffer->handle(), 1, &secondary.handle()); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 691 | m_commandBuffer->end(); |
| 692 | |
| 693 | // destroying the event should invalidate both primary and secondary CB |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 694 | vk::DestroyEvent(m_device->device(), event, nullptr); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 695 | |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 696 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "UNASSIGNED-CoreValidation-DrawState-InvalidCommandBuffer-VkEvent"); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 697 | m_commandBuffer->QueueCommandBuffer(false); |
| 698 | m_errorMonitor->VerifyFound(); |
| 699 | } |
| 700 | |
| 701 | TEST_F(VkLayerTest, CommandBufferResetErrors) { |
| 702 | // Cause error due to Begin while recording CB |
| 703 | // Then cause 2 errors for attempting to reset CB w/o having |
| 704 | // VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT set for the pool from |
| 705 | // which CBs were allocated. Note that this bit is off by default. |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 706 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkBeginCommandBuffer-commandBuffer-00049"); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 707 | |
| 708 | ASSERT_NO_FATAL_FAILURE(Init()); |
| 709 | |
| 710 | // Calls AllocateCommandBuffers |
| 711 | VkCommandBufferObj commandBuffer(m_device, m_commandPool); |
| 712 | |
| 713 | // Force the failure by setting the Renderpass and Framebuffer fields with (fake) data |
| 714 | VkCommandBufferInheritanceInfo cmd_buf_hinfo = {}; |
| 715 | cmd_buf_hinfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO; |
| 716 | VkCommandBufferBeginInfo cmd_buf_info = {}; |
| 717 | cmd_buf_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO; |
| 718 | cmd_buf_info.pNext = NULL; |
| 719 | cmd_buf_info.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT; |
| 720 | cmd_buf_info.pInheritanceInfo = &cmd_buf_hinfo; |
| 721 | |
| 722 | // Begin CB to transition to recording state |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 723 | vk::BeginCommandBuffer(commandBuffer.handle(), &cmd_buf_info); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 724 | // Can't re-begin. This should trigger error |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 725 | vk::BeginCommandBuffer(commandBuffer.handle(), &cmd_buf_info); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 726 | m_errorMonitor->VerifyFound(); |
| 727 | |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 728 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkResetCommandBuffer-commandBuffer-00046"); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 729 | VkCommandBufferResetFlags flags = 0; // Don't care about flags for this test |
| 730 | // Reset attempt will trigger error due to incorrect CommandPool state |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 731 | vk::ResetCommandBuffer(commandBuffer.handle(), flags); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 732 | m_errorMonitor->VerifyFound(); |
| 733 | |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 734 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkBeginCommandBuffer-commandBuffer-00050"); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 735 | // Transition CB to RECORDED state |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 736 | vk::EndCommandBuffer(commandBuffer.handle()); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 737 | // Now attempting to Begin will implicitly reset, which triggers error |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 738 | vk::BeginCommandBuffer(commandBuffer.handle(), &cmd_buf_info); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 739 | m_errorMonitor->VerifyFound(); |
| 740 | } |
| 741 | |
sfricke-samsung | ae9f00a | 2020-05-28 20:48:49 -0700 | [diff] [blame] | 742 | TEST_F(VkLayerTest, CommandBufferPrimaryFlags) { |
| 743 | ASSERT_NO_FATAL_FAILURE(Init()); |
| 744 | |
| 745 | // Calls AllocateCommandBuffers |
| 746 | VkCommandBufferObj commandBuffer(m_device, m_commandPool); |
| 747 | |
| 748 | VkCommandBufferBeginInfo cmd_buf_info = {}; |
| 749 | cmd_buf_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO; |
| 750 | cmd_buf_info.pNext = NULL; |
| 751 | cmd_buf_info.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT | VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT; |
| 752 | |
| 753 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkBeginCommandBuffer-commandBuffer-02840"); |
| 754 | vk::BeginCommandBuffer(commandBuffer.handle(), &cmd_buf_info); |
| 755 | m_errorMonitor->VerifyFound(); |
| 756 | } |
| 757 | |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 758 | TEST_F(VkLayerTest, ClearColorAttachmentsOutsideRenderPass) { |
| 759 | // Call CmdClearAttachmentss outside of an active RenderPass |
| 760 | |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 761 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 762 | "vkCmdClearAttachments(): This call must be issued inside an active render pass"); |
| 763 | |
| 764 | ASSERT_NO_FATAL_FAILURE(Init()); |
| 765 | ASSERT_NO_FATAL_FAILURE(InitRenderTarget()); |
| 766 | |
| 767 | // Start no RenderPass |
| 768 | m_commandBuffer->begin(); |
| 769 | |
| 770 | VkClearAttachment color_attachment; |
| 771 | color_attachment.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; |
| 772 | color_attachment.clearValue.color.float32[0] = 0; |
| 773 | color_attachment.clearValue.color.float32[1] = 0; |
| 774 | color_attachment.clearValue.color.float32[2] = 0; |
| 775 | color_attachment.clearValue.color.float32[3] = 0; |
| 776 | color_attachment.colorAttachment = 0; |
Mark Lobodzinski | d544751 | 2019-06-28 09:56:36 -0600 | [diff] [blame] | 777 | VkClearRect clear_rect = {{{0, 0}, {32, 32}}, 0, 1}; |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 778 | vk::CmdClearAttachments(m_commandBuffer->handle(), 1, &color_attachment, 1, &clear_rect); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 779 | |
| 780 | m_errorMonitor->VerifyFound(); |
| 781 | } |
| 782 | |
Mark Lobodzinski | 7d7da06 | 2019-06-27 16:01:39 -0600 | [diff] [blame] | 783 | TEST_F(VkLayerTest, ClearColorAttachmentsZeroLayercount) { |
| 784 | TEST_DESCRIPTION("Call CmdClearAttachments with a pRect having a layerCount of zero."); |
| 785 | |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 786 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdClearAttachments-layerCount-01934"); |
Mark Lobodzinski | 7d7da06 | 2019-06-27 16:01:39 -0600 | [diff] [blame] | 787 | |
| 788 | ASSERT_NO_FATAL_FAILURE(Init()); |
| 789 | ASSERT_NO_FATAL_FAILURE(InitRenderTarget()); |
| 790 | |
| 791 | m_commandBuffer->begin(); |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 792 | vk::CmdBeginRenderPass(m_commandBuffer->handle(), &renderPassBeginInfo(), VK_SUBPASS_CONTENTS_INLINE); |
Mark Lobodzinski | 7d7da06 | 2019-06-27 16:01:39 -0600 | [diff] [blame] | 793 | |
| 794 | VkClearAttachment color_attachment; |
| 795 | color_attachment.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; |
| 796 | color_attachment.clearValue.color.float32[0] = 0; |
| 797 | color_attachment.clearValue.color.float32[1] = 0; |
| 798 | color_attachment.clearValue.color.float32[2] = 0; |
| 799 | color_attachment.clearValue.color.float32[3] = 0; |
| 800 | color_attachment.colorAttachment = 0; |
| 801 | VkClearRect clear_rect = {{{0, 0}, {32, 32}}}; |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 802 | vk::CmdClearAttachments(m_commandBuffer->handle(), 1, &color_attachment, 1, &clear_rect); |
Mark Lobodzinski | 7d7da06 | 2019-06-27 16:01:39 -0600 | [diff] [blame] | 803 | |
| 804 | m_errorMonitor->VerifyFound(); |
| 805 | } |
| 806 | |
sfricke-samsung | f0f3d8b | 2020-04-25 02:20:47 -0700 | [diff] [blame] | 807 | TEST_F(VkLayerTest, ClearColorAttachmentsZeroExtent) { |
| 808 | TEST_DESCRIPTION("Call CmdClearAttachments with a pRect having a rect2D extent of zero."); |
| 809 | |
| 810 | ASSERT_NO_FATAL_FAILURE(Init()); |
| 811 | ASSERT_NO_FATAL_FAILURE(InitRenderTarget()); |
| 812 | |
| 813 | m_commandBuffer->begin(); |
| 814 | vk::CmdBeginRenderPass(m_commandBuffer->handle(), &renderPassBeginInfo(), VK_SUBPASS_CONTENTS_INLINE); |
| 815 | |
| 816 | VkClearAttachment color_attachment; |
| 817 | color_attachment.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; |
| 818 | color_attachment.clearValue.color.float32[0] = 0; |
| 819 | color_attachment.clearValue.color.float32[1] = 0; |
| 820 | color_attachment.clearValue.color.float32[2] = 0; |
| 821 | color_attachment.clearValue.color.float32[3] = 0; |
| 822 | color_attachment.colorAttachment = 0; |
| 823 | VkClearRect clear_rect = {}; |
| 824 | clear_rect.rect.offset = {0, 0}; |
| 825 | clear_rect.baseArrayLayer = 0; |
| 826 | clear_rect.layerCount = 1; |
| 827 | |
| 828 | clear_rect.rect.extent = {0, 1}; |
| 829 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdClearAttachments-rect-02682"); |
| 830 | vk::CmdClearAttachments(m_commandBuffer->handle(), 1, &color_attachment, 1, &clear_rect); |
| 831 | m_errorMonitor->VerifyFound(); |
| 832 | |
| 833 | clear_rect.rect.extent = {1, 0}; |
| 834 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdClearAttachments-rect-02683"); |
| 835 | vk::CmdClearAttachments(m_commandBuffer->handle(), 1, &color_attachment, 1, &clear_rect); |
| 836 | m_errorMonitor->VerifyFound(); |
| 837 | } |
| 838 | |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 839 | TEST_F(VkLayerTest, ExecuteCommandsPrimaryCB) { |
| 840 | TEST_DESCRIPTION("Attempt vkCmdExecuteCommands with a primary command buffer (should only be secondary)"); |
| 841 | |
| 842 | ASSERT_NO_FATAL_FAILURE(Init()); |
| 843 | ASSERT_NO_FATAL_FAILURE(InitRenderTarget()); |
| 844 | |
| 845 | // An empty primary command buffer |
| 846 | VkCommandBufferObj cb(m_device, m_commandPool); |
| 847 | cb.begin(); |
| 848 | cb.end(); |
| 849 | |
| 850 | m_commandBuffer->begin(); |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 851 | vk::CmdBeginRenderPass(m_commandBuffer->handle(), &renderPassBeginInfo(), VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 852 | VkCommandBuffer handle = cb.handle(); |
| 853 | |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 854 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdExecuteCommands-pCommandBuffers-00088"); |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 855 | vk::CmdExecuteCommands(m_commandBuffer->handle(), 1, &handle); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 856 | m_errorMonitor->VerifyFound(); |
| 857 | |
| 858 | m_errorMonitor->SetUnexpectedError("All elements of pCommandBuffers must not be in the pending state"); |
| 859 | |
| 860 | m_commandBuffer->EndRenderPass(); |
| 861 | m_commandBuffer->end(); |
| 862 | } |
| 863 | |
Petr Kraus | 8e53cf0 | 2020-01-03 05:30:04 +0100 | [diff] [blame] | 864 | TEST_F(VkLayerTest, ExecuteCommandsToSecondaryCB) { |
| 865 | TEST_DESCRIPTION("Attempt vkCmdExecuteCommands to a Secondary command buffer"); |
| 866 | |
| 867 | ASSERT_NO_FATAL_FAILURE(Init()); |
| 868 | |
| 869 | VkCommandBufferObj main_cb(m_device, m_commandPool, VK_COMMAND_BUFFER_LEVEL_SECONDARY); |
| 870 | VkCommandBufferObj secondary_cb(m_device, m_commandPool, VK_COMMAND_BUFFER_LEVEL_SECONDARY); |
| 871 | secondary_cb.begin(); |
| 872 | secondary_cb.end(); |
| 873 | |
| 874 | main_cb.begin(); |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 875 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdExecuteCommands-bufferlevel"); |
Petr Kraus | 8e53cf0 | 2020-01-03 05:30:04 +0100 | [diff] [blame] | 876 | vk::CmdExecuteCommands(main_cb.handle(), 1, &secondary_cb.handle()); |
| 877 | m_errorMonitor->VerifyFound(); |
| 878 | } |
| 879 | |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 880 | TEST_F(VkLayerTest, InvalidVertexAttributeAlignment) { |
| 881 | TEST_DESCRIPTION("Check for proper aligment of attribAddress which depends on a bound pipeline and on a bound vertex buffer"); |
| 882 | |
| 883 | ASSERT_NO_FATAL_FAILURE(Init()); |
| 884 | ASSERT_NO_FATAL_FAILURE(InitViewport()); |
| 885 | ASSERT_NO_FATAL_FAILURE(InitRenderTarget()); |
| 886 | |
| 887 | const VkPipelineLayoutObj pipeline_layout(m_device); |
| 888 | |
| 889 | struct VboEntry { |
| 890 | uint16_t input0[2]; |
| 891 | uint32_t input1; |
| 892 | float input2[4]; |
| 893 | }; |
| 894 | |
| 895 | const unsigned vbo_entry_count = 3; |
| 896 | const VboEntry vbo_data[vbo_entry_count] = {}; |
| 897 | |
| 898 | VkConstantBufferObj vbo(m_device, static_cast<int>(sizeof(VboEntry) * vbo_entry_count), |
| 899 | reinterpret_cast<const void *>(vbo_data), VK_BUFFER_USAGE_VERTEX_BUFFER_BIT); |
| 900 | |
| 901 | VkVertexInputBindingDescription input_binding; |
| 902 | input_binding.binding = 0; |
| 903 | input_binding.stride = sizeof(VboEntry); |
| 904 | input_binding.inputRate = VK_VERTEX_INPUT_RATE_VERTEX; |
| 905 | |
| 906 | VkVertexInputAttributeDescription input_attribs[3]; |
| 907 | |
| 908 | input_attribs[0].binding = 0; |
| 909 | // Location switch between attrib[0] and attrib[1] is intentional |
| 910 | input_attribs[0].location = 1; |
| 911 | input_attribs[0].format = VK_FORMAT_A8B8G8R8_UNORM_PACK32; |
| 912 | input_attribs[0].offset = offsetof(VboEntry, input1); |
| 913 | |
| 914 | input_attribs[1].binding = 0; |
| 915 | input_attribs[1].location = 0; |
| 916 | input_attribs[1].format = VK_FORMAT_R16G16_UNORM; |
| 917 | input_attribs[1].offset = offsetof(VboEntry, input0); |
| 918 | |
| 919 | input_attribs[2].binding = 0; |
| 920 | input_attribs[2].location = 2; |
| 921 | input_attribs[2].format = VK_FORMAT_R32G32B32A32_SFLOAT; |
| 922 | input_attribs[2].offset = offsetof(VboEntry, input2); |
| 923 | |
| 924 | char const *vsSource = |
| 925 | "#version 450\n" |
| 926 | "\n" |
| 927 | "layout(location = 0) in vec2 input0;" |
| 928 | "layout(location = 1) in vec4 input1;" |
| 929 | "layout(location = 2) in vec4 input2;" |
| 930 | "\n" |
| 931 | "void main(){\n" |
| 932 | " gl_Position = input1 + input2;\n" |
| 933 | " gl_Position.xy += input0;\n" |
| 934 | "}\n"; |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 935 | |
| 936 | VkShaderObj vs(m_device, vsSource, VK_SHADER_STAGE_VERTEX_BIT, this); |
locke-lunarg | 8e2c91b | 2019-06-11 17:53:26 -0600 | [diff] [blame] | 937 | VkShaderObj fs(m_device, bindStateFragShaderText, VK_SHADER_STAGE_FRAGMENT_BIT, this); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 938 | |
| 939 | VkPipelineObj pipe1(m_device); |
| 940 | pipe1.AddDefaultColorAttachment(); |
| 941 | pipe1.AddShader(&vs); |
| 942 | pipe1.AddShader(&fs); |
| 943 | pipe1.AddVertexInputBindings(&input_binding, 1); |
| 944 | pipe1.AddVertexInputAttribs(&input_attribs[0], 3); |
| 945 | pipe1.SetViewport(m_viewports); |
| 946 | pipe1.SetScissor(m_scissors); |
| 947 | pipe1.CreateVKPipeline(pipeline_layout.handle(), renderPass()); |
| 948 | |
| 949 | input_binding.stride = 6; |
| 950 | |
| 951 | VkPipelineObj pipe2(m_device); |
| 952 | pipe2.AddDefaultColorAttachment(); |
| 953 | pipe2.AddShader(&vs); |
| 954 | pipe2.AddShader(&fs); |
| 955 | pipe2.AddVertexInputBindings(&input_binding, 1); |
| 956 | pipe2.AddVertexInputAttribs(&input_attribs[0], 3); |
| 957 | pipe2.SetViewport(m_viewports); |
| 958 | pipe2.SetScissor(m_scissors); |
| 959 | pipe2.CreateVKPipeline(pipeline_layout.handle(), renderPass()); |
| 960 | |
| 961 | m_commandBuffer->begin(); |
| 962 | m_commandBuffer->BeginRenderPass(m_renderPassBeginInfo); |
| 963 | |
| 964 | // Test with invalid buffer offset |
| 965 | VkDeviceSize offset = 1; |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 966 | vk::CmdBindPipeline(m_commandBuffer->handle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipe1.handle()); |
| 967 | vk::CmdBindVertexBuffers(m_commandBuffer->handle(), 0, 1, &vbo.handle(), &offset); |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 968 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "Invalid attribAddress alignment for vertex attribute 0"); |
| 969 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "Invalid attribAddress alignment for vertex attribute 1"); |
| 970 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "Invalid attribAddress alignment for vertex attribute 2"); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 971 | m_commandBuffer->Draw(1, 0, 0, 0); |
| 972 | m_errorMonitor->VerifyFound(); |
| 973 | |
| 974 | // Test with invalid buffer stride |
| 975 | offset = 0; |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 976 | vk::CmdBindPipeline(m_commandBuffer->handle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipe2.handle()); |
| 977 | vk::CmdBindVertexBuffers(m_commandBuffer->handle(), 0, 1, &vbo.handle(), &offset); |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 978 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "Invalid attribAddress alignment for vertex attribute 0"); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 979 | // Attribute[1] is aligned properly even with a wrong stride |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 980 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "Invalid attribAddress alignment for vertex attribute 2"); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 981 | m_commandBuffer->Draw(1, 0, 0, 0); |
| 982 | m_errorMonitor->VerifyFound(); |
| 983 | |
| 984 | m_commandBuffer->EndRenderPass(); |
| 985 | m_commandBuffer->end(); |
| 986 | } |
| 987 | |
| 988 | TEST_F(VkLayerTest, NonSimultaneousSecondaryMarksPrimary) { |
| 989 | ASSERT_NO_FATAL_FAILURE(Init()); |
locke-lunarg | 77b9f7c | 2019-06-18 00:06:03 -0600 | [diff] [blame] | 990 | const char *simultaneous_use_message = "UNASSIGNED-CoreValidation-DrawState-InvalidCommandBufferSimultaneousUse"; |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 991 | |
| 992 | VkCommandBufferObj secondary(m_device, m_commandPool, VK_COMMAND_BUFFER_LEVEL_SECONDARY); |
| 993 | |
| 994 | secondary.begin(); |
| 995 | secondary.end(); |
| 996 | |
| 997 | VkCommandBufferBeginInfo cbbi = { |
| 998 | VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, |
| 999 | nullptr, |
| 1000 | VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT, |
| 1001 | nullptr, |
| 1002 | }; |
| 1003 | |
| 1004 | m_commandBuffer->begin(&cbbi); |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 1005 | m_errorMonitor->SetDesiredFailureMsg(kWarningBit, simultaneous_use_message); |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 1006 | vk::CmdExecuteCommands(m_commandBuffer->handle(), 1, &secondary.handle()); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 1007 | m_errorMonitor->VerifyFound(); |
| 1008 | m_commandBuffer->end(); |
| 1009 | } |
| 1010 | |
| 1011 | TEST_F(VkLayerTest, SimultaneousUseSecondaryTwoExecutes) { |
| 1012 | ASSERT_NO_FATAL_FAILURE(Init()); |
| 1013 | |
John Zulauf | f1640d1 | 2019-08-13 15:39:58 -0600 | [diff] [blame] | 1014 | const char *simultaneous_use_message = "VUID-vkCmdExecuteCommands-pCommandBuffers-00092"; |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 1015 | |
| 1016 | VkCommandBufferObj secondary(m_device, m_commandPool, VK_COMMAND_BUFFER_LEVEL_SECONDARY); |
| 1017 | |
| 1018 | VkCommandBufferInheritanceInfo inh = { |
| 1019 | VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO, |
| 1020 | nullptr, |
| 1021 | }; |
| 1022 | VkCommandBufferBeginInfo cbbi = {VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, nullptr, 0, &inh}; |
| 1023 | |
| 1024 | secondary.begin(&cbbi); |
| 1025 | secondary.end(); |
| 1026 | |
| 1027 | m_commandBuffer->begin(); |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 1028 | vk::CmdExecuteCommands(m_commandBuffer->handle(), 1, &secondary.handle()); |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 1029 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, simultaneous_use_message); |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 1030 | vk::CmdExecuteCommands(m_commandBuffer->handle(), 1, &secondary.handle()); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 1031 | m_errorMonitor->VerifyFound(); |
| 1032 | m_commandBuffer->end(); |
| 1033 | } |
| 1034 | |
| 1035 | TEST_F(VkLayerTest, SimultaneousUseSecondarySingleExecute) { |
| 1036 | ASSERT_NO_FATAL_FAILURE(Init()); |
| 1037 | |
| 1038 | // variation on previous test executing the same CB twice in the same |
| 1039 | // CmdExecuteCommands call |
| 1040 | |
John Zulauf | f1640d1 | 2019-08-13 15:39:58 -0600 | [diff] [blame] | 1041 | const char *simultaneous_use_message = "VUID-vkCmdExecuteCommands-pCommandBuffers-00093"; |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 1042 | |
| 1043 | VkCommandBufferObj secondary(m_device, m_commandPool, VK_COMMAND_BUFFER_LEVEL_SECONDARY); |
| 1044 | |
| 1045 | VkCommandBufferInheritanceInfo inh = { |
| 1046 | VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO, |
| 1047 | nullptr, |
| 1048 | }; |
| 1049 | VkCommandBufferBeginInfo cbbi = {VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, nullptr, 0, &inh}; |
| 1050 | |
| 1051 | secondary.begin(&cbbi); |
| 1052 | secondary.end(); |
| 1053 | |
| 1054 | m_commandBuffer->begin(); |
| 1055 | VkCommandBuffer cbs[] = {secondary.handle(), secondary.handle()}; |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 1056 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, simultaneous_use_message); |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 1057 | vk::CmdExecuteCommands(m_commandBuffer->handle(), 2, cbs); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 1058 | m_errorMonitor->VerifyFound(); |
| 1059 | m_commandBuffer->end(); |
| 1060 | } |
| 1061 | |
| 1062 | TEST_F(VkLayerTest, SimultaneousUseOneShot) { |
| 1063 | TEST_DESCRIPTION("Submit the same command buffer twice in one submit looking for simultaneous use and one time submit errors"); |
| 1064 | const char *simultaneous_use_message = "is already in use and is not marked for simultaneous use"; |
| 1065 | const char *one_shot_message = "VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT set, but has been submitted"; |
| 1066 | ASSERT_NO_FATAL_FAILURE(Init()); |
| 1067 | |
| 1068 | VkCommandBuffer cmd_bufs[2]; |
| 1069 | VkCommandBufferAllocateInfo alloc_info; |
| 1070 | alloc_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO; |
| 1071 | alloc_info.pNext = NULL; |
| 1072 | alloc_info.commandBufferCount = 2; |
| 1073 | alloc_info.commandPool = m_commandPool->handle(); |
| 1074 | alloc_info.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY; |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 1075 | vk::AllocateCommandBuffers(m_device->device(), &alloc_info, cmd_bufs); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 1076 | |
| 1077 | VkCommandBufferBeginInfo cb_binfo; |
| 1078 | cb_binfo.pNext = NULL; |
| 1079 | cb_binfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO; |
| 1080 | cb_binfo.pInheritanceInfo = VK_NULL_HANDLE; |
| 1081 | cb_binfo.flags = 0; |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 1082 | vk::BeginCommandBuffer(cmd_bufs[0], &cb_binfo); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 1083 | VkViewport viewport = {0, 0, 16, 16, 0, 1}; |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 1084 | vk::CmdSetViewport(cmd_bufs[0], 0, 1, &viewport); |
| 1085 | vk::EndCommandBuffer(cmd_bufs[0]); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 1086 | VkCommandBuffer duplicates[2] = {cmd_bufs[0], cmd_bufs[0]}; |
| 1087 | |
| 1088 | VkSubmitInfo submit_info = {}; |
| 1089 | submit_info.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO; |
| 1090 | submit_info.commandBufferCount = 2; |
| 1091 | submit_info.pCommandBuffers = duplicates; |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 1092 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, simultaneous_use_message); |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 1093 | vk::QueueSubmit(m_device->m_queue, 1, &submit_info, VK_NULL_HANDLE); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 1094 | m_errorMonitor->VerifyFound(); |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 1095 | vk::QueueWaitIdle(m_device->m_queue); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 1096 | |
| 1097 | // Set one time use and now look for one time submit |
| 1098 | duplicates[0] = duplicates[1] = cmd_bufs[1]; |
| 1099 | cb_binfo.flags = VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT | VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT; |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 1100 | vk::BeginCommandBuffer(cmd_bufs[1], &cb_binfo); |
| 1101 | vk::CmdSetViewport(cmd_bufs[1], 0, 1, &viewport); |
| 1102 | vk::EndCommandBuffer(cmd_bufs[1]); |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 1103 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, one_shot_message); |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 1104 | vk::QueueSubmit(m_device->m_queue, 1, &submit_info, VK_NULL_HANDLE); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 1105 | m_errorMonitor->VerifyFound(); |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 1106 | vk::QueueWaitIdle(m_device->m_queue); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 1107 | } |
| 1108 | |
| 1109 | TEST_F(VkLayerTest, DrawTimeImageViewTypeMismatchWithPipeline) { |
| 1110 | TEST_DESCRIPTION( |
| 1111 | "Test that an error is produced when an image view type does not match the dimensionality declared in the shader"); |
| 1112 | |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 1113 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "requires an image view of type VK_IMAGE_VIEW_TYPE_3D"); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 1114 | |
| 1115 | ASSERT_NO_FATAL_FAILURE(Init()); |
| 1116 | ASSERT_NO_FATAL_FAILURE(InitRenderTarget()); |
| 1117 | |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 1118 | char const *fsSource = |
| 1119 | "#version 450\n" |
| 1120 | "\n" |
| 1121 | "layout(set=0, binding=0) uniform sampler3D s;\n" |
| 1122 | "layout(location=0) out vec4 color;\n" |
| 1123 | "void main() {\n" |
| 1124 | " color = texture(s, vec3(0));\n" |
| 1125 | "}\n"; |
locke-lunarg | 8e2c91b | 2019-06-11 17:53:26 -0600 | [diff] [blame] | 1126 | VkShaderObj vs(m_device, bindStateVertShaderText, VK_SHADER_STAGE_VERTEX_BIT, this); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 1127 | VkShaderObj fs(m_device, fsSource, VK_SHADER_STAGE_FRAGMENT_BIT, this); |
| 1128 | |
| 1129 | VkPipelineObj pipe(m_device); |
| 1130 | pipe.AddShader(&vs); |
| 1131 | pipe.AddShader(&fs); |
| 1132 | pipe.AddDefaultColorAttachment(); |
| 1133 | |
| 1134 | VkTextureObj texture(m_device, nullptr); |
| 1135 | VkSamplerObj sampler(m_device); |
| 1136 | |
| 1137 | VkDescriptorSetObj descriptorSet(m_device); |
| 1138 | descriptorSet.AppendSamplerTexture(&sampler, &texture); |
| 1139 | descriptorSet.CreateVKDescriptorSet(m_commandBuffer); |
| 1140 | |
| 1141 | VkResult err = pipe.CreateVKPipeline(descriptorSet.GetPipelineLayout(), renderPass()); |
| 1142 | ASSERT_VK_SUCCESS(err); |
| 1143 | |
| 1144 | m_commandBuffer->begin(); |
| 1145 | m_commandBuffer->BeginRenderPass(m_renderPassBeginInfo); |
| 1146 | |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 1147 | vk::CmdBindPipeline(m_commandBuffer->handle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipe.handle()); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 1148 | m_commandBuffer->BindDescriptorSet(descriptorSet); |
| 1149 | |
| 1150 | VkViewport viewport = {0, 0, 16, 16, 0, 1}; |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 1151 | vk::CmdSetViewport(m_commandBuffer->handle(), 0, 1, &viewport); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 1152 | VkRect2D scissor = {{0, 0}, {16, 16}}; |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 1153 | vk::CmdSetScissor(m_commandBuffer->handle(), 0, 1, &scissor); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 1154 | |
| 1155 | // error produced here. |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 1156 | vk::CmdDraw(m_commandBuffer->handle(), 3, 1, 0, 0); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 1157 | |
| 1158 | m_errorMonitor->VerifyFound(); |
| 1159 | |
| 1160 | m_commandBuffer->EndRenderPass(); |
| 1161 | m_commandBuffer->end(); |
| 1162 | } |
| 1163 | |
| 1164 | TEST_F(VkLayerTest, DrawTimeImageMultisampleMismatchWithPipeline) { |
| 1165 | TEST_DESCRIPTION( |
| 1166 | "Test that an error is produced when a multisampled images are consumed via singlesample images types in the shader, or " |
| 1167 | "vice versa."); |
| 1168 | |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 1169 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "requires bound image to have multiple samples"); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 1170 | |
| 1171 | ASSERT_NO_FATAL_FAILURE(Init()); |
| 1172 | ASSERT_NO_FATAL_FAILURE(InitRenderTarget()); |
| 1173 | |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 1174 | char const *fsSource = |
| 1175 | "#version 450\n" |
| 1176 | "\n" |
| 1177 | "layout(set=0, binding=0) uniform sampler2DMS s;\n" |
| 1178 | "layout(location=0) out vec4 color;\n" |
| 1179 | "void main() {\n" |
| 1180 | " color = texelFetch(s, ivec2(0), 0);\n" |
| 1181 | "}\n"; |
locke-lunarg | 8e2c91b | 2019-06-11 17:53:26 -0600 | [diff] [blame] | 1182 | VkShaderObj vs(m_device, bindStateVertShaderText, VK_SHADER_STAGE_VERTEX_BIT, this); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 1183 | VkShaderObj fs(m_device, fsSource, VK_SHADER_STAGE_FRAGMENT_BIT, this); |
| 1184 | |
| 1185 | VkPipelineObj pipe(m_device); |
| 1186 | pipe.AddShader(&vs); |
| 1187 | pipe.AddShader(&fs); |
| 1188 | pipe.AddDefaultColorAttachment(); |
| 1189 | |
| 1190 | VkTextureObj texture(m_device, nullptr); // THIS LINE CAUSES CRASH ON MALI |
| 1191 | VkSamplerObj sampler(m_device); |
| 1192 | |
| 1193 | VkDescriptorSetObj descriptorSet(m_device); |
| 1194 | descriptorSet.AppendSamplerTexture(&sampler, &texture); |
| 1195 | descriptorSet.CreateVKDescriptorSet(m_commandBuffer); |
| 1196 | |
| 1197 | VkResult err = pipe.CreateVKPipeline(descriptorSet.GetPipelineLayout(), renderPass()); |
| 1198 | ASSERT_VK_SUCCESS(err); |
| 1199 | |
| 1200 | m_commandBuffer->begin(); |
| 1201 | m_commandBuffer->BeginRenderPass(m_renderPassBeginInfo); |
| 1202 | |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 1203 | vk::CmdBindPipeline(m_commandBuffer->handle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipe.handle()); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 1204 | m_commandBuffer->BindDescriptorSet(descriptorSet); |
| 1205 | |
| 1206 | VkViewport viewport = {0, 0, 16, 16, 0, 1}; |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 1207 | vk::CmdSetViewport(m_commandBuffer->handle(), 0, 1, &viewport); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 1208 | VkRect2D scissor = {{0, 0}, {16, 16}}; |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 1209 | vk::CmdSetScissor(m_commandBuffer->handle(), 0, 1, &scissor); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 1210 | |
| 1211 | // error produced here. |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 1212 | vk::CmdDraw(m_commandBuffer->handle(), 3, 1, 0, 0); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 1213 | |
| 1214 | m_errorMonitor->VerifyFound(); |
| 1215 | |
| 1216 | m_commandBuffer->EndRenderPass(); |
| 1217 | m_commandBuffer->end(); |
| 1218 | } |
| 1219 | |
| 1220 | TEST_F(VkLayerTest, DrawTimeImageComponentTypeMismatchWithPipeline) { |
| 1221 | TEST_DESCRIPTION( |
| 1222 | "Test that an error is produced when the component type of an imageview disagrees with the type in the shader."); |
| 1223 | |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 1224 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "SINT component type, but bound descriptor"); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 1225 | |
| 1226 | ASSERT_NO_FATAL_FAILURE(Init()); |
| 1227 | ASSERT_NO_FATAL_FAILURE(InitRenderTarget()); |
| 1228 | |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 1229 | char const *fsSource = |
| 1230 | "#version 450\n" |
| 1231 | "\n" |
| 1232 | "layout(set=0, binding=0) uniform isampler2D s;\n" |
| 1233 | "layout(location=0) out vec4 color;\n" |
| 1234 | "void main() {\n" |
| 1235 | " color = texelFetch(s, ivec2(0), 0);\n" |
| 1236 | "}\n"; |
locke-lunarg | 8e2c91b | 2019-06-11 17:53:26 -0600 | [diff] [blame] | 1237 | VkShaderObj vs(m_device, bindStateVertShaderText, VK_SHADER_STAGE_VERTEX_BIT, this); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 1238 | VkShaderObj fs(m_device, fsSource, VK_SHADER_STAGE_FRAGMENT_BIT, this); |
| 1239 | |
| 1240 | VkPipelineObj pipe(m_device); |
| 1241 | pipe.AddShader(&vs); |
| 1242 | pipe.AddShader(&fs); |
| 1243 | pipe.AddDefaultColorAttachment(); |
| 1244 | |
| 1245 | VkTextureObj texture(m_device, nullptr); // UNORM texture by default, incompatible with isampler2D |
| 1246 | VkSamplerObj sampler(m_device); |
| 1247 | |
| 1248 | VkDescriptorSetObj descriptorSet(m_device); |
| 1249 | descriptorSet.AppendSamplerTexture(&sampler, &texture); |
| 1250 | descriptorSet.CreateVKDescriptorSet(m_commandBuffer); |
| 1251 | |
| 1252 | VkResult err = pipe.CreateVKPipeline(descriptorSet.GetPipelineLayout(), renderPass()); |
| 1253 | ASSERT_VK_SUCCESS(err); |
| 1254 | |
| 1255 | m_commandBuffer->begin(); |
| 1256 | m_commandBuffer->BeginRenderPass(m_renderPassBeginInfo); |
| 1257 | |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 1258 | vk::CmdBindPipeline(m_commandBuffer->handle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipe.handle()); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 1259 | m_commandBuffer->BindDescriptorSet(descriptorSet); |
| 1260 | |
| 1261 | VkViewport viewport = {0, 0, 16, 16, 0, 1}; |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 1262 | vk::CmdSetViewport(m_commandBuffer->handle(), 0, 1, &viewport); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 1263 | VkRect2D scissor = {{0, 0}, {16, 16}}; |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 1264 | vk::CmdSetScissor(m_commandBuffer->handle(), 0, 1, &scissor); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 1265 | |
| 1266 | // error produced here. |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 1267 | vk::CmdDraw(m_commandBuffer->handle(), 3, 1, 0, 0); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 1268 | |
| 1269 | m_errorMonitor->VerifyFound(); |
| 1270 | |
| 1271 | m_commandBuffer->EndRenderPass(); |
| 1272 | m_commandBuffer->end(); |
| 1273 | } |
| 1274 | |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 1275 | TEST_F(VkLayerTest, CopyImageLayerCountMismatch) { |
| 1276 | TEST_DESCRIPTION( |
| 1277 | "Try to copy between images with the source subresource having a different layerCount than the destination subresource"); |
sfricke-samsung | 30b094c | 2020-05-30 11:42:11 -0700 | [diff] [blame] | 1278 | ASSERT_NO_FATAL_FAILURE(InitFramework(m_errorMonitor)); |
| 1279 | bool maintenance1 = false; |
| 1280 | if (DeviceExtensionSupported(gpu(), nullptr, VK_KHR_MAINTENANCE1_EXTENSION_NAME)) { |
| 1281 | m_device_extension_names.push_back(VK_KHR_MAINTENANCE1_EXTENSION_NAME); |
| 1282 | maintenance1 = true; |
| 1283 | } |
| 1284 | ASSERT_NO_FATAL_FAILURE(InitState()); |
| 1285 | |
| 1286 | VkFormat image_format = VK_FORMAT_B8G8R8A8_UNORM; |
| 1287 | VkFormatProperties format_props; |
| 1288 | vk::GetPhysicalDeviceFormatProperties(m_device->phy().handle(), image_format, &format_props); |
| 1289 | if ((format_props.optimalTilingFeatures & (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT)) == 0) { |
| 1290 | printf("%s Transfer for format is not supported.\n", kSkipPrefix); |
| 1291 | return; |
| 1292 | } |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 1293 | |
| 1294 | // Create two images to copy between |
| 1295 | VkImageObj src_image_obj(m_device); |
| 1296 | VkImageObj dst_image_obj(m_device); |
| 1297 | |
| 1298 | VkImageCreateInfo image_create_info = {}; |
| 1299 | image_create_info.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO; |
| 1300 | image_create_info.pNext = NULL; |
| 1301 | image_create_info.imageType = VK_IMAGE_TYPE_2D; |
sfricke-samsung | 30b094c | 2020-05-30 11:42:11 -0700 | [diff] [blame] | 1302 | image_create_info.format = image_format; |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 1303 | image_create_info.extent.width = 32; |
| 1304 | image_create_info.extent.height = 32; |
| 1305 | image_create_info.extent.depth = 1; |
| 1306 | image_create_info.mipLevels = 1; |
| 1307 | image_create_info.arrayLayers = 4; |
| 1308 | image_create_info.samples = VK_SAMPLE_COUNT_1_BIT; |
| 1309 | image_create_info.tiling = VK_IMAGE_TILING_OPTIMAL; |
| 1310 | image_create_info.usage = VK_IMAGE_USAGE_TRANSFER_SRC_BIT; |
| 1311 | image_create_info.flags = 0; |
| 1312 | |
| 1313 | src_image_obj.init(&image_create_info); |
| 1314 | ASSERT_TRUE(src_image_obj.initialized()); |
| 1315 | |
| 1316 | image_create_info.usage = VK_IMAGE_USAGE_TRANSFER_DST_BIT; |
| 1317 | dst_image_obj.init(&image_create_info); |
| 1318 | ASSERT_TRUE(dst_image_obj.initialized()); |
| 1319 | |
| 1320 | m_commandBuffer->begin(); |
| 1321 | VkImageCopy copyRegion; |
| 1322 | copyRegion.srcSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; |
| 1323 | copyRegion.srcSubresource.mipLevel = 0; |
| 1324 | copyRegion.srcSubresource.baseArrayLayer = 0; |
| 1325 | copyRegion.srcSubresource.layerCount = 1; |
| 1326 | copyRegion.srcOffset.x = 0; |
| 1327 | copyRegion.srcOffset.y = 0; |
| 1328 | copyRegion.srcOffset.z = 0; |
| 1329 | copyRegion.dstSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; |
| 1330 | copyRegion.dstSubresource.mipLevel = 0; |
| 1331 | copyRegion.dstSubresource.baseArrayLayer = 0; |
| 1332 | // Introduce failure by forcing the dst layerCount to differ from src |
| 1333 | copyRegion.dstSubresource.layerCount = 3; |
| 1334 | copyRegion.dstOffset.x = 0; |
| 1335 | copyRegion.dstOffset.y = 0; |
| 1336 | copyRegion.dstOffset.z = 0; |
| 1337 | copyRegion.extent.width = 1; |
| 1338 | copyRegion.extent.height = 1; |
| 1339 | copyRegion.extent.depth = 1; |
| 1340 | |
sfricke-samsung | 30b094c | 2020-05-30 11:42:11 -0700 | [diff] [blame] | 1341 | const char *vuid = (maintenance1 == true) ? "VUID-VkImageCopy-extent-00140" : "VUID-VkImageCopy-layerCount-00138"; |
| 1342 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, vuid); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 1343 | m_commandBuffer->CopyImage(src_image_obj.image(), VK_IMAGE_LAYOUT_GENERAL, dst_image_obj.image(), VK_IMAGE_LAYOUT_GENERAL, 1, |
| 1344 | ©Region); |
| 1345 | m_errorMonitor->VerifyFound(); |
| 1346 | } |
| 1347 | |
| 1348 | TEST_F(VkLayerTest, CompressedImageMipCopyTests) { |
| 1349 | TEST_DESCRIPTION("Image/Buffer copies for higher mip levels"); |
| 1350 | |
| 1351 | ASSERT_NO_FATAL_FAILURE(Init()); |
| 1352 | |
| 1353 | VkPhysicalDeviceFeatures device_features = {}; |
| 1354 | ASSERT_NO_FATAL_FAILURE(GetPhysicalDeviceFeatures(&device_features)); |
| 1355 | VkFormat compressed_format = VK_FORMAT_UNDEFINED; |
| 1356 | if (device_features.textureCompressionBC) { |
| 1357 | compressed_format = VK_FORMAT_BC3_SRGB_BLOCK; |
| 1358 | } else if (device_features.textureCompressionETC2) { |
| 1359 | compressed_format = VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK; |
| 1360 | } else if (device_features.textureCompressionASTC_LDR) { |
| 1361 | compressed_format = VK_FORMAT_ASTC_4x4_UNORM_BLOCK; |
| 1362 | } else { |
| 1363 | printf("%s No compressed formats supported - CompressedImageMipCopyTests skipped.\n", kSkipPrefix); |
| 1364 | return; |
| 1365 | } |
| 1366 | |
| 1367 | VkImageCreateInfo ci; |
| 1368 | ci.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO; |
| 1369 | ci.pNext = NULL; |
| 1370 | ci.flags = 0; |
| 1371 | ci.imageType = VK_IMAGE_TYPE_2D; |
| 1372 | ci.format = compressed_format; |
| 1373 | ci.extent = {32, 32, 1}; |
| 1374 | ci.mipLevels = 6; |
| 1375 | ci.arrayLayers = 1; |
| 1376 | ci.samples = VK_SAMPLE_COUNT_1_BIT; |
| 1377 | ci.tiling = VK_IMAGE_TILING_OPTIMAL; |
| 1378 | ci.usage = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT; |
| 1379 | ci.sharingMode = VK_SHARING_MODE_EXCLUSIVE; |
| 1380 | ci.queueFamilyIndexCount = 0; |
| 1381 | ci.pQueueFamilyIndices = NULL; |
| 1382 | ci.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED; |
| 1383 | |
| 1384 | VkImageObj image(m_device); |
| 1385 | image.init(&ci); |
| 1386 | ASSERT_TRUE(image.initialized()); |
| 1387 | |
| 1388 | VkImageObj odd_image(m_device); |
| 1389 | ci.extent = {31, 32, 1}; // Mips are [31,32] [15,16] [7,8] [3,4], [1,2] [1,1] |
| 1390 | odd_image.init(&ci); |
| 1391 | ASSERT_TRUE(odd_image.initialized()); |
| 1392 | |
| 1393 | // Allocate buffers |
| 1394 | VkMemoryPropertyFlags reqs = 0; |
| 1395 | VkBufferObj buffer_1024, buffer_64, buffer_16, buffer_8; |
| 1396 | buffer_1024.init_as_src_and_dst(*m_device, 1024, reqs); |
| 1397 | buffer_64.init_as_src_and_dst(*m_device, 64, reqs); |
| 1398 | buffer_16.init_as_src_and_dst(*m_device, 16, reqs); |
| 1399 | buffer_8.init_as_src_and_dst(*m_device, 8, reqs); |
| 1400 | |
| 1401 | VkBufferImageCopy region = {}; |
| 1402 | region.bufferRowLength = 0; |
| 1403 | region.bufferImageHeight = 0; |
| 1404 | region.imageSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; |
| 1405 | region.imageSubresource.layerCount = 1; |
| 1406 | region.imageOffset = {0, 0, 0}; |
| 1407 | region.bufferOffset = 0; |
| 1408 | |
| 1409 | // start recording |
| 1410 | m_commandBuffer->begin(); |
| 1411 | |
| 1412 | // Mip level copies that work - 5 levels |
| 1413 | m_errorMonitor->ExpectSuccess(); |
| 1414 | |
| 1415 | // Mip 0 should fit in 1k buffer - 1k texels @ 1b each |
| 1416 | region.imageExtent = {32, 32, 1}; |
| 1417 | region.imageSubresource.mipLevel = 0; |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 1418 | vk::CmdCopyImageToBuffer(m_commandBuffer->handle(), image.handle(), VK_IMAGE_LAYOUT_GENERAL, buffer_1024.handle(), 1, ®ion); |
| 1419 | vk::CmdCopyBufferToImage(m_commandBuffer->handle(), buffer_1024.handle(), image.handle(), VK_IMAGE_LAYOUT_GENERAL, 1, ®ion); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 1420 | |
| 1421 | // Mip 2 should fit in 64b buffer - 64 texels @ 1b each |
| 1422 | region.imageExtent = {8, 8, 1}; |
| 1423 | region.imageSubresource.mipLevel = 2; |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 1424 | vk::CmdCopyImageToBuffer(m_commandBuffer->handle(), image.handle(), VK_IMAGE_LAYOUT_GENERAL, buffer_64.handle(), 1, ®ion); |
| 1425 | vk::CmdCopyBufferToImage(m_commandBuffer->handle(), buffer_64.handle(), image.handle(), VK_IMAGE_LAYOUT_GENERAL, 1, ®ion); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 1426 | |
| 1427 | // Mip 3 should fit in 16b buffer - 16 texels @ 1b each |
| 1428 | region.imageExtent = {4, 4, 1}; |
| 1429 | region.imageSubresource.mipLevel = 3; |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 1430 | vk::CmdCopyImageToBuffer(m_commandBuffer->handle(), image.handle(), VK_IMAGE_LAYOUT_GENERAL, buffer_16.handle(), 1, ®ion); |
| 1431 | vk::CmdCopyBufferToImage(m_commandBuffer->handle(), buffer_16.handle(), image.handle(), VK_IMAGE_LAYOUT_GENERAL, 1, ®ion); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 1432 | |
| 1433 | // Mip 4&5 should fit in 16b buffer with no complaint - 4 & 1 texels @ 1b each |
| 1434 | region.imageExtent = {2, 2, 1}; |
| 1435 | region.imageSubresource.mipLevel = 4; |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 1436 | vk::CmdCopyImageToBuffer(m_commandBuffer->handle(), image.handle(), VK_IMAGE_LAYOUT_GENERAL, buffer_16.handle(), 1, ®ion); |
| 1437 | vk::CmdCopyBufferToImage(m_commandBuffer->handle(), buffer_16.handle(), image.handle(), VK_IMAGE_LAYOUT_GENERAL, 1, ®ion); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 1438 | |
| 1439 | region.imageExtent = {1, 1, 1}; |
| 1440 | region.imageSubresource.mipLevel = 5; |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 1441 | vk::CmdCopyImageToBuffer(m_commandBuffer->handle(), image.handle(), VK_IMAGE_LAYOUT_GENERAL, buffer_16.handle(), 1, ®ion); |
| 1442 | vk::CmdCopyBufferToImage(m_commandBuffer->handle(), buffer_16.handle(), image.handle(), VK_IMAGE_LAYOUT_GENERAL, 1, ®ion); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 1443 | m_errorMonitor->VerifyNotFound(); |
| 1444 | |
| 1445 | // Buffer must accommodate a full compressed block, regardless of texel count |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 1446 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyImageToBuffer-pRegions-00183"); |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 1447 | vk::CmdCopyImageToBuffer(m_commandBuffer->handle(), image.handle(), VK_IMAGE_LAYOUT_GENERAL, buffer_8.handle(), 1, ®ion); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 1448 | m_errorMonitor->VerifyFound(); |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 1449 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyBufferToImage-pRegions-00171"); |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 1450 | vk::CmdCopyBufferToImage(m_commandBuffer->handle(), buffer_8.handle(), image.handle(), VK_IMAGE_LAYOUT_GENERAL, 1, ®ion); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 1451 | m_errorMonitor->VerifyFound(); |
| 1452 | |
sfricke-samsung | 3a10b92 | 2020-05-13 23:23:16 -0700 | [diff] [blame] | 1453 | std::string vuid; |
| 1454 | bool ycbcr = (DeviceExtensionEnabled(VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME) || |
| 1455 | (DeviceValidationVersion() >= VK_API_VERSION_1_1)); |
| 1456 | |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 1457 | // Copy width < compressed block size, but not the full mip width |
| 1458 | region.imageExtent = {1, 2, 1}; |
| 1459 | region.imageSubresource.mipLevel = 4; |
sfricke-samsung | 3a10b92 | 2020-05-13 23:23:16 -0700 | [diff] [blame] | 1460 | vuid = ycbcr ? "VUID-VkBufferImageCopy-None-01739" : "VUID-VkBufferImageCopy-imageExtent-00207"; |
| 1461 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, vuid); // width not a multiple of compressed block width |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 1462 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 1463 | "VUID-vkCmdCopyImageToBuffer-imageOffset-01794"); // image transfer granularity |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 1464 | vk::CmdCopyImageToBuffer(m_commandBuffer->handle(), image.handle(), VK_IMAGE_LAYOUT_GENERAL, buffer_16.handle(), 1, ®ion); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 1465 | m_errorMonitor->VerifyFound(); |
sfricke-samsung | 3a10b92 | 2020-05-13 23:23:16 -0700 | [diff] [blame] | 1466 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, vuid); // width not a multiple of compressed block width |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 1467 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 1468 | "VUID-vkCmdCopyBufferToImage-imageOffset-01793"); // image transfer granularity |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 1469 | vk::CmdCopyBufferToImage(m_commandBuffer->handle(), buffer_16.handle(), image.handle(), VK_IMAGE_LAYOUT_GENERAL, 1, ®ion); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 1470 | m_errorMonitor->VerifyFound(); |
| 1471 | |
| 1472 | // Copy height < compressed block size but not the full mip height |
| 1473 | region.imageExtent = {2, 1, 1}; |
sfricke-samsung | 3a10b92 | 2020-05-13 23:23:16 -0700 | [diff] [blame] | 1474 | vuid = ycbcr ? "VUID-VkBufferImageCopy-None-01740" : "VUID-VkBufferImageCopy-imageExtent-00208"; |
| 1475 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, vuid); // height not a multiple of compressed block width |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 1476 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 1477 | "VUID-vkCmdCopyImageToBuffer-imageOffset-01794"); // image transfer granularity |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 1478 | vk::CmdCopyImageToBuffer(m_commandBuffer->handle(), image.handle(), VK_IMAGE_LAYOUT_GENERAL, buffer_16.handle(), 1, ®ion); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 1479 | m_errorMonitor->VerifyFound(); |
sfricke-samsung | 3a10b92 | 2020-05-13 23:23:16 -0700 | [diff] [blame] | 1480 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, vuid); // height not a multiple of compressed block width |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 1481 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 1482 | "VUID-vkCmdCopyBufferToImage-imageOffset-01793"); // image transfer granularity |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 1483 | vk::CmdCopyBufferToImage(m_commandBuffer->handle(), buffer_16.handle(), image.handle(), VK_IMAGE_LAYOUT_GENERAL, 1, ®ion); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 1484 | m_errorMonitor->VerifyFound(); |
| 1485 | |
| 1486 | // Offsets must be multiple of compressed block size |
| 1487 | region.imageOffset = {1, 1, 0}; |
| 1488 | region.imageExtent = {1, 1, 1}; |
sfricke-samsung | 3a10b92 | 2020-05-13 23:23:16 -0700 | [diff] [blame] | 1489 | vuid = ycbcr ? "VUID-VkBufferImageCopy-None-01737" : "VUID-VkBufferImageCopy-imageOffset-00205"; |
| 1490 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, vuid); // imageOffset not a multiple of block size |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 1491 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 1492 | "VUID-vkCmdCopyImageToBuffer-imageOffset-01794"); // image transfer granularity |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 1493 | vk::CmdCopyImageToBuffer(m_commandBuffer->handle(), image.handle(), VK_IMAGE_LAYOUT_GENERAL, buffer_16.handle(), 1, ®ion); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 1494 | m_errorMonitor->VerifyFound(); |
sfricke-samsung | 3a10b92 | 2020-05-13 23:23:16 -0700 | [diff] [blame] | 1495 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, vuid); // imageOffset not a multiple of block size |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 1496 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 1497 | "VUID-vkCmdCopyBufferToImage-imageOffset-01793"); // image transfer granularity |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 1498 | vk::CmdCopyBufferToImage(m_commandBuffer->handle(), buffer_16.handle(), image.handle(), VK_IMAGE_LAYOUT_GENERAL, 1, ®ion); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 1499 | m_errorMonitor->VerifyFound(); |
| 1500 | |
| 1501 | // Offset + extent width = mip width - should succeed |
| 1502 | region.imageOffset = {4, 4, 0}; |
| 1503 | region.imageExtent = {3, 4, 1}; |
| 1504 | region.imageSubresource.mipLevel = 2; |
| 1505 | m_errorMonitor->ExpectSuccess(); |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 1506 | vk::CmdCopyImageToBuffer(m_commandBuffer->handle(), odd_image.handle(), VK_IMAGE_LAYOUT_GENERAL, buffer_16.handle(), 1, |
| 1507 | ®ion); |
| 1508 | vk::CmdCopyBufferToImage(m_commandBuffer->handle(), buffer_16.handle(), odd_image.handle(), VK_IMAGE_LAYOUT_GENERAL, 1, |
| 1509 | ®ion); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 1510 | m_errorMonitor->VerifyNotFound(); |
| 1511 | |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 1512 | // Offset + extent width < mip width and not a multiple of block width - should fail |
| 1513 | region.imageExtent = {3, 3, 1}; |
sfricke-samsung | 3a10b92 | 2020-05-13 23:23:16 -0700 | [diff] [blame] | 1514 | vuid = ycbcr ? "VUID-VkBufferImageCopy-None-01740" : "VUID-VkBufferImageCopy-imageExtent-00208"; |
| 1515 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, vuid); // offset+extent not a multiple of block width |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 1516 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 1517 | "VUID-vkCmdCopyImageToBuffer-imageOffset-01794"); // image transfer granularity |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 1518 | vk::CmdCopyImageToBuffer(m_commandBuffer->handle(), odd_image.handle(), VK_IMAGE_LAYOUT_GENERAL, buffer_16.handle(), 1, |
| 1519 | ®ion); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 1520 | m_errorMonitor->VerifyFound(); |
sfricke-samsung | 3a10b92 | 2020-05-13 23:23:16 -0700 | [diff] [blame] | 1521 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, vuid); // offset+extent not a multiple of block width |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 1522 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 1523 | "VUID-vkCmdCopyBufferToImage-imageOffset-01793"); // image transfer granularity |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 1524 | vk::CmdCopyBufferToImage(m_commandBuffer->handle(), buffer_16.handle(), odd_image.handle(), VK_IMAGE_LAYOUT_GENERAL, 1, |
| 1525 | ®ion); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 1526 | m_errorMonitor->VerifyFound(); |
| 1527 | } |
| 1528 | |
| 1529 | TEST_F(VkLayerTest, ImageBufferCopyTests) { |
| 1530 | TEST_DESCRIPTION("Image to buffer and buffer to image tests"); |
sfricke-samsung | 6d97e56 | 2020-01-07 22:01:00 -0800 | [diff] [blame] | 1531 | |
| 1532 | // Enable KHR multiplane req'd extensions for multi-planar copy tests |
| 1533 | bool mp_extensions = InstanceExtensionSupported(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME, |
| 1534 | VK_KHR_GET_MEMORY_REQUIREMENTS_2_SPEC_VERSION); |
| 1535 | if (mp_extensions) { |
| 1536 | m_instance_extension_names.push_back(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME); |
| 1537 | } |
Mark Lobodzinski | 09ce9c4 | 2020-03-06 10:02:44 -0700 | [diff] [blame] | 1538 | ASSERT_NO_FATAL_FAILURE(InitFramework(m_errorMonitor, nullptr)); |
sfricke-samsung | 6d97e56 | 2020-01-07 22:01:00 -0800 | [diff] [blame] | 1539 | mp_extensions = mp_extensions && DeviceExtensionSupported(gpu(), nullptr, VK_KHR_MAINTENANCE1_EXTENSION_NAME); |
| 1540 | mp_extensions = mp_extensions && DeviceExtensionSupported(gpu(), nullptr, VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME); |
| 1541 | mp_extensions = mp_extensions && DeviceExtensionSupported(gpu(), nullptr, VK_KHR_BIND_MEMORY_2_EXTENSION_NAME); |
| 1542 | mp_extensions = mp_extensions && DeviceExtensionSupported(gpu(), nullptr, VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME); |
| 1543 | if (mp_extensions) { |
| 1544 | m_device_extension_names.push_back(VK_KHR_MAINTENANCE1_EXTENSION_NAME); |
| 1545 | m_device_extension_names.push_back(VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME); |
| 1546 | m_device_extension_names.push_back(VK_KHR_BIND_MEMORY_2_EXTENSION_NAME); |
| 1547 | m_device_extension_names.push_back(VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME); |
| 1548 | } |
| 1549 | ASSERT_NO_FATAL_FAILURE(InitState()); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 1550 | |
| 1551 | // Bail if any dimension of transfer granularity is 0. |
| 1552 | auto index = m_device->graphics_queue_node_index_; |
| 1553 | auto queue_family_properties = m_device->phy().queue_properties(); |
| 1554 | if ((queue_family_properties[index].minImageTransferGranularity.depth == 0) || |
| 1555 | (queue_family_properties[index].minImageTransferGranularity.width == 0) || |
| 1556 | (queue_family_properties[index].minImageTransferGranularity.height == 0)) { |
| 1557 | printf("%s Subresource copies are disallowed when xfer granularity (x|y|z) is 0. Skipped.\n", kSkipPrefix); |
| 1558 | return; |
| 1559 | } |
| 1560 | |
sfricke-samsung | 6d97e56 | 2020-01-07 22:01:00 -0800 | [diff] [blame] | 1561 | // All VkImageObj must be defined here as if defined inside below scopes will cause image memory to be deleted when out of scope |
| 1562 | // and invalidates the entire command buffer. This prevents from having to reset the commmand buffer every scope rgba |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 1563 | VkImageObj image_64k(m_device); // 128^2 texels, 64k |
| 1564 | VkImageObj image_16k(m_device); // 64^2 texels, 16k |
sfricke-samsung | 6d97e56 | 2020-01-07 22:01:00 -0800 | [diff] [blame] | 1565 | // depth stencil |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 1566 | VkImageObj image_16k_depth(m_device); // 64^2 texels, depth, 16k |
| 1567 | VkImageObj ds_image_4D_1S(m_device); // 256^2 texels, 512kb (256k depth, 64k stencil, 192k pack) |
| 1568 | VkImageObj ds_image_3D_1S(m_device); // 256^2 texels, 256kb (192k depth, 64k stencil) |
| 1569 | VkImageObj ds_image_2D(m_device); // 256^2 texels, 128k (128k depth) |
| 1570 | VkImageObj ds_image_1S(m_device); // 256^2 texels, 64k (64k stencil) |
sfricke-samsung | 6d97e56 | 2020-01-07 22:01:00 -0800 | [diff] [blame] | 1571 | // compression |
| 1572 | VkImageObj image_16k_4x4comp(m_device); // 128^2 texels as 32^2 compressed (4x4) blocks, 16k |
| 1573 | VkImageObj image_NPOT_4x4comp(m_device); // 130^2 texels as 33^2 compressed (4x4) blocks |
| 1574 | // multi-planar |
| 1575 | VkImageObj image_multi_planar(m_device); // 128^2 texels in plane_0 and 64^2 texels in plane_1 |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 1576 | |
sfricke-samsung | 6d97e56 | 2020-01-07 22:01:00 -0800 | [diff] [blame] | 1577 | // Verify R8G8B8A8_UINT format is supported for transfer |
| 1578 | bool missing_rgba_support = false; |
| 1579 | VkFormatProperties props = {0, 0, 0}; |
| 1580 | vk::GetPhysicalDeviceFormatProperties(m_device->phy().handle(), VK_FORMAT_R8G8B8A8_UINT, &props); |
| 1581 | missing_rgba_support |= (props.bufferFeatures == 0 && props.linearTilingFeatures == 0 && props.optimalTilingFeatures == 0); |
| 1582 | missing_rgba_support |= (props.optimalTilingFeatures & VK_FORMAT_FEATURE_TRANSFER_SRC_BIT) == 0; |
| 1583 | missing_rgba_support |= (props.optimalTilingFeatures & VK_FORMAT_FEATURE_TRANSFER_DST_BIT) == 0; |
| 1584 | |
| 1585 | if (!missing_rgba_support) { |
| 1586 | image_64k.Init(128, 128, 1, VK_FORMAT_R8G8B8A8_UINT, |
| 1587 | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT, |
| 1588 | VK_IMAGE_TILING_OPTIMAL, 0); |
| 1589 | ASSERT_TRUE(image_64k.initialized()); |
| 1590 | |
| 1591 | image_16k.Init(64, 64, 1, VK_FORMAT_R8G8B8A8_UINT, |
| 1592 | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT, |
| 1593 | VK_IMAGE_TILING_OPTIMAL, 0); |
| 1594 | ASSERT_TRUE(image_16k.initialized()); |
| 1595 | } |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 1596 | |
| 1597 | // Verify all needed Depth/Stencil formats are supported |
| 1598 | bool missing_ds_support = false; |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 1599 | vk::GetPhysicalDeviceFormatProperties(m_device->phy().handle(), VK_FORMAT_D32_SFLOAT_S8_UINT, &props); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 1600 | missing_ds_support |= (props.bufferFeatures == 0 && props.linearTilingFeatures == 0 && props.optimalTilingFeatures == 0); |
| 1601 | missing_ds_support |= (props.optimalTilingFeatures & VK_FORMAT_FEATURE_TRANSFER_SRC_BIT) == 0; |
| 1602 | missing_ds_support |= (props.optimalTilingFeatures & VK_FORMAT_FEATURE_TRANSFER_DST_BIT) == 0; |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 1603 | vk::GetPhysicalDeviceFormatProperties(m_device->phy().handle(), VK_FORMAT_D24_UNORM_S8_UINT, &props); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 1604 | missing_ds_support |= (props.bufferFeatures == 0 && props.linearTilingFeatures == 0 && props.optimalTilingFeatures == 0); |
| 1605 | missing_ds_support |= (props.optimalTilingFeatures & VK_FORMAT_FEATURE_TRANSFER_SRC_BIT) == 0; |
| 1606 | missing_ds_support |= (props.optimalTilingFeatures & VK_FORMAT_FEATURE_TRANSFER_DST_BIT) == 0; |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 1607 | vk::GetPhysicalDeviceFormatProperties(m_device->phy().handle(), VK_FORMAT_D16_UNORM, &props); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 1608 | missing_ds_support |= (props.bufferFeatures == 0 && props.linearTilingFeatures == 0 && props.optimalTilingFeatures == 0); |
| 1609 | missing_ds_support |= (props.optimalTilingFeatures & VK_FORMAT_FEATURE_TRANSFER_SRC_BIT) == 0; |
| 1610 | missing_ds_support |= (props.optimalTilingFeatures & VK_FORMAT_FEATURE_TRANSFER_DST_BIT) == 0; |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 1611 | vk::GetPhysicalDeviceFormatProperties(m_device->phy().handle(), VK_FORMAT_S8_UINT, &props); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 1612 | missing_ds_support |= (props.bufferFeatures == 0 && props.linearTilingFeatures == 0 && props.optimalTilingFeatures == 0); |
| 1613 | missing_ds_support |= (props.optimalTilingFeatures & VK_FORMAT_FEATURE_TRANSFER_SRC_BIT) == 0; |
| 1614 | missing_ds_support |= (props.optimalTilingFeatures & VK_FORMAT_FEATURE_TRANSFER_DST_BIT) == 0; |
| 1615 | |
| 1616 | if (!missing_ds_support) { |
| 1617 | image_16k_depth.Init(64, 64, 1, VK_FORMAT_D24_UNORM_S8_UINT, |
| 1618 | VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT, VK_IMAGE_TILING_OPTIMAL, 0); |
| 1619 | ASSERT_TRUE(image_16k_depth.initialized()); |
| 1620 | |
| 1621 | ds_image_4D_1S.Init( |
| 1622 | 256, 256, 1, VK_FORMAT_D32_SFLOAT_S8_UINT, |
| 1623 | VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, |
| 1624 | VK_IMAGE_TILING_OPTIMAL, 0); |
| 1625 | ASSERT_TRUE(ds_image_4D_1S.initialized()); |
| 1626 | |
| 1627 | ds_image_3D_1S.Init( |
| 1628 | 256, 256, 1, VK_FORMAT_D24_UNORM_S8_UINT, |
| 1629 | VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, |
| 1630 | VK_IMAGE_TILING_OPTIMAL, 0); |
| 1631 | ASSERT_TRUE(ds_image_3D_1S.initialized()); |
| 1632 | |
| 1633 | ds_image_2D.Init( |
| 1634 | 256, 256, 1, VK_FORMAT_D16_UNORM, |
| 1635 | VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, |
| 1636 | VK_IMAGE_TILING_OPTIMAL, 0); |
| 1637 | ASSERT_TRUE(ds_image_2D.initialized()); |
| 1638 | |
| 1639 | ds_image_1S.Init( |
| 1640 | 256, 256, 1, VK_FORMAT_S8_UINT, |
| 1641 | VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, |
| 1642 | VK_IMAGE_TILING_OPTIMAL, 0); |
| 1643 | ASSERT_TRUE(ds_image_1S.initialized()); |
| 1644 | } |
| 1645 | |
| 1646 | // Allocate buffers |
| 1647 | VkBufferObj buffer_256k, buffer_128k, buffer_64k, buffer_16k; |
| 1648 | VkMemoryPropertyFlags reqs = 0; |
| 1649 | buffer_256k.init_as_src_and_dst(*m_device, 262144, reqs); // 256k |
| 1650 | buffer_128k.init_as_src_and_dst(*m_device, 131072, reqs); // 128k |
| 1651 | buffer_64k.init_as_src_and_dst(*m_device, 65536, reqs); // 64k |
| 1652 | buffer_16k.init_as_src_and_dst(*m_device, 16384, reqs); // 16k |
| 1653 | |
| 1654 | VkBufferImageCopy region = {}; |
| 1655 | region.bufferRowLength = 0; |
| 1656 | region.bufferImageHeight = 0; |
| 1657 | region.imageSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; |
| 1658 | region.imageSubresource.layerCount = 1; |
| 1659 | region.imageOffset = {0, 0, 0}; |
| 1660 | region.imageExtent = {64, 64, 1}; |
| 1661 | region.bufferOffset = 0; |
| 1662 | |
sfricke-samsung | 6d97e56 | 2020-01-07 22:01:00 -0800 | [diff] [blame] | 1663 | if (missing_rgba_support) { |
| 1664 | printf("%s R8G8B8A8_UINT transfer unsupported - skipping RGBA tests.\n", kSkipPrefix); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 1665 | |
sfricke-samsung | 6d97e56 | 2020-01-07 22:01:00 -0800 | [diff] [blame] | 1666 | // start recording for future tests |
| 1667 | m_commandBuffer->begin(); |
| 1668 | } else { |
| 1669 | // attempt copies before putting command buffer in recording state |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 1670 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyBufferToImage-commandBuffer-recording"); |
sfricke-samsung | 6d97e56 | 2020-01-07 22:01:00 -0800 | [diff] [blame] | 1671 | vk::CmdCopyBufferToImage(m_commandBuffer->handle(), buffer_64k.handle(), image_64k.handle(), VK_IMAGE_LAYOUT_GENERAL, 1, |
| 1672 | ®ion); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 1673 | m_errorMonitor->VerifyFound(); |
| 1674 | |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 1675 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyImageToBuffer-commandBuffer-recording"); |
sfricke-samsung | 6d97e56 | 2020-01-07 22:01:00 -0800 | [diff] [blame] | 1676 | vk::CmdCopyImageToBuffer(m_commandBuffer->handle(), image_64k.handle(), VK_IMAGE_LAYOUT_GENERAL, buffer_64k.handle(), 1, |
| 1677 | ®ion); |
| 1678 | m_errorMonitor->VerifyFound(); |
| 1679 | |
| 1680 | // start recording |
| 1681 | m_commandBuffer->begin(); |
| 1682 | |
| 1683 | // successful copies |
| 1684 | m_errorMonitor->ExpectSuccess(); |
| 1685 | vk::CmdCopyImageToBuffer(m_commandBuffer->handle(), image_16k.handle(), VK_IMAGE_LAYOUT_GENERAL, buffer_16k.handle(), 1, |
| 1686 | ®ion); |
| 1687 | vk::CmdCopyBufferToImage(m_commandBuffer->handle(), buffer_16k.handle(), image_16k.handle(), VK_IMAGE_LAYOUT_GENERAL, 1, |
| 1688 | ®ion); |
| 1689 | region.imageOffset.x = 16; // 16k copy, offset requires larger image |
| 1690 | vk::CmdCopyImageToBuffer(m_commandBuffer->handle(), image_64k.handle(), VK_IMAGE_LAYOUT_GENERAL, buffer_16k.handle(), 1, |
| 1691 | ®ion); |
| 1692 | region.imageExtent.height = 78; // > 16k copy requires larger buffer & image |
| 1693 | vk::CmdCopyBufferToImage(m_commandBuffer->handle(), buffer_64k.handle(), image_64k.handle(), VK_IMAGE_LAYOUT_GENERAL, 1, |
| 1694 | ®ion); |
| 1695 | region.imageOffset.x = 0; |
| 1696 | region.imageExtent.height = 64; |
| 1697 | region.bufferOffset = 256; // 16k copy with buffer offset, requires larger buffer |
| 1698 | vk::CmdCopyImageToBuffer(m_commandBuffer->handle(), image_16k.handle(), VK_IMAGE_LAYOUT_GENERAL, buffer_64k.handle(), 1, |
| 1699 | ®ion); |
| 1700 | m_errorMonitor->VerifyNotFound(); |
| 1701 | |
| 1702 | // image/buffer too small (extent too large) on copy to image |
| 1703 | region.imageExtent = {65, 64, 1}; |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 1704 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, |
sfricke-samsung | 6d97e56 | 2020-01-07 22:01:00 -0800 | [diff] [blame] | 1705 | "VUID-vkCmdCopyBufferToImage-pRegions-00171"); // buffer too small |
| 1706 | vk::CmdCopyBufferToImage(m_commandBuffer->handle(), buffer_16k.handle(), image_64k.handle(), VK_IMAGE_LAYOUT_GENERAL, 1, |
| 1707 | ®ion); |
| 1708 | m_errorMonitor->VerifyFound(); |
| 1709 | |
| 1710 | m_errorMonitor->SetUnexpectedError("VUID-VkBufferImageCopy-imageOffset-00197"); |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 1711 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, |
sfricke-samsung | 6d97e56 | 2020-01-07 22:01:00 -0800 | [diff] [blame] | 1712 | "VUID-vkCmdCopyBufferToImage-pRegions-00172"); // image too small |
| 1713 | vk::CmdCopyBufferToImage(m_commandBuffer->handle(), buffer_64k.handle(), image_16k.handle(), VK_IMAGE_LAYOUT_GENERAL, 1, |
| 1714 | ®ion); |
| 1715 | m_errorMonitor->VerifyFound(); |
| 1716 | |
| 1717 | // image/buffer too small (offset) on copy to image |
| 1718 | region.imageExtent = {64, 64, 1}; |
| 1719 | region.imageOffset = {0, 4, 0}; |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 1720 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, |
sfricke-samsung | 6d97e56 | 2020-01-07 22:01:00 -0800 | [diff] [blame] | 1721 | "VUID-vkCmdCopyBufferToImage-pRegions-00171"); // buffer too small |
| 1722 | vk::CmdCopyBufferToImage(m_commandBuffer->handle(), buffer_16k.handle(), image_64k.handle(), VK_IMAGE_LAYOUT_GENERAL, 1, |
| 1723 | ®ion); |
| 1724 | m_errorMonitor->VerifyFound(); |
| 1725 | |
| 1726 | m_errorMonitor->SetUnexpectedError("VUID-VkBufferImageCopy-imageOffset-00197"); |
| 1727 | m_errorMonitor->SetUnexpectedError("VUID-VkBufferImageCopy-imageOffset-00198"); |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 1728 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, |
sfricke-samsung | 6d97e56 | 2020-01-07 22:01:00 -0800 | [diff] [blame] | 1729 | "VUID-vkCmdCopyBufferToImage-pRegions-00172"); // image too small |
| 1730 | vk::CmdCopyBufferToImage(m_commandBuffer->handle(), buffer_64k.handle(), image_16k.handle(), VK_IMAGE_LAYOUT_GENERAL, 1, |
| 1731 | ®ion); |
| 1732 | m_errorMonitor->VerifyFound(); |
| 1733 | |
| 1734 | // image/buffer too small on copy to buffer |
| 1735 | region.imageExtent = {64, 64, 1}; |
| 1736 | region.imageOffset = {0, 0, 0}; |
| 1737 | region.bufferOffset = 4; |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 1738 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, |
sfricke-samsung | 6d97e56 | 2020-01-07 22:01:00 -0800 | [diff] [blame] | 1739 | "VUID-vkCmdCopyImageToBuffer-pRegions-00183"); // buffer too small |
| 1740 | vk::CmdCopyImageToBuffer(m_commandBuffer->handle(), image_64k.handle(), VK_IMAGE_LAYOUT_GENERAL, buffer_16k.handle(), 1, |
| 1741 | ®ion); |
| 1742 | m_errorMonitor->VerifyFound(); |
| 1743 | |
| 1744 | region.imageExtent = {64, 65, 1}; |
| 1745 | region.bufferOffset = 0; |
| 1746 | m_errorMonitor->SetUnexpectedError("VUID-VkBufferImageCopy-imageOffset-00198"); |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 1747 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, |
sfricke-samsung | 6d97e56 | 2020-01-07 22:01:00 -0800 | [diff] [blame] | 1748 | "VUID-vkCmdCopyImageToBuffer-pRegions-00182"); // image too small |
| 1749 | vk::CmdCopyImageToBuffer(m_commandBuffer->handle(), image_16k.handle(), VK_IMAGE_LAYOUT_GENERAL, buffer_64k.handle(), 1, |
| 1750 | ®ion); |
| 1751 | m_errorMonitor->VerifyFound(); |
| 1752 | |
| 1753 | // buffer size OK but rowlength causes loose packing |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 1754 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyImageToBuffer-pRegions-00183"); |
sfricke-samsung | 6d97e56 | 2020-01-07 22:01:00 -0800 | [diff] [blame] | 1755 | region.imageExtent = {64, 64, 1}; |
| 1756 | region.bufferRowLength = 68; |
| 1757 | vk::CmdCopyImageToBuffer(m_commandBuffer->handle(), image_16k.handle(), VK_IMAGE_LAYOUT_GENERAL, buffer_16k.handle(), 1, |
| 1758 | ®ion); |
| 1759 | m_errorMonitor->VerifyFound(); |
| 1760 | |
| 1761 | // An extent with zero area should produce a warning, but no error |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 1762 | m_errorMonitor->SetDesiredFailureMsg(kWarningBit | kErrorBit, "} has zero area"); |
sfricke-samsung | 6d97e56 | 2020-01-07 22:01:00 -0800 | [diff] [blame] | 1763 | region.imageExtent.width = 0; |
| 1764 | vk::CmdCopyImageToBuffer(m_commandBuffer->handle(), image_16k.handle(), VK_IMAGE_LAYOUT_GENERAL, buffer_16k.handle(), 1, |
| 1765 | ®ion); |
| 1766 | m_errorMonitor->VerifyFound(); |
| 1767 | |
| 1768 | // aspect bits |
| 1769 | region.imageExtent = {64, 64, 1}; |
| 1770 | region.bufferRowLength = 0; |
| 1771 | region.bufferImageHeight = 0; |
| 1772 | if (!missing_ds_support) { |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 1773 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, |
sfricke-samsung | 6d97e56 | 2020-01-07 22:01:00 -0800 | [diff] [blame] | 1774 | "VUID-VkBufferImageCopy-aspectMask-00212"); // more than 1 aspect bit set |
| 1775 | region.imageSubresource.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT; |
| 1776 | vk::CmdCopyImageToBuffer(m_commandBuffer->handle(), image_16k_depth.handle(), VK_IMAGE_LAYOUT_GENERAL, |
| 1777 | buffer_16k.handle(), 1, ®ion); |
| 1778 | m_errorMonitor->VerifyFound(); |
| 1779 | |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 1780 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, |
sfricke-samsung | 6d97e56 | 2020-01-07 22:01:00 -0800 | [diff] [blame] | 1781 | "VUID-VkBufferImageCopy-aspectMask-00211"); // different mis-matched aspect |
| 1782 | region.imageSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; |
| 1783 | vk::CmdCopyImageToBuffer(m_commandBuffer->handle(), image_16k_depth.handle(), VK_IMAGE_LAYOUT_GENERAL, |
| 1784 | buffer_16k.handle(), 1, ®ion); |
| 1785 | m_errorMonitor->VerifyFound(); |
| 1786 | } |
| 1787 | |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 1788 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, |
sfricke-samsung | 6d97e56 | 2020-01-07 22:01:00 -0800 | [diff] [blame] | 1789 | "VUID-VkBufferImageCopy-aspectMask-00211"); // mis-matched aspect |
| 1790 | region.imageSubresource.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT; |
| 1791 | vk::CmdCopyImageToBuffer(m_commandBuffer->handle(), image_16k.handle(), VK_IMAGE_LAYOUT_GENERAL, buffer_16k.handle(), 1, |
| 1792 | ®ion); |
| 1793 | m_errorMonitor->VerifyFound(); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 1794 | region.imageSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; |
sfricke-samsung | 6d97e56 | 2020-01-07 22:01:00 -0800 | [diff] [blame] | 1795 | |
| 1796 | // Out-of-range mip levels should fail |
| 1797 | region.imageSubresource.mipLevel = image_16k.create_info().mipLevels + 1; |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 1798 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyImageToBuffer-imageSubresource-01703"); |
sfricke-samsung | 6d97e56 | 2020-01-07 22:01:00 -0800 | [diff] [blame] | 1799 | m_errorMonitor->SetUnexpectedError("VUID-VkBufferImageCopy-imageOffset-00197"); |
| 1800 | m_errorMonitor->SetUnexpectedError("VUID-VkBufferImageCopy-imageOffset-00198"); |
| 1801 | m_errorMonitor->SetUnexpectedError("VUID-VkBufferImageCopy-imageOffset-00200"); |
| 1802 | m_errorMonitor->SetDesiredFailureMsg( |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 1803 | kErrorBit, |
sfricke-samsung | 6d97e56 | 2020-01-07 22:01:00 -0800 | [diff] [blame] | 1804 | "VUID-vkCmdCopyImageToBuffer-pRegions-00182"); // unavoidable "region exceeds image bounds" for non-existent mip |
| 1805 | vk::CmdCopyImageToBuffer(m_commandBuffer->handle(), image_16k.handle(), VK_IMAGE_LAYOUT_GENERAL, buffer_16k.handle(), 1, |
| 1806 | ®ion); |
| 1807 | m_errorMonitor->VerifyFound(); |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 1808 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyBufferToImage-imageSubresource-01701"); |
sfricke-samsung | 6d97e56 | 2020-01-07 22:01:00 -0800 | [diff] [blame] | 1809 | m_errorMonitor->SetUnexpectedError("VUID-VkBufferImageCopy-imageOffset-00197"); |
| 1810 | m_errorMonitor->SetUnexpectedError("VUID-VkBufferImageCopy-imageOffset-00198"); |
| 1811 | m_errorMonitor->SetUnexpectedError("VUID-VkBufferImageCopy-imageOffset-00200"); |
| 1812 | m_errorMonitor->SetDesiredFailureMsg( |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 1813 | kErrorBit, |
sfricke-samsung | 6d97e56 | 2020-01-07 22:01:00 -0800 | [diff] [blame] | 1814 | "VUID-vkCmdCopyBufferToImage-pRegions-00172"); // unavoidable "region exceeds image bounds" for non-existent mip |
| 1815 | vk::CmdCopyBufferToImage(m_commandBuffer->handle(), buffer_16k.handle(), image_16k.handle(), VK_IMAGE_LAYOUT_GENERAL, 1, |
| 1816 | ®ion); |
| 1817 | m_errorMonitor->VerifyFound(); |
| 1818 | region.imageSubresource.mipLevel = 0; |
| 1819 | |
| 1820 | // Out-of-range array layers should fail |
| 1821 | region.imageSubresource.baseArrayLayer = image_16k.create_info().arrayLayers; |
| 1822 | region.imageSubresource.layerCount = 1; |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 1823 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyImageToBuffer-imageSubresource-01704"); |
sfricke-samsung | 6d97e56 | 2020-01-07 22:01:00 -0800 | [diff] [blame] | 1824 | vk::CmdCopyImageToBuffer(m_commandBuffer->handle(), image_16k.handle(), VK_IMAGE_LAYOUT_GENERAL, buffer_16k.handle(), 1, |
| 1825 | ®ion); |
| 1826 | m_errorMonitor->VerifyFound(); |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 1827 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyBufferToImage-imageSubresource-01702"); |
sfricke-samsung | 6d97e56 | 2020-01-07 22:01:00 -0800 | [diff] [blame] | 1828 | vk::CmdCopyBufferToImage(m_commandBuffer->handle(), buffer_16k.handle(), image_16k.handle(), VK_IMAGE_LAYOUT_GENERAL, 1, |
| 1829 | ®ion); |
| 1830 | m_errorMonitor->VerifyFound(); |
| 1831 | region.imageSubresource.baseArrayLayer = 0; |
| 1832 | |
| 1833 | // Layout mismatch should fail |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 1834 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyImageToBuffer-srcImageLayout-00189"); |
sfricke-samsung | 6d97e56 | 2020-01-07 22:01:00 -0800 | [diff] [blame] | 1835 | vk::CmdCopyImageToBuffer(m_commandBuffer->handle(), image_16k.handle(), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, |
| 1836 | buffer_16k.handle(), 1, ®ion); |
| 1837 | m_errorMonitor->VerifyFound(); |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 1838 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyBufferToImage-dstImageLayout-00180"); |
sfricke-samsung | 6d97e56 | 2020-01-07 22:01:00 -0800 | [diff] [blame] | 1839 | vk::CmdCopyBufferToImage(m_commandBuffer->handle(), buffer_16k.handle(), image_16k.handle(), |
| 1840 | VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, ®ion); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 1841 | m_errorMonitor->VerifyFound(); |
| 1842 | } |
| 1843 | |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 1844 | // Test Depth/Stencil copies |
| 1845 | if (missing_ds_support) { |
| 1846 | printf("%s Depth / Stencil formats unsupported - skipping D/S tests.\n", kSkipPrefix); |
| 1847 | } else { |
| 1848 | VkBufferImageCopy ds_region = {}; |
| 1849 | ds_region.bufferOffset = 0; |
| 1850 | ds_region.bufferRowLength = 0; |
| 1851 | ds_region.bufferImageHeight = 0; |
| 1852 | ds_region.imageSubresource.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT; |
| 1853 | ds_region.imageSubresource.mipLevel = 0; |
| 1854 | ds_region.imageSubresource.baseArrayLayer = 0; |
| 1855 | ds_region.imageSubresource.layerCount = 1; |
| 1856 | ds_region.imageOffset = {0, 0, 0}; |
| 1857 | ds_region.imageExtent = {256, 256, 1}; |
| 1858 | |
| 1859 | // Depth copies that should succeed |
| 1860 | m_errorMonitor->ExpectSuccess(); // Extract 4b depth per texel, pack into 256k buffer |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 1861 | vk::CmdCopyImageToBuffer(m_commandBuffer->handle(), ds_image_4D_1S.handle(), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, |
| 1862 | buffer_256k.handle(), 1, &ds_region); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 1863 | m_errorMonitor->VerifyNotFound(); |
| 1864 | |
| 1865 | m_errorMonitor->ExpectSuccess(); // Extract 3b depth per texel, pack (loose) into 256k buffer |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 1866 | vk::CmdCopyImageToBuffer(m_commandBuffer->handle(), ds_image_3D_1S.handle(), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, |
| 1867 | buffer_256k.handle(), 1, &ds_region); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 1868 | m_errorMonitor->VerifyNotFound(); |
| 1869 | |
| 1870 | m_errorMonitor->ExpectSuccess(); // Copy 2b depth per texel, into 128k buffer |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 1871 | vk::CmdCopyImageToBuffer(m_commandBuffer->handle(), ds_image_2D.handle(), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, |
| 1872 | buffer_128k.handle(), 1, &ds_region); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 1873 | m_errorMonitor->VerifyNotFound(); |
| 1874 | |
| 1875 | // Depth copies that should fail |
| 1876 | ds_region.bufferOffset = 4; |
| 1877 | m_errorMonitor->SetDesiredFailureMsg( |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 1878 | kErrorBit, |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 1879 | "VUID-vkCmdCopyImageToBuffer-pRegions-00183"); // Extract 4b depth per texel, pack into 256k buffer |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 1880 | vk::CmdCopyImageToBuffer(m_commandBuffer->handle(), ds_image_4D_1S.handle(), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, |
| 1881 | buffer_256k.handle(), 1, &ds_region); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 1882 | m_errorMonitor->VerifyFound(); |
| 1883 | |
| 1884 | m_errorMonitor->SetDesiredFailureMsg( |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 1885 | kErrorBit, |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 1886 | "VUID-vkCmdCopyImageToBuffer-pRegions-00183"); // Extract 3b depth per texel, pack (loose) into 256k buffer |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 1887 | vk::CmdCopyImageToBuffer(m_commandBuffer->handle(), ds_image_3D_1S.handle(), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, |
| 1888 | buffer_256k.handle(), 1, &ds_region); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 1889 | m_errorMonitor->VerifyFound(); |
| 1890 | |
| 1891 | m_errorMonitor->SetDesiredFailureMsg( |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 1892 | kErrorBit, |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 1893 | "VUID-vkCmdCopyImageToBuffer-pRegions-00183"); // Copy 2b depth per texel, into 128k buffer |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 1894 | vk::CmdCopyImageToBuffer(m_commandBuffer->handle(), ds_image_2D.handle(), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, |
| 1895 | buffer_128k.handle(), 1, &ds_region); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 1896 | m_errorMonitor->VerifyFound(); |
| 1897 | |
| 1898 | // Stencil copies that should succeed |
| 1899 | ds_region.bufferOffset = 0; |
| 1900 | ds_region.imageSubresource.aspectMask = VK_IMAGE_ASPECT_STENCIL_BIT; |
| 1901 | m_errorMonitor->ExpectSuccess(); // Extract 1b stencil per texel, pack into 64k buffer |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 1902 | vk::CmdCopyImageToBuffer(m_commandBuffer->handle(), ds_image_4D_1S.handle(), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, |
| 1903 | buffer_64k.handle(), 1, &ds_region); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 1904 | m_errorMonitor->VerifyNotFound(); |
| 1905 | |
| 1906 | m_errorMonitor->ExpectSuccess(); // Extract 1b stencil per texel, pack into 64k buffer |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 1907 | vk::CmdCopyImageToBuffer(m_commandBuffer->handle(), ds_image_3D_1S.handle(), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, |
| 1908 | buffer_64k.handle(), 1, &ds_region); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 1909 | m_errorMonitor->VerifyNotFound(); |
| 1910 | |
| 1911 | m_errorMonitor->ExpectSuccess(); // Copy 1b depth per texel, into 64k buffer |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 1912 | vk::CmdCopyImageToBuffer(m_commandBuffer->handle(), ds_image_1S.handle(), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, |
| 1913 | buffer_64k.handle(), 1, &ds_region); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 1914 | m_errorMonitor->VerifyNotFound(); |
| 1915 | |
| 1916 | // Stencil copies that should fail |
| 1917 | m_errorMonitor->SetDesiredFailureMsg( |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 1918 | kErrorBit, |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 1919 | "VUID-vkCmdCopyImageToBuffer-pRegions-00183"); // Extract 1b stencil per texel, pack into 64k buffer |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 1920 | vk::CmdCopyImageToBuffer(m_commandBuffer->handle(), ds_image_4D_1S.handle(), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, |
| 1921 | buffer_16k.handle(), 1, &ds_region); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 1922 | m_errorMonitor->VerifyFound(); |
| 1923 | |
| 1924 | m_errorMonitor->SetDesiredFailureMsg( |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 1925 | kErrorBit, |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 1926 | "VUID-vkCmdCopyImageToBuffer-pRegions-00183"); // Extract 1b stencil per texel, pack into 64k buffer |
| 1927 | ds_region.bufferRowLength = 260; |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 1928 | vk::CmdCopyImageToBuffer(m_commandBuffer->handle(), ds_image_3D_1S.handle(), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, |
| 1929 | buffer_64k.handle(), 1, &ds_region); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 1930 | m_errorMonitor->VerifyFound(); |
| 1931 | |
| 1932 | ds_region.bufferRowLength = 0; |
| 1933 | ds_region.bufferOffset = 4; |
| 1934 | m_errorMonitor->SetDesiredFailureMsg( |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 1935 | kErrorBit, |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 1936 | "VUID-vkCmdCopyImageToBuffer-pRegions-00183"); // Copy 1b depth per texel, into 64k buffer |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 1937 | vk::CmdCopyImageToBuffer(m_commandBuffer->handle(), ds_image_1S.handle(), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, |
| 1938 | buffer_64k.handle(), 1, &ds_region); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 1939 | m_errorMonitor->VerifyFound(); |
| 1940 | } |
| 1941 | |
| 1942 | // Test compressed formats, if supported |
sfricke-samsung | 6d97e56 | 2020-01-07 22:01:00 -0800 | [diff] [blame] | 1943 | // Support here requires both feature bit for compression and picked format supports transfer feature bits |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 1944 | VkPhysicalDeviceFeatures device_features = {}; |
| 1945 | ASSERT_NO_FATAL_FAILURE(GetPhysicalDeviceFeatures(&device_features)); |
| 1946 | if (!(device_features.textureCompressionBC || device_features.textureCompressionETC2 || |
| 1947 | device_features.textureCompressionASTC_LDR)) { |
| 1948 | printf("%s No compressed formats supported - block compression tests skipped.\n", kSkipPrefix); |
| 1949 | } else { |
sfricke-samsung | 6d97e56 | 2020-01-07 22:01:00 -0800 | [diff] [blame] | 1950 | // Verify transfer support for each compression format used blow |
| 1951 | bool missing_bc_support = false; |
| 1952 | bool missing_etc_support = false; |
| 1953 | bool missing_astc_support = false; |
| 1954 | bool missing_compression_support = false; |
| 1955 | |
| 1956 | vk::GetPhysicalDeviceFormatProperties(m_device->phy().handle(), VK_FORMAT_BC3_SRGB_BLOCK, &props); |
| 1957 | missing_bc_support |= (props.bufferFeatures == 0 && props.linearTilingFeatures == 0 && props.optimalTilingFeatures == 0); |
| 1958 | missing_bc_support |= (props.optimalTilingFeatures & VK_FORMAT_FEATURE_TRANSFER_SRC_BIT) == 0; |
| 1959 | missing_bc_support |= (props.optimalTilingFeatures & VK_FORMAT_FEATURE_TRANSFER_DST_BIT) == 0; |
| 1960 | |
| 1961 | vk::GetPhysicalDeviceFormatProperties(m_device->phy().handle(), VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK, &props); |
| 1962 | missing_etc_support |= (props.bufferFeatures == 0 && props.linearTilingFeatures == 0 && props.optimalTilingFeatures == 0); |
| 1963 | missing_etc_support |= (props.optimalTilingFeatures & VK_FORMAT_FEATURE_TRANSFER_SRC_BIT) == 0; |
| 1964 | missing_etc_support |= (props.optimalTilingFeatures & VK_FORMAT_FEATURE_TRANSFER_DST_BIT) == 0; |
| 1965 | |
| 1966 | vk::GetPhysicalDeviceFormatProperties(m_device->phy().handle(), VK_FORMAT_ASTC_4x4_UNORM_BLOCK, &props); |
| 1967 | missing_astc_support |= (props.bufferFeatures == 0 && props.linearTilingFeatures == 0 && props.optimalTilingFeatures == 0); |
| 1968 | missing_astc_support |= (props.optimalTilingFeatures & VK_FORMAT_FEATURE_TRANSFER_SRC_BIT) == 0; |
| 1969 | missing_astc_support |= (props.optimalTilingFeatures & VK_FORMAT_FEATURE_TRANSFER_DST_BIT) == 0; |
| 1970 | |
| 1971 | if (device_features.textureCompressionBC && (!missing_bc_support)) { |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 1972 | image_16k_4x4comp.Init(128, 128, 1, VK_FORMAT_BC3_SRGB_BLOCK, VK_IMAGE_USAGE_TRANSFER_SRC_BIT, VK_IMAGE_TILING_OPTIMAL, |
| 1973 | 0); |
| 1974 | image_NPOT_4x4comp.Init(130, 130, 1, VK_FORMAT_BC3_SRGB_BLOCK, VK_IMAGE_USAGE_TRANSFER_SRC_BIT, VK_IMAGE_TILING_OPTIMAL, |
| 1975 | 0); |
sfricke-samsung | 6d97e56 | 2020-01-07 22:01:00 -0800 | [diff] [blame] | 1976 | } else if (device_features.textureCompressionETC2 && (!missing_etc_support)) { |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 1977 | image_16k_4x4comp.Init(128, 128, 1, VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK, VK_IMAGE_USAGE_TRANSFER_SRC_BIT, |
| 1978 | VK_IMAGE_TILING_OPTIMAL, 0); |
| 1979 | image_NPOT_4x4comp.Init(130, 130, 1, VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK, VK_IMAGE_USAGE_TRANSFER_SRC_BIT, |
| 1980 | VK_IMAGE_TILING_OPTIMAL, 0); |
sfricke-samsung | 6d97e56 | 2020-01-07 22:01:00 -0800 | [diff] [blame] | 1981 | } else if (device_features.textureCompressionASTC_LDR && (!missing_astc_support)) { |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 1982 | image_16k_4x4comp.Init(128, 128, 1, VK_FORMAT_ASTC_4x4_UNORM_BLOCK, VK_IMAGE_USAGE_TRANSFER_SRC_BIT, |
| 1983 | VK_IMAGE_TILING_OPTIMAL, 0); |
| 1984 | image_NPOT_4x4comp.Init(130, 130, 1, VK_FORMAT_ASTC_4x4_UNORM_BLOCK, VK_IMAGE_USAGE_TRANSFER_SRC_BIT, |
| 1985 | VK_IMAGE_TILING_OPTIMAL, 0); |
sfricke-samsung | 6d97e56 | 2020-01-07 22:01:00 -0800 | [diff] [blame] | 1986 | } else { |
| 1987 | missing_compression_support = true; |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 1988 | } |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 1989 | |
sfricke-samsung | 6d97e56 | 2020-01-07 22:01:00 -0800 | [diff] [blame] | 1990 | if (missing_compression_support) { |
| 1991 | printf("%s No compressed formats transfers bits are supported - block compression tests skipped.\n", kSkipPrefix); |
| 1992 | } else { |
| 1993 | ASSERT_TRUE(image_16k_4x4comp.initialized()); |
sfricke-samsung | 3a10b92 | 2020-05-13 23:23:16 -0700 | [diff] [blame] | 1994 | std::string vuid; |
sfricke-samsung | 6d97e56 | 2020-01-07 22:01:00 -0800 | [diff] [blame] | 1995 | // Just fits |
| 1996 | m_errorMonitor->ExpectSuccess(); |
| 1997 | region.imageExtent = {128, 128, 1}; |
| 1998 | vk::CmdCopyImageToBuffer(m_commandBuffer->handle(), image_16k_4x4comp.handle(), VK_IMAGE_LAYOUT_GENERAL, |
| 1999 | buffer_16k.handle(), 1, ®ion); |
| 2000 | m_errorMonitor->VerifyNotFound(); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 2001 | |
sfricke-samsung | 6d97e56 | 2020-01-07 22:01:00 -0800 | [diff] [blame] | 2002 | // with offset, too big for buffer |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 2003 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyImageToBuffer-pRegions-00183"); |
sfricke-samsung | 6d97e56 | 2020-01-07 22:01:00 -0800 | [diff] [blame] | 2004 | region.bufferOffset = 16; |
| 2005 | vk::CmdCopyImageToBuffer(m_commandBuffer->handle(), image_16k_4x4comp.handle(), VK_IMAGE_LAYOUT_GENERAL, |
| 2006 | buffer_16k.handle(), 1, ®ion); |
| 2007 | m_errorMonitor->VerifyFound(); |
| 2008 | region.bufferOffset = 0; |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 2009 | |
sfricke-samsung | 6d97e56 | 2020-01-07 22:01:00 -0800 | [diff] [blame] | 2010 | // extents that are not a multiple of compressed block size |
sfricke-samsung | 3a10b92 | 2020-05-13 23:23:16 -0700 | [diff] [blame] | 2011 | vuid = mp_extensions ? "VUID-VkBufferImageCopy-None-01739" : "VUID-VkBufferImageCopy-imageExtent-00207"; |
| 2012 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, vuid); // extent width not a multiple of block size |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 2013 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, |
sfricke-samsung | 6d97e56 | 2020-01-07 22:01:00 -0800 | [diff] [blame] | 2014 | "VUID-vkCmdCopyImageToBuffer-imageOffset-01794"); // image transfer granularity |
| 2015 | region.imageExtent.width = 66; |
| 2016 | vk::CmdCopyImageToBuffer(m_commandBuffer->handle(), image_NPOT_4x4comp.handle(), VK_IMAGE_LAYOUT_GENERAL, |
| 2017 | buffer_16k.handle(), 1, ®ion); |
| 2018 | m_errorMonitor->VerifyFound(); |
| 2019 | region.imageExtent.width = 128; |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 2020 | |
sfricke-samsung | 3a10b92 | 2020-05-13 23:23:16 -0700 | [diff] [blame] | 2021 | vuid = mp_extensions ? "VUID-VkBufferImageCopy-None-01740" : "VUID-VkBufferImageCopy-imageExtent-00208"; |
| 2022 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, vuid); // extent height not a multiple of block size |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 2023 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, |
sfricke-samsung | 6d97e56 | 2020-01-07 22:01:00 -0800 | [diff] [blame] | 2024 | "VUID-vkCmdCopyImageToBuffer-imageOffset-01794"); // image transfer granularity |
| 2025 | region.imageExtent.height = 2; |
| 2026 | vk::CmdCopyImageToBuffer(m_commandBuffer->handle(), image_NPOT_4x4comp.handle(), VK_IMAGE_LAYOUT_GENERAL, |
| 2027 | buffer_16k.handle(), 1, ®ion); |
| 2028 | m_errorMonitor->VerifyFound(); |
| 2029 | region.imageExtent.height = 128; |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 2030 | |
sfricke-samsung | 6d97e56 | 2020-01-07 22:01:00 -0800 | [diff] [blame] | 2031 | // TODO: All available compressed formats are 2D, with block depth of 1. Unable to provoke VU_01277. |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 2032 | |
sfricke-samsung | 6d97e56 | 2020-01-07 22:01:00 -0800 | [diff] [blame] | 2033 | // non-multiple extents are allowed if at the far edge of a non-block-multiple image - these should pass |
| 2034 | m_errorMonitor->ExpectSuccess(); |
| 2035 | region.imageExtent.width = 66; |
| 2036 | region.imageOffset.x = 64; |
| 2037 | vk::CmdCopyImageToBuffer(m_commandBuffer->handle(), image_NPOT_4x4comp.handle(), VK_IMAGE_LAYOUT_GENERAL, |
| 2038 | buffer_16k.handle(), 1, ®ion); |
| 2039 | region.imageExtent.width = 16; |
| 2040 | region.imageOffset.x = 0; |
| 2041 | region.imageExtent.height = 2; |
| 2042 | region.imageOffset.y = 128; |
| 2043 | vk::CmdCopyImageToBuffer(m_commandBuffer->handle(), image_NPOT_4x4comp.handle(), VK_IMAGE_LAYOUT_GENERAL, |
| 2044 | buffer_16k.handle(), 1, ®ion); |
| 2045 | m_errorMonitor->VerifyNotFound(); |
| 2046 | region.imageOffset = {0, 0, 0}; |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 2047 | |
sfricke-samsung | 6d97e56 | 2020-01-07 22:01:00 -0800 | [diff] [blame] | 2048 | // buffer offset must be a multiple of texel block size (16) |
sfricke-samsung | 3a10b92 | 2020-05-13 23:23:16 -0700 | [diff] [blame] | 2049 | vuid = mp_extensions ? "VUID-VkBufferImageCopy-None-01738" : "VUID-VkBufferImageCopy-bufferOffset-00206"; |
| 2050 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, vuid); |
sfricke-samsung | 125d2b4 | 2020-05-28 06:32:43 -0700 | [diff] [blame] | 2051 | vuid = mp_extensions ? "VUID-VkBufferImageCopy-bufferOffset-01558" : "VUID-VkBufferImageCopy-bufferOffset-00193"; |
| 2052 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, vuid); |
sfricke-samsung | 6d97e56 | 2020-01-07 22:01:00 -0800 | [diff] [blame] | 2053 | region.imageExtent = {64, 64, 1}; |
| 2054 | region.bufferOffset = 24; |
| 2055 | vk::CmdCopyImageToBuffer(m_commandBuffer->handle(), image_16k_4x4comp.handle(), VK_IMAGE_LAYOUT_GENERAL, |
| 2056 | buffer_16k.handle(), 1, ®ion); |
| 2057 | m_errorMonitor->VerifyFound(); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 2058 | |
sfricke-samsung | 6d97e56 | 2020-01-07 22:01:00 -0800 | [diff] [blame] | 2059 | // rowlength not a multiple of block width (4) |
sfricke-samsung | 3a10b92 | 2020-05-13 23:23:16 -0700 | [diff] [blame] | 2060 | vuid = mp_extensions ? "VUID-VkBufferImageCopy-None-01735" : "VUID-VkBufferImageCopy-bufferRowLength-00203"; |
| 2061 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, vuid); |
sfricke-samsung | 6d97e56 | 2020-01-07 22:01:00 -0800 | [diff] [blame] | 2062 | region.bufferOffset = 0; |
| 2063 | region.bufferRowLength = 130; |
| 2064 | region.bufferImageHeight = 0; |
| 2065 | vk::CmdCopyImageToBuffer(m_commandBuffer->handle(), image_16k_4x4comp.handle(), VK_IMAGE_LAYOUT_GENERAL, |
| 2066 | buffer_64k.handle(), 1, ®ion); |
| 2067 | m_errorMonitor->VerifyFound(); |
| 2068 | |
| 2069 | // imageheight not a multiple of block height (4) |
sfricke-samsung | 3a10b92 | 2020-05-13 23:23:16 -0700 | [diff] [blame] | 2070 | vuid = mp_extensions ? "VUID-VkBufferImageCopy-None-01736" : "VUID-VkBufferImageCopy-bufferImageHeight-00204"; |
| 2071 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, vuid); |
sfricke-samsung | 6d97e56 | 2020-01-07 22:01:00 -0800 | [diff] [blame] | 2072 | region.bufferRowLength = 0; |
| 2073 | region.bufferImageHeight = 130; |
| 2074 | vk::CmdCopyImageToBuffer(m_commandBuffer->handle(), image_16k_4x4comp.handle(), VK_IMAGE_LAYOUT_GENERAL, |
| 2075 | buffer_64k.handle(), 1, ®ion); |
| 2076 | m_errorMonitor->VerifyFound(); |
| 2077 | } |
| 2078 | } |
| 2079 | |
| 2080 | // Test multi-planar formats, if supported |
| 2081 | if (!mp_extensions) { |
| 2082 | printf("%s multi-planar extensions not supported; skipped.\n", kSkipPrefix); |
| 2083 | } else { |
| 2084 | // Try to use G8_B8R8_2PLANE_420_UNORM because need 2-plane format for some tests and likely supported due to copy support |
| 2085 | // being required with samplerYcbcrConversion feature |
| 2086 | bool missing_mp_support = false; |
| 2087 | vk::GetPhysicalDeviceFormatProperties(m_device->phy().handle(), VK_FORMAT_G8_B8R8_2PLANE_420_UNORM, &props); |
| 2088 | missing_mp_support |= (props.bufferFeatures == 0 && props.linearTilingFeatures == 0 && props.optimalTilingFeatures == 0); |
| 2089 | missing_mp_support |= (props.optimalTilingFeatures & VK_FORMAT_FEATURE_TRANSFER_SRC_BIT) == 0; |
| 2090 | missing_mp_support |= (props.optimalTilingFeatures & VK_FORMAT_FEATURE_TRANSFER_DST_BIT) == 0; |
| 2091 | |
| 2092 | if (missing_mp_support) { |
| 2093 | printf("%s VK_FORMAT_G8_B8R8_2PLANE_420_UNORM transfer not supported; skipped.\n", kSkipPrefix); |
| 2094 | } else { |
| 2095 | VkBufferImageCopy mp_region = {}; |
| 2096 | mp_region.bufferOffset = 0; |
| 2097 | mp_region.bufferRowLength = 0; |
| 2098 | mp_region.bufferImageHeight = 0; |
| 2099 | mp_region.imageSubresource.mipLevel = 0; |
| 2100 | mp_region.imageSubresource.baseArrayLayer = 0; |
| 2101 | mp_region.imageSubresource.layerCount = 1; |
| 2102 | mp_region.imageOffset = {0, 0, 0}; |
| 2103 | mp_region.imageExtent = {128, 128, 1}; |
| 2104 | |
| 2105 | // YUV420 means 1/2 width and height so plane_0 is 128x128 and plane_1 is 64x64 here |
| 2106 | image_multi_planar.Init(128, 128, 1, VK_FORMAT_G8_B8R8_2PLANE_420_UNORM, VK_IMAGE_USAGE_TRANSFER_DST_BIT, |
| 2107 | VK_IMAGE_TILING_OPTIMAL, 0); |
| 2108 | ASSERT_TRUE(image_multi_planar.initialized()); |
| 2109 | |
| 2110 | // Copies into a mutli-planar image aspect properly |
| 2111 | m_errorMonitor->ExpectSuccess(); |
| 2112 | mp_region.imageSubresource.aspectMask = VK_IMAGE_ASPECT_PLANE_0_BIT; |
| 2113 | vk::CmdCopyBufferToImage(m_commandBuffer->handle(), buffer_16k.handle(), image_multi_planar.handle(), |
| 2114 | VK_IMAGE_LAYOUT_GENERAL, 1, &mp_region); |
| 2115 | m_errorMonitor->VerifyNotFound(); |
| 2116 | |
| 2117 | // uses plane_2 without being 3 planar format |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 2118 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkBufferImageCopy-aspectMask-01560"); |
sfricke-samsung | 6d97e56 | 2020-01-07 22:01:00 -0800 | [diff] [blame] | 2119 | mp_region.imageSubresource.aspectMask = VK_IMAGE_ASPECT_PLANE_2_BIT; |
| 2120 | vk::CmdCopyBufferToImage(m_commandBuffer->handle(), buffer_16k.handle(), image_multi_planar.handle(), |
| 2121 | VK_IMAGE_LAYOUT_GENERAL, 1, &mp_region); |
| 2122 | m_errorMonitor->VerifyFound(); |
| 2123 | |
| 2124 | // uses single-plane aspect mask |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 2125 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkBufferImageCopy-aspectMask-01560"); |
sfricke-samsung | 6d97e56 | 2020-01-07 22:01:00 -0800 | [diff] [blame] | 2126 | mp_region.imageSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; |
| 2127 | vk::CmdCopyBufferToImage(m_commandBuffer->handle(), buffer_16k.handle(), image_multi_planar.handle(), |
| 2128 | VK_IMAGE_LAYOUT_GENERAL, 1, &mp_region); |
| 2129 | m_errorMonitor->VerifyFound(); |
sfricke-samsung | b616d3f | 2020-06-03 22:00:34 -0700 | [diff] [blame^] | 2130 | |
| 2131 | // buffer offset must be a multiple of texel block size for VK_FORMAT_R8G8_UNORM (2) |
| 2132 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkBufferImageCopy-bufferOffset-01559"); |
| 2133 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkBufferImageCopy-bufferOffset-00194"); |
| 2134 | mp_region.imageSubresource.aspectMask = VK_IMAGE_ASPECT_PLANE_1_BIT; |
| 2135 | mp_region.bufferOffset = 5; |
| 2136 | mp_region.imageExtent = {8, 8, 1}; |
| 2137 | vk::CmdCopyBufferToImage(m_commandBuffer->handle(), buffer_16k.handle(), image_multi_planar.handle(), |
| 2138 | VK_IMAGE_LAYOUT_GENERAL, 1, &mp_region); |
| 2139 | m_errorMonitor->VerifyFound(); |
sfricke-samsung | 6d97e56 | 2020-01-07 22:01:00 -0800 | [diff] [blame] | 2140 | } |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 2141 | } |
| 2142 | } |
| 2143 | |
| 2144 | TEST_F(VkLayerTest, MiscImageLayerTests) { |
| 2145 | TEST_DESCRIPTION("Image-related tests that don't belong elsewhere"); |
| 2146 | |
| 2147 | ASSERT_NO_FATAL_FAILURE(Init()); |
| 2148 | |
| 2149 | // TODO: Ideally we should check if a format is supported, before using it. |
| 2150 | VkImageObj image(m_device); |
| 2151 | image.Init(128, 128, 1, VK_FORMAT_R16G16B16A16_UINT, VK_IMAGE_USAGE_TRANSFER_DST_BIT, VK_IMAGE_TILING_OPTIMAL, 0); // 64bpp |
| 2152 | ASSERT_TRUE(image.initialized()); |
| 2153 | VkBufferObj buffer; |
| 2154 | VkMemoryPropertyFlags reqs = 0; |
| 2155 | buffer.init_as_src(*m_device, 128 * 128 * 8, reqs); |
| 2156 | VkBufferImageCopy region = {}; |
| 2157 | region.bufferRowLength = 128; |
| 2158 | region.bufferImageHeight = 128; |
| 2159 | region.imageSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; |
| 2160 | // layerCount can't be 0 - Expect MISMATCHED_IMAGE_ASPECT |
| 2161 | region.imageSubresource.layerCount = 1; |
| 2162 | region.imageExtent.height = 4; |
| 2163 | region.imageExtent.width = 4; |
| 2164 | region.imageExtent.depth = 1; |
| 2165 | |
| 2166 | VkImageObj image2(m_device); |
| 2167 | image2.Init(128, 128, 1, VK_FORMAT_R8G8_UNORM, VK_IMAGE_USAGE_TRANSFER_DST_BIT, VK_IMAGE_TILING_OPTIMAL, 0); // 16bpp |
| 2168 | ASSERT_TRUE(image2.initialized()); |
| 2169 | VkBufferObj buffer2; |
| 2170 | VkMemoryPropertyFlags reqs2 = 0; |
| 2171 | buffer2.init_as_src(*m_device, 128 * 128 * 2, reqs2); |
| 2172 | VkBufferImageCopy region2 = {}; |
| 2173 | region2.bufferRowLength = 128; |
| 2174 | region2.bufferImageHeight = 128; |
| 2175 | region2.imageSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; |
| 2176 | // layerCount can't be 0 - Expect MISMATCHED_IMAGE_ASPECT |
| 2177 | region2.imageSubresource.layerCount = 1; |
| 2178 | region2.imageExtent.height = 4; |
| 2179 | region2.imageExtent.width = 4; |
| 2180 | region2.imageExtent.depth = 1; |
| 2181 | m_commandBuffer->begin(); |
| 2182 | |
| 2183 | // Image must have offset.z of 0 and extent.depth of 1 |
| 2184 | // Introduce failure by setting imageExtent.depth to 0 |
| 2185 | region.imageExtent.depth = 0; |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 2186 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkBufferImageCopy-srcImage-00201"); |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 2187 | vk::CmdCopyBufferToImage(m_commandBuffer->handle(), buffer.handle(), image.handle(), VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, |
| 2188 | ®ion); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 2189 | m_errorMonitor->VerifyFound(); |
| 2190 | |
| 2191 | region.imageExtent.depth = 1; |
| 2192 | |
| 2193 | // Image must have offset.z of 0 and extent.depth of 1 |
| 2194 | // Introduce failure by setting imageOffset.z to 4 |
| 2195 | // Note: Also (unavoidably) triggers 'region exceeds image' #1228 |
| 2196 | region.imageOffset.z = 4; |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 2197 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkBufferImageCopy-srcImage-00201"); |
| 2198 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkBufferImageCopy-imageOffset-00200"); |
| 2199 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyBufferToImage-pRegions-00172"); |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 2200 | vk::CmdCopyBufferToImage(m_commandBuffer->handle(), buffer.handle(), image.handle(), VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, |
| 2201 | ®ion); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 2202 | m_errorMonitor->VerifyFound(); |
| 2203 | |
| 2204 | region.imageOffset.z = 0; |
| 2205 | // BufferOffset must be a multiple of the calling command's VkImage parameter's texel size |
| 2206 | // Introduce failure by setting bufferOffset to 1 and 1/2 texels |
| 2207 | region.bufferOffset = 4; |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 2208 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkBufferImageCopy-bufferOffset-00193"); |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 2209 | vk::CmdCopyBufferToImage(m_commandBuffer->handle(), buffer.handle(), image.handle(), VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, |
| 2210 | ®ion); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 2211 | m_errorMonitor->VerifyFound(); |
| 2212 | |
| 2213 | // BufferOffset must be a multiple of 4 |
| 2214 | // Introduce failure by setting bufferOffset to a value not divisible by 4 |
| 2215 | region2.bufferOffset = 6; |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 2216 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkBufferImageCopy-bufferOffset-00194"); |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 2217 | vk::CmdCopyBufferToImage(m_commandBuffer->handle(), buffer2.handle(), image2.handle(), VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, |
| 2218 | ®ion2); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 2219 | m_errorMonitor->VerifyFound(); |
| 2220 | |
| 2221 | // BufferRowLength must be 0, or greater than or equal to the width member of imageExtent |
| 2222 | region.bufferOffset = 0; |
| 2223 | region.imageExtent.height = 128; |
| 2224 | region.imageExtent.width = 128; |
| 2225 | // Introduce failure by setting bufferRowLength > 0 but less than width |
| 2226 | region.bufferRowLength = 64; |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 2227 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkBufferImageCopy-bufferRowLength-00195"); |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 2228 | vk::CmdCopyBufferToImage(m_commandBuffer->handle(), buffer.handle(), image.handle(), VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, |
| 2229 | ®ion); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 2230 | m_errorMonitor->VerifyFound(); |
| 2231 | |
| 2232 | // BufferImageHeight must be 0, or greater than or equal to the height member of imageExtent |
| 2233 | region.bufferRowLength = 128; |
| 2234 | // Introduce failure by setting bufferRowHeight > 0 but less than height |
| 2235 | region.bufferImageHeight = 64; |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 2236 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkBufferImageCopy-bufferImageHeight-00196"); |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 2237 | vk::CmdCopyBufferToImage(m_commandBuffer->handle(), buffer.handle(), image.handle(), VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, |
| 2238 | ®ion); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 2239 | m_errorMonitor->VerifyFound(); |
| 2240 | |
| 2241 | region.bufferImageHeight = 128; |
| 2242 | VkImageObj intImage1(m_device); |
| 2243 | intImage1.Init(128, 128, 1, VK_FORMAT_R8_UNORM, VK_IMAGE_USAGE_TRANSFER_SRC_BIT, VK_IMAGE_TILING_OPTIMAL, 0); |
| 2244 | intImage1.SetLayout(VK_IMAGE_ASPECT_COLOR_BIT, VK_IMAGE_LAYOUT_GENERAL); |
| 2245 | VkImageObj intImage2(m_device); |
| 2246 | intImage2.Init(128, 128, 1, VK_FORMAT_R8_UNORM, VK_IMAGE_USAGE_TRANSFER_DST_BIT, VK_IMAGE_TILING_OPTIMAL, 0); |
| 2247 | intImage2.SetLayout(VK_IMAGE_ASPECT_COLOR_BIT, VK_IMAGE_LAYOUT_GENERAL); |
| 2248 | VkImageBlit blitRegion = {}; |
| 2249 | blitRegion.srcSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; |
| 2250 | blitRegion.srcSubresource.baseArrayLayer = 0; |
| 2251 | blitRegion.srcSubresource.layerCount = 1; |
| 2252 | blitRegion.srcSubresource.mipLevel = 0; |
| 2253 | blitRegion.dstSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; |
| 2254 | blitRegion.dstSubresource.baseArrayLayer = 0; |
| 2255 | blitRegion.dstSubresource.layerCount = 1; |
| 2256 | blitRegion.dstSubresource.mipLevel = 0; |
| 2257 | blitRegion.srcOffsets[0] = {128, 0, 0}; |
| 2258 | blitRegion.srcOffsets[1] = {128, 128, 1}; |
| 2259 | blitRegion.dstOffsets[0] = {0, 128, 0}; |
| 2260 | blitRegion.dstOffsets[1] = {128, 128, 1}; |
| 2261 | |
| 2262 | // Look for NULL-blit warning |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 2263 | m_errorMonitor->SetDesiredFailureMsg(kWarningBit, "vkCmdBlitImage(): pRegions[0].srcOffsets specify a zero-volume area."); |
| 2264 | m_errorMonitor->SetDesiredFailureMsg(kWarningBit, "vkCmdBlitImage(): pRegions[0].dstOffsets specify a zero-volume area."); |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 2265 | vk::CmdBlitImage(m_commandBuffer->handle(), intImage1.handle(), intImage1.Layout(), intImage2.handle(), intImage2.Layout(), 1, |
| 2266 | &blitRegion, VK_FILTER_LINEAR); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 2267 | m_errorMonitor->VerifyFound(); |
| 2268 | } |
| 2269 | |
| 2270 | TEST_F(VkLayerTest, CopyImageTypeExtentMismatch) { |
| 2271 | // Image copy tests where format type and extents don't match |
| 2272 | ASSERT_NO_FATAL_FAILURE(Init()); |
| 2273 | |
sfricke-samsung | 30b094c | 2020-05-30 11:42:11 -0700 | [diff] [blame] | 2274 | // Tests are designed to run without Maintenance1 which was promoted in 1.1 |
| 2275 | if (DeviceValidationVersion() >= VK_API_VERSION_1_1) { |
| 2276 | printf("%s Tests for 1.0 only, test skipped.\n", kSkipPrefix); |
| 2277 | return; |
| 2278 | } |
| 2279 | |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 2280 | VkImageCreateInfo ci; |
| 2281 | ci.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO; |
| 2282 | ci.pNext = NULL; |
| 2283 | ci.flags = 0; |
| 2284 | ci.imageType = VK_IMAGE_TYPE_1D; |
| 2285 | ci.format = VK_FORMAT_R8G8B8A8_UNORM; |
| 2286 | ci.extent = {32, 1, 1}; |
| 2287 | ci.mipLevels = 1; |
| 2288 | ci.arrayLayers = 1; |
| 2289 | ci.samples = VK_SAMPLE_COUNT_1_BIT; |
| 2290 | ci.tiling = VK_IMAGE_TILING_OPTIMAL; |
| 2291 | ci.usage = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT; |
| 2292 | ci.sharingMode = VK_SHARING_MODE_EXCLUSIVE; |
| 2293 | ci.queueFamilyIndexCount = 0; |
| 2294 | ci.pQueueFamilyIndices = NULL; |
| 2295 | ci.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED; |
| 2296 | |
| 2297 | // Create 1D image |
| 2298 | VkImageObj image_1D(m_device); |
| 2299 | image_1D.init(&ci); |
| 2300 | ASSERT_TRUE(image_1D.initialized()); |
| 2301 | |
| 2302 | // 2D image |
| 2303 | ci.imageType = VK_IMAGE_TYPE_2D; |
| 2304 | ci.extent = {32, 32, 1}; |
| 2305 | VkImageObj image_2D(m_device); |
| 2306 | image_2D.init(&ci); |
| 2307 | ASSERT_TRUE(image_2D.initialized()); |
| 2308 | |
| 2309 | // 3D image |
| 2310 | ci.imageType = VK_IMAGE_TYPE_3D; |
| 2311 | ci.extent = {32, 32, 8}; |
| 2312 | VkImageObj image_3D(m_device); |
| 2313 | image_3D.init(&ci); |
| 2314 | ASSERT_TRUE(image_3D.initialized()); |
| 2315 | |
| 2316 | // 2D image array |
| 2317 | ci.imageType = VK_IMAGE_TYPE_2D; |
| 2318 | ci.extent = {32, 32, 1}; |
| 2319 | ci.arrayLayers = 8; |
| 2320 | VkImageObj image_2D_array(m_device); |
| 2321 | image_2D_array.init(&ci); |
| 2322 | ASSERT_TRUE(image_2D_array.initialized()); |
| 2323 | |
| 2324 | m_commandBuffer->begin(); |
| 2325 | |
| 2326 | VkImageCopy copy_region; |
| 2327 | copy_region.extent = {32, 1, 1}; |
| 2328 | copy_region.srcSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; |
| 2329 | copy_region.dstSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; |
| 2330 | copy_region.srcSubresource.mipLevel = 0; |
| 2331 | copy_region.dstSubresource.mipLevel = 0; |
| 2332 | copy_region.srcSubresource.baseArrayLayer = 0; |
| 2333 | copy_region.dstSubresource.baseArrayLayer = 0; |
| 2334 | copy_region.srcSubresource.layerCount = 1; |
| 2335 | copy_region.dstSubresource.layerCount = 1; |
| 2336 | copy_region.srcOffset = {0, 0, 0}; |
| 2337 | copy_region.dstOffset = {0, 0, 0}; |
| 2338 | |
| 2339 | // Sanity check |
| 2340 | m_errorMonitor->ExpectSuccess(); |
| 2341 | m_commandBuffer->CopyImage(image_1D.image(), VK_IMAGE_LAYOUT_GENERAL, image_2D.image(), VK_IMAGE_LAYOUT_GENERAL, 1, |
| 2342 | ©_region); |
| 2343 | m_errorMonitor->VerifyNotFound(); |
| 2344 | |
| 2345 | // 1D texture w/ offset.y > 0. Source = VU 09c00124, dest = 09c00130 |
| 2346 | copy_region.srcOffset.y = 1; |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 2347 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageCopy-srcImage-00146"); |
| 2348 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageCopy-srcOffset-00145"); // also y-dim overrun |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 2349 | m_commandBuffer->CopyImage(image_1D.image(), VK_IMAGE_LAYOUT_GENERAL, image_2D.image(), VK_IMAGE_LAYOUT_GENERAL, 1, |
| 2350 | ©_region); |
| 2351 | m_errorMonitor->VerifyFound(); |
| 2352 | copy_region.srcOffset.y = 0; |
| 2353 | copy_region.dstOffset.y = 1; |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 2354 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageCopy-dstImage-00152"); |
| 2355 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageCopy-dstOffset-00151"); // also y-dim overrun |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 2356 | m_commandBuffer->CopyImage(image_2D.image(), VK_IMAGE_LAYOUT_GENERAL, image_1D.image(), VK_IMAGE_LAYOUT_GENERAL, 1, |
| 2357 | ©_region); |
| 2358 | m_errorMonitor->VerifyFound(); |
| 2359 | copy_region.dstOffset.y = 0; |
| 2360 | |
| 2361 | // 1D texture w/ extent.height > 1. Source = VU 09c00124, dest = 09c00130 |
| 2362 | copy_region.extent.height = 2; |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 2363 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageCopy-srcImage-00146"); |
| 2364 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageCopy-srcOffset-00145"); // also y-dim overrun |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 2365 | m_commandBuffer->CopyImage(image_1D.image(), VK_IMAGE_LAYOUT_GENERAL, image_2D.image(), VK_IMAGE_LAYOUT_GENERAL, 1, |
| 2366 | ©_region); |
| 2367 | m_errorMonitor->VerifyFound(); |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 2368 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageCopy-dstImage-00152"); |
| 2369 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageCopy-dstOffset-00151"); // also y-dim overrun |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 2370 | m_commandBuffer->CopyImage(image_2D.image(), VK_IMAGE_LAYOUT_GENERAL, image_1D.image(), VK_IMAGE_LAYOUT_GENERAL, 1, |
| 2371 | ©_region); |
| 2372 | m_errorMonitor->VerifyFound(); |
| 2373 | copy_region.extent.height = 1; |
| 2374 | |
| 2375 | // 1D texture w/ offset.z > 0. Source = VU 09c00df2, dest = 09c00df4 |
| 2376 | copy_region.srcOffset.z = 1; |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 2377 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageCopy-srcImage-01785"); |
| 2378 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageCopy-srcOffset-00147"); // also z-dim overrun |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 2379 | m_commandBuffer->CopyImage(image_1D.image(), VK_IMAGE_LAYOUT_GENERAL, image_2D.image(), VK_IMAGE_LAYOUT_GENERAL, 1, |
| 2380 | ©_region); |
| 2381 | m_errorMonitor->VerifyFound(); |
| 2382 | copy_region.srcOffset.z = 0; |
| 2383 | copy_region.dstOffset.z = 1; |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 2384 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageCopy-dstImage-01786"); |
| 2385 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageCopy-dstOffset-00153"); // also z-dim overrun |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 2386 | m_commandBuffer->CopyImage(image_2D.image(), VK_IMAGE_LAYOUT_GENERAL, image_1D.image(), VK_IMAGE_LAYOUT_GENERAL, 1, |
| 2387 | ©_region); |
| 2388 | m_errorMonitor->VerifyFound(); |
| 2389 | copy_region.dstOffset.z = 0; |
| 2390 | |
| 2391 | // 1D texture w/ extent.depth > 1. Source = VU 09c00df2, dest = 09c00df4 |
| 2392 | copy_region.extent.depth = 2; |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 2393 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageCopy-srcImage-01785"); |
| 2394 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 2395 | "VUID-VkImageCopy-srcOffset-00147"); // also z-dim overrun (src) |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 2396 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 2397 | "VUID-VkImageCopy-dstOffset-00153"); // also z-dim overrun (dst) |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 2398 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, |
sfricke-samsung | 211ee9c | 2020-02-13 23:38:39 -0800 | [diff] [blame] | 2399 | "VUID-VkImageCopy-srcImage-01789"); // 2D needs to be 1 pre-Vulkan 1.1 |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 2400 | m_commandBuffer->CopyImage(image_1D.image(), VK_IMAGE_LAYOUT_GENERAL, image_2D.image(), VK_IMAGE_LAYOUT_GENERAL, 1, |
| 2401 | ©_region); |
| 2402 | m_errorMonitor->VerifyFound(); |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 2403 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageCopy-dstImage-01786"); |
| 2404 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 2405 | "VUID-VkImageCopy-srcOffset-00147"); // also z-dim overrun (src) |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 2406 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 2407 | "VUID-VkImageCopy-dstOffset-00153"); // also z-dim overrun (dst) |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 2408 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, |
sfricke-samsung | 211ee9c | 2020-02-13 23:38:39 -0800 | [diff] [blame] | 2409 | "VUID-VkImageCopy-srcImage-01789"); // 2D needs to be 1 pre-Vulkan 1.1 |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 2410 | m_commandBuffer->CopyImage(image_2D.image(), VK_IMAGE_LAYOUT_GENERAL, image_1D.image(), VK_IMAGE_LAYOUT_GENERAL, 1, |
| 2411 | ©_region); |
| 2412 | m_errorMonitor->VerifyFound(); |
| 2413 | copy_region.extent.depth = 1; |
| 2414 | |
| 2415 | // 2D texture w/ offset.z > 0. Source = VU 09c00df6, dest = 09c00df8 |
| 2416 | copy_region.extent = {16, 16, 1}; |
| 2417 | copy_region.srcOffset.z = 4; |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 2418 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageCopy-srcImage-01787"); |
| 2419 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 2420 | "VUID-VkImageCopy-srcOffset-00147"); // also z-dim overrun (src) |
| 2421 | m_commandBuffer->CopyImage(image_2D.image(), VK_IMAGE_LAYOUT_GENERAL, image_3D.image(), VK_IMAGE_LAYOUT_GENERAL, 1, |
| 2422 | ©_region); |
| 2423 | m_errorMonitor->VerifyFound(); |
| 2424 | copy_region.srcOffset.z = 0; |
| 2425 | copy_region.dstOffset.z = 1; |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 2426 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageCopy-dstImage-01788"); |
| 2427 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 2428 | "VUID-VkImageCopy-dstOffset-00153"); // also z-dim overrun (dst) |
| 2429 | m_commandBuffer->CopyImage(image_3D.image(), VK_IMAGE_LAYOUT_GENERAL, image_2D.image(), VK_IMAGE_LAYOUT_GENERAL, 1, |
| 2430 | ©_region); |
| 2431 | m_errorMonitor->VerifyFound(); |
| 2432 | copy_region.dstOffset.z = 0; |
| 2433 | |
| 2434 | // 3D texture accessing an array layer other than 0. VU 09c0011a |
| 2435 | copy_region.extent = {4, 4, 1}; |
| 2436 | copy_region.srcSubresource.baseArrayLayer = 1; |
sfricke-samsung | 30b094c | 2020-05-30 11:42:11 -0700 | [diff] [blame] | 2437 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageCopy-srcImage-00139"); |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 2438 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 2439 | "VUID-vkCmdCopyImage-srcSubresource-01698"); // also 'too many layers' |
| 2440 | m_commandBuffer->CopyImage(image_3D.image(), VK_IMAGE_LAYOUT_GENERAL, image_2D.image(), VK_IMAGE_LAYOUT_GENERAL, 1, |
| 2441 | ©_region); |
| 2442 | m_errorMonitor->VerifyFound(); |
sfricke-samsung | 211ee9c | 2020-02-13 23:38:39 -0800 | [diff] [blame] | 2443 | copy_region.srcSubresource.baseArrayLayer = 0; |
| 2444 | |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 2445 | m_commandBuffer->end(); |
| 2446 | } |
| 2447 | |
| 2448 | TEST_F(VkLayerTest, CopyImageTypeExtentMismatchMaintenance1) { |
| 2449 | // Image copy tests where format type and extents don't match and the Maintenance1 extension is enabled |
Mark Lobodzinski | 09ce9c4 | 2020-03-06 10:02:44 -0700 | [diff] [blame] | 2450 | ASSERT_NO_FATAL_FAILURE(InitFramework(m_errorMonitor)); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 2451 | if (DeviceExtensionSupported(gpu(), nullptr, VK_KHR_MAINTENANCE1_EXTENSION_NAME)) { |
| 2452 | m_device_extension_names.push_back(VK_KHR_MAINTENANCE1_EXTENSION_NAME); |
| 2453 | } else { |
| 2454 | printf("%s Maintenance1 extension cannot be enabled, test skipped.\n", kSkipPrefix); |
| 2455 | return; |
| 2456 | } |
| 2457 | ASSERT_NO_FATAL_FAILURE(InitState()); |
| 2458 | |
| 2459 | VkFormat image_format = VK_FORMAT_R8G8B8A8_UNORM; |
| 2460 | VkFormatProperties format_props; |
| 2461 | // TODO: Remove this check if or when devsim handles extensions. |
| 2462 | // The chosen format has mandatory support the transfer src and dst format features when Maitenance1 is enabled. However, our |
| 2463 | // use of devsim and the mock ICD violate this guarantee. |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 2464 | vk::GetPhysicalDeviceFormatProperties(m_device->phy().handle(), image_format, &format_props); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 2465 | if (!(format_props.optimalTilingFeatures & VK_FORMAT_FEATURE_TRANSFER_SRC_BIT)) { |
| 2466 | printf("%s Maintenance1 extension is not supported.\n", kSkipPrefix); |
| 2467 | return; |
| 2468 | } |
| 2469 | |
| 2470 | VkImageCreateInfo ci; |
| 2471 | ci.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO; |
| 2472 | ci.pNext = NULL; |
| 2473 | ci.flags = 0; |
| 2474 | ci.imageType = VK_IMAGE_TYPE_1D; |
| 2475 | ci.format = image_format; |
| 2476 | ci.extent = {32, 1, 1}; |
| 2477 | ci.mipLevels = 1; |
| 2478 | ci.arrayLayers = 1; |
| 2479 | ci.samples = VK_SAMPLE_COUNT_1_BIT; |
| 2480 | ci.tiling = VK_IMAGE_TILING_OPTIMAL; |
| 2481 | ci.usage = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT; |
| 2482 | ci.sharingMode = VK_SHARING_MODE_EXCLUSIVE; |
| 2483 | ci.queueFamilyIndexCount = 0; |
| 2484 | ci.pQueueFamilyIndices = NULL; |
| 2485 | ci.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED; |
| 2486 | |
| 2487 | // Create 1D image |
| 2488 | VkImageObj image_1D(m_device); |
| 2489 | image_1D.init(&ci); |
| 2490 | ASSERT_TRUE(image_1D.initialized()); |
| 2491 | |
| 2492 | // 2D image |
| 2493 | ci.imageType = VK_IMAGE_TYPE_2D; |
| 2494 | ci.extent = {32, 32, 1}; |
| 2495 | VkImageObj image_2D(m_device); |
| 2496 | image_2D.init(&ci); |
| 2497 | ASSERT_TRUE(image_2D.initialized()); |
| 2498 | |
| 2499 | // 3D image |
| 2500 | ci.imageType = VK_IMAGE_TYPE_3D; |
| 2501 | ci.extent = {32, 32, 8}; |
| 2502 | VkImageObj image_3D(m_device); |
| 2503 | image_3D.init(&ci); |
| 2504 | ASSERT_TRUE(image_3D.initialized()); |
| 2505 | |
| 2506 | // 2D image array |
| 2507 | ci.imageType = VK_IMAGE_TYPE_2D; |
| 2508 | ci.extent = {32, 32, 1}; |
| 2509 | ci.arrayLayers = 8; |
| 2510 | VkImageObj image_2D_array(m_device); |
| 2511 | image_2D_array.init(&ci); |
| 2512 | ASSERT_TRUE(image_2D_array.initialized()); |
| 2513 | |
sfricke-samsung | 211ee9c | 2020-02-13 23:38:39 -0800 | [diff] [blame] | 2514 | // second 2D image array |
| 2515 | ci.imageType = VK_IMAGE_TYPE_2D; |
| 2516 | ci.extent = {32, 32, 1}; |
| 2517 | ci.arrayLayers = 8; |
| 2518 | VkImageObj image_2D_array_2(m_device); |
| 2519 | image_2D_array_2.init(&ci); |
| 2520 | ASSERT_TRUE(image_2D_array_2.initialized()); |
| 2521 | |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 2522 | m_commandBuffer->begin(); |
| 2523 | |
| 2524 | VkImageCopy copy_region; |
| 2525 | copy_region.extent = {32, 1, 1}; |
| 2526 | copy_region.srcSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; |
| 2527 | copy_region.dstSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; |
| 2528 | copy_region.srcSubresource.mipLevel = 0; |
| 2529 | copy_region.dstSubresource.mipLevel = 0; |
| 2530 | copy_region.srcSubresource.baseArrayLayer = 0; |
| 2531 | copy_region.dstSubresource.baseArrayLayer = 0; |
| 2532 | copy_region.srcSubresource.layerCount = 1; |
| 2533 | copy_region.dstSubresource.layerCount = 1; |
| 2534 | copy_region.srcOffset = {0, 0, 0}; |
| 2535 | copy_region.dstOffset = {0, 0, 0}; |
| 2536 | |
| 2537 | // Copy from layer not present |
| 2538 | copy_region.srcSubresource.baseArrayLayer = 4; |
| 2539 | copy_region.srcSubresource.layerCount = 6; |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 2540 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyImage-srcSubresource-01698"); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 2541 | m_commandBuffer->CopyImage(image_2D_array.image(), VK_IMAGE_LAYOUT_GENERAL, image_3D.image(), VK_IMAGE_LAYOUT_GENERAL, 1, |
| 2542 | ©_region); |
| 2543 | m_errorMonitor->VerifyFound(); |
| 2544 | copy_region.srcSubresource.baseArrayLayer = 0; |
| 2545 | copy_region.srcSubresource.layerCount = 1; |
| 2546 | |
| 2547 | // Copy to layer not present |
| 2548 | copy_region.dstSubresource.baseArrayLayer = 1; |
| 2549 | copy_region.dstSubresource.layerCount = 8; |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 2550 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyImage-dstSubresource-01699"); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 2551 | m_commandBuffer->CopyImage(image_3D.image(), VK_IMAGE_LAYOUT_GENERAL, image_2D_array.image(), VK_IMAGE_LAYOUT_GENERAL, 1, |
| 2552 | ©_region); |
| 2553 | m_errorMonitor->VerifyFound(); |
sfricke-samsung | 211ee9c | 2020-02-13 23:38:39 -0800 | [diff] [blame] | 2554 | copy_region.dstSubresource.baseArrayLayer = 0; |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 2555 | copy_region.dstSubresource.layerCount = 1; |
| 2556 | |
sfricke-samsung | 211ee9c | 2020-02-13 23:38:39 -0800 | [diff] [blame] | 2557 | // both 2D and extent.depth not 1 |
| 2558 | // Need two 2D array images to prevent other errors |
| 2559 | copy_region.extent = {4, 1, 2}; |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 2560 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageCopy-srcImage-01790"); |
sfricke-samsung | 211ee9c | 2020-02-13 23:38:39 -0800 | [diff] [blame] | 2561 | m_commandBuffer->CopyImage(image_2D_array.image(), VK_IMAGE_LAYOUT_GENERAL, image_2D_array_2.image(), VK_IMAGE_LAYOUT_GENERAL, |
| 2562 | 1, ©_region); |
| 2563 | m_errorMonitor->VerifyFound(); |
| 2564 | copy_region.extent = {32, 1, 1}; |
| 2565 | |
| 2566 | // 2D src / 3D dst and depth not equal to src layerCount |
| 2567 | copy_region.extent = {4, 1, 2}; |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 2568 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageCopy-srcImage-01791"); |
| 2569 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageCopy-extent-00140"); |
sfricke-samsung | 211ee9c | 2020-02-13 23:38:39 -0800 | [diff] [blame] | 2570 | m_commandBuffer->CopyImage(image_2D_array.image(), VK_IMAGE_LAYOUT_GENERAL, image_3D.image(), VK_IMAGE_LAYOUT_GENERAL, 1, |
| 2571 | ©_region); |
| 2572 | m_errorMonitor->VerifyFound(); |
| 2573 | copy_region.extent = {32, 1, 1}; |
| 2574 | |
| 2575 | // 3D src / 2D dst and depth not equal to dst layerCount |
| 2576 | copy_region.extent = {4, 1, 2}; |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 2577 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageCopy-dstImage-01792"); |
| 2578 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageCopy-extent-00140"); |
sfricke-samsung | 211ee9c | 2020-02-13 23:38:39 -0800 | [diff] [blame] | 2579 | m_commandBuffer->CopyImage(image_3D.image(), VK_IMAGE_LAYOUT_GENERAL, image_2D_array.image(), VK_IMAGE_LAYOUT_GENERAL, 1, |
| 2580 | ©_region); |
| 2581 | m_errorMonitor->VerifyFound(); |
| 2582 | copy_region.extent = {32, 1, 1}; |
| 2583 | |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 2584 | m_commandBuffer->end(); |
| 2585 | } |
| 2586 | |
| 2587 | TEST_F(VkLayerTest, CopyImageCompressedBlockAlignment) { |
| 2588 | // Image copy tests on compressed images with block alignment errors |
| 2589 | SetTargetApiVersion(VK_API_VERSION_1_1); |
| 2590 | ASSERT_NO_FATAL_FAILURE(Init()); |
| 2591 | |
| 2592 | // Select a compressed format and verify support |
| 2593 | VkPhysicalDeviceFeatures device_features = {}; |
| 2594 | ASSERT_NO_FATAL_FAILURE(GetPhysicalDeviceFeatures(&device_features)); |
| 2595 | VkFormat compressed_format = VK_FORMAT_UNDEFINED; |
| 2596 | if (device_features.textureCompressionBC) { |
| 2597 | compressed_format = VK_FORMAT_BC3_SRGB_BLOCK; |
| 2598 | } else if (device_features.textureCompressionETC2) { |
| 2599 | compressed_format = VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK; |
| 2600 | } else if (device_features.textureCompressionASTC_LDR) { |
| 2601 | compressed_format = VK_FORMAT_ASTC_4x4_UNORM_BLOCK; |
| 2602 | } |
| 2603 | |
| 2604 | VkImageCreateInfo ci; |
| 2605 | ci.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO; |
| 2606 | ci.pNext = NULL; |
| 2607 | ci.flags = 0; |
| 2608 | ci.imageType = VK_IMAGE_TYPE_2D; |
| 2609 | ci.format = compressed_format; |
| 2610 | ci.extent = {64, 64, 1}; |
| 2611 | ci.mipLevels = 1; |
| 2612 | ci.arrayLayers = 1; |
| 2613 | ci.samples = VK_SAMPLE_COUNT_1_BIT; |
| 2614 | ci.tiling = VK_IMAGE_TILING_OPTIMAL; |
| 2615 | ci.usage = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT; |
| 2616 | ci.sharingMode = VK_SHARING_MODE_EXCLUSIVE; |
| 2617 | ci.queueFamilyIndexCount = 0; |
| 2618 | ci.pQueueFamilyIndices = NULL; |
| 2619 | ci.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED; |
| 2620 | |
| 2621 | VkImageFormatProperties img_prop = {}; |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 2622 | if (VK_SUCCESS != vk::GetPhysicalDeviceImageFormatProperties(m_device->phy().handle(), ci.format, ci.imageType, ci.tiling, |
| 2623 | ci.usage, ci.flags, &img_prop)) { |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 2624 | printf("%s No compressed formats supported - CopyImageCompressedBlockAlignment skipped.\n", kSkipPrefix); |
| 2625 | return; |
| 2626 | } |
| 2627 | |
| 2628 | // Create images |
| 2629 | VkImageObj image_1(m_device); |
| 2630 | image_1.init(&ci); |
| 2631 | ASSERT_TRUE(image_1.initialized()); |
| 2632 | |
| 2633 | ci.extent = {62, 62, 1}; // slightly smaller and not divisible by block size |
| 2634 | VkImageObj image_2(m_device); |
| 2635 | image_2.init(&ci); |
| 2636 | ASSERT_TRUE(image_2.initialized()); |
| 2637 | |
| 2638 | m_commandBuffer->begin(); |
| 2639 | |
| 2640 | VkImageCopy copy_region; |
| 2641 | copy_region.extent = {48, 48, 1}; |
| 2642 | copy_region.srcSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; |
| 2643 | copy_region.dstSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; |
| 2644 | copy_region.srcSubresource.mipLevel = 0; |
| 2645 | copy_region.dstSubresource.mipLevel = 0; |
| 2646 | copy_region.srcSubresource.baseArrayLayer = 0; |
| 2647 | copy_region.dstSubresource.baseArrayLayer = 0; |
| 2648 | copy_region.srcSubresource.layerCount = 1; |
| 2649 | copy_region.dstSubresource.layerCount = 1; |
| 2650 | copy_region.srcOffset = {0, 0, 0}; |
| 2651 | copy_region.dstOffset = {0, 0, 0}; |
| 2652 | |
| 2653 | // Sanity check |
| 2654 | m_errorMonitor->ExpectSuccess(); |
| 2655 | m_commandBuffer->CopyImage(image_1.image(), VK_IMAGE_LAYOUT_GENERAL, image_2.image(), VK_IMAGE_LAYOUT_GENERAL, 1, ©_region); |
| 2656 | m_errorMonitor->VerifyNotFound(); |
| 2657 | |
| 2658 | std::string vuid; |
| 2659 | bool ycbcr = (DeviceExtensionEnabled(VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME) || |
| 2660 | (DeviceValidationVersion() >= VK_API_VERSION_1_1)); |
| 2661 | |
| 2662 | // Src, Dest offsets must be multiples of compressed block sizes {4, 4, 1} |
| 2663 | // Image transfer granularity gets set to compressed block size, so an ITG error is also (unavoidably) triggered. |
| 2664 | vuid = ycbcr ? "VUID-VkImageCopy-srcImage-01727" : "VUID-VkImageCopy-srcOffset-00157"; |
| 2665 | copy_region.srcOffset = {2, 4, 0}; // source width |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 2666 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, vuid); |
| 2667 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 2668 | "VUID-vkCmdCopyImage-srcOffset-01783"); // srcOffset image transfer granularity |
| 2669 | m_commandBuffer->CopyImage(image_1.image(), VK_IMAGE_LAYOUT_GENERAL, image_2.image(), VK_IMAGE_LAYOUT_GENERAL, 1, ©_region); |
| 2670 | m_errorMonitor->VerifyFound(); |
| 2671 | copy_region.srcOffset = {12, 1, 0}; // source height |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 2672 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, vuid); |
| 2673 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 2674 | "VUID-vkCmdCopyImage-srcOffset-01783"); // srcOffset image transfer granularity |
| 2675 | m_commandBuffer->CopyImage(image_1.image(), VK_IMAGE_LAYOUT_GENERAL, image_2.image(), VK_IMAGE_LAYOUT_GENERAL, 1, ©_region); |
| 2676 | m_errorMonitor->VerifyFound(); |
| 2677 | copy_region.srcOffset = {0, 0, 0}; |
| 2678 | |
| 2679 | vuid = ycbcr ? "VUID-VkImageCopy-dstImage-01731" : "VUID-VkImageCopy-dstOffset-00162"; |
| 2680 | copy_region.dstOffset = {1, 0, 0}; // dest width |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 2681 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, vuid); |
| 2682 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 2683 | "VUID-vkCmdCopyImage-dstOffset-01784"); // dstOffset image transfer granularity |
| 2684 | m_commandBuffer->CopyImage(image_1.image(), VK_IMAGE_LAYOUT_GENERAL, image_2.image(), VK_IMAGE_LAYOUT_GENERAL, 1, ©_region); |
| 2685 | m_errorMonitor->VerifyFound(); |
| 2686 | copy_region.dstOffset = {4, 1, 0}; // dest height |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 2687 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, vuid); |
| 2688 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 2689 | "VUID-vkCmdCopyImage-dstOffset-01784"); // dstOffset image transfer granularity |
| 2690 | m_commandBuffer->CopyImage(image_1.image(), VK_IMAGE_LAYOUT_GENERAL, image_2.image(), VK_IMAGE_LAYOUT_GENERAL, 1, ©_region); |
| 2691 | m_errorMonitor->VerifyFound(); |
| 2692 | copy_region.dstOffset = {0, 0, 0}; |
| 2693 | |
| 2694 | // Copy extent must be multiples of compressed block sizes {4, 4, 1} if not full width/height |
| 2695 | vuid = ycbcr ? "VUID-VkImageCopy-srcImage-01728" : "VUID-VkImageCopy-extent-00158"; |
| 2696 | copy_region.extent = {62, 60, 1}; // source width |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 2697 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, vuid); |
| 2698 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 2699 | "VUID-vkCmdCopyImage-srcOffset-01783"); // src extent image transfer granularity |
| 2700 | m_commandBuffer->CopyImage(image_1.image(), VK_IMAGE_LAYOUT_GENERAL, image_2.image(), VK_IMAGE_LAYOUT_GENERAL, 1, ©_region); |
| 2701 | m_errorMonitor->VerifyFound(); |
| 2702 | vuid = ycbcr ? "VUID-VkImageCopy-srcImage-01729" : "VUID-VkImageCopy-extent-00159"; |
| 2703 | copy_region.extent = {60, 62, 1}; // source height |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 2704 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, vuid); |
| 2705 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 2706 | "VUID-vkCmdCopyImage-srcOffset-01783"); // src extent image transfer granularity |
| 2707 | m_commandBuffer->CopyImage(image_1.image(), VK_IMAGE_LAYOUT_GENERAL, image_2.image(), VK_IMAGE_LAYOUT_GENERAL, 1, ©_region); |
| 2708 | m_errorMonitor->VerifyFound(); |
| 2709 | |
| 2710 | vuid = ycbcr ? "VUID-VkImageCopy-dstImage-01732" : "VUID-VkImageCopy-extent-00163"; |
| 2711 | copy_region.extent = {62, 60, 1}; // dest width |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 2712 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, vuid); |
| 2713 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 2714 | "VUID-vkCmdCopyImage-dstOffset-01784"); // dst extent image transfer granularity |
| 2715 | m_commandBuffer->CopyImage(image_2.image(), VK_IMAGE_LAYOUT_GENERAL, image_1.image(), VK_IMAGE_LAYOUT_GENERAL, 1, ©_region); |
| 2716 | m_errorMonitor->VerifyFound(); |
| 2717 | vuid = ycbcr ? "VUID-VkImageCopy-dstImage-01733" : "VUID-VkImageCopy-extent-00164"; |
| 2718 | copy_region.extent = {60, 62, 1}; // dest height |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 2719 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, vuid); |
| 2720 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 2721 | "VUID-vkCmdCopyImage-dstOffset-01784"); // dst extent image transfer granularity |
| 2722 | m_commandBuffer->CopyImage(image_2.image(), VK_IMAGE_LAYOUT_GENERAL, image_1.image(), VK_IMAGE_LAYOUT_GENERAL, 1, ©_region); |
| 2723 | m_errorMonitor->VerifyFound(); |
| 2724 | |
| 2725 | // Note: "VUID-VkImageCopy-extent-00160", "VUID-VkImageCopy-extent-00165", "VUID-VkImageCopy-srcImage-01730", |
| 2726 | // "VUID-VkImageCopy-dstImage-01734" |
| 2727 | // There are currently no supported compressed formats with a block depth other than 1, |
| 2728 | // so impossible to create a 'not a multiple' condition for depth. |
| 2729 | m_commandBuffer->end(); |
| 2730 | } |
| 2731 | |
| 2732 | TEST_F(VkLayerTest, CopyImageSinglePlane422Alignment) { |
| 2733 | // Image copy tests on single-plane _422 formats with block alignment errors |
| 2734 | |
| 2735 | // Enable KHR multiplane req'd extensions |
| 2736 | bool mp_extensions = InstanceExtensionSupported(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME, |
| 2737 | VK_KHR_GET_MEMORY_REQUIREMENTS_2_SPEC_VERSION); |
| 2738 | if (mp_extensions) { |
| 2739 | m_instance_extension_names.push_back(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME); |
| 2740 | } |
Mark Lobodzinski | 09ce9c4 | 2020-03-06 10:02:44 -0700 | [diff] [blame] | 2741 | ASSERT_NO_FATAL_FAILURE(InitFramework(m_errorMonitor)); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 2742 | mp_extensions = mp_extensions && DeviceExtensionSupported(gpu(), nullptr, VK_KHR_MAINTENANCE1_EXTENSION_NAME); |
| 2743 | mp_extensions = mp_extensions && DeviceExtensionSupported(gpu(), nullptr, VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME); |
| 2744 | mp_extensions = mp_extensions && DeviceExtensionSupported(gpu(), nullptr, VK_KHR_BIND_MEMORY_2_EXTENSION_NAME); |
| 2745 | mp_extensions = mp_extensions && DeviceExtensionSupported(gpu(), nullptr, VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME); |
| 2746 | if (mp_extensions) { |
| 2747 | m_device_extension_names.push_back(VK_KHR_MAINTENANCE1_EXTENSION_NAME); |
| 2748 | m_device_extension_names.push_back(VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME); |
| 2749 | m_device_extension_names.push_back(VK_KHR_BIND_MEMORY_2_EXTENSION_NAME); |
| 2750 | m_device_extension_names.push_back(VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME); |
| 2751 | } else { |
| 2752 | printf("%s test requires KHR multiplane extensions, not available. Skipping.\n", kSkipPrefix); |
| 2753 | return; |
| 2754 | } |
| 2755 | ASSERT_NO_FATAL_FAILURE(InitState()); |
| 2756 | |
| 2757 | // Select a _422 format and verify support |
| 2758 | VkImageCreateInfo ci = {}; |
| 2759 | ci.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO; |
| 2760 | ci.pNext = NULL; |
| 2761 | ci.flags = 0; |
| 2762 | ci.imageType = VK_IMAGE_TYPE_2D; |
| 2763 | ci.format = VK_FORMAT_G8B8G8R8_422_UNORM_KHR; |
| 2764 | ci.tiling = VK_IMAGE_TILING_OPTIMAL; |
| 2765 | ci.usage = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT; |
| 2766 | ci.mipLevels = 1; |
| 2767 | ci.arrayLayers = 1; |
| 2768 | ci.samples = VK_SAMPLE_COUNT_1_BIT; |
| 2769 | ci.sharingMode = VK_SHARING_MODE_EXCLUSIVE; |
| 2770 | ci.queueFamilyIndexCount = 0; |
| 2771 | ci.pQueueFamilyIndices = NULL; |
| 2772 | ci.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED; |
| 2773 | |
| 2774 | // Verify formats |
| 2775 | VkFormatFeatureFlags features = VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT; |
| 2776 | bool supported = ImageFormatAndFeaturesSupported(instance(), gpu(), ci, features); |
| 2777 | if (!supported) { |
| 2778 | printf("%s Single-plane _422 image format not supported. Skipping test.\n", kSkipPrefix); |
| 2779 | return; // Assume there's low ROI on searching for different mp formats |
| 2780 | } |
| 2781 | |
| 2782 | // Create images |
| 2783 | ci.extent = {64, 64, 1}; |
| 2784 | VkImageObj image_422(m_device); |
| 2785 | image_422.init(&ci); |
| 2786 | ASSERT_TRUE(image_422.initialized()); |
| 2787 | |
| 2788 | ci.extent = {64, 64, 1}; |
| 2789 | ci.format = VK_FORMAT_R8G8B8A8_UNORM; |
| 2790 | VkImageObj image_ucmp(m_device); |
| 2791 | image_ucmp.init(&ci); |
| 2792 | ASSERT_TRUE(image_ucmp.initialized()); |
| 2793 | |
| 2794 | m_commandBuffer->begin(); |
| 2795 | |
| 2796 | VkImageCopy copy_region; |
| 2797 | copy_region.extent = {48, 48, 1}; |
| 2798 | copy_region.srcSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; |
| 2799 | copy_region.dstSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; |
| 2800 | copy_region.srcSubresource.mipLevel = 0; |
| 2801 | copy_region.dstSubresource.mipLevel = 0; |
| 2802 | copy_region.srcSubresource.baseArrayLayer = 0; |
| 2803 | copy_region.dstSubresource.baseArrayLayer = 0; |
| 2804 | copy_region.srcSubresource.layerCount = 1; |
| 2805 | copy_region.dstSubresource.layerCount = 1; |
| 2806 | copy_region.srcOffset = {0, 0, 0}; |
| 2807 | copy_region.dstOffset = {0, 0, 0}; |
| 2808 | |
| 2809 | // Src offsets must be multiples of compressed block sizes |
| 2810 | copy_region.srcOffset = {3, 4, 0}; // source offset x |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 2811 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageCopy-srcImage-01727"); |
| 2812 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyImage-srcOffset-01783"); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 2813 | m_commandBuffer->CopyImage(image_422.image(), VK_IMAGE_LAYOUT_GENERAL, image_ucmp.image(), VK_IMAGE_LAYOUT_GENERAL, 1, |
| 2814 | ©_region); |
| 2815 | m_errorMonitor->VerifyFound(); |
| 2816 | copy_region.srcOffset = {0, 0, 0}; |
| 2817 | |
| 2818 | // Dst offsets must be multiples of compressed block sizes |
| 2819 | copy_region.dstOffset = {1, 0, 0}; |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 2820 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageCopy-dstImage-01731"); |
| 2821 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyImage-dstOffset-01784"); |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 2822 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageCopy-dstOffset-00150"); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 2823 | m_commandBuffer->CopyImage(image_ucmp.image(), VK_IMAGE_LAYOUT_GENERAL, image_422.image(), VK_IMAGE_LAYOUT_GENERAL, 1, |
| 2824 | ©_region); |
| 2825 | m_errorMonitor->VerifyFound(); |
| 2826 | copy_region.dstOffset = {0, 0, 0}; |
| 2827 | |
| 2828 | // Copy extent must be multiples of compressed block sizes if not full width/height |
| 2829 | copy_region.extent = {31, 60, 1}; // 422 source, extent.x |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 2830 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageCopy-srcImage-01728"); |
| 2831 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyImage-srcOffset-01783"); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 2832 | m_commandBuffer->CopyImage(image_422.image(), VK_IMAGE_LAYOUT_GENERAL, image_ucmp.image(), VK_IMAGE_LAYOUT_GENERAL, 1, |
| 2833 | ©_region); |
| 2834 | m_errorMonitor->VerifyFound(); |
| 2835 | |
unknown | 357e178 | 2019-09-25 17:57:40 -0600 | [diff] [blame] | 2836 | // 422 dest |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 2837 | m_commandBuffer->CopyImage(image_ucmp.image(), VK_IMAGE_LAYOUT_GENERAL, image_422.image(), VK_IMAGE_LAYOUT_GENERAL, 1, |
| 2838 | ©_region); |
unknown | 357e178 | 2019-09-25 17:57:40 -0600 | [diff] [blame] | 2839 | m_errorMonitor->VerifyNotFound(); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 2840 | copy_region.dstOffset = {0, 0, 0}; |
| 2841 | |
| 2842 | m_commandBuffer->end(); |
| 2843 | } |
| 2844 | |
| 2845 | TEST_F(VkLayerTest, CopyImageMultiplaneAspectBits) { |
| 2846 | // Image copy tests on multiplane images with aspect errors |
| 2847 | |
| 2848 | // Enable KHR multiplane req'd extensions |
| 2849 | bool mp_extensions = InstanceExtensionSupported(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME, |
| 2850 | VK_KHR_GET_MEMORY_REQUIREMENTS_2_SPEC_VERSION); |
| 2851 | if (mp_extensions) { |
| 2852 | m_instance_extension_names.push_back(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME); |
| 2853 | } |
Mark Lobodzinski | 09ce9c4 | 2020-03-06 10:02:44 -0700 | [diff] [blame] | 2854 | ASSERT_NO_FATAL_FAILURE(InitFramework(m_errorMonitor)); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 2855 | mp_extensions = mp_extensions && DeviceExtensionSupported(gpu(), nullptr, VK_KHR_MAINTENANCE1_EXTENSION_NAME); |
| 2856 | mp_extensions = mp_extensions && DeviceExtensionSupported(gpu(), nullptr, VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME); |
| 2857 | mp_extensions = mp_extensions && DeviceExtensionSupported(gpu(), nullptr, VK_KHR_BIND_MEMORY_2_EXTENSION_NAME); |
| 2858 | mp_extensions = mp_extensions && DeviceExtensionSupported(gpu(), nullptr, VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME); |
| 2859 | if (mp_extensions) { |
| 2860 | m_device_extension_names.push_back(VK_KHR_MAINTENANCE1_EXTENSION_NAME); |
| 2861 | m_device_extension_names.push_back(VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME); |
| 2862 | m_device_extension_names.push_back(VK_KHR_BIND_MEMORY_2_EXTENSION_NAME); |
| 2863 | m_device_extension_names.push_back(VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME); |
| 2864 | } else { |
| 2865 | printf("%s test requires KHR multiplane extensions, not available. Skipping.\n", kSkipPrefix); |
| 2866 | return; |
| 2867 | } |
| 2868 | ASSERT_NO_FATAL_FAILURE(InitState()); |
| 2869 | |
| 2870 | // Select multi-plane formats and verify support |
| 2871 | VkFormat mp3_format = VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM_KHR; |
| 2872 | VkFormat mp2_format = VK_FORMAT_G8_B8R8_2PLANE_422_UNORM_KHR; |
| 2873 | |
| 2874 | VkImageCreateInfo ci = {}; |
| 2875 | ci.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO; |
| 2876 | ci.pNext = NULL; |
| 2877 | ci.flags = 0; |
| 2878 | ci.imageType = VK_IMAGE_TYPE_2D; |
| 2879 | ci.format = mp2_format; |
| 2880 | ci.extent = {256, 256, 1}; |
| 2881 | ci.tiling = VK_IMAGE_TILING_OPTIMAL; |
| 2882 | ci.usage = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT; |
| 2883 | ci.mipLevels = 1; |
| 2884 | ci.arrayLayers = 1; |
| 2885 | ci.samples = VK_SAMPLE_COUNT_1_BIT; |
| 2886 | ci.sharingMode = VK_SHARING_MODE_EXCLUSIVE; |
| 2887 | ci.queueFamilyIndexCount = 0; |
| 2888 | ci.pQueueFamilyIndices = NULL; |
| 2889 | ci.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED; |
| 2890 | |
| 2891 | // Verify formats |
| 2892 | VkFormatFeatureFlags features = VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT; |
| 2893 | bool supported = ImageFormatAndFeaturesSupported(instance(), gpu(), ci, features); |
| 2894 | ci.format = VK_FORMAT_D24_UNORM_S8_UINT; |
| 2895 | supported = supported && ImageFormatAndFeaturesSupported(instance(), gpu(), ci, features); |
| 2896 | ci.format = mp3_format; |
| 2897 | supported = supported && ImageFormatAndFeaturesSupported(instance(), gpu(), ci, features); |
| 2898 | if (!supported) { |
| 2899 | printf("%s Multiplane image formats or optimally tiled depth-stencil buffers not supported. Skipping test.\n", |
| 2900 | kSkipPrefix); |
| 2901 | return; // Assume there's low ROI on searching for different mp formats |
| 2902 | } |
| 2903 | |
| 2904 | // Create images |
| 2905 | VkImageObj mp3_image(m_device); |
| 2906 | mp3_image.init(&ci); |
| 2907 | ASSERT_TRUE(mp3_image.initialized()); |
| 2908 | |
| 2909 | ci.format = mp2_format; |
| 2910 | VkImageObj mp2_image(m_device); |
| 2911 | mp2_image.init(&ci); |
| 2912 | ASSERT_TRUE(mp2_image.initialized()); |
| 2913 | |
| 2914 | ci.format = VK_FORMAT_D24_UNORM_S8_UINT; |
| 2915 | VkImageObj sp_image(m_device); |
| 2916 | sp_image.init(&ci); |
| 2917 | ASSERT_TRUE(sp_image.initialized()); |
| 2918 | |
| 2919 | m_commandBuffer->begin(); |
| 2920 | |
| 2921 | VkImageCopy copy_region; |
| 2922 | copy_region.extent = {128, 128, 1}; |
| 2923 | copy_region.srcSubresource.aspectMask = VK_IMAGE_ASPECT_PLANE_2_BIT_KHR; |
| 2924 | copy_region.dstSubresource.aspectMask = VK_IMAGE_ASPECT_PLANE_2_BIT_KHR; |
| 2925 | copy_region.srcSubresource.mipLevel = 0; |
| 2926 | copy_region.dstSubresource.mipLevel = 0; |
| 2927 | copy_region.srcSubresource.baseArrayLayer = 0; |
| 2928 | copy_region.dstSubresource.baseArrayLayer = 0; |
| 2929 | copy_region.srcSubresource.layerCount = 1; |
| 2930 | copy_region.dstSubresource.layerCount = 1; |
| 2931 | copy_region.srcOffset = {0, 0, 0}; |
| 2932 | copy_region.dstOffset = {0, 0, 0}; |
| 2933 | |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 2934 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageCopy-srcImage-01552"); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 2935 | m_commandBuffer->CopyImage(mp2_image.image(), VK_IMAGE_LAYOUT_GENERAL, mp3_image.image(), VK_IMAGE_LAYOUT_GENERAL, 1, |
| 2936 | ©_region); |
| 2937 | m_errorMonitor->VerifyFound(); |
| 2938 | |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 2939 | copy_region.srcSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; |
| 2940 | copy_region.dstSubresource.aspectMask = VK_IMAGE_ASPECT_PLANE_0_BIT_KHR; |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 2941 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageCopy-srcImage-01553"); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 2942 | m_commandBuffer->CopyImage(mp3_image.image(), VK_IMAGE_LAYOUT_GENERAL, mp2_image.image(), VK_IMAGE_LAYOUT_GENERAL, 1, |
| 2943 | ©_region); |
| 2944 | m_errorMonitor->VerifyFound(); |
| 2945 | |
| 2946 | copy_region.srcSubresource.aspectMask = VK_IMAGE_ASPECT_PLANE_1_BIT_KHR; |
| 2947 | copy_region.dstSubresource.aspectMask = VK_IMAGE_ASPECT_PLANE_2_BIT_KHR; |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 2948 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageCopy-dstImage-01554"); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 2949 | m_commandBuffer->CopyImage(mp3_image.image(), VK_IMAGE_LAYOUT_GENERAL, mp2_image.image(), VK_IMAGE_LAYOUT_GENERAL, 1, |
| 2950 | ©_region); |
| 2951 | m_errorMonitor->VerifyFound(); |
| 2952 | |
| 2953 | copy_region.dstSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 2954 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageCopy-dstImage-01555"); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 2955 | m_commandBuffer->CopyImage(mp2_image.image(), VK_IMAGE_LAYOUT_GENERAL, mp3_image.image(), VK_IMAGE_LAYOUT_GENERAL, 1, |
| 2956 | ©_region); |
| 2957 | m_errorMonitor->VerifyFound(); |
| 2958 | |
| 2959 | copy_region.dstSubresource.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT; |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 2960 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageCopy-srcImage-01556"); |
sfricke-samsung | 99dc12c | 2020-04-23 01:52:01 -0700 | [diff] [blame] | 2961 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyImage-None-01549"); // since also non-compatiable |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 2962 | m_commandBuffer->CopyImage(mp2_image.image(), VK_IMAGE_LAYOUT_GENERAL, sp_image.image(), VK_IMAGE_LAYOUT_GENERAL, 1, |
| 2963 | ©_region); |
| 2964 | m_errorMonitor->VerifyFound(); |
| 2965 | |
| 2966 | copy_region.srcSubresource.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT; |
| 2967 | copy_region.dstSubresource.aspectMask = VK_IMAGE_ASPECT_PLANE_2_BIT_KHR; |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 2968 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageCopy-dstImage-01557"); |
sfricke-samsung | 99dc12c | 2020-04-23 01:52:01 -0700 | [diff] [blame] | 2969 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyImage-None-01549"); // since also non-compatiable |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 2970 | m_commandBuffer->CopyImage(sp_image.image(), VK_IMAGE_LAYOUT_GENERAL, mp3_image.image(), VK_IMAGE_LAYOUT_GENERAL, 1, |
| 2971 | ©_region); |
| 2972 | m_errorMonitor->VerifyFound(); |
| 2973 | |
| 2974 | m_commandBuffer->end(); |
| 2975 | } |
| 2976 | |
| 2977 | TEST_F(VkLayerTest, CopyImageSrcSizeExceeded) { |
| 2978 | // Image copy with source region specified greater than src image size |
| 2979 | ASSERT_NO_FATAL_FAILURE(Init()); |
| 2980 | |
| 2981 | // Create images with full mip chain |
| 2982 | VkImageCreateInfo ci; |
| 2983 | ci.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO; |
| 2984 | ci.pNext = NULL; |
| 2985 | ci.flags = 0; |
| 2986 | ci.imageType = VK_IMAGE_TYPE_3D; |
| 2987 | ci.format = VK_FORMAT_R8G8B8A8_UNORM; |
| 2988 | ci.extent = {32, 32, 8}; |
| 2989 | ci.mipLevels = 6; |
| 2990 | ci.arrayLayers = 1; |
| 2991 | ci.samples = VK_SAMPLE_COUNT_1_BIT; |
| 2992 | ci.tiling = VK_IMAGE_TILING_OPTIMAL; |
| 2993 | ci.usage = VK_IMAGE_USAGE_TRANSFER_SRC_BIT; |
| 2994 | ci.sharingMode = VK_SHARING_MODE_EXCLUSIVE; |
| 2995 | ci.queueFamilyIndexCount = 0; |
| 2996 | ci.pQueueFamilyIndices = NULL; |
| 2997 | ci.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED; |
| 2998 | |
| 2999 | VkImageObj src_image(m_device); |
| 3000 | src_image.init(&ci); |
| 3001 | ASSERT_TRUE(src_image.initialized()); |
| 3002 | |
| 3003 | // Dest image with one more mip level |
| 3004 | ci.extent = {64, 64, 16}; |
| 3005 | ci.mipLevels = 7; |
| 3006 | ci.usage = VK_IMAGE_USAGE_TRANSFER_DST_BIT; |
| 3007 | VkImageObj dst_image(m_device); |
| 3008 | dst_image.init(&ci); |
| 3009 | ASSERT_TRUE(dst_image.initialized()); |
| 3010 | |
| 3011 | m_commandBuffer->begin(); |
| 3012 | |
| 3013 | VkImageCopy copy_region; |
| 3014 | copy_region.extent = {32, 32, 8}; |
| 3015 | copy_region.srcSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; |
| 3016 | copy_region.dstSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; |
| 3017 | copy_region.srcSubresource.mipLevel = 0; |
| 3018 | copy_region.dstSubresource.mipLevel = 0; |
| 3019 | copy_region.srcSubresource.baseArrayLayer = 0; |
| 3020 | copy_region.dstSubresource.baseArrayLayer = 0; |
| 3021 | copy_region.srcSubresource.layerCount = 1; |
| 3022 | copy_region.dstSubresource.layerCount = 1; |
| 3023 | copy_region.srcOffset = {0, 0, 0}; |
| 3024 | copy_region.dstOffset = {0, 0, 0}; |
| 3025 | |
| 3026 | m_errorMonitor->ExpectSuccess(); |
| 3027 | m_commandBuffer->CopyImage(src_image.image(), VK_IMAGE_LAYOUT_GENERAL, dst_image.image(), VK_IMAGE_LAYOUT_GENERAL, 1, |
| 3028 | ©_region); |
| 3029 | m_errorMonitor->VerifyNotFound(); |
| 3030 | |
| 3031 | // Source exceeded in x-dim, VU 01202 |
| 3032 | copy_region.srcOffset.x = 4; |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 3033 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageCopy-srcOffset-00144"); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 3034 | m_commandBuffer->CopyImage(src_image.image(), VK_IMAGE_LAYOUT_GENERAL, dst_image.image(), VK_IMAGE_LAYOUT_GENERAL, 1, |
| 3035 | ©_region); |
| 3036 | m_errorMonitor->VerifyFound(); |
| 3037 | |
| 3038 | // Source exceeded in y-dim, VU 01203 |
| 3039 | copy_region.srcOffset.x = 0; |
| 3040 | copy_region.extent.height = 48; |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 3041 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageCopy-srcOffset-00145"); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 3042 | m_commandBuffer->CopyImage(src_image.image(), VK_IMAGE_LAYOUT_GENERAL, dst_image.image(), VK_IMAGE_LAYOUT_GENERAL, 1, |
| 3043 | ©_region); |
| 3044 | m_errorMonitor->VerifyFound(); |
| 3045 | |
| 3046 | // Source exceeded in z-dim, VU 01204 |
| 3047 | copy_region.extent = {4, 4, 4}; |
| 3048 | copy_region.srcSubresource.mipLevel = 2; |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 3049 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageCopy-srcOffset-00147"); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 3050 | m_commandBuffer->CopyImage(src_image.image(), VK_IMAGE_LAYOUT_GENERAL, dst_image.image(), VK_IMAGE_LAYOUT_GENERAL, 1, |
| 3051 | ©_region); |
| 3052 | m_errorMonitor->VerifyFound(); |
| 3053 | |
| 3054 | m_commandBuffer->end(); |
| 3055 | } |
| 3056 | |
| 3057 | TEST_F(VkLayerTest, CopyImageDstSizeExceeded) { |
| 3058 | // Image copy with dest region specified greater than dest image size |
| 3059 | ASSERT_NO_FATAL_FAILURE(Init()); |
| 3060 | |
| 3061 | // Create images with full mip chain |
| 3062 | VkImageCreateInfo ci; |
| 3063 | ci.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO; |
| 3064 | ci.pNext = NULL; |
| 3065 | ci.flags = 0; |
| 3066 | ci.imageType = VK_IMAGE_TYPE_3D; |
| 3067 | ci.format = VK_FORMAT_R8G8B8A8_UNORM; |
| 3068 | ci.extent = {32, 32, 8}; |
| 3069 | ci.mipLevels = 6; |
| 3070 | ci.arrayLayers = 1; |
| 3071 | ci.samples = VK_SAMPLE_COUNT_1_BIT; |
| 3072 | ci.tiling = VK_IMAGE_TILING_OPTIMAL; |
| 3073 | ci.usage = VK_IMAGE_USAGE_TRANSFER_DST_BIT; |
| 3074 | ci.sharingMode = VK_SHARING_MODE_EXCLUSIVE; |
| 3075 | ci.queueFamilyIndexCount = 0; |
| 3076 | ci.pQueueFamilyIndices = NULL; |
| 3077 | ci.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED; |
| 3078 | |
| 3079 | VkImageObj dst_image(m_device); |
| 3080 | dst_image.init(&ci); |
| 3081 | ASSERT_TRUE(dst_image.initialized()); |
| 3082 | |
| 3083 | // Src image with one more mip level |
| 3084 | ci.extent = {64, 64, 16}; |
| 3085 | ci.mipLevels = 7; |
| 3086 | ci.usage = VK_IMAGE_USAGE_TRANSFER_SRC_BIT; |
| 3087 | VkImageObj src_image(m_device); |
| 3088 | src_image.init(&ci); |
| 3089 | ASSERT_TRUE(src_image.initialized()); |
| 3090 | |
| 3091 | m_commandBuffer->begin(); |
| 3092 | |
| 3093 | VkImageCopy copy_region; |
| 3094 | copy_region.extent = {32, 32, 8}; |
| 3095 | copy_region.srcSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; |
| 3096 | copy_region.dstSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; |
| 3097 | copy_region.srcSubresource.mipLevel = 0; |
| 3098 | copy_region.dstSubresource.mipLevel = 0; |
| 3099 | copy_region.srcSubresource.baseArrayLayer = 0; |
| 3100 | copy_region.dstSubresource.baseArrayLayer = 0; |
| 3101 | copy_region.srcSubresource.layerCount = 1; |
| 3102 | copy_region.dstSubresource.layerCount = 1; |
| 3103 | copy_region.srcOffset = {0, 0, 0}; |
| 3104 | copy_region.dstOffset = {0, 0, 0}; |
| 3105 | |
| 3106 | m_errorMonitor->ExpectSuccess(); |
| 3107 | m_commandBuffer->CopyImage(src_image.image(), VK_IMAGE_LAYOUT_GENERAL, dst_image.image(), VK_IMAGE_LAYOUT_GENERAL, 1, |
| 3108 | ©_region); |
| 3109 | m_errorMonitor->VerifyNotFound(); |
| 3110 | |
| 3111 | // Dest exceeded in x-dim, VU 01205 |
| 3112 | copy_region.dstOffset.x = 4; |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 3113 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageCopy-dstOffset-00150"); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 3114 | m_commandBuffer->CopyImage(src_image.image(), VK_IMAGE_LAYOUT_GENERAL, dst_image.image(), VK_IMAGE_LAYOUT_GENERAL, 1, |
| 3115 | ©_region); |
| 3116 | m_errorMonitor->VerifyFound(); |
| 3117 | |
| 3118 | // Dest exceeded in y-dim, VU 01206 |
| 3119 | copy_region.dstOffset.x = 0; |
| 3120 | copy_region.extent.height = 48; |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 3121 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageCopy-dstOffset-00151"); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 3122 | m_commandBuffer->CopyImage(src_image.image(), VK_IMAGE_LAYOUT_GENERAL, dst_image.image(), VK_IMAGE_LAYOUT_GENERAL, 1, |
| 3123 | ©_region); |
| 3124 | m_errorMonitor->VerifyFound(); |
| 3125 | |
| 3126 | // Dest exceeded in z-dim, VU 01207 |
| 3127 | copy_region.extent = {4, 4, 4}; |
| 3128 | copy_region.dstSubresource.mipLevel = 2; |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 3129 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageCopy-dstOffset-00153"); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 3130 | m_commandBuffer->CopyImage(src_image.image(), VK_IMAGE_LAYOUT_GENERAL, dst_image.image(), VK_IMAGE_LAYOUT_GENERAL, 1, |
| 3131 | ©_region); |
| 3132 | m_errorMonitor->VerifyFound(); |
| 3133 | |
| 3134 | m_commandBuffer->end(); |
| 3135 | } |
| 3136 | |
sfricke-samsung | 8ceaaea | 2020-03-07 14:08:08 -0800 | [diff] [blame] | 3137 | TEST_F(VkLayerTest, CopyImageMultiPlaneSizeExceeded) { |
| 3138 | TEST_DESCRIPTION("Image Copy for multi-planar format that exceed size of plane for both src and dst"); |
| 3139 | |
| 3140 | // Enable KHR multiplane req'd extensions |
| 3141 | bool mp_extensions = InstanceExtensionSupported(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME, |
| 3142 | VK_KHR_GET_MEMORY_REQUIREMENTS_2_SPEC_VERSION); |
| 3143 | if (mp_extensions == true) { |
| 3144 | m_instance_extension_names.push_back(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME); |
| 3145 | } |
| 3146 | ASSERT_NO_FATAL_FAILURE(InitFramework(m_errorMonitor)); |
| 3147 | mp_extensions = mp_extensions && DeviceExtensionSupported(gpu(), nullptr, VK_KHR_MAINTENANCE1_EXTENSION_NAME); |
| 3148 | mp_extensions = mp_extensions && DeviceExtensionSupported(gpu(), nullptr, VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME); |
| 3149 | mp_extensions = mp_extensions && DeviceExtensionSupported(gpu(), nullptr, VK_KHR_BIND_MEMORY_2_EXTENSION_NAME); |
| 3150 | mp_extensions = mp_extensions && DeviceExtensionSupported(gpu(), nullptr, VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME); |
| 3151 | if (mp_extensions == true) { |
| 3152 | m_device_extension_names.push_back(VK_KHR_MAINTENANCE1_EXTENSION_NAME); |
| 3153 | m_device_extension_names.push_back(VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME); |
| 3154 | m_device_extension_names.push_back(VK_KHR_BIND_MEMORY_2_EXTENSION_NAME); |
| 3155 | m_device_extension_names.push_back(VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME); |
| 3156 | } else { |
| 3157 | printf("%s test requires KHR multiplane extensions, not available. Skipping.\n", kSkipPrefix); |
| 3158 | return; |
| 3159 | } |
| 3160 | ASSERT_NO_FATAL_FAILURE(InitState()); |
| 3161 | |
sfricke-samsung | 99dc12c | 2020-04-23 01:52:01 -0700 | [diff] [blame] | 3162 | // Try to use VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM because need multi-plane format for some tests and likely supported due to |
| 3163 | // copy support being required with samplerYcbcrConversion feature |
sfricke-samsung | 8ceaaea | 2020-03-07 14:08:08 -0800 | [diff] [blame] | 3164 | VkFormatProperties props = {0, 0, 0}; |
| 3165 | bool missing_format_support = false; |
sfricke-samsung | 99dc12c | 2020-04-23 01:52:01 -0700 | [diff] [blame] | 3166 | vk::GetPhysicalDeviceFormatProperties(m_device->phy().handle(), VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM, &props); |
sfricke-samsung | 8ceaaea | 2020-03-07 14:08:08 -0800 | [diff] [blame] | 3167 | missing_format_support |= (props.bufferFeatures == 0 && props.linearTilingFeatures == 0 && props.optimalTilingFeatures == 0); |
| 3168 | missing_format_support |= (props.optimalTilingFeatures & VK_FORMAT_FEATURE_TRANSFER_SRC_BIT) == 0; |
| 3169 | missing_format_support |= (props.optimalTilingFeatures & VK_FORMAT_FEATURE_TRANSFER_DST_BIT) == 0; |
| 3170 | |
| 3171 | if (missing_format_support == true) { |
sfricke-samsung | 99dc12c | 2020-04-23 01:52:01 -0700 | [diff] [blame] | 3172 | printf("%s VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM transfer not supported; skipped.\n", kSkipPrefix); |
sfricke-samsung | 8ceaaea | 2020-03-07 14:08:08 -0800 | [diff] [blame] | 3173 | return; |
| 3174 | } |
| 3175 | |
| 3176 | // 128^2 texels in plane_0 and 64^2 texels in plane_1 |
| 3177 | VkImageObj src_image(m_device); |
| 3178 | VkImageObj dst_image(m_device); |
sfricke-samsung | 99dc12c | 2020-04-23 01:52:01 -0700 | [diff] [blame] | 3179 | src_image.Init(128, 128, 1, VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM, VK_IMAGE_USAGE_TRANSFER_SRC_BIT, VK_IMAGE_TILING_OPTIMAL, 0); |
sfricke-samsung | 8ceaaea | 2020-03-07 14:08:08 -0800 | [diff] [blame] | 3180 | ASSERT_TRUE(src_image.initialized()); |
sfricke-samsung | 99dc12c | 2020-04-23 01:52:01 -0700 | [diff] [blame] | 3181 | dst_image.Init(128, 128, 1, VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM, VK_IMAGE_USAGE_TRANSFER_DST_BIT, VK_IMAGE_TILING_OPTIMAL, 0); |
sfricke-samsung | 8ceaaea | 2020-03-07 14:08:08 -0800 | [diff] [blame] | 3182 | ASSERT_TRUE(dst_image.initialized()); |
| 3183 | |
| 3184 | VkImageCopy copy_region = {}; |
| 3185 | copy_region.extent = {64, 64, 1}; // Size of plane 1 |
| 3186 | copy_region.srcSubresource.aspectMask = VK_IMAGE_ASPECT_PLANE_1_BIT; |
| 3187 | copy_region.dstSubresource.aspectMask = VK_IMAGE_ASPECT_PLANE_1_BIT; |
| 3188 | copy_region.srcSubresource.mipLevel = 0; |
| 3189 | copy_region.dstSubresource.mipLevel = 0; |
| 3190 | copy_region.srcSubresource.baseArrayLayer = 0; |
| 3191 | copy_region.dstSubresource.baseArrayLayer = 0; |
| 3192 | copy_region.srcSubresource.layerCount = 1; |
| 3193 | copy_region.dstSubresource.layerCount = 1; |
| 3194 | copy_region.srcOffset = {0, 0, 0}; |
| 3195 | copy_region.dstOffset = {0, 0, 0}; |
| 3196 | VkImageCopy original_region = copy_region; |
| 3197 | |
| 3198 | m_commandBuffer->begin(); |
| 3199 | |
| 3200 | // Should be able to do a 64x64 copy from plane 1 -> Plane 1 |
| 3201 | m_errorMonitor->ExpectSuccess(); |
| 3202 | m_commandBuffer->CopyImage(src_image.image(), VK_IMAGE_LAYOUT_GENERAL, dst_image.image(), VK_IMAGE_LAYOUT_GENERAL, 1, |
| 3203 | ©_region); |
| 3204 | m_errorMonitor->VerifyNotFound(); |
| 3205 | |
| 3206 | // Should be able to do a 64x64 copy from plane 0 -> Plane 0 |
| 3207 | copy_region.srcSubresource.aspectMask = VK_IMAGE_ASPECT_PLANE_0_BIT; |
| 3208 | copy_region.dstSubresource.aspectMask = VK_IMAGE_ASPECT_PLANE_0_BIT; |
| 3209 | m_errorMonitor->ExpectSuccess(); |
| 3210 | m_commandBuffer->CopyImage(src_image.image(), VK_IMAGE_LAYOUT_GENERAL, dst_image.image(), VK_IMAGE_LAYOUT_GENERAL, 1, |
| 3211 | ©_region); |
| 3212 | m_errorMonitor->VerifyNotFound(); |
| 3213 | |
| 3214 | // Should be able to do a 64x64 copy from plane 0 -> Plane 1 |
| 3215 | copy_region.srcSubresource.aspectMask = VK_IMAGE_ASPECT_PLANE_0_BIT; |
| 3216 | copy_region.dstSubresource.aspectMask = VK_IMAGE_ASPECT_PLANE_1_BIT; |
| 3217 | m_errorMonitor->ExpectSuccess(); |
| 3218 | m_commandBuffer->CopyImage(src_image.image(), VK_IMAGE_LAYOUT_GENERAL, dst_image.image(), VK_IMAGE_LAYOUT_GENERAL, 1, |
| 3219 | ©_region); |
| 3220 | m_errorMonitor->VerifyNotFound(); |
| 3221 | |
| 3222 | // Should be able to do a 64x64 copy from plane 0 -> Plane 1 |
| 3223 | copy_region.srcSubresource.aspectMask = VK_IMAGE_ASPECT_PLANE_1_BIT; |
| 3224 | copy_region.dstSubresource.aspectMask = VK_IMAGE_ASPECT_PLANE_0_BIT; |
| 3225 | m_errorMonitor->ExpectSuccess(); |
| 3226 | m_commandBuffer->CopyImage(src_image.image(), VK_IMAGE_LAYOUT_GENERAL, dst_image.image(), VK_IMAGE_LAYOUT_GENERAL, 1, |
| 3227 | ©_region); |
| 3228 | m_errorMonitor->VerifyNotFound(); |
| 3229 | |
| 3230 | // Should be able to do a 128x64 copy from plane 0 -> Plane 0 |
| 3231 | copy_region.extent = {128, 64, 1}; |
| 3232 | copy_region.srcSubresource.aspectMask = VK_IMAGE_ASPECT_PLANE_0_BIT; |
| 3233 | copy_region.dstSubresource.aspectMask = VK_IMAGE_ASPECT_PLANE_0_BIT; |
| 3234 | m_errorMonitor->ExpectSuccess(); |
| 3235 | m_commandBuffer->CopyImage(src_image.image(), VK_IMAGE_LAYOUT_GENERAL, dst_image.image(), VK_IMAGE_LAYOUT_GENERAL, 1, |
| 3236 | ©_region); |
| 3237 | m_errorMonitor->VerifyNotFound(); |
| 3238 | |
| 3239 | // 128x64 copy from plane 0 -> Plane 1 |
| 3240 | copy_region.extent = {128, 64, 1}; |
| 3241 | copy_region.srcSubresource.aspectMask = VK_IMAGE_ASPECT_PLANE_0_BIT; |
| 3242 | copy_region.dstSubresource.aspectMask = VK_IMAGE_ASPECT_PLANE_1_BIT; |
sfricke-samsung | 8ceaaea | 2020-03-07 14:08:08 -0800 | [diff] [blame] | 3243 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageCopy-dstOffset-00150"); |
| 3244 | m_commandBuffer->CopyImage(src_image.image(), VK_IMAGE_LAYOUT_GENERAL, dst_image.image(), VK_IMAGE_LAYOUT_GENERAL, 1, |
| 3245 | ©_region); |
| 3246 | m_errorMonitor->VerifyFound(); |
| 3247 | |
| 3248 | // 128x64 copy from plane 1 -> Plane 0 |
| 3249 | copy_region.extent = {128, 64, 1}; |
| 3250 | copy_region.srcSubresource.aspectMask = VK_IMAGE_ASPECT_PLANE_1_BIT; |
| 3251 | copy_region.dstSubresource.aspectMask = VK_IMAGE_ASPECT_PLANE_0_BIT; |
sfricke-samsung | 8ceaaea | 2020-03-07 14:08:08 -0800 | [diff] [blame] | 3252 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageCopy-srcOffset-00144"); |
| 3253 | m_commandBuffer->CopyImage(src_image.image(), VK_IMAGE_LAYOUT_GENERAL, dst_image.image(), VK_IMAGE_LAYOUT_GENERAL, 1, |
| 3254 | ©_region); |
| 3255 | m_errorMonitor->VerifyFound(); |
| 3256 | |
| 3257 | // src exceeded in y-dim from offset |
| 3258 | copy_region = original_region; |
| 3259 | copy_region.srcOffset.y = 4; |
sfricke-samsung | 8ceaaea | 2020-03-07 14:08:08 -0800 | [diff] [blame] | 3260 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageCopy-srcOffset-00145"); |
| 3261 | m_commandBuffer->CopyImage(src_image.image(), VK_IMAGE_LAYOUT_GENERAL, dst_image.image(), VK_IMAGE_LAYOUT_GENERAL, 1, |
| 3262 | ©_region); |
| 3263 | m_errorMonitor->VerifyFound(); |
| 3264 | |
| 3265 | // dst exceeded in y-dim from offset |
| 3266 | copy_region = original_region; |
| 3267 | copy_region.dstOffset.y = 4; |
sfricke-samsung | 8ceaaea | 2020-03-07 14:08:08 -0800 | [diff] [blame] | 3268 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageCopy-dstOffset-00151"); |
| 3269 | m_commandBuffer->CopyImage(src_image.image(), VK_IMAGE_LAYOUT_GENERAL, dst_image.image(), VK_IMAGE_LAYOUT_GENERAL, 1, |
| 3270 | ©_region); |
| 3271 | m_errorMonitor->VerifyFound(); |
| 3272 | |
| 3273 | m_commandBuffer->end(); |
| 3274 | } |
| 3275 | |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 3276 | TEST_F(VkLayerTest, CopyImageFormatSizeMismatch) { |
sfricke-samsung | 51067b2 | 2020-04-30 21:41:17 -0700 | [diff] [blame] | 3277 | if (!EnableDeviceProfileLayer()) { |
| 3278 | printf("%s Failed to enable device profile layer.\n", kSkipPrefix); |
| 3279 | return; |
| 3280 | } |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 3281 | |
sfricke-samsung | 8ceaaea | 2020-03-07 14:08:08 -0800 | [diff] [blame] | 3282 | // Enable KHR multiplane req'd extensions |
| 3283 | bool mp_extensions = InstanceExtensionSupported(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME, |
| 3284 | VK_KHR_GET_MEMORY_REQUIREMENTS_2_SPEC_VERSION); |
| 3285 | if (mp_extensions == true) { |
| 3286 | m_instance_extension_names.push_back(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME); |
| 3287 | } |
| 3288 | ASSERT_NO_FATAL_FAILURE(InitFramework(m_errorMonitor)); |
| 3289 | mp_extensions = mp_extensions && DeviceExtensionSupported(gpu(), nullptr, VK_KHR_MAINTENANCE1_EXTENSION_NAME); |
| 3290 | mp_extensions = mp_extensions && DeviceExtensionSupported(gpu(), nullptr, VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME); |
| 3291 | mp_extensions = mp_extensions && DeviceExtensionSupported(gpu(), nullptr, VK_KHR_BIND_MEMORY_2_EXTENSION_NAME); |
| 3292 | mp_extensions = mp_extensions && DeviceExtensionSupported(gpu(), nullptr, VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME); |
| 3293 | if (mp_extensions == true) { |
| 3294 | m_device_extension_names.push_back(VK_KHR_MAINTENANCE1_EXTENSION_NAME); |
| 3295 | m_device_extension_names.push_back(VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME); |
| 3296 | m_device_extension_names.push_back(VK_KHR_BIND_MEMORY_2_EXTENSION_NAME); |
| 3297 | m_device_extension_names.push_back(VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME); |
| 3298 | } |
| 3299 | ASSERT_NO_FATAL_FAILURE(InitState()); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 3300 | |
sfricke-samsung | 51067b2 | 2020-04-30 21:41:17 -0700 | [diff] [blame] | 3301 | PFN_vkSetPhysicalDeviceFormatPropertiesEXT fpvkSetPhysicalDeviceFormatPropertiesEXT = nullptr; |
| 3302 | PFN_vkGetOriginalPhysicalDeviceFormatPropertiesEXT fpvkGetOriginalPhysicalDeviceFormatPropertiesEXT = nullptr; |
sfricke-samsung | dce5f69 | 2020-03-07 13:59:31 -0800 | [diff] [blame] | 3303 | |
sfricke-samsung | 51067b2 | 2020-04-30 21:41:17 -0700 | [diff] [blame] | 3304 | // Load required functions |
| 3305 | if (!LoadDeviceProfileLayer(fpvkSetPhysicalDeviceFormatPropertiesEXT, fpvkGetOriginalPhysicalDeviceFormatPropertiesEXT)) { |
| 3306 | printf("%s Failed to device profile layer.\n", kSkipPrefix); |
| 3307 | return; |
| 3308 | } |
| 3309 | |
| 3310 | // Set transfer for all potential used formats |
| 3311 | VkFormatProperties format_props; |
| 3312 | fpvkGetOriginalPhysicalDeviceFormatPropertiesEXT(gpu(), VK_FORMAT_R8_UNORM, &format_props); |
| 3313 | format_props.optimalTilingFeatures |= (VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT); |
| 3314 | fpvkSetPhysicalDeviceFormatPropertiesEXT(gpu(), VK_FORMAT_R8_UNORM, format_props); |
| 3315 | |
| 3316 | fpvkGetOriginalPhysicalDeviceFormatPropertiesEXT(gpu(), VK_FORMAT_R8_UINT, &format_props); |
| 3317 | format_props.optimalTilingFeatures |= (VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT); |
| 3318 | fpvkSetPhysicalDeviceFormatPropertiesEXT(gpu(), VK_FORMAT_R8_UINT, format_props); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 3319 | |
| 3320 | VkImageCreateInfo image_create_info = {}; |
| 3321 | image_create_info.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO; |
| 3322 | image_create_info.pNext = NULL; |
| 3323 | image_create_info.imageType = VK_IMAGE_TYPE_2D; |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 3324 | image_create_info.extent.width = 32; |
| 3325 | image_create_info.extent.height = 32; |
| 3326 | image_create_info.extent.depth = 1; |
| 3327 | image_create_info.mipLevels = 1; |
| 3328 | image_create_info.arrayLayers = 1; |
| 3329 | image_create_info.samples = VK_SAMPLE_COUNT_1_BIT; |
sfricke-samsung | 51067b2 | 2020-04-30 21:41:17 -0700 | [diff] [blame] | 3330 | image_create_info.tiling = VK_IMAGE_TILING_OPTIMAL; |
| 3331 | image_create_info.usage = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT; |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 3332 | image_create_info.flags = 0; |
| 3333 | |
sfricke-samsung | 51067b2 | 2020-04-30 21:41:17 -0700 | [diff] [blame] | 3334 | image_create_info.format = VK_FORMAT_R8_UNORM; |
| 3335 | VkImageObj image_8b_unorm(m_device); |
| 3336 | image_8b_unorm.init(&image_create_info); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 3337 | |
sfricke-samsung | 51067b2 | 2020-04-30 21:41:17 -0700 | [diff] [blame] | 3338 | image_create_info.format = VK_FORMAT_R8_UINT; |
| 3339 | VkImageObj image_8b_uint(m_device); |
| 3340 | image_8b_uint.init(&image_create_info); |
| 3341 | |
| 3342 | // First try to test two single plane mismatch |
| 3343 | { |
| 3344 | fpvkGetOriginalPhysicalDeviceFormatPropertiesEXT(gpu(), VK_FORMAT_R8G8B8A8_UNORM, &format_props); |
| 3345 | format_props.optimalTilingFeatures |= (VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT); |
| 3346 | fpvkSetPhysicalDeviceFormatPropertiesEXT(gpu(), VK_FORMAT_R8G8B8A8_UNORM, format_props); |
| 3347 | |
| 3348 | image_create_info.format = VK_FORMAT_R8G8B8A8_UNORM; |
| 3349 | VkImageObj image_32b_unorm(m_device); |
| 3350 | image_32b_unorm.init(&image_create_info); |
| 3351 | |
| 3352 | m_commandBuffer->begin(); |
| 3353 | VkImageCopy copyRegion; |
| 3354 | copyRegion.srcSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; |
| 3355 | copyRegion.srcSubresource.mipLevel = 0; |
| 3356 | copyRegion.srcSubresource.baseArrayLayer = 0; |
| 3357 | copyRegion.srcSubresource.layerCount = 1; |
| 3358 | copyRegion.srcOffset.x = 0; |
| 3359 | copyRegion.srcOffset.y = 0; |
| 3360 | copyRegion.srcOffset.z = 0; |
| 3361 | copyRegion.dstSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; |
| 3362 | copyRegion.dstSubresource.mipLevel = 0; |
| 3363 | copyRegion.dstSubresource.baseArrayLayer = 0; |
| 3364 | copyRegion.dstSubresource.layerCount = 1; |
| 3365 | copyRegion.dstOffset.x = 0; |
| 3366 | copyRegion.dstOffset.y = 0; |
| 3367 | copyRegion.dstOffset.z = 0; |
| 3368 | copyRegion.extent.width = 1; |
| 3369 | copyRegion.extent.height = 1; |
| 3370 | copyRegion.extent.depth = 1; |
| 3371 | |
| 3372 | // Sanity check between two 8bit formats |
| 3373 | m_errorMonitor->ExpectSuccess(); |
| 3374 | m_commandBuffer->CopyImage(image_8b_unorm.handle(), VK_IMAGE_LAYOUT_GENERAL, image_8b_uint.handle(), |
| 3375 | VK_IMAGE_LAYOUT_GENERAL, 1, ©Region); |
| 3376 | m_errorMonitor->VerifyNotFound(); |
| 3377 | |
| 3378 | const char *vuid = (mp_extensions) ? "VUID-vkCmdCopyImage-srcImage-01548" : "VUID-vkCmdCopyImage-srcImage-00135"; |
| 3379 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, vuid); |
| 3380 | m_commandBuffer->CopyImage(image_8b_unorm.handle(), VK_IMAGE_LAYOUT_GENERAL, image_32b_unorm.handle(), |
| 3381 | VK_IMAGE_LAYOUT_GENERAL, 1, ©Region); |
| 3382 | m_errorMonitor->VerifyFound(); |
| 3383 | |
| 3384 | // Swap src and dst |
| 3385 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, vuid); |
| 3386 | m_commandBuffer->CopyImage(image_32b_unorm.handle(), VK_IMAGE_LAYOUT_GENERAL, image_8b_unorm.handle(), |
| 3387 | VK_IMAGE_LAYOUT_GENERAL, 1, ©Region); |
| 3388 | m_errorMonitor->VerifyFound(); |
| 3389 | |
| 3390 | m_commandBuffer->end(); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 3391 | } |
| 3392 | |
sfricke-samsung | 51067b2 | 2020-04-30 21:41:17 -0700 | [diff] [blame] | 3393 | // DstImage is a mismatched plane of a multi-planar format |
| 3394 | if (mp_extensions == false) { |
| 3395 | printf("%s No multi-planar support; section of tests skipped.\n", kSkipPrefix); |
| 3396 | } else { |
| 3397 | fpvkGetOriginalPhysicalDeviceFormatPropertiesEXT(gpu(), VK_FORMAT_G8_B8R8_2PLANE_420_UNORM, &format_props); |
| 3398 | format_props.optimalTilingFeatures |= (VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT); |
| 3399 | fpvkSetPhysicalDeviceFormatPropertiesEXT(gpu(), VK_FORMAT_G8_B8R8_2PLANE_420_UNORM, format_props); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 3400 | |
sfricke-samsung | 51067b2 | 2020-04-30 21:41:17 -0700 | [diff] [blame] | 3401 | image_create_info.format = VK_FORMAT_G8_B8R8_2PLANE_420_UNORM; |
| 3402 | VkImageObj image_8b_16b_420_unorm(m_device); |
| 3403 | image_8b_16b_420_unorm.init(&image_create_info); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 3404 | |
sfricke-samsung | 51067b2 | 2020-04-30 21:41:17 -0700 | [diff] [blame] | 3405 | m_commandBuffer->begin(); |
| 3406 | VkImageCopy copyRegion; |
| 3407 | copyRegion.srcSubresource.mipLevel = 0; |
| 3408 | copyRegion.srcSubresource.baseArrayLayer = 0; |
| 3409 | copyRegion.srcSubresource.layerCount = 1; |
| 3410 | copyRegion.srcOffset.x = 0; |
| 3411 | copyRegion.srcOffset.y = 0; |
| 3412 | copyRegion.srcOffset.z = 0; |
| 3413 | copyRegion.dstSubresource.mipLevel = 0; |
| 3414 | copyRegion.dstSubresource.baseArrayLayer = 0; |
| 3415 | copyRegion.dstSubresource.layerCount = 1; |
| 3416 | copyRegion.dstOffset.x = 0; |
| 3417 | copyRegion.dstOffset.y = 0; |
| 3418 | copyRegion.dstOffset.z = 0; |
| 3419 | copyRegion.extent.width = 1; |
| 3420 | copyRegion.extent.height = 1; |
| 3421 | copyRegion.extent.depth = 1; |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 3422 | |
sfricke-samsung | 51067b2 | 2020-04-30 21:41:17 -0700 | [diff] [blame] | 3423 | // First test single-plane -> multi-plan |
| 3424 | copyRegion.srcSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; |
| 3425 | copyRegion.dstSubresource.aspectMask = VK_IMAGE_ASPECT_PLANE_0_BIT; |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 3426 | |
sfricke-samsung | 51067b2 | 2020-04-30 21:41:17 -0700 | [diff] [blame] | 3427 | // Plane 0 is VK_FORMAT_R8_UNORM so this should succeed |
| 3428 | m_errorMonitor->ExpectSuccess(); |
| 3429 | m_commandBuffer->CopyImage(image_8b_unorm.handle(), VK_IMAGE_LAYOUT_GENERAL, image_8b_16b_420_unorm.handle(), |
| 3430 | VK_IMAGE_LAYOUT_GENERAL, 1, ©Region); |
| 3431 | m_errorMonitor->VerifyNotFound(); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 3432 | |
sfricke-samsung | 51067b2 | 2020-04-30 21:41:17 -0700 | [diff] [blame] | 3433 | // Make sure no false postiives if Compatible format |
| 3434 | m_errorMonitor->ExpectSuccess(); |
| 3435 | m_commandBuffer->CopyImage(image_8b_uint.handle(), VK_IMAGE_LAYOUT_GENERAL, image_8b_16b_420_unorm.handle(), |
| 3436 | VK_IMAGE_LAYOUT_GENERAL, 1, ©Region); |
| 3437 | m_errorMonitor->VerifyNotFound(); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 3438 | |
sfricke-samsung | 51067b2 | 2020-04-30 21:41:17 -0700 | [diff] [blame] | 3439 | // Plane 1 is VK_FORMAT_R8G8_UNORM so this should fail |
| 3440 | copyRegion.dstSubresource.aspectMask = VK_IMAGE_ASPECT_PLANE_1_BIT; |
| 3441 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyImage-None-01549"); |
| 3442 | m_commandBuffer->CopyImage(image_8b_unorm.handle(), VK_IMAGE_LAYOUT_GENERAL, image_8b_16b_420_unorm.handle(), |
| 3443 | VK_IMAGE_LAYOUT_GENERAL, 1, ©Region); |
| 3444 | m_errorMonitor->VerifyFound(); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 3445 | |
sfricke-samsung | 51067b2 | 2020-04-30 21:41:17 -0700 | [diff] [blame] | 3446 | // Same tests but swap src and dst |
| 3447 | copyRegion.srcSubresource.aspectMask = VK_IMAGE_ASPECT_PLANE_0_BIT; |
| 3448 | copyRegion.dstSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; |
sfricke-samsung | dce5f69 | 2020-03-07 13:59:31 -0800 | [diff] [blame] | 3449 | |
sfricke-samsung | 51067b2 | 2020-04-30 21:41:17 -0700 | [diff] [blame] | 3450 | m_errorMonitor->ExpectSuccess(); |
| 3451 | m_commandBuffer->CopyImage(image_8b_16b_420_unorm.handle(), VK_IMAGE_LAYOUT_GENERAL, image_8b_unorm.handle(), |
| 3452 | VK_IMAGE_LAYOUT_GENERAL, 1, ©Region); |
| 3453 | m_errorMonitor->VerifyNotFound(); |
| 3454 | |
| 3455 | m_errorMonitor->ExpectSuccess(); |
| 3456 | m_commandBuffer->CopyImage(image_8b_16b_420_unorm.handle(), VK_IMAGE_LAYOUT_GENERAL, image_8b_uint.handle(), |
| 3457 | VK_IMAGE_LAYOUT_GENERAL, 1, ©Region); |
| 3458 | m_errorMonitor->VerifyNotFound(); |
| 3459 | |
| 3460 | copyRegion.srcSubresource.aspectMask = VK_IMAGE_ASPECT_PLANE_1_BIT; |
| 3461 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyImage-None-01549"); |
| 3462 | m_commandBuffer->CopyImage(image_8b_16b_420_unorm.handle(), VK_IMAGE_LAYOUT_GENERAL, image_8b_unorm.handle(), |
| 3463 | VK_IMAGE_LAYOUT_GENERAL, 1, ©Region); |
| 3464 | m_errorMonitor->VerifyFound(); |
| 3465 | |
| 3466 | m_commandBuffer->end(); |
| 3467 | } |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 3468 | } |
| 3469 | |
| 3470 | TEST_F(VkLayerTest, CopyImageDepthStencilFormatMismatch) { |
| 3471 | ASSERT_NO_FATAL_FAILURE(Init()); |
| 3472 | auto depth_format = FindSupportedDepthStencilFormat(gpu()); |
| 3473 | if (!depth_format) { |
| 3474 | printf("%s Couldn't depth stencil image format.\n", kSkipPrefix); |
| 3475 | return; |
| 3476 | } |
| 3477 | |
| 3478 | VkFormatProperties properties; |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 3479 | vk::GetPhysicalDeviceFormatProperties(m_device->phy().handle(), VK_FORMAT_D32_SFLOAT, &properties); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 3480 | if (properties.optimalTilingFeatures == 0) { |
| 3481 | printf("%s Image format not supported; skipped.\n", kSkipPrefix); |
| 3482 | return; |
| 3483 | } |
| 3484 | |
| 3485 | VkImageObj srcImage(m_device); |
| 3486 | srcImage.Init(32, 32, 1, VK_FORMAT_D32_SFLOAT, VK_IMAGE_USAGE_TRANSFER_SRC_BIT, VK_IMAGE_TILING_OPTIMAL); |
| 3487 | ASSERT_TRUE(srcImage.initialized()); |
| 3488 | VkImageObj dstImage(m_device); |
| 3489 | dstImage.Init(32, 32, 1, depth_format, VK_IMAGE_USAGE_TRANSFER_DST_BIT, VK_IMAGE_TILING_OPTIMAL); |
| 3490 | ASSERT_TRUE(dstImage.initialized()); |
| 3491 | |
| 3492 | // Create two images of different types and try to copy between them |
| 3493 | |
| 3494 | m_commandBuffer->begin(); |
| 3495 | VkImageCopy copyRegion; |
| 3496 | copyRegion.srcSubresource.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT; |
| 3497 | copyRegion.srcSubresource.mipLevel = 0; |
| 3498 | copyRegion.srcSubresource.baseArrayLayer = 0; |
| 3499 | copyRegion.srcSubresource.layerCount = 1; |
| 3500 | copyRegion.srcOffset.x = 0; |
| 3501 | copyRegion.srcOffset.y = 0; |
| 3502 | copyRegion.srcOffset.z = 0; |
| 3503 | copyRegion.dstSubresource.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT; |
| 3504 | copyRegion.dstSubresource.mipLevel = 0; |
| 3505 | copyRegion.dstSubresource.baseArrayLayer = 0; |
| 3506 | copyRegion.dstSubresource.layerCount = 1; |
| 3507 | copyRegion.dstOffset.x = 0; |
| 3508 | copyRegion.dstOffset.y = 0; |
| 3509 | copyRegion.dstOffset.z = 0; |
| 3510 | copyRegion.extent.width = 1; |
| 3511 | copyRegion.extent.height = 1; |
| 3512 | copyRegion.extent.depth = 1; |
| 3513 | |
sfricke-samsung | 99dc12c | 2020-04-23 01:52:01 -0700 | [diff] [blame] | 3514 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyImage-srcImage-00135"); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 3515 | m_commandBuffer->CopyImage(srcImage.handle(), VK_IMAGE_LAYOUT_GENERAL, dstImage.handle(), VK_IMAGE_LAYOUT_GENERAL, 1, |
| 3516 | ©Region); |
| 3517 | m_commandBuffer->end(); |
| 3518 | |
| 3519 | m_errorMonitor->VerifyFound(); |
| 3520 | } |
| 3521 | |
| 3522 | TEST_F(VkLayerTest, CopyImageSampleCountMismatch) { |
| 3523 | TEST_DESCRIPTION("Image copies with sample count mis-matches"); |
| 3524 | |
| 3525 | ASSERT_NO_FATAL_FAILURE(Init()); |
| 3526 | |
| 3527 | VkImageFormatProperties image_format_properties; |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 3528 | vk::GetPhysicalDeviceImageFormatProperties(gpu(), VK_FORMAT_R8G8B8A8_UNORM, VK_IMAGE_TYPE_2D, VK_IMAGE_TILING_OPTIMAL, |
| 3529 | VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT, 0, |
| 3530 | &image_format_properties); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 3531 | |
| 3532 | if ((0 == (VK_SAMPLE_COUNT_2_BIT & image_format_properties.sampleCounts)) || |
| 3533 | (0 == (VK_SAMPLE_COUNT_4_BIT & image_format_properties.sampleCounts))) { |
| 3534 | printf("%s Image multi-sample support not found; skipped.\n", kSkipPrefix); |
| 3535 | return; |
| 3536 | } |
| 3537 | |
| 3538 | VkImageCreateInfo ci; |
| 3539 | ci.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO; |
| 3540 | ci.pNext = NULL; |
| 3541 | ci.flags = 0; |
| 3542 | ci.imageType = VK_IMAGE_TYPE_2D; |
| 3543 | ci.format = VK_FORMAT_R8G8B8A8_UNORM; |
| 3544 | ci.extent = {128, 128, 1}; |
| 3545 | ci.mipLevels = 1; |
| 3546 | ci.arrayLayers = 1; |
| 3547 | ci.samples = VK_SAMPLE_COUNT_1_BIT; |
| 3548 | ci.tiling = VK_IMAGE_TILING_OPTIMAL; |
| 3549 | ci.usage = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT; |
| 3550 | ci.sharingMode = VK_SHARING_MODE_EXCLUSIVE; |
| 3551 | ci.queueFamilyIndexCount = 0; |
| 3552 | ci.pQueueFamilyIndices = NULL; |
| 3553 | ci.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED; |
| 3554 | |
| 3555 | VkImageObj image1(m_device); |
| 3556 | image1.init(&ci); |
| 3557 | ASSERT_TRUE(image1.initialized()); |
| 3558 | |
| 3559 | ci.samples = VK_SAMPLE_COUNT_2_BIT; |
| 3560 | VkImageObj image2(m_device); |
| 3561 | image2.init(&ci); |
| 3562 | ASSERT_TRUE(image2.initialized()); |
| 3563 | |
| 3564 | ci.samples = VK_SAMPLE_COUNT_4_BIT; |
| 3565 | VkImageObj image4(m_device); |
| 3566 | image4.init(&ci); |
| 3567 | ASSERT_TRUE(image4.initialized()); |
| 3568 | |
| 3569 | m_commandBuffer->begin(); |
| 3570 | |
| 3571 | VkImageCopy copyRegion; |
| 3572 | copyRegion.srcSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; |
| 3573 | copyRegion.srcSubresource.mipLevel = 0; |
| 3574 | copyRegion.srcSubresource.baseArrayLayer = 0; |
| 3575 | copyRegion.srcSubresource.layerCount = 1; |
| 3576 | copyRegion.srcOffset = {0, 0, 0}; |
| 3577 | copyRegion.dstSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; |
| 3578 | copyRegion.dstSubresource.mipLevel = 0; |
| 3579 | copyRegion.dstSubresource.baseArrayLayer = 0; |
| 3580 | copyRegion.dstSubresource.layerCount = 1; |
| 3581 | copyRegion.dstOffset = {0, 0, 0}; |
| 3582 | copyRegion.extent = {128, 128, 1}; |
| 3583 | |
| 3584 | // Copy a single sample image to/from a multi-sample image |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 3585 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyImage-srcImage-00136"); |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 3586 | vk::CmdCopyImage(m_commandBuffer->handle(), image1.handle(), VK_IMAGE_LAYOUT_GENERAL, image4.handle(), VK_IMAGE_LAYOUT_GENERAL, |
| 3587 | 1, ©Region); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 3588 | m_errorMonitor->VerifyFound(); |
| 3589 | |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 3590 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyImage-srcImage-00136"); |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 3591 | vk::CmdCopyImage(m_commandBuffer->handle(), image2.handle(), VK_IMAGE_LAYOUT_GENERAL, image1.handle(), VK_IMAGE_LAYOUT_GENERAL, |
| 3592 | 1, ©Region); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 3593 | m_errorMonitor->VerifyFound(); |
| 3594 | |
| 3595 | // Copy between multi-sample images with different sample counts |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 3596 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyImage-srcImage-00136"); |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 3597 | vk::CmdCopyImage(m_commandBuffer->handle(), image2.handle(), VK_IMAGE_LAYOUT_GENERAL, image4.handle(), VK_IMAGE_LAYOUT_GENERAL, |
| 3598 | 1, ©Region); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 3599 | m_errorMonitor->VerifyFound(); |
| 3600 | |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 3601 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyImage-srcImage-00136"); |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 3602 | vk::CmdCopyImage(m_commandBuffer->handle(), image4.handle(), VK_IMAGE_LAYOUT_GENERAL, image2.handle(), VK_IMAGE_LAYOUT_GENERAL, |
| 3603 | 1, ©Region); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 3604 | m_errorMonitor->VerifyFound(); |
| 3605 | |
| 3606 | m_commandBuffer->end(); |
| 3607 | } |
| 3608 | |
| 3609 | TEST_F(VkLayerTest, CopyImageAspectMismatch) { |
| 3610 | TEST_DESCRIPTION("Image copies with aspect mask errors"); |
sfricke-samsung | 99dc12c | 2020-04-23 01:52:01 -0700 | [diff] [blame] | 3611 | |
| 3612 | if (!EnableDeviceProfileLayer()) { |
| 3613 | printf("%s Failed to enable device profile layer.\n", kSkipPrefix); |
| 3614 | return; |
| 3615 | } |
| 3616 | |
| 3617 | bool mp_extensions = InstanceExtensionSupported(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME, 1); |
| 3618 | if (mp_extensions) { |
| 3619 | m_instance_extension_names.push_back(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME); |
| 3620 | } |
| 3621 | |
| 3622 | ASSERT_NO_FATAL_FAILURE(InitFramework(m_errorMonitor)); |
| 3623 | mp_extensions = mp_extensions && DeviceExtensionSupported(gpu(), nullptr, VK_KHR_MAINTENANCE1_EXTENSION_NAME); |
| 3624 | mp_extensions = mp_extensions && DeviceExtensionSupported(gpu(), nullptr, VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME); |
| 3625 | mp_extensions = mp_extensions && DeviceExtensionSupported(gpu(), nullptr, VK_KHR_BIND_MEMORY_2_EXTENSION_NAME); |
| 3626 | mp_extensions = mp_extensions && DeviceExtensionSupported(gpu(), nullptr, VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME); |
| 3627 | if (mp_extensions) { |
| 3628 | m_device_extension_names.push_back(VK_KHR_MAINTENANCE1_EXTENSION_NAME); |
| 3629 | m_device_extension_names.push_back(VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME); |
| 3630 | m_device_extension_names.push_back(VK_KHR_BIND_MEMORY_2_EXTENSION_NAME); |
| 3631 | m_device_extension_names.push_back(VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME); |
| 3632 | } |
| 3633 | ASSERT_NO_FATAL_FAILURE(InitState()); |
| 3634 | |
| 3635 | PFN_vkSetPhysicalDeviceFormatPropertiesEXT fpvkSetPhysicalDeviceFormatPropertiesEXT = nullptr; |
| 3636 | PFN_vkGetOriginalPhysicalDeviceFormatPropertiesEXT fpvkGetOriginalPhysicalDeviceFormatPropertiesEXT = nullptr; |
| 3637 | |
| 3638 | if (!LoadDeviceProfileLayer(fpvkSetPhysicalDeviceFormatPropertiesEXT, fpvkGetOriginalPhysicalDeviceFormatPropertiesEXT)) { |
| 3639 | printf("%s Required extensions are not avaiable.\n", kSkipPrefix); |
| 3640 | return; |
| 3641 | } |
| 3642 | |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 3643 | auto ds_format = FindSupportedDepthStencilFormat(gpu()); |
| 3644 | if (!ds_format) { |
| 3645 | printf("%s Couldn't find depth stencil format.\n", kSkipPrefix); |
| 3646 | return; |
| 3647 | } |
| 3648 | |
sfricke-samsung | 99dc12c | 2020-04-23 01:52:01 -0700 | [diff] [blame] | 3649 | // Add Transfer support for all used formats |
| 3650 | VkFormatProperties formatProps; |
| 3651 | fpvkGetOriginalPhysicalDeviceFormatPropertiesEXT(gpu(), VK_FORMAT_R32_SFLOAT, &formatProps); |
| 3652 | formatProps.optimalTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); |
| 3653 | fpvkSetPhysicalDeviceFormatPropertiesEXT(gpu(), VK_FORMAT_R32_SFLOAT, formatProps); |
| 3654 | fpvkGetOriginalPhysicalDeviceFormatPropertiesEXT(gpu(), VK_FORMAT_D32_SFLOAT, &formatProps); |
| 3655 | formatProps.optimalTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); |
| 3656 | fpvkSetPhysicalDeviceFormatPropertiesEXT(gpu(), VK_FORMAT_R32_SFLOAT, formatProps); |
| 3657 | fpvkGetOriginalPhysicalDeviceFormatPropertiesEXT(gpu(), ds_format, &formatProps); |
| 3658 | formatProps.optimalTilingFeatures |= (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | VK_FORMAT_FEATURE_TRANSFER_DST_BIT); |
| 3659 | fpvkSetPhysicalDeviceFormatPropertiesEXT(gpu(), ds_format, formatProps); |
| 3660 | |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 3661 | VkImageObj color_image(m_device), ds_image(m_device), depth_image(m_device); |
| 3662 | color_image.Init(128, 128, 1, VK_FORMAT_R32_SFLOAT, VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT); |
| 3663 | depth_image.Init(128, 128, 1, VK_FORMAT_D32_SFLOAT, VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT, |
| 3664 | VK_IMAGE_TILING_OPTIMAL, 0); |
| 3665 | ds_image.Init(128, 128, 1, ds_format, VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT, |
| 3666 | VK_IMAGE_TILING_OPTIMAL, 0); |
| 3667 | ASSERT_TRUE(color_image.initialized()); |
| 3668 | ASSERT_TRUE(depth_image.initialized()); |
| 3669 | ASSERT_TRUE(ds_image.initialized()); |
| 3670 | |
| 3671 | VkImageCopy copyRegion; |
| 3672 | copyRegion.srcSubresource.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT; |
| 3673 | copyRegion.srcSubresource.mipLevel = 0; |
| 3674 | copyRegion.srcSubresource.baseArrayLayer = 0; |
| 3675 | copyRegion.srcSubresource.layerCount = 1; |
| 3676 | copyRegion.srcOffset = {0, 0, 0}; |
| 3677 | copyRegion.dstSubresource.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT; |
| 3678 | copyRegion.dstSubresource.mipLevel = 0; |
| 3679 | copyRegion.dstSubresource.baseArrayLayer = 0; |
| 3680 | copyRegion.dstSubresource.layerCount = 1; |
| 3681 | copyRegion.dstOffset = {64, 0, 0}; |
| 3682 | copyRegion.extent = {64, 128, 1}; |
| 3683 | |
| 3684 | // Submitting command before command buffer is in recording state |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 3685 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 3686 | "You must call vkBeginCommandBuffer"); // "VUID-vkCmdCopyImage-commandBuffer-recording"); |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 3687 | vk::CmdCopyImage(m_commandBuffer->handle(), depth_image.handle(), VK_IMAGE_LAYOUT_GENERAL, depth_image.handle(), |
| 3688 | VK_IMAGE_LAYOUT_GENERAL, 1, ©Region); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 3689 | m_errorMonitor->VerifyFound(); |
| 3690 | |
| 3691 | m_commandBuffer->begin(); |
| 3692 | |
| 3693 | // Src and dest aspect masks don't match |
| 3694 | copyRegion.dstSubresource.aspectMask = VK_IMAGE_ASPECT_STENCIL_BIT; |
sfricke-samsung | 99dc12c | 2020-04-23 01:52:01 -0700 | [diff] [blame] | 3695 | const char *vuid = mp_extensions ? "VUID-VkImageCopy-srcImage-01551" : "VUID-VkImageCopy-aspectMask-00137"; |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 3696 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, vuid); |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 3697 | vk::CmdCopyImage(m_commandBuffer->handle(), ds_image.handle(), VK_IMAGE_LAYOUT_GENERAL, ds_image.handle(), |
| 3698 | VK_IMAGE_LAYOUT_GENERAL, 1, ©Region); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 3699 | m_errorMonitor->VerifyFound(); |
| 3700 | copyRegion.dstSubresource.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT; |
| 3701 | |
| 3702 | // Illegal combinations of aspect bits |
| 3703 | copyRegion.srcSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT | VK_IMAGE_ASPECT_DEPTH_BIT; // color must be alone |
| 3704 | copyRegion.dstSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 3705 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageSubresourceLayers-aspectMask-00167"); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 3706 | // These aspect/format mismatches are redundant but unavoidable here |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 3707 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageCopy-aspectMask-00142"); |
| 3708 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, vuid); |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 3709 | vk::CmdCopyImage(m_commandBuffer->handle(), color_image.handle(), VK_IMAGE_LAYOUT_GENERAL, color_image.handle(), |
| 3710 | VK_IMAGE_LAYOUT_GENERAL, 1, ©Region); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 3711 | m_errorMonitor->VerifyFound(); |
| 3712 | // same test for dstSubresource |
| 3713 | copyRegion.srcSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; |
| 3714 | copyRegion.dstSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT | VK_IMAGE_ASPECT_DEPTH_BIT; // color must be alone |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 3715 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageSubresourceLayers-aspectMask-00167"); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 3716 | // These aspect/format mismatches are redundant but unavoidable here |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 3717 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageCopy-aspectMask-00143"); |
| 3718 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, vuid); |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 3719 | vk::CmdCopyImage(m_commandBuffer->handle(), color_image.handle(), VK_IMAGE_LAYOUT_GENERAL, color_image.handle(), |
| 3720 | VK_IMAGE_LAYOUT_GENERAL, 1, ©Region); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 3721 | m_errorMonitor->VerifyFound(); |
| 3722 | |
| 3723 | // Metadata aspect is illegal |
| 3724 | copyRegion.srcSubresource.aspectMask = VK_IMAGE_ASPECT_METADATA_BIT; |
| 3725 | copyRegion.dstSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 3726 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageSubresourceLayers-aspectMask-00168"); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 3727 | // These aspect/format mismatches are redundant but unavoidable here |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 3728 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, vuid); |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 3729 | vk::CmdCopyImage(m_commandBuffer->handle(), color_image.handle(), VK_IMAGE_LAYOUT_GENERAL, color_image.handle(), |
| 3730 | VK_IMAGE_LAYOUT_GENERAL, 1, ©Region); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 3731 | m_errorMonitor->VerifyFound(); |
| 3732 | // same test for dstSubresource |
| 3733 | copyRegion.srcSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; |
| 3734 | copyRegion.dstSubresource.aspectMask = VK_IMAGE_ASPECT_METADATA_BIT; |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 3735 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageSubresourceLayers-aspectMask-00168"); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 3736 | // These aspect/format mismatches are redundant but unavoidable here |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 3737 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, vuid); |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 3738 | vk::CmdCopyImage(m_commandBuffer->handle(), color_image.handle(), VK_IMAGE_LAYOUT_GENERAL, color_image.handle(), |
| 3739 | VK_IMAGE_LAYOUT_GENERAL, 1, ©Region); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 3740 | m_errorMonitor->VerifyFound(); |
| 3741 | |
| 3742 | copyRegion.srcSubresource.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT; |
| 3743 | copyRegion.dstSubresource.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT; |
sfricke-samsung | 99dc12c | 2020-04-23 01:52:01 -0700 | [diff] [blame] | 3744 | const char *compatible_vuid = mp_extensions ? "VUID-vkCmdCopyImage-srcImage-01548" : "VUID-vkCmdCopyImage-srcImage-00135"; |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 3745 | |
| 3746 | // Aspect mask doesn't match source image format |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 3747 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageCopy-aspectMask-00142"); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 3748 | // Again redundant but unavoidable |
sfricke-samsung | 99dc12c | 2020-04-23 01:52:01 -0700 | [diff] [blame] | 3749 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, compatible_vuid); |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 3750 | vk::CmdCopyImage(m_commandBuffer->handle(), color_image.handle(), VK_IMAGE_LAYOUT_GENERAL, depth_image.handle(), |
| 3751 | VK_IMAGE_LAYOUT_GENERAL, 1, ©Region); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 3752 | m_errorMonitor->VerifyFound(); |
| 3753 | |
| 3754 | // Aspect mask doesn't match dest image format |
| 3755 | copyRegion.srcSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; |
| 3756 | copyRegion.dstSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 3757 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageCopy-aspectMask-00143"); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 3758 | // Again redundant but unavoidable |
sfricke-samsung | 99dc12c | 2020-04-23 01:52:01 -0700 | [diff] [blame] | 3759 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, compatible_vuid); |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 3760 | vk::CmdCopyImage(m_commandBuffer->handle(), color_image.handle(), VK_IMAGE_LAYOUT_GENERAL, depth_image.handle(), |
| 3761 | VK_IMAGE_LAYOUT_GENERAL, 1, ©Region); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 3762 | m_errorMonitor->VerifyFound(); |
| 3763 | |
| 3764 | m_commandBuffer->end(); |
| 3765 | } |
| 3766 | |
| 3767 | TEST_F(VkLayerTest, ResolveImageLowSampleCount) { |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 3768 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "vkCmdResolveImage called with source sample count less than 2."); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 3769 | |
| 3770 | ASSERT_NO_FATAL_FAILURE(Init()); |
| 3771 | |
| 3772 | // Create two images of sample count 1 and try to Resolve between them |
| 3773 | |
| 3774 | VkImageCreateInfo image_create_info = {}; |
| 3775 | image_create_info.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO; |
| 3776 | image_create_info.pNext = NULL; |
| 3777 | image_create_info.imageType = VK_IMAGE_TYPE_2D; |
| 3778 | image_create_info.format = VK_FORMAT_B8G8R8A8_UNORM; |
| 3779 | image_create_info.extent.width = 32; |
| 3780 | image_create_info.extent.height = 1; |
| 3781 | image_create_info.extent.depth = 1; |
| 3782 | image_create_info.mipLevels = 1; |
| 3783 | image_create_info.arrayLayers = 1; |
| 3784 | image_create_info.samples = VK_SAMPLE_COUNT_1_BIT; |
| 3785 | image_create_info.tiling = VK_IMAGE_TILING_OPTIMAL; |
| 3786 | image_create_info.usage = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT; |
| 3787 | image_create_info.flags = 0; |
| 3788 | |
| 3789 | VkImageObj srcImage(m_device); |
| 3790 | srcImage.init(&image_create_info); |
| 3791 | ASSERT_TRUE(srcImage.initialized()); |
| 3792 | |
| 3793 | VkImageObj dstImage(m_device); |
| 3794 | dstImage.init(&image_create_info); |
| 3795 | ASSERT_TRUE(dstImage.initialized()); |
| 3796 | |
| 3797 | m_commandBuffer->begin(); |
| 3798 | VkImageResolve resolveRegion; |
| 3799 | resolveRegion.srcSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; |
| 3800 | resolveRegion.srcSubresource.mipLevel = 0; |
| 3801 | resolveRegion.srcSubresource.baseArrayLayer = 0; |
| 3802 | resolveRegion.srcSubresource.layerCount = 1; |
| 3803 | resolveRegion.srcOffset.x = 0; |
| 3804 | resolveRegion.srcOffset.y = 0; |
| 3805 | resolveRegion.srcOffset.z = 0; |
| 3806 | resolveRegion.dstSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; |
| 3807 | resolveRegion.dstSubresource.mipLevel = 0; |
| 3808 | resolveRegion.dstSubresource.baseArrayLayer = 0; |
| 3809 | resolveRegion.dstSubresource.layerCount = 1; |
| 3810 | resolveRegion.dstOffset.x = 0; |
| 3811 | resolveRegion.dstOffset.y = 0; |
| 3812 | resolveRegion.dstOffset.z = 0; |
| 3813 | resolveRegion.extent.width = 1; |
| 3814 | resolveRegion.extent.height = 1; |
| 3815 | resolveRegion.extent.depth = 1; |
| 3816 | m_commandBuffer->ResolveImage(srcImage.handle(), VK_IMAGE_LAYOUT_GENERAL, dstImage.handle(), VK_IMAGE_LAYOUT_GENERAL, 1, |
| 3817 | &resolveRegion); |
| 3818 | m_commandBuffer->end(); |
| 3819 | |
| 3820 | m_errorMonitor->VerifyFound(); |
| 3821 | } |
| 3822 | |
| 3823 | TEST_F(VkLayerTest, ResolveImageHighSampleCount) { |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 3824 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "vkCmdResolveImage called with dest sample count greater than 1."); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 3825 | |
| 3826 | ASSERT_NO_FATAL_FAILURE(Init()); |
| 3827 | |
| 3828 | // Create two images of sample count 4 and try to Resolve between them |
| 3829 | |
| 3830 | VkImageCreateInfo image_create_info = {}; |
| 3831 | image_create_info.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO; |
| 3832 | image_create_info.pNext = NULL; |
| 3833 | image_create_info.imageType = VK_IMAGE_TYPE_2D; |
| 3834 | image_create_info.format = VK_FORMAT_B8G8R8A8_UNORM; |
| 3835 | image_create_info.extent.width = 32; |
| 3836 | image_create_info.extent.height = 1; |
| 3837 | image_create_info.extent.depth = 1; |
| 3838 | image_create_info.mipLevels = 1; |
| 3839 | image_create_info.arrayLayers = 1; |
| 3840 | image_create_info.samples = VK_SAMPLE_COUNT_4_BIT; |
| 3841 | image_create_info.tiling = VK_IMAGE_TILING_OPTIMAL; |
| 3842 | // Note: Some implementations expect color attachment usage for any |
| 3843 | // multisample surface |
| 3844 | image_create_info.usage = |
| 3845 | VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT; |
| 3846 | image_create_info.flags = 0; |
| 3847 | |
| 3848 | VkImageObj srcImage(m_device); |
| 3849 | srcImage.init(&image_create_info); |
| 3850 | ASSERT_TRUE(srcImage.initialized()); |
| 3851 | |
| 3852 | VkImageObj dstImage(m_device); |
| 3853 | dstImage.init(&image_create_info); |
| 3854 | ASSERT_TRUE(dstImage.initialized()); |
| 3855 | |
| 3856 | m_commandBuffer->begin(); |
| 3857 | // Need memory barrier to VK_IMAGE_LAYOUT_GENERAL for source and dest? |
| 3858 | // VK_IMAGE_LAYOUT_UNDEFINED = 0, |
| 3859 | // VK_IMAGE_LAYOUT_GENERAL = 1, |
| 3860 | VkImageResolve resolveRegion; |
| 3861 | resolveRegion.srcSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; |
| 3862 | resolveRegion.srcSubresource.mipLevel = 0; |
| 3863 | resolveRegion.srcSubresource.baseArrayLayer = 0; |
| 3864 | resolveRegion.srcSubresource.layerCount = 1; |
| 3865 | resolveRegion.srcOffset.x = 0; |
| 3866 | resolveRegion.srcOffset.y = 0; |
| 3867 | resolveRegion.srcOffset.z = 0; |
| 3868 | resolveRegion.dstSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; |
| 3869 | resolveRegion.dstSubresource.mipLevel = 0; |
| 3870 | resolveRegion.dstSubresource.baseArrayLayer = 0; |
| 3871 | resolveRegion.dstSubresource.layerCount = 1; |
| 3872 | resolveRegion.dstOffset.x = 0; |
| 3873 | resolveRegion.dstOffset.y = 0; |
| 3874 | resolveRegion.dstOffset.z = 0; |
| 3875 | resolveRegion.extent.width = 1; |
| 3876 | resolveRegion.extent.height = 1; |
| 3877 | resolveRegion.extent.depth = 1; |
| 3878 | m_commandBuffer->ResolveImage(srcImage.handle(), VK_IMAGE_LAYOUT_GENERAL, dstImage.handle(), VK_IMAGE_LAYOUT_GENERAL, 1, |
| 3879 | &resolveRegion); |
| 3880 | m_commandBuffer->end(); |
| 3881 | |
| 3882 | m_errorMonitor->VerifyFound(); |
| 3883 | } |
| 3884 | |
| 3885 | TEST_F(VkLayerTest, ResolveImageFormatMismatch) { |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 3886 | m_errorMonitor->SetDesiredFailureMsg(kWarningBit, "vkCmdResolveImage called with unmatched source and dest formats."); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 3887 | |
| 3888 | ASSERT_NO_FATAL_FAILURE(Init()); |
| 3889 | |
| 3890 | // Create two images of different types and try to copy between them |
locke-lunarg | 8e2c91b | 2019-06-11 17:53:26 -0600 | [diff] [blame] | 3891 | VkImageObj srcImage(m_device); |
| 3892 | VkImageObj dstImage(m_device); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 3893 | |
| 3894 | VkImageCreateInfo image_create_info = {}; |
| 3895 | image_create_info.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO; |
| 3896 | image_create_info.pNext = NULL; |
| 3897 | image_create_info.imageType = VK_IMAGE_TYPE_2D; |
| 3898 | image_create_info.format = VK_FORMAT_B8G8R8A8_UNORM; |
| 3899 | image_create_info.extent.width = 32; |
| 3900 | image_create_info.extent.height = 1; |
| 3901 | image_create_info.extent.depth = 1; |
| 3902 | image_create_info.mipLevels = 1; |
| 3903 | image_create_info.arrayLayers = 1; |
| 3904 | image_create_info.samples = VK_SAMPLE_COUNT_2_BIT; |
| 3905 | image_create_info.tiling = VK_IMAGE_TILING_OPTIMAL; |
| 3906 | // Note: Some implementations expect color attachment usage for any |
| 3907 | // multisample surface |
| 3908 | image_create_info.usage = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT; |
| 3909 | image_create_info.flags = 0; |
locke-lunarg | 8e2c91b | 2019-06-11 17:53:26 -0600 | [diff] [blame] | 3910 | srcImage.init(&image_create_info); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 3911 | |
| 3912 | // Set format to something other than source image |
| 3913 | image_create_info.format = VK_FORMAT_R32_SFLOAT; |
| 3914 | // Note: Some implementations expect color attachment usage for any |
| 3915 | // multisample surface |
| 3916 | image_create_info.usage = VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT; |
| 3917 | image_create_info.samples = VK_SAMPLE_COUNT_1_BIT; |
locke-lunarg | 8e2c91b | 2019-06-11 17:53:26 -0600 | [diff] [blame] | 3918 | dstImage.init(&image_create_info); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 3919 | |
| 3920 | m_commandBuffer->begin(); |
| 3921 | // Need memory barrier to VK_IMAGE_LAYOUT_GENERAL for source and dest? |
| 3922 | // VK_IMAGE_LAYOUT_UNDEFINED = 0, |
| 3923 | // VK_IMAGE_LAYOUT_GENERAL = 1, |
| 3924 | VkImageResolve resolveRegion; |
| 3925 | resolveRegion.srcSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; |
| 3926 | resolveRegion.srcSubresource.mipLevel = 0; |
| 3927 | resolveRegion.srcSubresource.baseArrayLayer = 0; |
| 3928 | resolveRegion.srcSubresource.layerCount = 1; |
| 3929 | resolveRegion.srcOffset.x = 0; |
| 3930 | resolveRegion.srcOffset.y = 0; |
| 3931 | resolveRegion.srcOffset.z = 0; |
| 3932 | resolveRegion.dstSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; |
| 3933 | resolveRegion.dstSubresource.mipLevel = 0; |
| 3934 | resolveRegion.dstSubresource.baseArrayLayer = 0; |
| 3935 | resolveRegion.dstSubresource.layerCount = 1; |
| 3936 | resolveRegion.dstOffset.x = 0; |
| 3937 | resolveRegion.dstOffset.y = 0; |
| 3938 | resolveRegion.dstOffset.z = 0; |
| 3939 | resolveRegion.extent.width = 1; |
| 3940 | resolveRegion.extent.height = 1; |
| 3941 | resolveRegion.extent.depth = 1; |
locke-lunarg | 8e2c91b | 2019-06-11 17:53:26 -0600 | [diff] [blame] | 3942 | m_commandBuffer->ResolveImage(srcImage.handle(), VK_IMAGE_LAYOUT_GENERAL, dstImage.handle(), VK_IMAGE_LAYOUT_GENERAL, 1, |
| 3943 | &resolveRegion); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 3944 | m_commandBuffer->end(); |
| 3945 | |
| 3946 | m_errorMonitor->VerifyFound(); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 3947 | } |
| 3948 | |
| 3949 | TEST_F(VkLayerTest, ResolveImageTypeMismatch) { |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 3950 | m_errorMonitor->SetDesiredFailureMsg(kWarningBit, "vkCmdResolveImage called with unmatched source and dest image types."); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 3951 | |
| 3952 | ASSERT_NO_FATAL_FAILURE(Init()); |
| 3953 | |
| 3954 | // Create two images of different types and try to copy between them |
locke-lunarg | 8e2c91b | 2019-06-11 17:53:26 -0600 | [diff] [blame] | 3955 | VkImageObj srcImage(m_device); |
| 3956 | VkImageObj dstImage(m_device); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 3957 | |
| 3958 | VkImageCreateInfo image_create_info = {}; |
| 3959 | image_create_info.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO; |
| 3960 | image_create_info.pNext = NULL; |
| 3961 | image_create_info.imageType = VK_IMAGE_TYPE_2D; |
| 3962 | image_create_info.format = VK_FORMAT_B8G8R8A8_UNORM; |
| 3963 | image_create_info.extent.width = 32; |
| 3964 | image_create_info.extent.height = 1; |
| 3965 | image_create_info.extent.depth = 1; |
| 3966 | image_create_info.mipLevels = 1; |
| 3967 | image_create_info.arrayLayers = 1; |
| 3968 | image_create_info.samples = VK_SAMPLE_COUNT_2_BIT; |
| 3969 | image_create_info.tiling = VK_IMAGE_TILING_OPTIMAL; |
| 3970 | // Note: Some implementations expect color attachment usage for any |
| 3971 | // multisample surface |
| 3972 | image_create_info.usage = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT; |
| 3973 | image_create_info.flags = 0; |
locke-lunarg | 8e2c91b | 2019-06-11 17:53:26 -0600 | [diff] [blame] | 3974 | srcImage.init(&image_create_info); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 3975 | |
| 3976 | image_create_info.imageType = VK_IMAGE_TYPE_1D; |
| 3977 | // Note: Some implementations expect color attachment usage for any |
| 3978 | // multisample surface |
| 3979 | image_create_info.usage = VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT; |
| 3980 | image_create_info.samples = VK_SAMPLE_COUNT_1_BIT; |
locke-lunarg | 8e2c91b | 2019-06-11 17:53:26 -0600 | [diff] [blame] | 3981 | dstImage.init(&image_create_info); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 3982 | |
| 3983 | m_commandBuffer->begin(); |
| 3984 | // Need memory barrier to VK_IMAGE_LAYOUT_GENERAL for source and dest? |
| 3985 | // VK_IMAGE_LAYOUT_UNDEFINED = 0, |
| 3986 | // VK_IMAGE_LAYOUT_GENERAL = 1, |
| 3987 | VkImageResolve resolveRegion; |
| 3988 | resolveRegion.srcSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; |
| 3989 | resolveRegion.srcSubresource.mipLevel = 0; |
| 3990 | resolveRegion.srcSubresource.baseArrayLayer = 0; |
| 3991 | resolveRegion.srcSubresource.layerCount = 1; |
| 3992 | resolveRegion.srcOffset.x = 0; |
| 3993 | resolveRegion.srcOffset.y = 0; |
| 3994 | resolveRegion.srcOffset.z = 0; |
| 3995 | resolveRegion.dstSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; |
| 3996 | resolveRegion.dstSubresource.mipLevel = 0; |
| 3997 | resolveRegion.dstSubresource.baseArrayLayer = 0; |
| 3998 | resolveRegion.dstSubresource.layerCount = 1; |
| 3999 | resolveRegion.dstOffset.x = 0; |
| 4000 | resolveRegion.dstOffset.y = 0; |
| 4001 | resolveRegion.dstOffset.z = 0; |
| 4002 | resolveRegion.extent.width = 1; |
| 4003 | resolveRegion.extent.height = 1; |
| 4004 | resolveRegion.extent.depth = 1; |
locke-lunarg | 8e2c91b | 2019-06-11 17:53:26 -0600 | [diff] [blame] | 4005 | m_commandBuffer->ResolveImage(srcImage.handle(), VK_IMAGE_LAYOUT_GENERAL, dstImage.handle(), VK_IMAGE_LAYOUT_GENERAL, 1, |
| 4006 | &resolveRegion); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 4007 | m_commandBuffer->end(); |
| 4008 | |
| 4009 | m_errorMonitor->VerifyFound(); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 4010 | } |
| 4011 | |
| 4012 | TEST_F(VkLayerTest, ResolveImageLayoutMismatch) { |
| 4013 | ASSERT_NO_FATAL_FAILURE(Init()); |
| 4014 | |
| 4015 | // Create two images of different types and try to copy between them |
| 4016 | VkImageObj srcImage(m_device); |
| 4017 | VkImageObj dstImage(m_device); |
| 4018 | |
| 4019 | VkImageCreateInfo image_create_info = {}; |
| 4020 | image_create_info.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO; |
| 4021 | image_create_info.pNext = NULL; |
| 4022 | image_create_info.imageType = VK_IMAGE_TYPE_2D; |
| 4023 | image_create_info.format = VK_FORMAT_B8G8R8A8_UNORM; |
| 4024 | image_create_info.extent.width = 32; |
| 4025 | image_create_info.extent.height = 32; |
| 4026 | image_create_info.extent.depth = 1; |
| 4027 | image_create_info.mipLevels = 1; |
| 4028 | image_create_info.arrayLayers = 1; |
| 4029 | image_create_info.samples = VK_SAMPLE_COUNT_2_BIT; |
| 4030 | image_create_info.tiling = VK_IMAGE_TILING_OPTIMAL; |
| 4031 | image_create_info.usage = |
| 4032 | VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT; |
| 4033 | // Note: Some implementations expect color attachment usage for any |
| 4034 | // multisample surface |
| 4035 | image_create_info.flags = 0; |
| 4036 | srcImage.init(&image_create_info); |
| 4037 | ASSERT_TRUE(srcImage.initialized()); |
| 4038 | |
| 4039 | // Note: Some implementations expect color attachment usage for any |
| 4040 | // multisample surface |
| 4041 | image_create_info.samples = VK_SAMPLE_COUNT_1_BIT; |
| 4042 | dstImage.init(&image_create_info); |
| 4043 | ASSERT_TRUE(dstImage.initialized()); |
| 4044 | |
| 4045 | m_commandBuffer->begin(); |
| 4046 | // source image must have valid contents before resolve |
| 4047 | VkClearColorValue clear_color = {{0, 0, 0, 0}}; |
| 4048 | VkImageSubresourceRange subresource = {}; |
| 4049 | subresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; |
| 4050 | subresource.layerCount = 1; |
| 4051 | subresource.levelCount = 1; |
| 4052 | srcImage.SetLayout(m_commandBuffer, VK_IMAGE_ASPECT_COLOR_BIT, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL); |
| 4053 | m_commandBuffer->ClearColorImage(srcImage.image(), VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, &clear_color, 1, &subresource); |
| 4054 | srcImage.SetLayout(m_commandBuffer, VK_IMAGE_ASPECT_COLOR_BIT, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL); |
| 4055 | dstImage.SetLayout(m_commandBuffer, VK_IMAGE_ASPECT_COLOR_BIT, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL); |
| 4056 | |
| 4057 | VkImageResolve resolveRegion; |
| 4058 | resolveRegion.srcSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; |
| 4059 | resolveRegion.srcSubresource.mipLevel = 0; |
| 4060 | resolveRegion.srcSubresource.baseArrayLayer = 0; |
| 4061 | resolveRegion.srcSubresource.layerCount = 1; |
| 4062 | resolveRegion.srcOffset.x = 0; |
| 4063 | resolveRegion.srcOffset.y = 0; |
| 4064 | resolveRegion.srcOffset.z = 0; |
| 4065 | resolveRegion.dstSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; |
| 4066 | resolveRegion.dstSubresource.mipLevel = 0; |
| 4067 | resolveRegion.dstSubresource.baseArrayLayer = 0; |
| 4068 | resolveRegion.dstSubresource.layerCount = 1; |
| 4069 | resolveRegion.dstOffset.x = 0; |
| 4070 | resolveRegion.dstOffset.y = 0; |
| 4071 | resolveRegion.dstOffset.z = 0; |
| 4072 | resolveRegion.extent.width = 1; |
| 4073 | resolveRegion.extent.height = 1; |
| 4074 | resolveRegion.extent.depth = 1; |
| 4075 | // source image layout mismatch |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 4076 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdResolveImage-srcImageLayout-00260"); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 4077 | m_commandBuffer->ResolveImage(srcImage.image(), VK_IMAGE_LAYOUT_GENERAL, dstImage.image(), VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, |
| 4078 | 1, &resolveRegion); |
| 4079 | m_errorMonitor->VerifyFound(); |
| 4080 | // dst image layout mismatch |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 4081 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdResolveImage-dstImageLayout-00262"); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 4082 | m_commandBuffer->ResolveImage(srcImage.image(), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, dstImage.image(), VK_IMAGE_LAYOUT_GENERAL, |
| 4083 | 1, &resolveRegion); |
| 4084 | m_errorMonitor->VerifyFound(); |
| 4085 | m_commandBuffer->end(); |
| 4086 | } |
| 4087 | |
| 4088 | TEST_F(VkLayerTest, ResolveInvalidSubresource) { |
| 4089 | ASSERT_NO_FATAL_FAILURE(Init()); |
| 4090 | |
| 4091 | // Create two images of different types and try to copy between them |
| 4092 | VkImageObj srcImage(m_device); |
| 4093 | VkImageObj dstImage(m_device); |
| 4094 | |
| 4095 | VkImageCreateInfo image_create_info = {}; |
| 4096 | image_create_info.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO; |
| 4097 | image_create_info.pNext = NULL; |
| 4098 | image_create_info.imageType = VK_IMAGE_TYPE_2D; |
| 4099 | image_create_info.format = VK_FORMAT_B8G8R8A8_UNORM; |
| 4100 | image_create_info.extent.width = 32; |
| 4101 | image_create_info.extent.height = 32; |
| 4102 | image_create_info.extent.depth = 1; |
| 4103 | image_create_info.mipLevels = 1; |
| 4104 | image_create_info.arrayLayers = 1; |
| 4105 | image_create_info.samples = VK_SAMPLE_COUNT_2_BIT; |
| 4106 | image_create_info.tiling = VK_IMAGE_TILING_OPTIMAL; |
| 4107 | image_create_info.usage = |
| 4108 | VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT; |
| 4109 | // Note: Some implementations expect color attachment usage for any |
| 4110 | // multisample surface |
| 4111 | image_create_info.flags = 0; |
| 4112 | srcImage.init(&image_create_info); |
| 4113 | ASSERT_TRUE(srcImage.initialized()); |
| 4114 | |
| 4115 | // Note: Some implementations expect color attachment usage for any |
| 4116 | // multisample surface |
| 4117 | image_create_info.samples = VK_SAMPLE_COUNT_1_BIT; |
| 4118 | dstImage.init(&image_create_info); |
| 4119 | ASSERT_TRUE(dstImage.initialized()); |
| 4120 | |
| 4121 | m_commandBuffer->begin(); |
| 4122 | // source image must have valid contents before resolve |
| 4123 | VkClearColorValue clear_color = {{0, 0, 0, 0}}; |
| 4124 | VkImageSubresourceRange subresource = {}; |
| 4125 | subresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; |
| 4126 | subresource.layerCount = 1; |
| 4127 | subresource.levelCount = 1; |
| 4128 | srcImage.SetLayout(m_commandBuffer, VK_IMAGE_ASPECT_COLOR_BIT, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL); |
| 4129 | m_commandBuffer->ClearColorImage(srcImage.image(), VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, &clear_color, 1, &subresource); |
| 4130 | srcImage.SetLayout(m_commandBuffer, VK_IMAGE_ASPECT_COLOR_BIT, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL); |
| 4131 | dstImage.SetLayout(m_commandBuffer, VK_IMAGE_ASPECT_COLOR_BIT, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL); |
| 4132 | |
| 4133 | VkImageResolve resolveRegion; |
| 4134 | resolveRegion.srcSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; |
| 4135 | resolveRegion.srcSubresource.mipLevel = 0; |
| 4136 | resolveRegion.srcSubresource.baseArrayLayer = 0; |
| 4137 | resolveRegion.srcSubresource.layerCount = 1; |
| 4138 | resolveRegion.srcOffset.x = 0; |
| 4139 | resolveRegion.srcOffset.y = 0; |
| 4140 | resolveRegion.srcOffset.z = 0; |
| 4141 | resolveRegion.dstSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; |
| 4142 | resolveRegion.dstSubresource.mipLevel = 0; |
| 4143 | resolveRegion.dstSubresource.baseArrayLayer = 0; |
| 4144 | resolveRegion.dstSubresource.layerCount = 1; |
| 4145 | resolveRegion.dstOffset.x = 0; |
| 4146 | resolveRegion.dstOffset.y = 0; |
| 4147 | resolveRegion.dstOffset.z = 0; |
| 4148 | resolveRegion.extent.width = 1; |
| 4149 | resolveRegion.extent.height = 1; |
| 4150 | resolveRegion.extent.depth = 1; |
| 4151 | // invalid source mip level |
| 4152 | resolveRegion.srcSubresource.mipLevel = image_create_info.mipLevels; |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 4153 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdResolveImage-srcSubresource-01709"); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 4154 | m_commandBuffer->ResolveImage(srcImage.image(), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, dstImage.image(), |
| 4155 | VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &resolveRegion); |
| 4156 | m_errorMonitor->VerifyFound(); |
| 4157 | resolveRegion.srcSubresource.mipLevel = 0; |
| 4158 | // invalid dest mip level |
| 4159 | resolveRegion.dstSubresource.mipLevel = image_create_info.mipLevels; |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 4160 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdResolveImage-dstSubresource-01710"); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 4161 | m_commandBuffer->ResolveImage(srcImage.image(), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, dstImage.image(), |
| 4162 | VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &resolveRegion); |
| 4163 | m_errorMonitor->VerifyFound(); |
| 4164 | resolveRegion.dstSubresource.mipLevel = 0; |
| 4165 | // invalid source array layer range |
| 4166 | resolveRegion.srcSubresource.baseArrayLayer = image_create_info.arrayLayers; |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 4167 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdResolveImage-srcSubresource-01711"); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 4168 | m_commandBuffer->ResolveImage(srcImage.image(), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, dstImage.image(), |
| 4169 | VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &resolveRegion); |
| 4170 | m_errorMonitor->VerifyFound(); |
| 4171 | resolveRegion.srcSubresource.baseArrayLayer = 0; |
| 4172 | // invalid dest array layer range |
| 4173 | resolveRegion.dstSubresource.baseArrayLayer = image_create_info.arrayLayers; |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 4174 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdResolveImage-dstSubresource-01712"); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 4175 | m_commandBuffer->ResolveImage(srcImage.image(), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, dstImage.image(), |
| 4176 | VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &resolveRegion); |
| 4177 | m_errorMonitor->VerifyFound(); |
| 4178 | resolveRegion.dstSubresource.baseArrayLayer = 0; |
| 4179 | |
| 4180 | m_commandBuffer->end(); |
| 4181 | } |
| 4182 | |
| 4183 | TEST_F(VkLayerTest, ClearImageErrors) { |
| 4184 | TEST_DESCRIPTION("Call ClearColorImage w/ a depth|stencil image and ClearDepthStencilImage with a color image."); |
| 4185 | |
| 4186 | ASSERT_NO_FATAL_FAILURE(Init()); |
| 4187 | ASSERT_NO_FATAL_FAILURE(InitRenderTarget()); |
| 4188 | |
| 4189 | m_commandBuffer->begin(); |
| 4190 | |
| 4191 | // Color image |
| 4192 | VkClearColorValue clear_color; |
| 4193 | memset(clear_color.uint32, 0, sizeof(uint32_t) * 4); |
| 4194 | const VkFormat color_format = VK_FORMAT_B8G8R8A8_UNORM; |
| 4195 | const int32_t img_width = 32; |
| 4196 | const int32_t img_height = 32; |
| 4197 | VkImageCreateInfo image_create_info = {}; |
| 4198 | image_create_info.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO; |
| 4199 | image_create_info.pNext = NULL; |
| 4200 | image_create_info.imageType = VK_IMAGE_TYPE_2D; |
| 4201 | image_create_info.format = color_format; |
| 4202 | image_create_info.extent.width = img_width; |
| 4203 | image_create_info.extent.height = img_height; |
| 4204 | image_create_info.extent.depth = 1; |
| 4205 | image_create_info.mipLevels = 1; |
| 4206 | image_create_info.arrayLayers = 1; |
| 4207 | image_create_info.samples = VK_SAMPLE_COUNT_1_BIT; |
| 4208 | image_create_info.tiling = VK_IMAGE_TILING_OPTIMAL; |
| 4209 | |
| 4210 | image_create_info.usage = VK_IMAGE_USAGE_SAMPLED_BIT; |
| 4211 | vk_testing::Image color_image_no_transfer; |
| 4212 | color_image_no_transfer.init(*m_device, image_create_info); |
| 4213 | |
| 4214 | image_create_info.usage = VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT; |
| 4215 | vk_testing::Image color_image; |
| 4216 | color_image.init(*m_device, image_create_info); |
| 4217 | |
| 4218 | const VkImageSubresourceRange color_range = vk_testing::Image::subresource_range(image_create_info, VK_IMAGE_ASPECT_COLOR_BIT); |
| 4219 | |
| 4220 | // Depth/Stencil image |
| 4221 | VkClearDepthStencilValue clear_value = {0}; |
| 4222 | VkImageCreateInfo ds_image_create_info = vk_testing::Image::create_info(); |
| 4223 | ds_image_create_info.imageType = VK_IMAGE_TYPE_2D; |
| 4224 | ds_image_create_info.format = VK_FORMAT_D16_UNORM; |
| 4225 | ds_image_create_info.extent.width = 64; |
| 4226 | ds_image_create_info.extent.height = 64; |
| 4227 | ds_image_create_info.tiling = VK_IMAGE_TILING_OPTIMAL; |
| 4228 | ds_image_create_info.usage = VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT; |
| 4229 | |
| 4230 | vk_testing::Image ds_image; |
| 4231 | ds_image.init(*m_device, ds_image_create_info); |
| 4232 | |
| 4233 | const VkImageSubresourceRange ds_range = vk_testing::Image::subresource_range(ds_image_create_info, VK_IMAGE_ASPECT_DEPTH_BIT); |
| 4234 | |
sfricke-samsung | cd924d9 | 2020-05-20 23:51:17 -0700 | [diff] [blame] | 4235 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdClearColorImage-image-00007"); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 4236 | |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 4237 | vk::CmdClearColorImage(m_commandBuffer->handle(), ds_image.handle(), VK_IMAGE_LAYOUT_GENERAL, &clear_color, 1, &color_range); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 4238 | |
| 4239 | m_errorMonitor->VerifyFound(); |
| 4240 | |
sfricke-samsung | cd924d9 | 2020-05-20 23:51:17 -0700 | [diff] [blame] | 4241 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdClearColorImage-image-00002"); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 4242 | |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 4243 | vk::CmdClearColorImage(m_commandBuffer->handle(), color_image_no_transfer.handle(), VK_IMAGE_LAYOUT_GENERAL, &clear_color, 1, |
| 4244 | &color_range); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 4245 | |
| 4246 | m_errorMonitor->VerifyFound(); |
| 4247 | |
| 4248 | // Call CmdClearDepthStencilImage with color image |
sfricke-samsung | cd924d9 | 2020-05-20 23:51:17 -0700 | [diff] [blame] | 4249 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdClearDepthStencilImage-image-00014"); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 4250 | |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 4251 | vk::CmdClearDepthStencilImage(m_commandBuffer->handle(), color_image.handle(), VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, |
| 4252 | &clear_value, 1, &ds_range); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 4253 | |
| 4254 | m_errorMonitor->VerifyFound(); |
| 4255 | } |
| 4256 | |
| 4257 | TEST_F(VkLayerTest, CommandQueueFlags) { |
| 4258 | TEST_DESCRIPTION( |
| 4259 | "Allocate a command buffer on a queue that does not support graphics and try to issue a graphics-only command"); |
| 4260 | |
| 4261 | ASSERT_NO_FATAL_FAILURE(Init()); |
| 4262 | |
| 4263 | uint32_t queueFamilyIndex = m_device->QueueFamilyWithoutCapabilities(VK_QUEUE_GRAPHICS_BIT); |
| 4264 | if (queueFamilyIndex == UINT32_MAX) { |
| 4265 | printf("%s Non-graphics queue family not found; skipped.\n", kSkipPrefix); |
| 4266 | return; |
| 4267 | } else { |
| 4268 | // Create command pool on a non-graphics queue |
| 4269 | VkCommandPoolObj command_pool(m_device, queueFamilyIndex); |
| 4270 | |
| 4271 | // Setup command buffer on pool |
| 4272 | VkCommandBufferObj command_buffer(m_device, &command_pool); |
| 4273 | command_buffer.begin(); |
| 4274 | |
| 4275 | // Issue a graphics only command |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 4276 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdSetViewport-commandBuffer-cmdpool"); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 4277 | VkViewport viewport = {0, 0, 16, 16, 0, 1}; |
| 4278 | command_buffer.SetViewport(0, 1, &viewport); |
| 4279 | m_errorMonitor->VerifyFound(); |
| 4280 | } |
| 4281 | } |
| 4282 | |
| 4283 | TEST_F(VkLayerTest, ExecuteUnrecordedSecondaryCB) { |
| 4284 | TEST_DESCRIPTION("Attempt vkCmdExecuteCommands with a CB in the initial state"); |
| 4285 | ASSERT_NO_FATAL_FAILURE(Init()); |
| 4286 | VkCommandBufferObj secondary(m_device, m_commandPool, VK_COMMAND_BUFFER_LEVEL_SECONDARY); |
| 4287 | // never record secondary |
| 4288 | |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 4289 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdExecuteCommands-pCommandBuffers-00089"); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 4290 | m_commandBuffer->begin(); |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 4291 | vk::CmdExecuteCommands(m_commandBuffer->handle(), 1, &secondary.handle()); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 4292 | m_errorMonitor->VerifyFound(); |
| 4293 | m_commandBuffer->end(); |
| 4294 | } |
| 4295 | |
| 4296 | TEST_F(VkLayerTest, ExecuteSecondaryCBWithLayoutMismatch) { |
| 4297 | TEST_DESCRIPTION("Attempt vkCmdExecuteCommands with a CB with incorrect initial layout."); |
| 4298 | |
Mark Lobodzinski | 09ce9c4 | 2020-03-06 10:02:44 -0700 | [diff] [blame] | 4299 | ASSERT_NO_FATAL_FAILURE(InitFramework(m_errorMonitor)); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 4300 | ASSERT_NO_FATAL_FAILURE(InitState(nullptr, nullptr, VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT)); |
| 4301 | |
| 4302 | VkImageCreateInfo image_create_info = {}; |
| 4303 | image_create_info.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO; |
| 4304 | image_create_info.pNext = NULL; |
| 4305 | image_create_info.imageType = VK_IMAGE_TYPE_2D; |
| 4306 | image_create_info.format = VK_FORMAT_B8G8R8A8_UNORM; |
| 4307 | image_create_info.extent.width = 32; |
| 4308 | image_create_info.extent.height = 1; |
| 4309 | image_create_info.extent.depth = 1; |
| 4310 | image_create_info.mipLevels = 1; |
| 4311 | image_create_info.arrayLayers = 1; |
| 4312 | image_create_info.samples = VK_SAMPLE_COUNT_1_BIT; |
| 4313 | image_create_info.tiling = VK_IMAGE_TILING_OPTIMAL; |
| 4314 | image_create_info.usage = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT; |
| 4315 | image_create_info.flags = 0; |
| 4316 | |
| 4317 | VkImageSubresource image_sub = VkImageObj::subresource(VK_IMAGE_ASPECT_COLOR_BIT, 0, 0); |
| 4318 | VkImageSubresourceRange image_sub_range = VkImageObj::subresource_range(image_sub); |
| 4319 | |
| 4320 | VkImageObj image(m_device); |
| 4321 | image.init(&image_create_info); |
| 4322 | ASSERT_TRUE(image.initialized()); |
| 4323 | VkImageMemoryBarrier image_barrier = |
| 4324 | image.image_memory_barrier(0, 0, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_GENERAL, image_sub_range); |
| 4325 | |
| 4326 | auto pipeline = [&image_barrier](const VkCommandBufferObj &cb, VkImageLayout old_layout, VkImageLayout new_layout) { |
| 4327 | image_barrier.oldLayout = old_layout; |
| 4328 | image_barrier.newLayout = new_layout; |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 4329 | vk::CmdPipelineBarrier(cb.handle(), VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, 0, 0, nullptr, |
| 4330 | 0, nullptr, 1, &image_barrier); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 4331 | }; |
| 4332 | |
| 4333 | // Validate that mismatched use of image layout in secondary command buffer is caught at record time |
| 4334 | VkCommandBufferObj secondary(m_device, m_commandPool, VK_COMMAND_BUFFER_LEVEL_SECONDARY); |
| 4335 | secondary.begin(); |
| 4336 | pipeline(secondary, VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL); |
| 4337 | secondary.end(); |
| 4338 | |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 4339 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "UNASSIGNED-vkCmdExecuteCommands-commandBuffer-00001"); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 4340 | m_commandBuffer->begin(); |
| 4341 | pipeline(*m_commandBuffer, VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL); |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 4342 | vk::CmdExecuteCommands(m_commandBuffer->handle(), 1, &secondary.handle()); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 4343 | m_errorMonitor->VerifyFound(); |
| 4344 | |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 4345 | m_commandBuffer->reset(); |
| 4346 | secondary.reset(); |
| 4347 | |
| 4348 | // Validate that UNDEFINED doesn't false positive on us |
| 4349 | secondary.begin(); |
| 4350 | pipeline(secondary, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL); |
| 4351 | secondary.end(); |
| 4352 | m_commandBuffer->begin(); |
| 4353 | pipeline(*m_commandBuffer, VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL); |
| 4354 | m_errorMonitor->ExpectSuccess(); |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 4355 | vk::CmdExecuteCommands(m_commandBuffer->handle(), 1, &secondary.handle()); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 4356 | m_errorMonitor->VerifyNotFound(); |
| 4357 | m_commandBuffer->end(); |
| 4358 | } |
| 4359 | |
| 4360 | TEST_F(VkLayerTest, SetDynViewportParamTests) { |
| 4361 | TEST_DESCRIPTION("Test parameters of vkCmdSetViewport without multiViewport feature"); |
| 4362 | |
| 4363 | SetTargetApiVersion(VK_API_VERSION_1_1); |
| 4364 | VkPhysicalDeviceFeatures features{}; |
| 4365 | ASSERT_NO_FATAL_FAILURE(Init(&features)); |
| 4366 | |
| 4367 | const VkViewport vp = {0.0, 0.0, 64.0, 64.0, 0.0, 1.0}; |
| 4368 | const VkViewport viewports[] = {vp, vp}; |
| 4369 | |
| 4370 | m_commandBuffer->begin(); |
| 4371 | |
| 4372 | // array tests |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 4373 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdSetViewport-firstViewport-01224"); |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 4374 | vk::CmdSetViewport(m_commandBuffer->handle(), 1, 1, viewports); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 4375 | m_errorMonitor->VerifyFound(); |
| 4376 | |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 4377 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdSetViewport-viewportCount-arraylength"); |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 4378 | vk::CmdSetViewport(m_commandBuffer->handle(), 0, 0, nullptr); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 4379 | m_errorMonitor->VerifyFound(); |
| 4380 | |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 4381 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdSetViewport-viewportCount-01225"); |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 4382 | vk::CmdSetViewport(m_commandBuffer->handle(), 0, 2, viewports); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 4383 | m_errorMonitor->VerifyFound(); |
| 4384 | |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 4385 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdSetViewport-firstViewport-01224"); |
| 4386 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdSetViewport-viewportCount-01225"); |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 4387 | vk::CmdSetViewport(m_commandBuffer->handle(), 1, 2, viewports); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 4388 | m_errorMonitor->VerifyFound(); |
| 4389 | |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 4390 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdSetViewport-pViewports-parameter"); |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 4391 | vk::CmdSetViewport(m_commandBuffer->handle(), 0, 1, nullptr); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 4392 | m_errorMonitor->VerifyFound(); |
| 4393 | |
| 4394 | // core viewport tests |
| 4395 | using std::vector; |
| 4396 | struct TestCase { |
| 4397 | VkViewport vp; |
| 4398 | std::string veid; |
| 4399 | }; |
| 4400 | |
| 4401 | // not necessarily boundary values (unspecified cast rounding), but guaranteed to be over limit |
| 4402 | const auto one_past_max_w = NearestGreater(static_cast<float>(m_device->props.limits.maxViewportDimensions[0])); |
| 4403 | const auto one_past_max_h = NearestGreater(static_cast<float>(m_device->props.limits.maxViewportDimensions[1])); |
| 4404 | |
| 4405 | const auto min_bound = m_device->props.limits.viewportBoundsRange[0]; |
| 4406 | const auto max_bound = m_device->props.limits.viewportBoundsRange[1]; |
| 4407 | const auto one_before_min_bounds = NearestSmaller(min_bound); |
| 4408 | const auto one_past_max_bounds = NearestGreater(max_bound); |
| 4409 | |
| 4410 | const auto below_zero = NearestSmaller(0.0f); |
| 4411 | const auto past_one = NearestGreater(1.0f); |
| 4412 | |
| 4413 | vector<TestCase> test_cases = { |
| 4414 | {{0.0, 0.0, 0.0, 64.0, 0.0, 1.0}, "VUID-VkViewport-width-01770"}, |
| 4415 | {{0.0, 0.0, one_past_max_w, 64.0, 0.0, 1.0}, "VUID-VkViewport-width-01771"}, |
| 4416 | {{0.0, 0.0, NAN, 64.0, 0.0, 1.0}, "VUID-VkViewport-width-01770"}, |
| 4417 | {{0.0, 0.0, 64.0, one_past_max_h, 0.0, 1.0}, "VUID-VkViewport-height-01773"}, |
| 4418 | {{one_before_min_bounds, 0.0, 64.0, 64.0, 0.0, 1.0}, "VUID-VkViewport-x-01774"}, |
| 4419 | {{one_past_max_bounds, 0.0, 64.0, 64.0, 0.0, 1.0}, "VUID-VkViewport-x-01232"}, |
| 4420 | {{NAN, 0.0, 64.0, 64.0, 0.0, 1.0}, "VUID-VkViewport-x-01774"}, |
| 4421 | {{0.0, one_before_min_bounds, 64.0, 64.0, 0.0, 1.0}, "VUID-VkViewport-y-01775"}, |
| 4422 | {{0.0, NAN, 64.0, 64.0, 0.0, 1.0}, "VUID-VkViewport-y-01775"}, |
| 4423 | {{max_bound, 0.0, 1.0, 64.0, 0.0, 1.0}, "VUID-VkViewport-x-01232"}, |
| 4424 | {{0.0, max_bound, 64.0, 1.0, 0.0, 1.0}, "VUID-VkViewport-y-01233"}, |
| 4425 | {{0.0, 0.0, 64.0, 64.0, below_zero, 1.0}, "VUID-VkViewport-minDepth-01234"}, |
| 4426 | {{0.0, 0.0, 64.0, 64.0, past_one, 1.0}, "VUID-VkViewport-minDepth-01234"}, |
| 4427 | {{0.0, 0.0, 64.0, 64.0, NAN, 1.0}, "VUID-VkViewport-minDepth-01234"}, |
| 4428 | {{0.0, 0.0, 64.0, 64.0, 0.0, below_zero}, "VUID-VkViewport-maxDepth-01235"}, |
| 4429 | {{0.0, 0.0, 64.0, 64.0, 0.0, past_one}, "VUID-VkViewport-maxDepth-01235"}, |
| 4430 | {{0.0, 0.0, 64.0, 64.0, 0.0, NAN}, "VUID-VkViewport-maxDepth-01235"}, |
| 4431 | }; |
| 4432 | |
| 4433 | if (DeviceValidationVersion() < VK_API_VERSION_1_1) { |
| 4434 | test_cases.push_back({{0.0, 0.0, 64.0, 0.0, 0.0, 1.0}, "VUID-VkViewport-height-01772"}); |
| 4435 | test_cases.push_back({{0.0, 0.0, 64.0, NAN, 0.0, 1.0}, "VUID-VkViewport-height-01772"}); |
| 4436 | } else { |
| 4437 | test_cases.push_back({{0.0, 0.0, 64.0, NAN, 0.0, 1.0}, "VUID-VkViewport-height-01773"}); |
| 4438 | } |
| 4439 | |
| 4440 | for (const auto &test_case : test_cases) { |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 4441 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, test_case.veid); |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 4442 | vk::CmdSetViewport(m_commandBuffer->handle(), 0, 1, &test_case.vp); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 4443 | m_errorMonitor->VerifyFound(); |
| 4444 | } |
| 4445 | } |
| 4446 | |
| 4447 | TEST_F(VkLayerTest, SetDynViewportParamMaintenance1Tests) { |
| 4448 | TEST_DESCRIPTION("Verify errors are detected on misuse of SetViewport with a negative viewport extension enabled."); |
| 4449 | |
Mark Lobodzinski | 09ce9c4 | 2020-03-06 10:02:44 -0700 | [diff] [blame] | 4450 | ASSERT_NO_FATAL_FAILURE(InitFramework(m_errorMonitor)); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 4451 | |
| 4452 | if (DeviceExtensionSupported(gpu(), nullptr, VK_KHR_MAINTENANCE1_EXTENSION_NAME)) { |
| 4453 | m_device_extension_names.push_back(VK_KHR_MAINTENANCE1_EXTENSION_NAME); |
| 4454 | } else { |
| 4455 | printf("%s VK_KHR_maintenance1 extension not supported -- skipping test\n", kSkipPrefix); |
| 4456 | return; |
| 4457 | } |
| 4458 | ASSERT_NO_FATAL_FAILURE(InitState()); |
| 4459 | |
| 4460 | NegHeightViewportTests(m_device, m_commandBuffer, m_errorMonitor); |
| 4461 | } |
| 4462 | |
| 4463 | TEST_F(VkLayerTest, SetDynViewportParamMultiviewportTests) { |
| 4464 | TEST_DESCRIPTION("Test parameters of vkCmdSetViewport with multiViewport feature enabled"); |
| 4465 | |
| 4466 | ASSERT_NO_FATAL_FAILURE(Init()); |
| 4467 | |
| 4468 | if (!m_device->phy().features().multiViewport) { |
| 4469 | printf("%s VkPhysicalDeviceFeatures::multiViewport is not supported -- skipping test.\n", kSkipPrefix); |
| 4470 | return; |
| 4471 | } |
| 4472 | |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 4473 | m_commandBuffer->begin(); |
| 4474 | |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 4475 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdSetViewport-viewportCount-arraylength"); |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 4476 | vk::CmdSetViewport(m_commandBuffer->handle(), 0, 0, nullptr); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 4477 | m_errorMonitor->VerifyFound(); |
| 4478 | |
Petr Kraus | 14e4949 | 2019-09-09 20:13:29 +0200 | [diff] [blame] | 4479 | const auto max_viewports = m_device->props.limits.maxViewports; |
| 4480 | |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 4481 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdSetViewport-pViewports-parameter"); |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 4482 | vk::CmdSetViewport(m_commandBuffer->handle(), 0, max_viewports, nullptr); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 4483 | m_errorMonitor->VerifyFound(); |
| 4484 | |
Petr Kraus | 14e4949 | 2019-09-09 20:13:29 +0200 | [diff] [blame] | 4485 | const uint32_t too_big_max_viewports = 65536 + 1; // let's say this is too much to allocate |
| 4486 | if (max_viewports >= too_big_max_viewports) { |
| 4487 | printf("%s VkPhysicalDeviceLimits::maxViewports is too large to practically test against -- skipping part of test.\n", |
| 4488 | kSkipPrefix); |
| 4489 | } else { |
| 4490 | const VkViewport vp = {0.0, 0.0, 64.0, 64.0, 0.0, 1.0}; |
| 4491 | const std::vector<VkViewport> viewports(max_viewports + 1, vp); |
| 4492 | |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 4493 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdSetViewport-firstViewport-01223"); |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 4494 | vk::CmdSetViewport(m_commandBuffer->handle(), 0, max_viewports + 1, viewports.data()); |
Petr Kraus | 14e4949 | 2019-09-09 20:13:29 +0200 | [diff] [blame] | 4495 | m_errorMonitor->VerifyFound(); |
| 4496 | |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 4497 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdSetViewport-firstViewport-01223"); |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 4498 | vk::CmdSetViewport(m_commandBuffer->handle(), max_viewports, 1, viewports.data()); |
Petr Kraus | 14e4949 | 2019-09-09 20:13:29 +0200 | [diff] [blame] | 4499 | m_errorMonitor->VerifyFound(); |
| 4500 | |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 4501 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdSetViewport-firstViewport-01223"); |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 4502 | vk::CmdSetViewport(m_commandBuffer->handle(), 1, max_viewports, viewports.data()); |
Petr Kraus | 14e4949 | 2019-09-09 20:13:29 +0200 | [diff] [blame] | 4503 | m_errorMonitor->VerifyFound(); |
| 4504 | |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 4505 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdSetViewport-viewportCount-arraylength"); |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 4506 | vk::CmdSetViewport(m_commandBuffer->handle(), 1, 0, viewports.data()); |
Petr Kraus | 14e4949 | 2019-09-09 20:13:29 +0200 | [diff] [blame] | 4507 | m_errorMonitor->VerifyFound(); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 4508 | } |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 4509 | } |
| 4510 | |
| 4511 | TEST_F(VkLayerTest, BadRenderPassScopeSecondaryCmdBuffer) { |
| 4512 | TEST_DESCRIPTION( |
| 4513 | "Test secondary buffers executed in wrong render pass scope wrt VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT"); |
| 4514 | |
| 4515 | ASSERT_NO_FATAL_FAILURE(Init()); |
| 4516 | ASSERT_NO_FATAL_FAILURE(InitRenderTarget()); |
| 4517 | |
| 4518 | VkCommandBufferObj sec_cmdbuff_inside_rp(m_device, m_commandPool, VK_COMMAND_BUFFER_LEVEL_SECONDARY); |
| 4519 | VkCommandBufferObj sec_cmdbuff_outside_rp(m_device, m_commandPool, VK_COMMAND_BUFFER_LEVEL_SECONDARY); |
| 4520 | |
| 4521 | const VkCommandBufferInheritanceInfo cmdbuff_ii = { |
| 4522 | VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO, |
| 4523 | nullptr, // pNext |
| 4524 | m_renderPass, |
| 4525 | 0, // subpass |
| 4526 | m_framebuffer, |
| 4527 | }; |
| 4528 | const VkCommandBufferBeginInfo cmdbuff_bi_tmpl = {VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, |
| 4529 | nullptr, // pNext |
| 4530 | VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT, &cmdbuff_ii}; |
| 4531 | |
| 4532 | VkCommandBufferBeginInfo cmdbuff_inside_rp_bi = cmdbuff_bi_tmpl; |
| 4533 | cmdbuff_inside_rp_bi.flags |= VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT; |
| 4534 | sec_cmdbuff_inside_rp.begin(&cmdbuff_inside_rp_bi); |
| 4535 | sec_cmdbuff_inside_rp.end(); |
| 4536 | |
| 4537 | VkCommandBufferBeginInfo cmdbuff_outside_rp_bi = cmdbuff_bi_tmpl; |
| 4538 | cmdbuff_outside_rp_bi.flags &= ~VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT; |
| 4539 | sec_cmdbuff_outside_rp.begin(&cmdbuff_outside_rp_bi); |
| 4540 | sec_cmdbuff_outside_rp.end(); |
| 4541 | |
| 4542 | m_commandBuffer->begin(); |
| 4543 | |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 4544 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdExecuteCommands-pCommandBuffers-00100"); |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 4545 | vk::CmdExecuteCommands(m_commandBuffer->handle(), 1, &sec_cmdbuff_inside_rp.handle()); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 4546 | m_errorMonitor->VerifyFound(); |
| 4547 | |
| 4548 | const VkRenderPassBeginInfo rp_bi{VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO, |
| 4549 | nullptr, // pNext |
| 4550 | m_renderPass, |
| 4551 | m_framebuffer, |
| 4552 | {{0, 0}, {32, 32}}, |
| 4553 | static_cast<uint32_t>(m_renderPassClearValues.size()), |
| 4554 | m_renderPassClearValues.data()}; |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 4555 | vk::CmdBeginRenderPass(m_commandBuffer->handle(), &rp_bi, VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 4556 | |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 4557 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdExecuteCommands-pCommandBuffers-00096"); |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 4558 | vk::CmdExecuteCommands(m_commandBuffer->handle(), 1, &sec_cmdbuff_outside_rp.handle()); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 4559 | m_errorMonitor->VerifyFound(); |
| 4560 | } |
| 4561 | |
| 4562 | TEST_F(VkLayerTest, SecondaryCommandBufferClearColorAttachmentsRenderArea) { |
| 4563 | TEST_DESCRIPTION( |
| 4564 | "Create a secondary command buffer with CmdClearAttachments call that has a rect outside of renderPass renderArea"); |
| 4565 | ASSERT_NO_FATAL_FAILURE(Init()); |
| 4566 | ASSERT_NO_FATAL_FAILURE(InitRenderTarget()); |
| 4567 | |
| 4568 | VkCommandBufferAllocateInfo command_buffer_allocate_info = {}; |
| 4569 | command_buffer_allocate_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO; |
| 4570 | command_buffer_allocate_info.commandPool = m_commandPool->handle(); |
| 4571 | command_buffer_allocate_info.level = VK_COMMAND_BUFFER_LEVEL_SECONDARY; |
| 4572 | command_buffer_allocate_info.commandBufferCount = 1; |
| 4573 | |
| 4574 | VkCommandBuffer secondary_command_buffer; |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 4575 | ASSERT_VK_SUCCESS(vk::AllocateCommandBuffers(m_device->device(), &command_buffer_allocate_info, &secondary_command_buffer)); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 4576 | VkCommandBufferBeginInfo command_buffer_begin_info = {}; |
| 4577 | VkCommandBufferInheritanceInfo command_buffer_inheritance_info = {}; |
| 4578 | command_buffer_inheritance_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO; |
| 4579 | command_buffer_inheritance_info.renderPass = m_renderPass; |
| 4580 | command_buffer_inheritance_info.framebuffer = m_framebuffer; |
| 4581 | |
| 4582 | command_buffer_begin_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO; |
| 4583 | command_buffer_begin_info.flags = |
| 4584 | VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT | VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT; |
| 4585 | command_buffer_begin_info.pInheritanceInfo = &command_buffer_inheritance_info; |
| 4586 | |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 4587 | vk::BeginCommandBuffer(secondary_command_buffer, &command_buffer_begin_info); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 4588 | VkClearAttachment color_attachment; |
| 4589 | color_attachment.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; |
| 4590 | color_attachment.clearValue.color.float32[0] = 0; |
| 4591 | color_attachment.clearValue.color.float32[1] = 0; |
| 4592 | color_attachment.clearValue.color.float32[2] = 0; |
| 4593 | color_attachment.clearValue.color.float32[3] = 0; |
| 4594 | color_attachment.colorAttachment = 0; |
| 4595 | // x extent of 257 exceeds render area of 256 |
Mark Lobodzinski | 6249089 | 2019-06-28 09:58:27 -0600 | [diff] [blame] | 4596 | VkClearRect clear_rect = {{{0, 0}, {257, 32}}, 0, 1}; |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 4597 | vk::CmdClearAttachments(secondary_command_buffer, 1, &color_attachment, 1, &clear_rect); |
| 4598 | vk::EndCommandBuffer(secondary_command_buffer); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 4599 | m_commandBuffer->begin(); |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 4600 | vk::CmdBeginRenderPass(m_commandBuffer->handle(), &m_renderPassBeginInfo, VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 4601 | |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 4602 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdClearAttachments-pRects-00016"); |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 4603 | vk::CmdExecuteCommands(m_commandBuffer->handle(), 1, &secondary_command_buffer); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 4604 | m_errorMonitor->VerifyFound(); |
| 4605 | |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 4606 | vk::CmdEndRenderPass(m_commandBuffer->handle()); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 4607 | m_commandBuffer->end(); |
| 4608 | } |
| 4609 | |
| 4610 | TEST_F(VkLayerTest, PushDescriptorSetCmdPushBadArgs) { |
| 4611 | TEST_DESCRIPTION("Attempt to push a push descriptor set with incorrect arguments."); |
| 4612 | if (InstanceExtensionSupported(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME)) { |
| 4613 | m_instance_extension_names.push_back(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME); |
| 4614 | } else { |
| 4615 | printf("%s %s Extension not supported, skipping tests\n", kSkipPrefix, |
| 4616 | VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME); |
| 4617 | return; |
| 4618 | } |
| 4619 | |
Mark Lobodzinski | 09ce9c4 | 2020-03-06 10:02:44 -0700 | [diff] [blame] | 4620 | ASSERT_NO_FATAL_FAILURE(InitFramework(m_errorMonitor)); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 4621 | if (DeviceExtensionSupported(gpu(), nullptr, VK_KHR_PUSH_DESCRIPTOR_EXTENSION_NAME)) { |
| 4622 | m_device_extension_names.push_back(VK_KHR_PUSH_DESCRIPTOR_EXTENSION_NAME); |
| 4623 | } else { |
| 4624 | printf("%s %s Extension not supported, skipping tests\n", kSkipPrefix, VK_KHR_PUSH_DESCRIPTOR_EXTENSION_NAME); |
| 4625 | return; |
| 4626 | } |
| 4627 | ASSERT_NO_FATAL_FAILURE(InitState()); |
| 4628 | |
| 4629 | auto push_descriptor_prop = GetPushDescriptorProperties(instance(), gpu()); |
| 4630 | if (push_descriptor_prop.maxPushDescriptors < 1) { |
| 4631 | // Some implementations report an invalid maxPushDescriptors of 0 |
| 4632 | printf("%s maxPushDescriptors is zero, skipping tests\n", kSkipPrefix); |
| 4633 | return; |
| 4634 | } |
| 4635 | |
| 4636 | // Create ordinary and push descriptor set layout |
| 4637 | VkDescriptorSetLayoutBinding binding = {0, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 1, VK_SHADER_STAGE_FRAGMENT_BIT, nullptr}; |
| 4638 | const VkDescriptorSetLayoutObj ds_layout(m_device, {binding}); |
| 4639 | ASSERT_TRUE(ds_layout.initialized()); |
| 4640 | const VkDescriptorSetLayoutObj push_ds_layout(m_device, {binding}, VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR); |
| 4641 | ASSERT_TRUE(push_ds_layout.initialized()); |
| 4642 | |
| 4643 | // Now use the descriptor set layouts to create a pipeline layout |
| 4644 | const VkPipelineLayoutObj pipeline_layout(m_device, {&push_ds_layout, &ds_layout}); |
| 4645 | ASSERT_TRUE(pipeline_layout.initialized()); |
| 4646 | |
| 4647 | // Create a descriptor to push |
| 4648 | const uint32_t buffer_data[4] = {4, 5, 6, 7}; |
| 4649 | VkConstantBufferObj buffer_obj(m_device, sizeof(buffer_data), &buffer_data); |
| 4650 | ASSERT_TRUE(buffer_obj.initialized()); |
| 4651 | |
| 4652 | // Create a "write" struct, noting that the buffer_info cannot be a temporary arg (the return from write_descriptor_set |
| 4653 | // references its data), and the DescriptorSet() can be temporary, because the value is ignored |
| 4654 | VkDescriptorBufferInfo buffer_info = {buffer_obj.handle(), 0, VK_WHOLE_SIZE}; |
| 4655 | |
| 4656 | VkWriteDescriptorSet descriptor_write = vk_testing::Device::write_descriptor_set( |
| 4657 | vk_testing::DescriptorSet(), 0, 0, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 1, &buffer_info); |
| 4658 | |
| 4659 | // Find address of extension call and make the call |
| 4660 | PFN_vkCmdPushDescriptorSetKHR vkCmdPushDescriptorSetKHR = |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 4661 | (PFN_vkCmdPushDescriptorSetKHR)vk::GetDeviceProcAddr(m_device->device(), "vkCmdPushDescriptorSetKHR"); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 4662 | ASSERT_TRUE(vkCmdPushDescriptorSetKHR != nullptr); |
| 4663 | |
| 4664 | // Section 1: Queue family matching/capabilities. |
| 4665 | // Create command pool on a non-graphics queue |
| 4666 | const uint32_t no_gfx_qfi = m_device->QueueFamilyMatching(VK_QUEUE_COMPUTE_BIT, VK_QUEUE_GRAPHICS_BIT); |
| 4667 | const uint32_t transfer_only_qfi = |
| 4668 | m_device->QueueFamilyMatching(VK_QUEUE_TRANSFER_BIT, (VK_QUEUE_COMPUTE_BIT | VK_QUEUE_GRAPHICS_BIT)); |
| 4669 | if ((UINT32_MAX == transfer_only_qfi) && (UINT32_MAX == no_gfx_qfi)) { |
unknown | c3033e5 | 2019-06-21 16:56:20 -0600 | [diff] [blame] | 4670 | printf("%s No compute or transfer only queue family, skipping bindpoint and queue tests.\n", kSkipPrefix); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 4671 | } else { |
| 4672 | const uint32_t err_qfi = (UINT32_MAX == no_gfx_qfi) ? transfer_only_qfi : no_gfx_qfi; |
| 4673 | |
| 4674 | VkCommandPoolObj command_pool(m_device, err_qfi); |
| 4675 | ASSERT_TRUE(command_pool.initialized()); |
| 4676 | VkCommandBufferObj command_buffer(m_device, &command_pool); |
| 4677 | ASSERT_TRUE(command_buffer.initialized()); |
| 4678 | command_buffer.begin(); |
| 4679 | |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 4680 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdPushDescriptorSetKHR-pipelineBindPoint-00363"); |
| 4681 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkWriteDescriptorSet-descriptorType-00330"); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 4682 | if (err_qfi == transfer_only_qfi) { |
| 4683 | // This as this queue neither supports the gfx or compute bindpoints, we'll get two errors |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 4684 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdPushDescriptorSetKHR-commandBuffer-cmdpool"); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 4685 | } |
| 4686 | vkCmdPushDescriptorSetKHR(command_buffer.handle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline_layout.handle(), 0, 1, |
| 4687 | &descriptor_write); |
| 4688 | m_errorMonitor->VerifyFound(); |
| 4689 | command_buffer.end(); |
| 4690 | |
| 4691 | // If we succeed in testing only one condition above, we need to test the other below. |
| 4692 | if ((UINT32_MAX != transfer_only_qfi) && (err_qfi != transfer_only_qfi)) { |
| 4693 | // Need to test the neither compute/gfx supported case separately. |
| 4694 | VkCommandPoolObj tran_command_pool(m_device, transfer_only_qfi); |
| 4695 | ASSERT_TRUE(tran_command_pool.initialized()); |
| 4696 | VkCommandBufferObj tran_command_buffer(m_device, &tran_command_pool); |
| 4697 | ASSERT_TRUE(tran_command_buffer.initialized()); |
| 4698 | tran_command_buffer.begin(); |
| 4699 | |
| 4700 | // We can't avoid getting *both* errors in this case |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 4701 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdPushDescriptorSetKHR-pipelineBindPoint-00363"); |
| 4702 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkWriteDescriptorSet-descriptorType-00330"); |
| 4703 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdPushDescriptorSetKHR-commandBuffer-cmdpool"); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 4704 | vkCmdPushDescriptorSetKHR(tran_command_buffer.handle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline_layout.handle(), 0, 1, |
| 4705 | &descriptor_write); |
| 4706 | m_errorMonitor->VerifyFound(); |
| 4707 | tran_command_buffer.end(); |
| 4708 | } |
| 4709 | } |
| 4710 | |
| 4711 | // Push to the non-push binding |
| 4712 | m_commandBuffer->begin(); |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 4713 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdPushDescriptorSetKHR-set-00365"); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 4714 | vkCmdPushDescriptorSetKHR(m_commandBuffer->handle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline_layout.handle(), 1, 1, |
| 4715 | &descriptor_write); |
| 4716 | m_errorMonitor->VerifyFound(); |
| 4717 | |
| 4718 | // Specify set out of bounds |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 4719 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdPushDescriptorSetKHR-set-00364"); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 4720 | vkCmdPushDescriptorSetKHR(m_commandBuffer->handle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline_layout.handle(), 2, 1, |
| 4721 | &descriptor_write); |
| 4722 | m_errorMonitor->VerifyFound(); |
| 4723 | m_commandBuffer->end(); |
| 4724 | |
| 4725 | // This is a test for VUID-vkCmdPushDescriptorSetKHR-commandBuffer-recording |
| 4726 | // TODO: Add VALIDATION_ERROR_ code support to core_validation::ValidateCmd |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 4727 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 4728 | "You must call vkBeginCommandBuffer() before this call to vkCmdPushDescriptorSetKHR()"); |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 4729 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkWriteDescriptorSet-descriptorType-00330"); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 4730 | vkCmdPushDescriptorSetKHR(m_commandBuffer->handle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline_layout.handle(), 0, 1, |
| 4731 | &descriptor_write); |
| 4732 | m_errorMonitor->VerifyFound(); |
| 4733 | } |
| 4734 | |
Jeremy Hayes | f96a516 | 2020-02-10 13:49:31 -0700 | [diff] [blame] | 4735 | TEST_F(VkLayerTest, PushDescriptorSetCmdBufferOffsetUnaligned) { |
| 4736 | TEST_DESCRIPTION("Attempt to push a push descriptor set buffer with unaligned offset."); |
| 4737 | if (InstanceExtensionSupported(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME)) { |
| 4738 | m_instance_extension_names.push_back(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME); |
| 4739 | } else { |
| 4740 | printf("%s %s Extension not supported, skipping tests\n", kSkipPrefix, |
| 4741 | VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME); |
| 4742 | return; |
| 4743 | } |
| 4744 | |
Mark Lobodzinski | 09ce9c4 | 2020-03-06 10:02:44 -0700 | [diff] [blame] | 4745 | ASSERT_NO_FATAL_FAILURE(InitFramework(m_errorMonitor)); |
Jeremy Hayes | f96a516 | 2020-02-10 13:49:31 -0700 | [diff] [blame] | 4746 | if (DeviceExtensionSupported(gpu(), nullptr, VK_KHR_PUSH_DESCRIPTOR_EXTENSION_NAME)) { |
| 4747 | m_device_extension_names.push_back(VK_KHR_PUSH_DESCRIPTOR_EXTENSION_NAME); |
| 4748 | } else { |
| 4749 | printf("%s %s Extension not supported, skipping tests\n", kSkipPrefix, VK_KHR_PUSH_DESCRIPTOR_EXTENSION_NAME); |
| 4750 | return; |
| 4751 | } |
| 4752 | ASSERT_NO_FATAL_FAILURE(InitState()); |
| 4753 | |
| 4754 | auto const push_descriptor_prop = GetPushDescriptorProperties(instance(), gpu()); |
| 4755 | if (push_descriptor_prop.maxPushDescriptors < 1) { |
| 4756 | // Some implementations report an invalid maxPushDescriptors of 0. |
| 4757 | printf("%s maxPushDescriptors is zero, skipping test\n", kSkipPrefix); |
| 4758 | return; |
| 4759 | } |
| 4760 | |
| 4761 | auto const min_alignment = m_device->props.limits.minUniformBufferOffsetAlignment; |
| 4762 | if (min_alignment == 0) { |
| 4763 | printf("%s minUniformBufferOffsetAlignment is zero, skipping test\n", kSkipPrefix); |
| 4764 | return; |
| 4765 | } |
| 4766 | |
| 4767 | VkDescriptorSetLayoutBinding binding = {0, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 1, VK_SHADER_STAGE_FRAGMENT_BIT, nullptr}; |
| 4768 | const VkDescriptorSetLayoutObj push_ds_layout(m_device, {binding}, VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR); |
| 4769 | ASSERT_TRUE(push_ds_layout.initialized()); |
| 4770 | |
| 4771 | const VkPipelineLayoutObj pipeline_layout(m_device, {&push_ds_layout}); |
| 4772 | ASSERT_TRUE(pipeline_layout.initialized()); |
| 4773 | |
| 4774 | const uint32_t buffer_data[4] = {4, 5, 6, 7}; |
| 4775 | VkConstantBufferObj buffer_obj(m_device, sizeof(buffer_data), &buffer_data, VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT); |
| 4776 | ASSERT_TRUE(buffer_obj.initialized()); |
| 4777 | |
| 4778 | // Use an invalid alignment. |
| 4779 | VkDescriptorBufferInfo buffer_info = {buffer_obj.handle(), min_alignment - 1, VK_WHOLE_SIZE}; |
| 4780 | VkWriteDescriptorSet descriptor_write = vk_testing::Device::write_descriptor_set( |
| 4781 | vk_testing::DescriptorSet(), 0, 0, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 1, &buffer_info); |
| 4782 | |
| 4783 | PFN_vkCmdPushDescriptorSetKHR vkCmdPushDescriptorSetKHR = |
| 4784 | (PFN_vkCmdPushDescriptorSetKHR)vk::GetDeviceProcAddr(m_device->device(), "vkCmdPushDescriptorSetKHR"); |
| 4785 | ASSERT_TRUE(vkCmdPushDescriptorSetKHR != nullptr); |
| 4786 | |
| 4787 | m_commandBuffer->begin(); |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 4788 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkWriteDescriptorSet-descriptorType-00327"); |
Jeremy Hayes | f96a516 | 2020-02-10 13:49:31 -0700 | [diff] [blame] | 4789 | vkCmdPushDescriptorSetKHR(m_commandBuffer->handle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline_layout.handle(), 0, 1, |
| 4790 | &descriptor_write); |
| 4791 | m_errorMonitor->VerifyFound(); |
| 4792 | |
| 4793 | m_commandBuffer->end(); |
| 4794 | } |
| 4795 | |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 4796 | TEST_F(VkLayerTest, SetDynScissorParamTests) { |
| 4797 | TEST_DESCRIPTION("Test parameters of vkCmdSetScissor without multiViewport feature"); |
| 4798 | |
| 4799 | VkPhysicalDeviceFeatures features{}; |
| 4800 | ASSERT_NO_FATAL_FAILURE(Init(&features)); |
| 4801 | |
| 4802 | const VkRect2D scissor = {{0, 0}, {16, 16}}; |
| 4803 | const VkRect2D scissors[] = {scissor, scissor}; |
| 4804 | |
| 4805 | m_commandBuffer->begin(); |
| 4806 | |
| 4807 | // array tests |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 4808 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdSetScissor-firstScissor-00593"); |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 4809 | vk::CmdSetScissor(m_commandBuffer->handle(), 1, 1, scissors); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 4810 | m_errorMonitor->VerifyFound(); |
| 4811 | |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 4812 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdSetScissor-scissorCount-arraylength"); |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 4813 | vk::CmdSetScissor(m_commandBuffer->handle(), 0, 0, nullptr); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 4814 | m_errorMonitor->VerifyFound(); |
| 4815 | |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 4816 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdSetScissor-scissorCount-00594"); |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 4817 | vk::CmdSetScissor(m_commandBuffer->handle(), 0, 2, scissors); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 4818 | m_errorMonitor->VerifyFound(); |
| 4819 | |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 4820 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdSetScissor-firstScissor-00593"); |
| 4821 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdSetScissor-scissorCount-00594"); |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 4822 | vk::CmdSetScissor(m_commandBuffer->handle(), 1, 2, scissors); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 4823 | m_errorMonitor->VerifyFound(); |
| 4824 | |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 4825 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdSetScissor-pScissors-parameter"); |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 4826 | vk::CmdSetScissor(m_commandBuffer->handle(), 0, 1, nullptr); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 4827 | m_errorMonitor->VerifyFound(); |
| 4828 | |
| 4829 | struct TestCase { |
| 4830 | VkRect2D scissor; |
| 4831 | std::string vuid; |
| 4832 | }; |
| 4833 | |
| 4834 | std::vector<TestCase> test_cases = {{{{-1, 0}, {16, 16}}, "VUID-vkCmdSetScissor-x-00595"}, |
| 4835 | {{{0, -1}, {16, 16}}, "VUID-vkCmdSetScissor-x-00595"}, |
| 4836 | {{{1, 0}, {INT32_MAX, 16}}, "VUID-vkCmdSetScissor-offset-00596"}, |
| 4837 | {{{INT32_MAX, 0}, {1, 16}}, "VUID-vkCmdSetScissor-offset-00596"}, |
| 4838 | {{{0, 0}, {uint32_t{INT32_MAX} + 1, 16}}, "VUID-vkCmdSetScissor-offset-00596"}, |
| 4839 | {{{0, 1}, {16, INT32_MAX}}, "VUID-vkCmdSetScissor-offset-00597"}, |
| 4840 | {{{0, INT32_MAX}, {16, 1}}, "VUID-vkCmdSetScissor-offset-00597"}, |
| 4841 | {{{0, 0}, {16, uint32_t{INT32_MAX} + 1}}, "VUID-vkCmdSetScissor-offset-00597"}}; |
| 4842 | |
| 4843 | for (const auto &test_case : test_cases) { |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 4844 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, test_case.vuid); |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 4845 | vk::CmdSetScissor(m_commandBuffer->handle(), 0, 1, &test_case.scissor); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 4846 | m_errorMonitor->VerifyFound(); |
| 4847 | } |
| 4848 | |
| 4849 | m_commandBuffer->end(); |
| 4850 | } |
| 4851 | |
| 4852 | TEST_F(VkLayerTest, SetDynScissorParamMultiviewportTests) { |
| 4853 | TEST_DESCRIPTION("Test parameters of vkCmdSetScissor with multiViewport feature enabled"); |
| 4854 | |
| 4855 | ASSERT_NO_FATAL_FAILURE(Init()); |
| 4856 | |
| 4857 | if (!m_device->phy().features().multiViewport) { |
| 4858 | printf("%s VkPhysicalDeviceFeatures::multiViewport is not supported -- skipping test.\n", kSkipPrefix); |
| 4859 | return; |
| 4860 | } |
| 4861 | |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 4862 | m_commandBuffer->begin(); |
| 4863 | |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 4864 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdSetScissor-scissorCount-arraylength"); |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 4865 | vk::CmdSetScissor(m_commandBuffer->handle(), 0, 0, nullptr); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 4866 | m_errorMonitor->VerifyFound(); |
| 4867 | |
Petr Kraus | 14e4949 | 2019-09-09 20:13:29 +0200 | [diff] [blame] | 4868 | const auto max_scissors = m_device->props.limits.maxViewports; |
| 4869 | |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 4870 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdSetScissor-pScissors-parameter"); |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 4871 | vk::CmdSetScissor(m_commandBuffer->handle(), 0, max_scissors, nullptr); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 4872 | m_errorMonitor->VerifyFound(); |
| 4873 | |
Petr Kraus | 14e4949 | 2019-09-09 20:13:29 +0200 | [diff] [blame] | 4874 | const uint32_t too_big_max_scissors = 65536 + 1; // let's say this is too much to allocate |
| 4875 | if (max_scissors >= too_big_max_scissors) { |
| 4876 | printf("%s VkPhysicalDeviceLimits::maxViewports is too large to practically test against -- skipping part of test.\n", |
| 4877 | kSkipPrefix); |
| 4878 | } else { |
| 4879 | const VkRect2D scissor = {{0, 0}, {16, 16}}; |
| 4880 | const std::vector<VkRect2D> scissors(max_scissors + 1, scissor); |
| 4881 | |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 4882 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdSetScissor-firstScissor-00592"); |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 4883 | vk::CmdSetScissor(m_commandBuffer->handle(), 0, max_scissors + 1, scissors.data()); |
Petr Kraus | 14e4949 | 2019-09-09 20:13:29 +0200 | [diff] [blame] | 4884 | m_errorMonitor->VerifyFound(); |
| 4885 | |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 4886 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdSetScissor-firstScissor-00592"); |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 4887 | vk::CmdSetScissor(m_commandBuffer->handle(), max_scissors, 1, scissors.data()); |
Petr Kraus | 14e4949 | 2019-09-09 20:13:29 +0200 | [diff] [blame] | 4888 | m_errorMonitor->VerifyFound(); |
| 4889 | |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 4890 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdSetScissor-firstScissor-00592"); |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 4891 | vk::CmdSetScissor(m_commandBuffer->handle(), 1, max_scissors, scissors.data()); |
Petr Kraus | 14e4949 | 2019-09-09 20:13:29 +0200 | [diff] [blame] | 4892 | m_errorMonitor->VerifyFound(); |
| 4893 | |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 4894 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdSetScissor-scissorCount-arraylength"); |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 4895 | vk::CmdSetScissor(m_commandBuffer->handle(), 1, 0, scissors.data()); |
Petr Kraus | 14e4949 | 2019-09-09 20:13:29 +0200 | [diff] [blame] | 4896 | m_errorMonitor->VerifyFound(); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 4897 | } |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 4898 | } |
| 4899 | |
| 4900 | TEST_F(VkLayerTest, DrawIndirect) { |
| 4901 | TEST_DESCRIPTION("Test covered valid usage for vkCmdDrawIndirect"); |
| 4902 | |
| 4903 | ASSERT_NO_FATAL_FAILURE(Init()); |
| 4904 | ASSERT_NO_FATAL_FAILURE(InitRenderTarget()); |
| 4905 | |
locke-lunarg | 8e2c91b | 2019-06-11 17:53:26 -0600 | [diff] [blame] | 4906 | CreatePipelineHelper pipe(*this); |
| 4907 | pipe.InitInfo(); |
| 4908 | const VkDynamicState dyn_states[] = {VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR}; |
| 4909 | VkPipelineDynamicStateCreateInfo dyn_state_ci = {}; |
| 4910 | dyn_state_ci.sType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO; |
| 4911 | dyn_state_ci.dynamicStateCount = size(dyn_states); |
| 4912 | dyn_state_ci.pDynamicStates = dyn_states; |
| 4913 | pipe.dyn_state_ci_ = dyn_state_ci; |
| 4914 | pipe.InitState(); |
| 4915 | pipe.CreateGraphicsPipeline(); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 4916 | |
| 4917 | m_commandBuffer->begin(); |
| 4918 | m_commandBuffer->BeginRenderPass(m_renderPassBeginInfo); |
| 4919 | |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 4920 | vk::CmdBindPipeline(m_commandBuffer->handle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipe.pipeline_); |
| 4921 | vk::CmdBindDescriptorSets(m_commandBuffer->handle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipe.pipeline_layout_.handle(), 0, 1, |
| 4922 | &pipe.descriptor_set_->set_, 0, NULL); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 4923 | |
| 4924 | VkViewport viewport = {0, 0, 16, 16, 0, 1}; |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 4925 | vk::CmdSetViewport(m_commandBuffer->handle(), 0, 1, &viewport); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 4926 | VkRect2D scissor = {{0, 0}, {16, 16}}; |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 4927 | vk::CmdSetScissor(m_commandBuffer->handle(), 0, 1, &scissor); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 4928 | |
| 4929 | VkBufferCreateInfo buffer_create_info = {VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO}; |
| 4930 | buffer_create_info.usage = VK_BUFFER_USAGE_VERTEX_BUFFER_BIT; |
| 4931 | buffer_create_info.size = sizeof(VkDrawIndirectCommand); |
locke-lunarg | 8e2c91b | 2019-06-11 17:53:26 -0600 | [diff] [blame] | 4932 | VkBufferObj draw_buffer; |
| 4933 | draw_buffer.init(*m_device, buffer_create_info); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 4934 | |
| 4935 | // VUID-vkCmdDrawIndirect-buffer-02709 |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 4936 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdDrawIndirect-buffer-02709"); |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 4937 | vk::CmdDrawIndirect(m_commandBuffer->handle(), draw_buffer.handle(), 0, 1, sizeof(VkDrawIndirectCommand)); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 4938 | m_errorMonitor->VerifyFound(); |
| 4939 | |
| 4940 | m_commandBuffer->EndRenderPass(); |
| 4941 | m_commandBuffer->end(); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 4942 | } |
| 4943 | |
Mark Lobodzinski | 977f034 | 2019-12-19 14:24:09 -0700 | [diff] [blame] | 4944 | TEST_F(VkLayerTest, DrawIndirectByteCountEXT) { |
| 4945 | TEST_DESCRIPTION("Test covered valid usage for vkCmdDrawIndirectByteCountEXT"); |
| 4946 | |
| 4947 | if (InstanceExtensionSupported(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME)) { |
| 4948 | m_instance_extension_names.push_back(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME); |
| 4949 | } else { |
| 4950 | printf("%s Did not find required instance extension %s; skipped.\n", kSkipPrefix, |
| 4951 | VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME); |
| 4952 | return; |
| 4953 | } |
Mark Lobodzinski | 09ce9c4 | 2020-03-06 10:02:44 -0700 | [diff] [blame] | 4954 | ASSERT_NO_FATAL_FAILURE(InitFramework(m_errorMonitor)); |
Mark Lobodzinski | 977f034 | 2019-12-19 14:24:09 -0700 | [diff] [blame] | 4955 | |
| 4956 | if (DeviceExtensionSupported(gpu(), nullptr, VK_EXT_TRANSFORM_FEEDBACK_EXTENSION_NAME)) { |
| 4957 | m_device_extension_names.push_back(VK_EXT_TRANSFORM_FEEDBACK_EXTENSION_NAME); |
| 4958 | } else { |
| 4959 | printf("%s VK_EXT_transform_feedback extension not supported, skipping test\n", kSkipPrefix); |
Mark Lobodzinski | d01b2bc | 2019-12-20 10:19:36 -0700 | [diff] [blame] | 4960 | return; |
Mark Lobodzinski | 977f034 | 2019-12-19 14:24:09 -0700 | [diff] [blame] | 4961 | } |
| 4962 | |
| 4963 | ASSERT_NO_FATAL_FAILURE(InitState()); |
| 4964 | ASSERT_NO_FATAL_FAILURE(InitRenderTarget()); |
| 4965 | |
| 4966 | PFN_vkCmdDrawIndirectByteCountEXT fpvkCmdDrawIndirectByteCountEXT = |
| 4967 | (PFN_vkCmdDrawIndirectByteCountEXT)vk::GetDeviceProcAddr(device(), "vkCmdDrawIndirectByteCountEXT"); |
| 4968 | |
| 4969 | m_commandBuffer->begin(); |
| 4970 | m_commandBuffer->BeginRenderPass(m_renderPassBeginInfo); |
| 4971 | VkBufferCreateInfo buffer_create_info = {VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO}; |
| 4972 | buffer_create_info.usage = VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT; |
| 4973 | buffer_create_info.size = 1024; |
| 4974 | VkBufferObj counter_buffer; |
| 4975 | counter_buffer.init(*m_device, buffer_create_info); |
| 4976 | |
| 4977 | // VUID-vkCmdDrawIndirectByteCountEXT-vertexStride-02289 |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 4978 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdDrawIndirectByteCountEXT-vertexStride-02289"); |
Mark Lobodzinski | 977f034 | 2019-12-19 14:24:09 -0700 | [diff] [blame] | 4979 | fpvkCmdDrawIndirectByteCountEXT(m_commandBuffer->handle(), 1, 0, counter_buffer.handle(), 0, 1, 0xCADECADE); |
| 4980 | m_errorMonitor->VerifyFound(); |
| 4981 | |
| 4982 | m_commandBuffer->EndRenderPass(); |
| 4983 | m_commandBuffer->end(); |
| 4984 | } |
| 4985 | |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 4986 | TEST_F(VkLayerTest, DrawIndirectCountKHR) { |
| 4987 | TEST_DESCRIPTION("Test covered valid usage for vkCmdDrawIndirectCountKHR"); |
| 4988 | |
Mark Lobodzinski | 09ce9c4 | 2020-03-06 10:02:44 -0700 | [diff] [blame] | 4989 | ASSERT_NO_FATAL_FAILURE(InitFramework(m_errorMonitor)); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 4990 | if (DeviceExtensionSupported(gpu(), nullptr, VK_KHR_DRAW_INDIRECT_COUNT_EXTENSION_NAME)) { |
| 4991 | m_device_extension_names.push_back(VK_KHR_DRAW_INDIRECT_COUNT_EXTENSION_NAME); |
| 4992 | } else { |
| 4993 | printf(" VK_KHR_draw_indirect_count Extension not supported, skipping test\n"); |
| 4994 | return; |
| 4995 | } |
| 4996 | ASSERT_NO_FATAL_FAILURE(InitState()); |
| 4997 | ASSERT_NO_FATAL_FAILURE(InitRenderTarget()); |
| 4998 | |
| 4999 | VkMemoryRequirements memory_requirements; |
| 5000 | VkMemoryAllocateInfo memory_allocate_info = {VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO}; |
| 5001 | |
| 5002 | auto vkCmdDrawIndirectCountKHR = |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 5003 | (PFN_vkCmdDrawIndirectCountKHR)vk::GetDeviceProcAddr(m_device->device(), "vkCmdDrawIndirectCountKHR"); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 5004 | |
locke-lunarg | 8e2c91b | 2019-06-11 17:53:26 -0600 | [diff] [blame] | 5005 | CreatePipelineHelper pipe(*this); |
| 5006 | pipe.InitInfo(); |
| 5007 | const VkDynamicState dyn_states[] = {VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR}; |
| 5008 | VkPipelineDynamicStateCreateInfo dyn_state_ci = {}; |
| 5009 | dyn_state_ci.sType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO; |
| 5010 | dyn_state_ci.dynamicStateCount = size(dyn_states); |
| 5011 | dyn_state_ci.pDynamicStates = dyn_states; |
| 5012 | pipe.dyn_state_ci_ = dyn_state_ci; |
| 5013 | pipe.InitState(); |
| 5014 | pipe.CreateGraphicsPipeline(); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 5015 | |
| 5016 | m_commandBuffer->begin(); |
| 5017 | m_commandBuffer->BeginRenderPass(m_renderPassBeginInfo); |
| 5018 | |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 5019 | vk::CmdBindPipeline(m_commandBuffer->handle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipe.pipeline_); |
| 5020 | vk::CmdBindDescriptorSets(m_commandBuffer->handle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipe.pipeline_layout_.handle(), 0, 1, |
| 5021 | &pipe.descriptor_set_->set_, 0, NULL); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 5022 | |
| 5023 | VkViewport viewport = {0, 0, 16, 16, 0, 1}; |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 5024 | vk::CmdSetViewport(m_commandBuffer->handle(), 0, 1, &viewport); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 5025 | VkRect2D scissor = {{0, 0}, {16, 16}}; |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 5026 | vk::CmdSetScissor(m_commandBuffer->handle(), 0, 1, &scissor); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 5027 | |
| 5028 | VkBufferCreateInfo buffer_create_info = {VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO}; |
| 5029 | buffer_create_info.size = sizeof(VkDrawIndirectCommand); |
| 5030 | buffer_create_info.usage = VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT; |
| 5031 | VkBuffer draw_buffer; |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 5032 | vk::CreateBuffer(m_device->device(), &buffer_create_info, nullptr, &draw_buffer); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 5033 | |
| 5034 | VkBufferCreateInfo count_buffer_create_info = {VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO}; |
| 5035 | count_buffer_create_info.size = sizeof(uint32_t); |
| 5036 | count_buffer_create_info.usage = VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT; |
locke-lunarg | 8e2c91b | 2019-06-11 17:53:26 -0600 | [diff] [blame] | 5037 | VkBufferObj count_buffer; |
| 5038 | count_buffer.init(*m_device, count_buffer_create_info); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 5039 | |
Mike Schuchardt | 65847d9 | 2019-12-20 13:50:47 -0800 | [diff] [blame] | 5040 | // VUID-vkCmdDrawIndirectCount-buffer-02708 |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 5041 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdDrawIndirectCount-buffer-02708"); |
locke-lunarg | 8e2c91b | 2019-06-11 17:53:26 -0600 | [diff] [blame] | 5042 | vkCmdDrawIndirectCountKHR(m_commandBuffer->handle(), draw_buffer, 0, count_buffer.handle(), 0, 1, |
| 5043 | sizeof(VkDrawIndirectCommand)); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 5044 | m_errorMonitor->VerifyFound(); |
| 5045 | |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 5046 | vk::GetBufferMemoryRequirements(m_device->device(), draw_buffer, &memory_requirements); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 5047 | memory_allocate_info.allocationSize = memory_requirements.size; |
| 5048 | m_device->phy().set_memory_type(memory_requirements.memoryTypeBits, &memory_allocate_info, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT); |
| 5049 | VkDeviceMemory draw_buffer_memory; |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 5050 | vk::AllocateMemory(m_device->device(), &memory_allocate_info, NULL, &draw_buffer_memory); |
| 5051 | vk::BindBufferMemory(m_device->device(), draw_buffer, draw_buffer_memory, 0); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 5052 | |
| 5053 | VkBuffer count_buffer_unbound; |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 5054 | vk::CreateBuffer(m_device->device(), &count_buffer_create_info, nullptr, &count_buffer_unbound); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 5055 | |
Mike Schuchardt | 65847d9 | 2019-12-20 13:50:47 -0800 | [diff] [blame] | 5056 | // VUID-vkCmdDrawIndirectCount-countBuffer-02714 |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 5057 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdDrawIndirectCount-countBuffer-02714"); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 5058 | vkCmdDrawIndirectCountKHR(m_commandBuffer->handle(), draw_buffer, 0, count_buffer_unbound, 0, 1, sizeof(VkDrawIndirectCommand)); |
| 5059 | m_errorMonitor->VerifyFound(); |
| 5060 | |
Mike Schuchardt | 65847d9 | 2019-12-20 13:50:47 -0800 | [diff] [blame] | 5061 | // VUID-vkCmdDrawIndirectCount-offset-02710 |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 5062 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdDrawIndirectCount-offset-02710"); |
locke-lunarg | 8e2c91b | 2019-06-11 17:53:26 -0600 | [diff] [blame] | 5063 | vkCmdDrawIndirectCountKHR(m_commandBuffer->handle(), draw_buffer, 1, count_buffer.handle(), 0, 1, |
| 5064 | sizeof(VkDrawIndirectCommand)); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 5065 | m_errorMonitor->VerifyFound(); |
| 5066 | |
Mike Schuchardt | 65847d9 | 2019-12-20 13:50:47 -0800 | [diff] [blame] | 5067 | // VUID-vkCmdDrawIndirectCount-countBufferOffset-02716 |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 5068 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdDrawIndirectCount-countBufferOffset-02716"); |
locke-lunarg | 8e2c91b | 2019-06-11 17:53:26 -0600 | [diff] [blame] | 5069 | vkCmdDrawIndirectCountKHR(m_commandBuffer->handle(), draw_buffer, 0, count_buffer.handle(), 1, 1, |
| 5070 | sizeof(VkDrawIndirectCommand)); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 5071 | m_errorMonitor->VerifyFound(); |
| 5072 | |
Mike Schuchardt | 65847d9 | 2019-12-20 13:50:47 -0800 | [diff] [blame] | 5073 | // VUID-vkCmdDrawIndirectCount-stride-03110 |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 5074 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdDrawIndirectCount-stride-03110"); |
locke-lunarg | 8e2c91b | 2019-06-11 17:53:26 -0600 | [diff] [blame] | 5075 | vkCmdDrawIndirectCountKHR(m_commandBuffer->handle(), draw_buffer, 0, count_buffer.handle(), 0, 1, 1); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 5076 | m_errorMonitor->VerifyFound(); |
| 5077 | |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 5078 | // TODO: These covered VUIDs aren't tested. There is also no test coverage for the core Vulkan 1.0 vk::CmdDraw* equivalent of |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 5079 | // these: |
Mike Schuchardt | 65847d9 | 2019-12-20 13:50:47 -0800 | [diff] [blame] | 5080 | // VUID-vkCmdDrawIndirectCount-renderPass-02684 |
| 5081 | // VUID-vkCmdDrawIndirectCount-subpass-02685 |
| 5082 | // VUID-vkCmdDrawIndirectCount-commandBuffer-02701 |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 5083 | |
| 5084 | m_commandBuffer->EndRenderPass(); |
| 5085 | m_commandBuffer->end(); |
| 5086 | |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 5087 | vk::DestroyBuffer(m_device->device(), draw_buffer, 0); |
| 5088 | vk::DestroyBuffer(m_device->device(), count_buffer_unbound, 0); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 5089 | |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 5090 | vk::FreeMemory(m_device->device(), draw_buffer_memory, 0); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 5091 | } |
| 5092 | |
| 5093 | TEST_F(VkLayerTest, DrawIndexedIndirectCountKHR) { |
| 5094 | TEST_DESCRIPTION("Test covered valid usage for vkCmdDrawIndexedIndirectCountKHR"); |
| 5095 | |
Mark Lobodzinski | 09ce9c4 | 2020-03-06 10:02:44 -0700 | [diff] [blame] | 5096 | ASSERT_NO_FATAL_FAILURE(InitFramework(m_errorMonitor)); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 5097 | if (DeviceExtensionSupported(gpu(), nullptr, VK_KHR_DRAW_INDIRECT_COUNT_EXTENSION_NAME)) { |
| 5098 | m_device_extension_names.push_back(VK_KHR_DRAW_INDIRECT_COUNT_EXTENSION_NAME); |
| 5099 | } else { |
| 5100 | printf(" VK_KHR_draw_indirect_count Extension not supported, skipping test\n"); |
| 5101 | return; |
| 5102 | } |
| 5103 | ASSERT_NO_FATAL_FAILURE(InitState()); |
| 5104 | ASSERT_NO_FATAL_FAILURE(InitRenderTarget()); |
| 5105 | |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 5106 | auto vkCmdDrawIndexedIndirectCountKHR = |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 5107 | (PFN_vkCmdDrawIndexedIndirectCountKHR)vk::GetDeviceProcAddr(m_device->device(), "vkCmdDrawIndexedIndirectCountKHR"); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 5108 | |
locke-lunarg | 8e2c91b | 2019-06-11 17:53:26 -0600 | [diff] [blame] | 5109 | CreatePipelineHelper pipe(*this); |
| 5110 | pipe.InitInfo(); |
| 5111 | const VkDynamicState dyn_states[] = {VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR}; |
| 5112 | VkPipelineDynamicStateCreateInfo dyn_state_ci = {}; |
| 5113 | dyn_state_ci.sType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO; |
| 5114 | dyn_state_ci.dynamicStateCount = size(dyn_states); |
| 5115 | dyn_state_ci.pDynamicStates = dyn_states; |
| 5116 | pipe.dyn_state_ci_ = dyn_state_ci; |
| 5117 | pipe.InitState(); |
| 5118 | pipe.CreateGraphicsPipeline(); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 5119 | |
| 5120 | m_commandBuffer->begin(); |
| 5121 | m_commandBuffer->BeginRenderPass(m_renderPassBeginInfo); |
| 5122 | |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 5123 | vk::CmdBindPipeline(m_commandBuffer->handle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipe.pipeline_); |
| 5124 | vk::CmdBindDescriptorSets(m_commandBuffer->handle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipe.pipeline_layout_.handle(), 0, 1, |
| 5125 | &pipe.descriptor_set_->set_, 0, NULL); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 5126 | |
| 5127 | VkViewport viewport = {0, 0, 16, 16, 0, 1}; |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 5128 | vk::CmdSetViewport(m_commandBuffer->handle(), 0, 1, &viewport); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 5129 | VkRect2D scissor = {{0, 0}, {16, 16}}; |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 5130 | vk::CmdSetScissor(m_commandBuffer->handle(), 0, 1, &scissor); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 5131 | |
| 5132 | VkBufferCreateInfo buffer_create_info = {VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO}; |
| 5133 | buffer_create_info.size = sizeof(VkDrawIndexedIndirectCommand); |
| 5134 | buffer_create_info.usage = VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT; |
locke-lunarg | 8e2c91b | 2019-06-11 17:53:26 -0600 | [diff] [blame] | 5135 | VkBufferObj draw_buffer; |
| 5136 | draw_buffer.init(*m_device, buffer_create_info); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 5137 | |
| 5138 | VkBufferCreateInfo count_buffer_create_info = {VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO}; |
| 5139 | count_buffer_create_info.size = sizeof(uint32_t); |
| 5140 | count_buffer_create_info.usage = VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT; |
locke-lunarg | 8e2c91b | 2019-06-11 17:53:26 -0600 | [diff] [blame] | 5141 | VkBufferObj count_buffer; |
| 5142 | count_buffer.init(*m_device, count_buffer_create_info); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 5143 | |
| 5144 | VkBufferCreateInfo index_buffer_create_info = {VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO}; |
| 5145 | index_buffer_create_info.size = sizeof(uint32_t); |
| 5146 | index_buffer_create_info.usage = VK_BUFFER_USAGE_INDEX_BUFFER_BIT; |
locke-lunarg | 8e2c91b | 2019-06-11 17:53:26 -0600 | [diff] [blame] | 5147 | VkBufferObj index_buffer; |
| 5148 | index_buffer.init(*m_device, index_buffer_create_info); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 5149 | |
Mike Schuchardt | 65847d9 | 2019-12-20 13:50:47 -0800 | [diff] [blame] | 5150 | // VUID-vkCmdDrawIndexedIndirectCount-commandBuffer-02701 (partial - only tests whether the index buffer is bound) |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 5151 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdDrawIndexedIndirectCount-commandBuffer-02701"); |
locke-lunarg | 8e2c91b | 2019-06-11 17:53:26 -0600 | [diff] [blame] | 5152 | vkCmdDrawIndexedIndirectCountKHR(m_commandBuffer->handle(), draw_buffer.handle(), 0, count_buffer.handle(), 0, 1, |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 5153 | sizeof(VkDrawIndexedIndirectCommand)); |
| 5154 | m_errorMonitor->VerifyFound(); |
| 5155 | |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 5156 | vk::CmdBindIndexBuffer(m_commandBuffer->handle(), index_buffer.handle(), 0, VK_INDEX_TYPE_UINT32); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 5157 | |
| 5158 | VkBuffer draw_buffer_unbound; |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 5159 | vk::CreateBuffer(m_device->device(), &count_buffer_create_info, nullptr, &draw_buffer_unbound); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 5160 | |
Mike Schuchardt | 65847d9 | 2019-12-20 13:50:47 -0800 | [diff] [blame] | 5161 | // VUID-vkCmdDrawIndexedIndirectCount-buffer-02708 |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 5162 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdDrawIndexedIndirectCount-buffer-02708"); |
locke-lunarg | 8e2c91b | 2019-06-11 17:53:26 -0600 | [diff] [blame] | 5163 | vkCmdDrawIndexedIndirectCountKHR(m_commandBuffer->handle(), draw_buffer_unbound, 0, count_buffer.handle(), 0, 1, |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 5164 | sizeof(VkDrawIndexedIndirectCommand)); |
| 5165 | m_errorMonitor->VerifyFound(); |
| 5166 | |
| 5167 | VkBuffer count_buffer_unbound; |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 5168 | vk::CreateBuffer(m_device->device(), &count_buffer_create_info, nullptr, &count_buffer_unbound); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 5169 | |
Mike Schuchardt | 65847d9 | 2019-12-20 13:50:47 -0800 | [diff] [blame] | 5170 | // VUID-vkCmdDrawIndexedIndirectCount-countBuffer-02714 |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 5171 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdDrawIndexedIndirectCount-countBuffer-02714"); |
locke-lunarg | 8e2c91b | 2019-06-11 17:53:26 -0600 | [diff] [blame] | 5172 | vkCmdDrawIndexedIndirectCountKHR(m_commandBuffer->handle(), draw_buffer.handle(), 0, count_buffer_unbound, 0, 1, |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 5173 | sizeof(VkDrawIndexedIndirectCommand)); |
| 5174 | m_errorMonitor->VerifyFound(); |
| 5175 | |
Mike Schuchardt | 65847d9 | 2019-12-20 13:50:47 -0800 | [diff] [blame] | 5176 | // VUID-vkCmdDrawIndexedIndirectCount-offset-02710 |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 5177 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdDrawIndexedIndirectCount-offset-02710"); |
locke-lunarg | 8e2c91b | 2019-06-11 17:53:26 -0600 | [diff] [blame] | 5178 | vkCmdDrawIndexedIndirectCountKHR(m_commandBuffer->handle(), draw_buffer.handle(), 1, count_buffer.handle(), 0, 1, |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 5179 | sizeof(VkDrawIndexedIndirectCommand)); |
| 5180 | m_errorMonitor->VerifyFound(); |
| 5181 | |
Mike Schuchardt | 65847d9 | 2019-12-20 13:50:47 -0800 | [diff] [blame] | 5182 | // VUID-vkCmdDrawIndexedIndirectCount-countBufferOffset-02716 |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 5183 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdDrawIndexedIndirectCount-countBufferOffset-02716"); |
locke-lunarg | 8e2c91b | 2019-06-11 17:53:26 -0600 | [diff] [blame] | 5184 | vkCmdDrawIndexedIndirectCountKHR(m_commandBuffer->handle(), draw_buffer.handle(), 0, count_buffer.handle(), 1, 1, |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 5185 | sizeof(VkDrawIndexedIndirectCommand)); |
| 5186 | m_errorMonitor->VerifyFound(); |
| 5187 | |
Mike Schuchardt | 65847d9 | 2019-12-20 13:50:47 -0800 | [diff] [blame] | 5188 | // VUID-vkCmdDrawIndexedIndirectCount-stride-03142 |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 5189 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdDrawIndexedIndirectCount-stride-03142"); |
locke-lunarg | 8e2c91b | 2019-06-11 17:53:26 -0600 | [diff] [blame] | 5190 | vkCmdDrawIndexedIndirectCountKHR(m_commandBuffer->handle(), draw_buffer.handle(), 0, count_buffer.handle(), 0, 1, 1); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 5191 | m_errorMonitor->VerifyFound(); |
| 5192 | |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 5193 | // TODO: These covered VUIDs aren't tested. There is also no test coverage for the core Vulkan 1.0 vk::CmdDraw* equivalent of |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 5194 | // these: |
Mike Schuchardt | 65847d9 | 2019-12-20 13:50:47 -0800 | [diff] [blame] | 5195 | // VUID-vkCmdDrawIndexedIndirectCount-renderPass-02684 |
| 5196 | // VUID-vkCmdDrawIndexedIndirectCount-subpass-02685 |
| 5197 | // VUID-vkCmdDrawIndexedIndirectCount-commandBuffer-02701 (partial) |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 5198 | |
| 5199 | m_commandBuffer->EndRenderPass(); |
| 5200 | m_commandBuffer->end(); |
| 5201 | |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 5202 | vk::DestroyBuffer(m_device->device(), draw_buffer_unbound, 0); |
| 5203 | vk::DestroyBuffer(m_device->device(), count_buffer_unbound, 0); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 5204 | } |
| 5205 | |
sfricke-samsung | 860d3b2 | 2020-05-04 21:08:29 -0700 | [diff] [blame] | 5206 | TEST_F(VkLayerTest, DrawIndirectCountFeature) { |
| 5207 | TEST_DESCRIPTION("Test covered valid usage for the 1.2 drawIndirectCount feature"); |
| 5208 | |
| 5209 | SetTargetApiVersion(VK_API_VERSION_1_2); |
| 5210 | ASSERT_NO_FATAL_FAILURE(Init()); |
| 5211 | ASSERT_NO_FATAL_FAILURE(InitRenderTarget()); |
| 5212 | if (DeviceValidationVersion() < VK_API_VERSION_1_2) { |
| 5213 | printf("%s Tests requires Vulkan 1.2+, skipping test\n", kSkipPrefix); |
| 5214 | return; |
| 5215 | } |
| 5216 | |
| 5217 | VkBufferObj indirect_buffer; |
| 5218 | indirect_buffer.init(*m_device, sizeof(VkDrawIndirectCommand), VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, |
| 5219 | VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT); |
| 5220 | |
| 5221 | VkBufferObj indexed_indirect_buffer; |
| 5222 | indexed_indirect_buffer.init(*m_device, sizeof(VkDrawIndexedIndirectCommand), VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, |
| 5223 | VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT); |
| 5224 | |
| 5225 | VkBufferObj count_buffer; |
| 5226 | count_buffer.init(*m_device, sizeof(uint32_t), VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT); |
| 5227 | |
| 5228 | VkBufferObj index_buffer; |
| 5229 | index_buffer.init(*m_device, sizeof(uint32_t), VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, VK_BUFFER_USAGE_INDEX_BUFFER_BIT); |
| 5230 | |
| 5231 | CreatePipelineHelper pipe(*this); |
| 5232 | pipe.InitInfo(); |
| 5233 | pipe.InitState(); |
| 5234 | pipe.CreateGraphicsPipeline(); |
| 5235 | |
| 5236 | // Make calls to valid commands but without the drawIndirectCount feature set |
| 5237 | m_commandBuffer->begin(); |
| 5238 | m_commandBuffer->BeginRenderPass(m_renderPassBeginInfo); |
| 5239 | |
| 5240 | vk::CmdBindPipeline(m_commandBuffer->handle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipe.pipeline_); |
| 5241 | |
| 5242 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdDrawIndirectCount-None-02836"); |
| 5243 | vk::CmdDrawIndirectCount(m_commandBuffer->handle(), indirect_buffer.handle(), 0, count_buffer.handle(), 0, 1, |
| 5244 | sizeof(VkDrawIndirectCommand)); |
| 5245 | m_errorMonitor->VerifyFound(); |
| 5246 | |
| 5247 | vk::CmdBindIndexBuffer(m_commandBuffer->handle(), index_buffer.handle(), 0, VK_INDEX_TYPE_UINT32); |
| 5248 | |
| 5249 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdDrawIndexedIndirect-None-02837"); |
| 5250 | vk::CmdDrawIndexedIndirectCount(m_commandBuffer->handle(), indexed_indirect_buffer.handle(), 0, count_buffer.handle(), 0, 1, |
| 5251 | sizeof(VkDrawIndexedIndirectCommand)); |
| 5252 | m_errorMonitor->VerifyFound(); |
| 5253 | |
| 5254 | m_commandBuffer->EndRenderPass(); |
| 5255 | m_commandBuffer->end(); |
| 5256 | } |
| 5257 | |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 5258 | TEST_F(VkLayerTest, ExclusiveScissorNV) { |
| 5259 | TEST_DESCRIPTION("Test VK_NV_scissor_exclusive with multiViewport disabled."); |
| 5260 | |
| 5261 | if (InstanceExtensionSupported(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME)) { |
| 5262 | m_instance_extension_names.push_back(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME); |
| 5263 | } else { |
| 5264 | printf("%s Did not find required instance extension %s; skipped.\n", kSkipPrefix, |
| 5265 | VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME); |
| 5266 | return; |
| 5267 | } |
Mark Lobodzinski | 09ce9c4 | 2020-03-06 10:02:44 -0700 | [diff] [blame] | 5268 | ASSERT_NO_FATAL_FAILURE(InitFramework(m_errorMonitor)); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 5269 | std::array<const char *, 1> required_device_extensions = {{VK_NV_SCISSOR_EXCLUSIVE_EXTENSION_NAME}}; |
| 5270 | for (auto device_extension : required_device_extensions) { |
| 5271 | if (DeviceExtensionSupported(gpu(), nullptr, device_extension)) { |
| 5272 | m_device_extension_names.push_back(device_extension); |
| 5273 | } else { |
| 5274 | printf("%s %s Extension not supported, skipping tests\n", kSkipPrefix, device_extension); |
| 5275 | return; |
| 5276 | } |
| 5277 | } |
| 5278 | |
| 5279 | PFN_vkGetPhysicalDeviceFeatures2KHR vkGetPhysicalDeviceFeatures2KHR = |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 5280 | (PFN_vkGetPhysicalDeviceFeatures2KHR)vk::GetInstanceProcAddr(instance(), "vkGetPhysicalDeviceFeatures2KHR"); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 5281 | ASSERT_TRUE(vkGetPhysicalDeviceFeatures2KHR != nullptr); |
| 5282 | |
| 5283 | // Create a device that enables exclusive scissor but disables multiViewport |
| 5284 | auto exclusive_scissor_features = lvl_init_struct<VkPhysicalDeviceExclusiveScissorFeaturesNV>(); |
| 5285 | auto features2 = lvl_init_struct<VkPhysicalDeviceFeatures2KHR>(&exclusive_scissor_features); |
| 5286 | vkGetPhysicalDeviceFeatures2KHR(gpu(), &features2); |
| 5287 | |
| 5288 | features2.features.multiViewport = VK_FALSE; |
| 5289 | |
| 5290 | ASSERT_NO_FATAL_FAILURE(InitState(nullptr, &features2)); |
| 5291 | ASSERT_NO_FATAL_FAILURE(InitRenderTarget()); |
| 5292 | |
| 5293 | if (m_device->phy().properties().limits.maxViewports) { |
| 5294 | printf("%s Device doesn't support the necessary number of viewports, skipping test.\n", kSkipPrefix); |
| 5295 | return; |
| 5296 | } |
| 5297 | |
| 5298 | // Based on PSOViewportStateTests |
| 5299 | { |
| 5300 | VkViewport viewport = {0.0f, 0.0f, 64.0f, 64.0f, 0.0f, 1.0f}; |
| 5301 | VkViewport viewports[] = {viewport, viewport}; |
| 5302 | VkRect2D scissor = {{0, 0}, {64, 64}}; |
| 5303 | VkRect2D scissors[100] = {scissor, scissor}; |
| 5304 | |
| 5305 | using std::vector; |
| 5306 | struct TestCase { |
| 5307 | uint32_t viewport_count; |
| 5308 | VkViewport *viewports; |
| 5309 | uint32_t scissor_count; |
| 5310 | VkRect2D *scissors; |
| 5311 | uint32_t exclusive_scissor_count; |
| 5312 | VkRect2D *exclusive_scissors; |
| 5313 | |
| 5314 | vector<std::string> vuids; |
| 5315 | }; |
| 5316 | |
| 5317 | vector<TestCase> test_cases = { |
| 5318 | {1, |
| 5319 | viewports, |
| 5320 | 1, |
| 5321 | scissors, |
| 5322 | 2, |
| 5323 | scissors, |
| 5324 | {"VUID-VkPipelineViewportExclusiveScissorStateCreateInfoNV-exclusiveScissorCount-02027", |
| 5325 | "VUID-VkPipelineViewportExclusiveScissorStateCreateInfoNV-exclusiveScissorCount-02029"}}, |
| 5326 | {1, |
| 5327 | viewports, |
| 5328 | 1, |
| 5329 | scissors, |
| 5330 | 100, |
| 5331 | scissors, |
| 5332 | {"VUID-VkPipelineViewportExclusiveScissorStateCreateInfoNV-exclusiveScissorCount-02027", |
| 5333 | "VUID-VkPipelineViewportExclusiveScissorStateCreateInfoNV-exclusiveScissorCount-02028", |
| 5334 | "VUID-VkPipelineViewportExclusiveScissorStateCreateInfoNV-exclusiveScissorCount-02029"}}, |
| 5335 | {1, |
| 5336 | viewports, |
| 5337 | 1, |
| 5338 | scissors, |
| 5339 | 1, |
| 5340 | nullptr, |
| 5341 | {"VUID-VkPipelineViewportExclusiveScissorStateCreateInfoNV-pDynamicStates-02030"}}, |
| 5342 | }; |
| 5343 | |
| 5344 | for (const auto &test_case : test_cases) { |
| 5345 | VkPipelineViewportExclusiveScissorStateCreateInfoNV exc = { |
| 5346 | VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV}; |
| 5347 | |
| 5348 | const auto break_vp = [&test_case, &exc](CreatePipelineHelper &helper) { |
| 5349 | helper.vp_state_ci_.viewportCount = test_case.viewport_count; |
| 5350 | helper.vp_state_ci_.pViewports = test_case.viewports; |
| 5351 | helper.vp_state_ci_.scissorCount = test_case.scissor_count; |
| 5352 | helper.vp_state_ci_.pScissors = test_case.scissors; |
| 5353 | helper.vp_state_ci_.pNext = &exc; |
| 5354 | |
| 5355 | exc.exclusiveScissorCount = test_case.exclusive_scissor_count; |
| 5356 | exc.pExclusiveScissors = test_case.exclusive_scissors; |
| 5357 | }; |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 5358 | CreatePipelineHelper::OneshotTest(*this, break_vp, kErrorBit, test_case.vuids); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 5359 | } |
| 5360 | } |
| 5361 | |
| 5362 | // Based on SetDynScissorParamTests |
| 5363 | { |
| 5364 | auto vkCmdSetExclusiveScissorNV = |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 5365 | (PFN_vkCmdSetExclusiveScissorNV)vk::GetDeviceProcAddr(m_device->device(), "vkCmdSetExclusiveScissorNV"); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 5366 | |
| 5367 | const VkRect2D scissor = {{0, 0}, {16, 16}}; |
| 5368 | const VkRect2D scissors[] = {scissor, scissor}; |
| 5369 | |
| 5370 | m_commandBuffer->begin(); |
| 5371 | |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 5372 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdSetExclusiveScissorNV-firstExclusiveScissor-02035"); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 5373 | vkCmdSetExclusiveScissorNV(m_commandBuffer->handle(), 1, 1, scissors); |
| 5374 | m_errorMonitor->VerifyFound(); |
| 5375 | |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 5376 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 5377 | "vkCmdSetExclusiveScissorNV: parameter exclusiveScissorCount must be greater than 0"); |
| 5378 | vkCmdSetExclusiveScissorNV(m_commandBuffer->handle(), 0, 0, nullptr); |
| 5379 | m_errorMonitor->VerifyFound(); |
| 5380 | |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 5381 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdSetExclusiveScissorNV-exclusiveScissorCount-02036"); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 5382 | vkCmdSetExclusiveScissorNV(m_commandBuffer->handle(), 0, 2, scissors); |
| 5383 | m_errorMonitor->VerifyFound(); |
| 5384 | |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 5385 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 5386 | "vkCmdSetExclusiveScissorNV: parameter exclusiveScissorCount must be greater than 0"); |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 5387 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdSetExclusiveScissorNV-firstExclusiveScissor-02035"); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 5388 | vkCmdSetExclusiveScissorNV(m_commandBuffer->handle(), 1, 0, scissors); |
| 5389 | m_errorMonitor->VerifyFound(); |
| 5390 | |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 5391 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdSetExclusiveScissorNV-firstExclusiveScissor-02035"); |
| 5392 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdSetExclusiveScissorNV-exclusiveScissorCount-02036"); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 5393 | vkCmdSetExclusiveScissorNV(m_commandBuffer->handle(), 1, 2, scissors); |
| 5394 | m_errorMonitor->VerifyFound(); |
| 5395 | |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 5396 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 5397 | "vkCmdSetExclusiveScissorNV: required parameter pExclusiveScissors specified as NULL"); |
| 5398 | vkCmdSetExclusiveScissorNV(m_commandBuffer->handle(), 0, 1, nullptr); |
| 5399 | m_errorMonitor->VerifyFound(); |
| 5400 | |
| 5401 | struct TestCase { |
| 5402 | VkRect2D scissor; |
| 5403 | std::string vuid; |
| 5404 | }; |
| 5405 | |
| 5406 | std::vector<TestCase> test_cases = { |
| 5407 | {{{-1, 0}, {16, 16}}, "VUID-vkCmdSetExclusiveScissorNV-x-02037"}, |
| 5408 | {{{0, -1}, {16, 16}}, "VUID-vkCmdSetExclusiveScissorNV-x-02037"}, |
| 5409 | {{{1, 0}, {INT32_MAX, 16}}, "VUID-vkCmdSetExclusiveScissorNV-offset-02038"}, |
| 5410 | {{{INT32_MAX, 0}, {1, 16}}, "VUID-vkCmdSetExclusiveScissorNV-offset-02038"}, |
| 5411 | {{{0, 0}, {uint32_t{INT32_MAX} + 1, 16}}, "VUID-vkCmdSetExclusiveScissorNV-offset-02038"}, |
| 5412 | {{{0, 1}, {16, INT32_MAX}}, "VUID-vkCmdSetExclusiveScissorNV-offset-02039"}, |
| 5413 | {{{0, INT32_MAX}, {16, 1}}, "VUID-vkCmdSetExclusiveScissorNV-offset-02039"}, |
| 5414 | {{{0, 0}, {16, uint32_t{INT32_MAX} + 1}}, "VUID-vkCmdSetExclusiveScissorNV-offset-02039"}}; |
| 5415 | |
| 5416 | for (const auto &test_case : test_cases) { |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 5417 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, test_case.vuid); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 5418 | vkCmdSetExclusiveScissorNV(m_commandBuffer->handle(), 0, 1, &test_case.scissor); |
| 5419 | m_errorMonitor->VerifyFound(); |
| 5420 | } |
| 5421 | |
| 5422 | m_commandBuffer->end(); |
| 5423 | } |
| 5424 | } |
| 5425 | |
| 5426 | TEST_F(VkLayerTest, MeshShaderNV) { |
| 5427 | TEST_DESCRIPTION("Test VK_NV_mesh_shader."); |
| 5428 | |
| 5429 | if (InstanceExtensionSupported(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME)) { |
| 5430 | m_instance_extension_names.push_back(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME); |
| 5431 | } else { |
| 5432 | printf("%s Did not find required instance extension %s; skipped.\n", kSkipPrefix, |
| 5433 | VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME); |
| 5434 | return; |
| 5435 | } |
Mark Lobodzinski | 09ce9c4 | 2020-03-06 10:02:44 -0700 | [diff] [blame] | 5436 | ASSERT_NO_FATAL_FAILURE(InitFramework(m_errorMonitor)); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 5437 | std::array<const char *, 1> required_device_extensions = {{VK_NV_MESH_SHADER_EXTENSION_NAME}}; |
| 5438 | for (auto device_extension : required_device_extensions) { |
| 5439 | if (DeviceExtensionSupported(gpu(), nullptr, device_extension)) { |
| 5440 | m_device_extension_names.push_back(device_extension); |
| 5441 | } else { |
| 5442 | printf("%s %s Extension not supported, skipping tests\n", kSkipPrefix, device_extension); |
| 5443 | return; |
| 5444 | } |
| 5445 | } |
| 5446 | |
Tony-LunarG | 048f501 | 2020-04-29 16:55:11 -0600 | [diff] [blame] | 5447 | if (IsPlatform(kMockICD) || DeviceSimulation()) { |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 5448 | printf("%sNot suppored by MockICD, skipping tests\n", kSkipPrefix); |
| 5449 | return; |
| 5450 | } |
| 5451 | |
| 5452 | PFN_vkGetPhysicalDeviceFeatures2KHR vkGetPhysicalDeviceFeatures2KHR = |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 5453 | (PFN_vkGetPhysicalDeviceFeatures2KHR)vk::GetInstanceProcAddr(instance(), "vkGetPhysicalDeviceFeatures2KHR"); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 5454 | ASSERT_TRUE(vkGetPhysicalDeviceFeatures2KHR != nullptr); |
| 5455 | |
| 5456 | // Create a device that enables mesh_shader |
| 5457 | auto mesh_shader_features = lvl_init_struct<VkPhysicalDeviceMeshShaderFeaturesNV>(); |
| 5458 | auto features2 = lvl_init_struct<VkPhysicalDeviceFeatures2KHR>(&mesh_shader_features); |
| 5459 | vkGetPhysicalDeviceFeatures2KHR(gpu(), &features2); |
| 5460 | features2.features.multiDrawIndirect = VK_FALSE; |
| 5461 | |
| 5462 | ASSERT_NO_FATAL_FAILURE(InitState(nullptr, &features2)); |
| 5463 | ASSERT_NO_FATAL_FAILURE(InitRenderTarget()); |
| 5464 | |
| 5465 | static const char vertShaderText[] = |
| 5466 | "#version 450\n" |
| 5467 | "vec2 vertices[3];\n" |
| 5468 | "void main() {\n" |
| 5469 | " vertices[0] = vec2(-1.0, -1.0);\n" |
| 5470 | " vertices[1] = vec2( 1.0, -1.0);\n" |
| 5471 | " vertices[2] = vec2( 0.0, 1.0);\n" |
| 5472 | " gl_Position = vec4(vertices[gl_VertexIndex % 3], 0.0, 1.0);\n" |
| 5473 | " gl_PointSize = 1.0f;\n" |
| 5474 | "}\n"; |
| 5475 | |
| 5476 | static const char meshShaderText[] = |
| 5477 | "#version 450\n" |
| 5478 | "#extension GL_NV_mesh_shader : require\n" |
| 5479 | "layout(local_size_x = 1) in;\n" |
| 5480 | "layout(max_vertices = 3) out;\n" |
| 5481 | "layout(max_primitives = 1) out;\n" |
| 5482 | "layout(triangles) out;\n" |
| 5483 | "void main() {\n" |
| 5484 | " gl_MeshVerticesNV[0].gl_Position = vec4(-1.0, -1.0, 0, 1);\n" |
| 5485 | " gl_MeshVerticesNV[1].gl_Position = vec4( 1.0, -1.0, 0, 1);\n" |
| 5486 | " gl_MeshVerticesNV[2].gl_Position = vec4( 0.0, 1.0, 0, 1);\n" |
| 5487 | " gl_PrimitiveIndicesNV[0] = 0;\n" |
| 5488 | " gl_PrimitiveIndicesNV[1] = 1;\n" |
| 5489 | " gl_PrimitiveIndicesNV[2] = 2;\n" |
| 5490 | " gl_PrimitiveCountNV = 1;\n" |
| 5491 | "}\n"; |
| 5492 | |
| 5493 | VkShaderObj vs(m_device, vertShaderText, VK_SHADER_STAGE_VERTEX_BIT, this); |
| 5494 | VkShaderObj ms(m_device, meshShaderText, VK_SHADER_STAGE_MESH_BIT_NV, this); |
| 5495 | VkShaderObj fs(m_device, bindStateFragShaderText, VK_SHADER_STAGE_FRAGMENT_BIT, this); |
| 5496 | |
| 5497 | // Test pipeline creation |
| 5498 | { |
| 5499 | // can't mix mesh with vertex |
| 5500 | const auto break_vp = [&](CreatePipelineHelper &helper) { |
| 5501 | helper.shader_stages_ = {vs.GetStageCreateInfo(), fs.GetStageCreateInfo(), ms.GetStageCreateInfo()}; |
| 5502 | }; |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 5503 | CreatePipelineHelper::OneshotTest(*this, break_vp, kErrorBit, |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 5504 | vector<std::string>({"VUID-VkGraphicsPipelineCreateInfo-pStages-02095"})); |
| 5505 | |
| 5506 | // vertex or mesh must be present |
| 5507 | const auto break_vp2 = [&](CreatePipelineHelper &helper) { helper.shader_stages_ = {fs.GetStageCreateInfo()}; }; |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 5508 | CreatePipelineHelper::OneshotTest(*this, break_vp2, kErrorBit, |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 5509 | vector<std::string>({"VUID-VkGraphicsPipelineCreateInfo-stage-02096"})); |
| 5510 | |
| 5511 | // vertexinput and inputassembly must be valid when vertex stage is present |
| 5512 | const auto break_vp3 = [&](CreatePipelineHelper &helper) { |
| 5513 | helper.shader_stages_ = {vs.GetStageCreateInfo(), fs.GetStageCreateInfo()}; |
| 5514 | helper.gp_ci_.pVertexInputState = nullptr; |
| 5515 | helper.gp_ci_.pInputAssemblyState = nullptr; |
| 5516 | }; |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 5517 | CreatePipelineHelper::OneshotTest(*this, break_vp3, kErrorBit, |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 5518 | vector<std::string>({"VUID-VkGraphicsPipelineCreateInfo-pStages-02097", |
| 5519 | "VUID-VkGraphicsPipelineCreateInfo-pStages-02098"})); |
| 5520 | } |
| 5521 | |
| 5522 | PFN_vkCmdDrawMeshTasksIndirectNV vkCmdDrawMeshTasksIndirectNV = |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 5523 | (PFN_vkCmdDrawMeshTasksIndirectNV)vk::GetInstanceProcAddr(instance(), "vkCmdDrawMeshTasksIndirectNV"); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 5524 | |
| 5525 | VkBufferCreateInfo buffer_create_info = {VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO}; |
| 5526 | buffer_create_info.size = sizeof(uint32_t); |
| 5527 | buffer_create_info.usage = VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT; |
| 5528 | VkBuffer buffer; |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 5529 | VkResult result = vk::CreateBuffer(m_device->device(), &buffer_create_info, nullptr, &buffer); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 5530 | ASSERT_VK_SUCCESS(result); |
| 5531 | |
| 5532 | m_commandBuffer->begin(); |
| 5533 | |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 5534 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdDrawMeshTasksIndirectNV-drawCount-02146"); |
| 5535 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdDrawMeshTasksIndirectNV-drawCount-02718"); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 5536 | vkCmdDrawMeshTasksIndirectNV(m_commandBuffer->handle(), buffer, 0, 2, 0); |
| 5537 | m_errorMonitor->VerifyFound(); |
| 5538 | |
| 5539 | m_commandBuffer->end(); |
| 5540 | |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 5541 | vk::DestroyBuffer(m_device->device(), buffer, 0); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 5542 | } |
| 5543 | |
| 5544 | TEST_F(VkLayerTest, MeshShaderDisabledNV) { |
| 5545 | TEST_DESCRIPTION("Test VK_NV_mesh_shader VUs with NV_mesh_shader disabled."); |
| 5546 | ASSERT_NO_FATAL_FAILURE(Init()); |
| 5547 | ASSERT_NO_FATAL_FAILURE(InitRenderTarget()); |
| 5548 | |
| 5549 | VkEvent event; |
| 5550 | VkEventCreateInfo event_create_info{}; |
| 5551 | event_create_info.sType = VK_STRUCTURE_TYPE_EVENT_CREATE_INFO; |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 5552 | vk::CreateEvent(m_device->device(), &event_create_info, nullptr, &event); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 5553 | |
| 5554 | m_commandBuffer->begin(); |
| 5555 | |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 5556 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdSetEvent-stageMask-02107"); |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 5557 | vk::CmdSetEvent(m_commandBuffer->handle(), event, VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 5558 | m_errorMonitor->VerifyFound(); |
| 5559 | |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 5560 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdSetEvent-stageMask-02108"); |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 5561 | vk::CmdSetEvent(m_commandBuffer->handle(), event, VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 5562 | m_errorMonitor->VerifyFound(); |
| 5563 | |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 5564 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdResetEvent-stageMask-02109"); |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 5565 | vk::CmdResetEvent(m_commandBuffer->handle(), event, VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 5566 | m_errorMonitor->VerifyFound(); |
| 5567 | |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 5568 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdResetEvent-stageMask-02110"); |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 5569 | vk::CmdResetEvent(m_commandBuffer->handle(), event, VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 5570 | m_errorMonitor->VerifyFound(); |
| 5571 | |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 5572 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdWaitEvents-srcStageMask-02111"); |
| 5573 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdWaitEvents-dstStageMask-02113"); |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 5574 | vk::CmdWaitEvents(m_commandBuffer->handle(), 1, &event, VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV, |
| 5575 | VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV, 0, nullptr, 0, nullptr, 0, nullptr); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 5576 | m_errorMonitor->VerifyFound(); |
| 5577 | |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 5578 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdWaitEvents-srcStageMask-02112"); |
| 5579 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdWaitEvents-dstStageMask-02114"); |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 5580 | vk::CmdWaitEvents(m_commandBuffer->handle(), 1, &event, VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV, |
| 5581 | VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV, 0, nullptr, 0, nullptr, 0, nullptr); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 5582 | m_errorMonitor->VerifyFound(); |
| 5583 | |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 5584 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdPipelineBarrier-srcStageMask-02115"); |
| 5585 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdPipelineBarrier-dstStageMask-02117"); |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 5586 | vk::CmdPipelineBarrier(m_commandBuffer->handle(), VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV, VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV, 0, |
| 5587 | 0, nullptr, 0, nullptr, 0, nullptr); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 5588 | m_errorMonitor->VerifyFound(); |
| 5589 | |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 5590 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdPipelineBarrier-srcStageMask-02116"); |
| 5591 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdPipelineBarrier-dstStageMask-02118"); |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 5592 | vk::CmdPipelineBarrier(m_commandBuffer->handle(), VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV, VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV, 0, |
| 5593 | 0, nullptr, 0, nullptr, 0, nullptr); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 5594 | m_errorMonitor->VerifyFound(); |
| 5595 | |
| 5596 | m_commandBuffer->end(); |
| 5597 | |
| 5598 | VkSemaphoreCreateInfo semaphore_create_info = {}; |
| 5599 | semaphore_create_info.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO; |
| 5600 | VkSemaphore semaphore; |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 5601 | ASSERT_VK_SUCCESS(vk::CreateSemaphore(m_device->device(), &semaphore_create_info, nullptr, &semaphore)); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 5602 | |
| 5603 | VkPipelineStageFlags stage_flags = VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV | VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV; |
| 5604 | VkSubmitInfo submit_info = {}; |
| 5605 | |
| 5606 | // Signal the semaphore so the next test can wait on it. |
| 5607 | submit_info.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO; |
| 5608 | submit_info.signalSemaphoreCount = 1; |
| 5609 | submit_info.pSignalSemaphores = &semaphore; |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 5610 | vk::QueueSubmit(m_device->m_queue, 1, &submit_info, VK_NULL_HANDLE); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 5611 | m_errorMonitor->VerifyNotFound(); |
| 5612 | |
| 5613 | submit_info.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO; |
| 5614 | submit_info.signalSemaphoreCount = 0; |
| 5615 | submit_info.pSignalSemaphores = nullptr; |
| 5616 | submit_info.waitSemaphoreCount = 1; |
| 5617 | submit_info.pWaitSemaphores = &semaphore; |
| 5618 | submit_info.pWaitDstStageMask = &stage_flags; |
| 5619 | |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 5620 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkSubmitInfo-pWaitDstStageMask-02089"); |
| 5621 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkSubmitInfo-pWaitDstStageMask-02090"); |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 5622 | vk::QueueSubmit(m_device->m_queue, 1, &submit_info, VK_NULL_HANDLE); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 5623 | m_errorMonitor->VerifyFound(); |
| 5624 | |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 5625 | vk::QueueWaitIdle(m_device->m_queue); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 5626 | |
| 5627 | VkShaderObj vs(m_device, bindStateVertShaderText, VK_SHADER_STAGE_VERTEX_BIT, this); |
| 5628 | VkPipelineShaderStageCreateInfo meshStage = {VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO}; |
| 5629 | meshStage = vs.GetStageCreateInfo(); |
| 5630 | meshStage.stage = VK_SHADER_STAGE_MESH_BIT_NV; |
| 5631 | VkPipelineShaderStageCreateInfo taskStage = {VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO}; |
| 5632 | taskStage = vs.GetStageCreateInfo(); |
| 5633 | taskStage.stage = VK_SHADER_STAGE_TASK_BIT_NV; |
| 5634 | |
| 5635 | // mesh and task shaders not supported |
| 5636 | const auto break_vp = [&](CreatePipelineHelper &helper) { |
| 5637 | helper.shader_stages_ = {meshStage, taskStage, vs.GetStageCreateInfo()}; |
| 5638 | }; |
| 5639 | CreatePipelineHelper::OneshotTest( |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 5640 | *this, break_vp, kErrorBit, |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 5641 | vector<std::string>({"VUID-VkPipelineShaderStageCreateInfo-pName-00707", "VUID-VkPipelineShaderStageCreateInfo-pName-00707", |
| 5642 | "VUID-VkPipelineShaderStageCreateInfo-stage-02091", |
| 5643 | "VUID-VkPipelineShaderStageCreateInfo-stage-02092"})); |
| 5644 | |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 5645 | vk::DestroyEvent(m_device->device(), event, nullptr); |
| 5646 | vk::DestroySemaphore(m_device->device(), semaphore, nullptr); |
unknown | 088160a | 2019-05-23 17:43:13 -0600 | [diff] [blame] | 5647 | } |
Chris Mayer | c93536f | 2019-09-19 16:34:49 +0200 | [diff] [blame] | 5648 | |
| 5649 | TEST_F(VkLayerTest, ViewportWScalingNV) { |
| 5650 | TEST_DESCRIPTION("Verify VK_NV_clip_space_w_scaling"); |
| 5651 | |
Mark Lobodzinski | 09ce9c4 | 2020-03-06 10:02:44 -0700 | [diff] [blame] | 5652 | ASSERT_NO_FATAL_FAILURE(InitFramework(m_errorMonitor)); |
Chris Mayer | c93536f | 2019-09-19 16:34:49 +0200 | [diff] [blame] | 5653 | |
| 5654 | VkPhysicalDeviceFeatures device_features = {}; |
| 5655 | ASSERT_NO_FATAL_FAILURE(GetPhysicalDeviceFeatures(&device_features)); |
| 5656 | |
| 5657 | if (!device_features.multiViewport) { |
| 5658 | printf("%s VkPhysicalDeviceFeatures::multiViewport is not supported, skipping tests\n", kSkipPrefix); |
| 5659 | return; |
| 5660 | } |
| 5661 | |
| 5662 | if (DeviceExtensionSupported(gpu(), nullptr, VK_NV_CLIP_SPACE_W_SCALING_EXTENSION_NAME)) { |
| 5663 | m_device_extension_names.push_back(VK_NV_CLIP_SPACE_W_SCALING_EXTENSION_NAME); |
| 5664 | } else { |
| 5665 | printf("%s %s Extension not supported, skipping tests\n", kSkipPrefix, VK_NV_CLIP_SPACE_W_SCALING_EXTENSION_NAME); |
| 5666 | return; |
| 5667 | } |
| 5668 | |
| 5669 | ASSERT_NO_FATAL_FAILURE(InitState(&device_features)); |
| 5670 | ASSERT_NO_FATAL_FAILURE(InitRenderTarget()); |
| 5671 | |
| 5672 | auto vkCmdSetViewportWScalingNV = |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 5673 | reinterpret_cast<PFN_vkCmdSetViewportWScalingNV>(vk::GetDeviceProcAddr(m_device->device(), "vkCmdSetViewportWScalingNV")); |
Chris Mayer | c93536f | 2019-09-19 16:34:49 +0200 | [diff] [blame] | 5674 | |
| 5675 | const char vs_src[] = R"( |
| 5676 | #version 450 |
| 5677 | const vec2 positions[] = { vec2(-1.0f, 1.0f), |
| 5678 | vec2( 1.0f, 1.0f), |
| 5679 | vec2(-1.0f, -1.0f), |
| 5680 | vec2( 1.0f, -1.0f) }; |
| 5681 | out gl_PerVertex { |
| 5682 | vec4 gl_Position; |
| 5683 | }; |
| 5684 | |
| 5685 | void main() { |
| 5686 | gl_Position = vec4(positions[gl_VertexIndex % 4], 0.0f, 1.0f); |
| 5687 | })"; |
| 5688 | |
| 5689 | const char fs_src[] = R"( |
| 5690 | #version 450 |
| 5691 | layout(location = 0) out vec4 outColor; |
| 5692 | |
| 5693 | void main() { |
| 5694 | outColor = vec4(0.0f, 1.0f, 0.0f, 1.0f); |
| 5695 | })"; |
| 5696 | |
| 5697 | const std::vector<VkViewport> vp = { |
| 5698 | {0.0f, 0.0f, 64.0f, 64.0f}, {0.0f, 0.0f, 64.0f, 64.0f}, {0.0f, 0.0f, 64.0f, 64.0f}, {0.0f, 0.0f, 64.0f, 64.0f}}; |
| 5699 | const std::vector<VkRect2D> sc = {{{0, 0}, {32, 32}}, {{32, 0}, {32, 32}}, {{0, 32}, {32, 32}}, {{32, 32}, {32, 32}}}; |
| 5700 | const std::vector<VkViewportWScalingNV> scale = {{-0.2f, -0.2f}, {0.2f, -0.2f}, {-0.2f, 0.2f}, {0.2f, 0.2f}}; |
| 5701 | |
| 5702 | const uint32_t vp_count = static_cast<uint32_t>(vp.size()); |
| 5703 | |
| 5704 | VkPipelineViewportWScalingStateCreateInfoNV vpsi = {VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV}; |
| 5705 | vpsi.viewportWScalingEnable = VK_TRUE; |
| 5706 | vpsi.viewportCount = vp_count; |
| 5707 | vpsi.pViewportWScalings = scale.data(); |
| 5708 | |
| 5709 | VkPipelineViewportStateCreateInfo vpci = {VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO}; |
| 5710 | vpci.viewportCount = vp_count; |
| 5711 | vpci.pViewports = vp.data(); |
| 5712 | vpci.scissorCount = vp_count; |
| 5713 | vpci.pScissors = sc.data(); |
| 5714 | vpci.pNext = &vpsi; |
| 5715 | |
| 5716 | const auto set_vpci = [&vpci](CreatePipelineHelper &helper) { helper.vp_state_ci_ = vpci; }; |
| 5717 | |
| 5718 | // Make sure no errors show up when creating the pipeline with w-scaling enabled |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 5719 | CreatePipelineHelper::OneshotTest(*this, set_vpci, kErrorBit, vector<std::string>(), true); |
Chris Mayer | c93536f | 2019-09-19 16:34:49 +0200 | [diff] [blame] | 5720 | |
| 5721 | // Create pipeline with w-scaling enabled but without a valid scaling array |
| 5722 | vpsi.pViewportWScalings = nullptr; |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 5723 | CreatePipelineHelper::OneshotTest(*this, set_vpci, kErrorBit, |
Chris Mayer | c93536f | 2019-09-19 16:34:49 +0200 | [diff] [blame] | 5724 | vector<std::string>({"VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-01715"})); |
| 5725 | |
| 5726 | vpsi.pViewportWScalings = scale.data(); |
| 5727 | |
| 5728 | // Create pipeline with w-scaling enabled but without matching viewport counts |
| 5729 | vpsi.viewportCount = 1; |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 5730 | CreatePipelineHelper::OneshotTest(*this, set_vpci, kErrorBit, |
Chris Mayer | c93536f | 2019-09-19 16:34:49 +0200 | [diff] [blame] | 5731 | vector<std::string>({"VUID-VkPipelineViewportStateCreateInfo-viewportWScalingEnable-01726"})); |
| 5732 | |
| 5733 | const VkPipelineLayoutObj pl(m_device); |
| 5734 | |
| 5735 | VkShaderObj vs(m_device, vs_src, VK_SHADER_STAGE_VERTEX_BIT, this); |
| 5736 | VkShaderObj fs(m_device, fs_src, VK_SHADER_STAGE_FRAGMENT_BIT, this); |
| 5737 | |
| 5738 | VkPipelineObj pipe(m_device); |
| 5739 | pipe.AddDefaultColorAttachment(); |
| 5740 | pipe.AddShader(&vs); |
| 5741 | pipe.AddShader(&fs); |
| 5742 | pipe.SetViewport(vp); |
| 5743 | pipe.SetScissor(sc); |
| 5744 | pipe.CreateVKPipeline(pl.handle(), renderPass()); |
| 5745 | |
| 5746 | VkPipelineObj pipeDynWScale(m_device); |
| 5747 | pipeDynWScale.AddDefaultColorAttachment(); |
| 5748 | pipeDynWScale.AddShader(&vs); |
| 5749 | pipeDynWScale.AddShader(&fs); |
| 5750 | pipeDynWScale.SetViewport(vp); |
| 5751 | pipeDynWScale.SetScissor(sc); |
| 5752 | pipeDynWScale.MakeDynamic(VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV); |
| 5753 | pipeDynWScale.CreateVKPipeline(pl.handle(), renderPass()); |
| 5754 | |
| 5755 | m_commandBuffer->begin(); |
| 5756 | |
| 5757 | // Bind pipeline without dynamic w scaling enabled |
| 5758 | m_errorMonitor->ExpectSuccess(); |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 5759 | vk::CmdBindPipeline(m_commandBuffer->handle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipe.handle()); |
Chris Mayer | c93536f | 2019-09-19 16:34:49 +0200 | [diff] [blame] | 5760 | m_errorMonitor->VerifyNotFound(); |
| 5761 | |
Chris Mayer | c93536f | 2019-09-19 16:34:49 +0200 | [diff] [blame] | 5762 | // Bind pipeline that has dynamic w-scaling enabled |
| 5763 | m_errorMonitor->ExpectSuccess(); |
Mark Lobodzinski | 902cb0f | 2019-09-27 14:45:36 -0600 | [diff] [blame] | 5764 | vk::CmdBindPipeline(m_commandBuffer->handle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipeDynWScale.handle()); |
Chris Mayer | c93536f | 2019-09-19 16:34:49 +0200 | [diff] [blame] | 5765 | m_errorMonitor->VerifyNotFound(); |
| 5766 | |
| 5767 | const auto max_vps = m_device->props.limits.maxViewports; |
| 5768 | |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 5769 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdSetViewportWScalingNV-firstViewport-01323"); |
Chris Mayer | c93536f | 2019-09-19 16:34:49 +0200 | [diff] [blame] | 5770 | vkCmdSetViewportWScalingNV(m_commandBuffer->handle(), max_vps, vp_count, scale.data()); |
| 5771 | m_errorMonitor->VerifyFound(); |
| 5772 | |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 5773 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdSetViewportWScalingNV-firstViewport-01324"); |
Chris Mayer | c93536f | 2019-09-19 16:34:49 +0200 | [diff] [blame] | 5774 | vkCmdSetViewportWScalingNV(m_commandBuffer->handle(), 1, max_vps, scale.data()); |
| 5775 | m_errorMonitor->VerifyFound(); |
| 5776 | |
| 5777 | m_errorMonitor->ExpectSuccess(); |
| 5778 | vkCmdSetViewportWScalingNV(m_commandBuffer->handle(), 0, vp_count, scale.data()); |
| 5779 | m_errorMonitor->VerifyNotFound(); |
| 5780 | |
| 5781 | m_commandBuffer->end(); |
| 5782 | } |
sfricke-samsung | 914e800 | 2020-01-07 22:26:18 -0800 | [diff] [blame] | 5783 | |
| 5784 | TEST_F(VkLayerTest, CreateSamplerYcbcrConversionEnable) { |
| 5785 | TEST_DESCRIPTION("Checks samplerYcbcrConversion is enabled before calling vkCreateSamplerYcbcrConversion"); |
| 5786 | |
| 5787 | // Enable Sampler YCbCr Conversion req'd extensions |
| 5788 | // Only need revision 1 of vkGetPhysicalDeviceProperties2 and this allows more device capable for testing |
| 5789 | bool mp_extensions = InstanceExtensionSupported(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME, 1); |
| 5790 | if (mp_extensions) { |
| 5791 | m_instance_extension_names.push_back(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME); |
| 5792 | } |
| 5793 | SetTargetApiVersion(VK_API_VERSION_1_1); |
Mark Lobodzinski | 09ce9c4 | 2020-03-06 10:02:44 -0700 | [diff] [blame] | 5794 | ASSERT_NO_FATAL_FAILURE(InitFramework(m_errorMonitor)); |
sfricke-samsung | 914e800 | 2020-01-07 22:26:18 -0800 | [diff] [blame] | 5795 | mp_extensions = mp_extensions && DeviceExtensionSupported(gpu(), nullptr, VK_KHR_MAINTENANCE1_EXTENSION_NAME); |
| 5796 | mp_extensions = mp_extensions && DeviceExtensionSupported(gpu(), nullptr, VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME); |
| 5797 | mp_extensions = mp_extensions && DeviceExtensionSupported(gpu(), nullptr, VK_KHR_BIND_MEMORY_2_EXTENSION_NAME); |
| 5798 | mp_extensions = mp_extensions && DeviceExtensionSupported(gpu(), nullptr, VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME); |
| 5799 | if (mp_extensions) { |
| 5800 | m_device_extension_names.push_back(VK_KHR_MAINTENANCE1_EXTENSION_NAME); |
| 5801 | m_device_extension_names.push_back(VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME); |
| 5802 | m_device_extension_names.push_back(VK_KHR_BIND_MEMORY_2_EXTENSION_NAME); |
| 5803 | m_device_extension_names.push_back(VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME); |
| 5804 | } else { |
| 5805 | printf("%s test requires Sampler YCbCr Conversion extensions, not available. Skipping.\n", kSkipPrefix); |
| 5806 | return; |
| 5807 | } |
| 5808 | |
| 5809 | // Explictly not enable Ycbcr Conversion Features |
| 5810 | VkPhysicalDeviceSamplerYcbcrConversionFeatures ycbcr_features = {}; |
| 5811 | ycbcr_features.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES; |
| 5812 | ycbcr_features.samplerYcbcrConversion = VK_FALSE; |
| 5813 | ASSERT_NO_FATAL_FAILURE(InitState(nullptr, &ycbcr_features)); |
| 5814 | |
| 5815 | PFN_vkCreateSamplerYcbcrConversionKHR vkCreateSamplerYcbcrConversionFunction = |
| 5816 | (PFN_vkCreateSamplerYcbcrConversionKHR)vk::GetDeviceProcAddr(m_device->handle(), "vkCreateSamplerYcbcrConversionKHR"); |
| 5817 | if (vkCreateSamplerYcbcrConversionFunction == nullptr) { |
| 5818 | printf("%s did not find vkCreateSamplerYcbcrConversionKHR function pointer; Skipping.\n", kSkipPrefix); |
| 5819 | return; |
| 5820 | } |
| 5821 | |
| 5822 | // Create Ycbcr conversion |
| 5823 | VkSamplerYcbcrConversion conversions; |
| 5824 | VkSamplerYcbcrConversionCreateInfo ycbcr_create_info = {VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO, |
| 5825 | NULL, |
| 5826 | VK_FORMAT_G8_B8R8_2PLANE_420_UNORM_KHR, |
| 5827 | VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY, |
| 5828 | VK_SAMPLER_YCBCR_RANGE_ITU_FULL, |
| 5829 | {VK_COMPONENT_SWIZZLE_IDENTITY, VK_COMPONENT_SWIZZLE_IDENTITY, |
| 5830 | VK_COMPONENT_SWIZZLE_IDENTITY, VK_COMPONENT_SWIZZLE_IDENTITY}, |
| 5831 | VK_CHROMA_LOCATION_COSITED_EVEN, |
| 5832 | VK_CHROMA_LOCATION_COSITED_EVEN, |
| 5833 | VK_FILTER_NEAREST, |
| 5834 | false}; |
| 5835 | |
Mark Lobodzinski | 2031078 | 2020-02-28 14:25:17 -0700 | [diff] [blame] | 5836 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCreateSamplerYcbcrConversion-None-01648"); |
sfricke-samsung | 914e800 | 2020-01-07 22:26:18 -0800 | [diff] [blame] | 5837 | vkCreateSamplerYcbcrConversionFunction(m_device->handle(), &ycbcr_create_info, nullptr, &conversions); |
| 5838 | m_errorMonitor->VerifyFound(); |
Shannon McPherson | 5042160 | 2020-01-28 15:18:46 -0700 | [diff] [blame] | 5839 | } |
Jeremy Hayes | cd7df2c | 2020-05-21 16:36:47 -0600 | [diff] [blame] | 5840 | |
| 5841 | TEST_F(VkLayerTest, TransformFeedbackFeatureEnabled) { |
| 5842 | TEST_DESCRIPTION("VkPhysicalDeviceTransformFeedbackFeaturesEXT::transformFeedback must be enabled"); |
| 5843 | |
| 5844 | if (!InstanceExtensionSupported(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME)) { |
| 5845 | printf("%s Did not find required instance extension %s; skipped.\n", kSkipPrefix, |
| 5846 | VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME); |
| 5847 | return; |
| 5848 | } |
| 5849 | m_instance_extension_names.push_back(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME); |
| 5850 | |
| 5851 | ASSERT_NO_FATAL_FAILURE(InitFramework(m_errorMonitor)); |
| 5852 | |
| 5853 | if (!DeviceExtensionSupported(gpu(), nullptr, VK_EXT_TRANSFORM_FEEDBACK_EXTENSION_NAME)) { |
| 5854 | printf("%s %s Extension not supported, skipping tests\n", kSkipPrefix, VK_EXT_TRANSFORM_FEEDBACK_EXTENSION_NAME); |
| 5855 | return; |
| 5856 | } |
| 5857 | m_device_extension_names.push_back(VK_EXT_TRANSFORM_FEEDBACK_EXTENSION_NAME); |
| 5858 | |
| 5859 | { |
| 5860 | PFN_vkGetPhysicalDeviceFeatures2KHR vkGetPhysicalDeviceFeatures2KHR = |
| 5861 | (PFN_vkGetPhysicalDeviceFeatures2KHR)vk::GetInstanceProcAddr(instance(), "vkGetPhysicalDeviceFeatures2KHR"); |
| 5862 | ASSERT_TRUE(vkGetPhysicalDeviceFeatures2KHR != nullptr); |
| 5863 | |
| 5864 | auto tf_features = lvl_init_struct<VkPhysicalDeviceTransformFeedbackFeaturesEXT>(); |
| 5865 | auto pd_features = lvl_init_struct<VkPhysicalDeviceFeatures2>(&tf_features); |
| 5866 | vkGetPhysicalDeviceFeatures2KHR(gpu(), &pd_features); |
| 5867 | |
| 5868 | if (!tf_features.transformFeedback) { |
| 5869 | printf("%s transformFeedback not supported; skipped.\n", kSkipPrefix); |
| 5870 | return; |
| 5871 | } |
| 5872 | } |
| 5873 | |
| 5874 | ASSERT_NO_FATAL_FAILURE(InitState()); |
| 5875 | ASSERT_NO_FATAL_FAILURE(InitRenderTarget()); |
| 5876 | |
| 5877 | { |
| 5878 | auto vkCmdBindTransformFeedbackBuffersEXT = (PFN_vkCmdBindTransformFeedbackBuffersEXT)vk::GetDeviceProcAddr( |
| 5879 | m_device->device(), "vkCmdBindTransformFeedbackBuffersEXT"); |
| 5880 | ASSERT_TRUE(vkCmdBindTransformFeedbackBuffersEXT != nullptr); |
| 5881 | |
| 5882 | auto info = lvl_init_struct<VkBufferCreateInfo>(); |
| 5883 | info.usage = VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT; |
| 5884 | info.size = 4; |
| 5885 | VkBufferObj buffer; |
| 5886 | buffer.init(*m_device, info); |
| 5887 | VkDeviceSize offsets[1]{}; |
| 5888 | |
| 5889 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdBindTransformFeedbackBuffersEXT-transformFeedback-02355"); |
| 5890 | vkCmdBindTransformFeedbackBuffersEXT(m_commandBuffer->handle(), 0, 1, &buffer.handle(), offsets, nullptr); |
| 5891 | m_errorMonitor->VerifyFound(); |
| 5892 | } |
| 5893 | |
| 5894 | { |
| 5895 | auto vkCmdBeginTransformFeedbackEXT = |
| 5896 | (PFN_vkCmdBeginTransformFeedbackEXT)vk::GetDeviceProcAddr(m_device->device(), "vkCmdBeginTransformFeedbackEXT"); |
| 5897 | ASSERT_TRUE(vkCmdBeginTransformFeedbackEXT != nullptr); |
| 5898 | |
| 5899 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdBeginTransformFeedbackEXT-transformFeedback-02366"); |
| 5900 | vkCmdBeginTransformFeedbackEXT(m_commandBuffer->handle(), 0, 1, nullptr, nullptr); |
| 5901 | m_errorMonitor->VerifyFound(); |
| 5902 | } |
| 5903 | |
| 5904 | { |
| 5905 | auto vkCmdEndTransformFeedbackEXT = |
| 5906 | (PFN_vkCmdEndTransformFeedbackEXT)vk::GetDeviceProcAddr(m_device->device(), "vkCmdEndTransformFeedbackEXT"); |
| 5907 | ASSERT_TRUE(vkCmdEndTransformFeedbackEXT != nullptr); |
| 5908 | |
| 5909 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdEndTransformFeedbackEXT-transformFeedback-02374"); |
| 5910 | m_errorMonitor->SetUnexpectedError("VUID-vkCmdEndTransformFeedbackEXT-None-02375"); |
| 5911 | vkCmdEndTransformFeedbackEXT(m_commandBuffer->handle(), 0, 1, nullptr, nullptr); |
| 5912 | m_errorMonitor->VerifyFound(); |
| 5913 | } |
| 5914 | } |
| 5915 | |
| 5916 | TEST_F(VkLayerTest, TransformFeedbackCmdBindTransformFeedbackBuffersEXT) { |
| 5917 | TEST_DESCRIPTION("Submit invalid arguments to vkCmdBindTransformFeedbackBuffersEXT"); |
| 5918 | |
| 5919 | if (!InstanceExtensionSupported(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME)) { |
| 5920 | printf("%s Did not find required instance extension %s; skipped.\n", kSkipPrefix, |
| 5921 | VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME); |
| 5922 | return; |
| 5923 | } |
| 5924 | m_instance_extension_names.push_back(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME); |
| 5925 | |
| 5926 | ASSERT_NO_FATAL_FAILURE(InitFramework(m_errorMonitor)); |
| 5927 | |
| 5928 | if (!DeviceExtensionSupported(gpu(), nullptr, VK_EXT_TRANSFORM_FEEDBACK_EXTENSION_NAME)) { |
| 5929 | printf("%s %s Extension not supported, skipping tests\n", kSkipPrefix, VK_EXT_TRANSFORM_FEEDBACK_EXTENSION_NAME); |
| 5930 | return; |
| 5931 | } |
| 5932 | m_device_extension_names.push_back(VK_EXT_TRANSFORM_FEEDBACK_EXTENSION_NAME); |
| 5933 | |
| 5934 | { |
| 5935 | PFN_vkGetPhysicalDeviceFeatures2KHR vkGetPhysicalDeviceFeatures2KHR = |
| 5936 | (PFN_vkGetPhysicalDeviceFeatures2KHR)vk::GetInstanceProcAddr(instance(), "vkGetPhysicalDeviceFeatures2KHR"); |
| 5937 | ASSERT_TRUE(vkGetPhysicalDeviceFeatures2KHR != nullptr); |
| 5938 | |
| 5939 | auto tf_features = lvl_init_struct<VkPhysicalDeviceTransformFeedbackFeaturesEXT>(); |
| 5940 | auto pd_features = lvl_init_struct<VkPhysicalDeviceFeatures2>(&tf_features); |
| 5941 | vkGetPhysicalDeviceFeatures2KHR(gpu(), &pd_features); |
| 5942 | |
| 5943 | if (!tf_features.transformFeedback) { |
| 5944 | printf("%s transformFeedback not supported; skipped.\n", kSkipPrefix); |
| 5945 | return; |
| 5946 | } |
| 5947 | |
| 5948 | ASSERT_NO_FATAL_FAILURE(InitState(nullptr, &pd_features)); |
| 5949 | } |
| 5950 | |
| 5951 | ASSERT_NO_FATAL_FAILURE(InitRenderTarget()); |
| 5952 | |
| 5953 | auto vkCmdBindTransformFeedbackBuffersEXT = |
| 5954 | (PFN_vkCmdBindTransformFeedbackBuffersEXT)vk::GetDeviceProcAddr(m_device->device(), "vkCmdBindTransformFeedbackBuffersEXT"); |
| 5955 | ASSERT_TRUE(vkCmdBindTransformFeedbackBuffersEXT != nullptr); |
| 5956 | |
| 5957 | { |
| 5958 | auto tf_properties = lvl_init_struct<VkPhysicalDeviceTransformFeedbackPropertiesEXT>(); |
| 5959 | auto pd_properties = lvl_init_struct<VkPhysicalDeviceProperties2>(&tf_properties); |
| 5960 | vk::GetPhysicalDeviceProperties2(gpu(), &pd_properties); |
| 5961 | |
| 5962 | auto info = lvl_init_struct<VkBufferCreateInfo>(); |
| 5963 | info.usage = VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT; |
| 5964 | info.size = 8; |
| 5965 | VkBufferObj const buffer_obj(*m_device, info); |
| 5966 | |
| 5967 | // Request a firstBinding that is too large. |
| 5968 | { |
| 5969 | auto const firstBinding = tf_properties.maxTransformFeedbackBuffers; |
| 5970 | VkDeviceSize const offsets[1]{}; |
| 5971 | |
| 5972 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdBindTransformFeedbackBuffersEXT-firstBinding-02356"); |
| 5973 | m_errorMonitor->SetUnexpectedError("VUID-vkCmdBindTransformFeedbackBuffersEXT-firstBinding-02357"); |
| 5974 | vkCmdBindTransformFeedbackBuffersEXT(m_commandBuffer->handle(), firstBinding, 1, &buffer_obj.handle(), offsets, |
| 5975 | nullptr); |
| 5976 | m_errorMonitor->VerifyFound(); |
| 5977 | } |
| 5978 | |
| 5979 | // Request too many bindings. |
| 5980 | if (tf_properties.maxTransformFeedbackBuffers < std::numeric_limits<uint32_t>::max()) { |
| 5981 | auto const bindingCount = tf_properties.maxTransformFeedbackBuffers + 1; |
| 5982 | std::vector<VkBuffer> buffers(bindingCount, buffer_obj.handle()); |
| 5983 | |
| 5984 | std::vector<VkDeviceSize> offsets(bindingCount); |
| 5985 | |
| 5986 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdBindTransformFeedbackBuffersEXT-firstBinding-02357"); |
| 5987 | vkCmdBindTransformFeedbackBuffersEXT(m_commandBuffer->handle(), 0, bindingCount, buffers.data(), offsets.data(), |
| 5988 | nullptr); |
| 5989 | m_errorMonitor->VerifyFound(); |
| 5990 | } |
| 5991 | |
| 5992 | // Request a size that is larger than the maximum size. |
| 5993 | if (tf_properties.maxTransformFeedbackBufferSize < std::numeric_limits<VkDeviceSize>::max()) { |
| 5994 | VkDeviceSize const offsets[1]{}; |
| 5995 | VkDeviceSize const sizes[1]{tf_properties.maxTransformFeedbackBufferSize + 1}; |
| 5996 | |
| 5997 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdBindTransformFeedbackBuffersEXT-pSize-02361"); |
| 5998 | vkCmdBindTransformFeedbackBuffersEXT(m_commandBuffer->handle(), 0, 1, &buffer_obj.handle(), offsets, sizes); |
| 5999 | m_errorMonitor->VerifyFound(); |
| 6000 | } |
| 6001 | } |
| 6002 | |
| 6003 | { |
| 6004 | auto info = lvl_init_struct<VkBufferCreateInfo>(); |
| 6005 | info.usage = VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT; |
| 6006 | info.size = 8; |
| 6007 | VkBufferObj const buffer_obj(*m_device, info); |
| 6008 | |
| 6009 | // Request an offset that is too large. |
| 6010 | { |
| 6011 | VkDeviceSize const offsets[1]{info.size + 4}; |
| 6012 | |
| 6013 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdBindTransformFeedbackBuffersEXT-pOffsets-02358"); |
| 6014 | vkCmdBindTransformFeedbackBuffersEXT(m_commandBuffer->handle(), 0, 1, &buffer_obj.handle(), offsets, nullptr); |
| 6015 | m_errorMonitor->VerifyFound(); |
| 6016 | } |
| 6017 | |
| 6018 | // Request an offset that is not a multiple of 4. |
| 6019 | { |
| 6020 | VkDeviceSize const offsets[1]{1}; |
| 6021 | |
| 6022 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdBindTransformFeedbackBuffersEXT-pOffsets-02359"); |
| 6023 | vkCmdBindTransformFeedbackBuffersEXT(m_commandBuffer->handle(), 0, 1, &buffer_obj.handle(), offsets, nullptr); |
| 6024 | m_errorMonitor->VerifyFound(); |
| 6025 | } |
| 6026 | |
| 6027 | // Request a size that is larger than the buffer's size. |
| 6028 | { |
| 6029 | VkDeviceSize const offsets[1]{}; |
| 6030 | VkDeviceSize const sizes[1]{info.size + 1}; |
| 6031 | |
| 6032 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdBindTransformFeedbackBuffersEXT-pSizes-02362"); |
| 6033 | m_errorMonitor->SetUnexpectedError("VUID-vkCmdBindTransformFeedbackBuffersEXT-pOffsets-02363"); |
| 6034 | vkCmdBindTransformFeedbackBuffersEXT(m_commandBuffer->handle(), 0, 1, &buffer_obj.handle(), offsets, sizes); |
| 6035 | m_errorMonitor->VerifyFound(); |
| 6036 | } |
| 6037 | |
| 6038 | // Request an offset and size whose sum is larger than the buffer's size. |
| 6039 | { |
| 6040 | VkDeviceSize const offsets[1]{4}; |
| 6041 | VkDeviceSize const sizes[1]{info.size - 3}; |
| 6042 | |
| 6043 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdBindTransformFeedbackBuffersEXT-pOffsets-02363"); |
| 6044 | vkCmdBindTransformFeedbackBuffersEXT(m_commandBuffer->handle(), 0, 1, &buffer_obj.handle(), offsets, sizes); |
| 6045 | m_errorMonitor->VerifyFound(); |
| 6046 | } |
| 6047 | |
| 6048 | // Bind while transform feedback is active. |
| 6049 | { |
| 6050 | auto vkCmdBeginTransformFeedbackEXT = |
| 6051 | (PFN_vkCmdBeginTransformFeedbackEXT)vk::GetDeviceProcAddr(m_device->device(), "vkCmdBeginTransformFeedbackEXT"); |
| 6052 | ASSERT_TRUE(vkCmdBeginTransformFeedbackEXT != nullptr); |
| 6053 | vkCmdBeginTransformFeedbackEXT(m_commandBuffer->handle(), 0, 1, nullptr, nullptr); |
| 6054 | |
| 6055 | VkDeviceSize const offsets[1]{}; |
| 6056 | |
| 6057 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdBindTransformFeedbackBuffersEXT-None-02365"); |
| 6058 | vkCmdBindTransformFeedbackBuffersEXT(m_commandBuffer->handle(), 0, 1, &buffer_obj.handle(), offsets, nullptr); |
| 6059 | m_errorMonitor->VerifyFound(); |
| 6060 | |
| 6061 | auto vkCmdEndTransformFeedbackEXT = |
| 6062 | (PFN_vkCmdEndTransformFeedbackEXT)vk::GetDeviceProcAddr(m_device->device(), "vkCmdEndTransformFeedbackEXT"); |
| 6063 | ASSERT_TRUE(vkCmdEndTransformFeedbackEXT != nullptr); |
| 6064 | vkCmdEndTransformFeedbackEXT(m_commandBuffer->handle(), 0, 1, nullptr, nullptr); |
| 6065 | } |
| 6066 | } |
| 6067 | |
| 6068 | // Don't set VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT. |
| 6069 | { |
| 6070 | auto info = lvl_init_struct<VkBufferCreateInfo>(); |
| 6071 | // info.usage = VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT; |
| 6072 | info.size = 4; |
| 6073 | VkBufferObj const buffer_obj(*m_device, info); |
| 6074 | |
| 6075 | VkDeviceSize const offsets[1]{}; |
| 6076 | |
| 6077 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdBindTransformFeedbackBuffersEXT-pBuffers-02360"); |
| 6078 | vkCmdBindTransformFeedbackBuffersEXT(m_commandBuffer->handle(), 0, 1, &buffer_obj.handle(), offsets, nullptr); |
| 6079 | m_errorMonitor->VerifyFound(); |
| 6080 | } |
| 6081 | |
| 6082 | // Don't bind memory. |
| 6083 | { |
| 6084 | VkBuffer buffer{}; |
| 6085 | { |
| 6086 | auto vkCreateBuffer = (PFN_vkCreateBuffer)vk::GetDeviceProcAddr(m_device->device(), "vkCreateBuffer"); |
| 6087 | ASSERT_TRUE(vkCreateBuffer != nullptr); |
| 6088 | |
| 6089 | auto info = lvl_init_struct<VkBufferCreateInfo>(); |
| 6090 | info.usage = VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT; |
| 6091 | info.size = 4; |
| 6092 | vkCreateBuffer(m_device->device(), &info, nullptr, &buffer); |
| 6093 | } |
| 6094 | |
| 6095 | VkDeviceSize const offsets[1]{}; |
| 6096 | |
| 6097 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdBindTransformFeedbackBuffersEXT-pBuffers-02364"); |
| 6098 | vkCmdBindTransformFeedbackBuffersEXT(m_commandBuffer->handle(), 0, 1, &buffer, offsets, nullptr); |
| 6099 | m_errorMonitor->VerifyFound(); |
| 6100 | } |
| 6101 | } |
| 6102 | |
| 6103 | TEST_F(VkLayerTest, TransformFeedbackCmdBeginTransformFeedbackEXT) { |
| 6104 | TEST_DESCRIPTION("Submit invalid arguments to vkCmdBeginTransformFeedbackEXT"); |
| 6105 | |
| 6106 | if (!InstanceExtensionSupported(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME)) { |
| 6107 | printf("%s Did not find required instance extension %s; skipped.\n", kSkipPrefix, |
| 6108 | VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME); |
| 6109 | return; |
| 6110 | } |
| 6111 | m_instance_extension_names.push_back(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME); |
| 6112 | |
| 6113 | ASSERT_NO_FATAL_FAILURE(InitFramework(m_errorMonitor)); |
| 6114 | |
| 6115 | if (!DeviceExtensionSupported(gpu(), nullptr, VK_EXT_TRANSFORM_FEEDBACK_EXTENSION_NAME)) { |
| 6116 | printf("%s %s Extension not supported, skipping tests\n", kSkipPrefix, VK_EXT_TRANSFORM_FEEDBACK_EXTENSION_NAME); |
| 6117 | return; |
| 6118 | } |
| 6119 | m_device_extension_names.push_back(VK_EXT_TRANSFORM_FEEDBACK_EXTENSION_NAME); |
| 6120 | |
| 6121 | { |
| 6122 | PFN_vkGetPhysicalDeviceFeatures2KHR vkGetPhysicalDeviceFeatures2KHR = |
| 6123 | (PFN_vkGetPhysicalDeviceFeatures2KHR)vk::GetInstanceProcAddr(instance(), "vkGetPhysicalDeviceFeatures2KHR"); |
| 6124 | ASSERT_TRUE(vkGetPhysicalDeviceFeatures2KHR != nullptr); |
| 6125 | |
| 6126 | auto tf_features = lvl_init_struct<VkPhysicalDeviceTransformFeedbackFeaturesEXT>(); |
| 6127 | auto pd_features = lvl_init_struct<VkPhysicalDeviceFeatures2>(&tf_features); |
| 6128 | vkGetPhysicalDeviceFeatures2KHR(gpu(), &pd_features); |
| 6129 | |
| 6130 | if (!tf_features.transformFeedback) { |
| 6131 | printf("%s transformFeedback not supported; skipped.\n", kSkipPrefix); |
| 6132 | return; |
| 6133 | } |
| 6134 | |
| 6135 | ASSERT_NO_FATAL_FAILURE(InitState(nullptr, &pd_features)); |
| 6136 | } |
| 6137 | |
| 6138 | ASSERT_NO_FATAL_FAILURE(InitRenderTarget()); |
| 6139 | |
| 6140 | auto vkCmdBeginTransformFeedbackEXT = |
| 6141 | (PFN_vkCmdBeginTransformFeedbackEXT)vk::GetDeviceProcAddr(m_device->device(), "vkCmdBeginTransformFeedbackEXT"); |
| 6142 | ASSERT_TRUE(vkCmdBeginTransformFeedbackEXT != nullptr); |
| 6143 | |
| 6144 | { |
| 6145 | auto tf_properties = lvl_init_struct<VkPhysicalDeviceTransformFeedbackPropertiesEXT>(); |
| 6146 | auto pd_properties = lvl_init_struct<VkPhysicalDeviceProperties2>(&tf_properties); |
| 6147 | vk::GetPhysicalDeviceProperties2(gpu(), &pd_properties); |
| 6148 | |
| 6149 | // Request a firstCounterBuffer that is too large. |
| 6150 | { |
| 6151 | auto const firstCounterBuffer = tf_properties.maxTransformFeedbackBuffers; |
| 6152 | |
| 6153 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdBeginTransformFeedbackEXT-firstCounterBuffer-02368"); |
| 6154 | m_errorMonitor->SetUnexpectedError("VUID-vkCmdBeginTransformFeedbackEXT-firstCounterBuffer-02369"); |
| 6155 | vkCmdBeginTransformFeedbackEXT(m_commandBuffer->handle(), firstCounterBuffer, 1, nullptr, nullptr); |
| 6156 | m_errorMonitor->VerifyFound(); |
| 6157 | } |
| 6158 | |
| 6159 | // Request too many buffers. |
| 6160 | if (tf_properties.maxTransformFeedbackBuffers < std::numeric_limits<uint32_t>::max()) { |
| 6161 | auto const counterBufferCount = tf_properties.maxTransformFeedbackBuffers + 1; |
| 6162 | |
| 6163 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdBeginTransformFeedbackEXT-firstCounterBuffer-02369"); |
| 6164 | vkCmdBeginTransformFeedbackEXT(m_commandBuffer->handle(), 0, counterBufferCount, nullptr, nullptr); |
| 6165 | m_errorMonitor->VerifyFound(); |
| 6166 | } |
| 6167 | } |
| 6168 | |
| 6169 | // Request an out-of-bounds location. |
| 6170 | { |
| 6171 | auto info = lvl_init_struct<VkBufferCreateInfo>(); |
| 6172 | info.usage = VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT; |
| 6173 | info.size = 4; |
| 6174 | VkBufferObj const buffer_obj(*m_device, info); |
| 6175 | |
| 6176 | VkDeviceSize const offsets[1]{1}; |
| 6177 | |
| 6178 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdBeginTransformFeedbackEXT-pCounterBufferOffsets-02370"); |
| 6179 | vkCmdBeginTransformFeedbackEXT(m_commandBuffer->handle(), 0, 1, &buffer_obj.handle(), offsets); |
| 6180 | m_errorMonitor->VerifyFound(); |
| 6181 | } |
| 6182 | |
| 6183 | // Request specific offsets without specifying buffers. |
| 6184 | { |
| 6185 | VkDeviceSize const offsets[1]{}; |
| 6186 | |
| 6187 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdBeginTransformFeedbackEXT-pCounterBuffer-02371"); |
| 6188 | vkCmdBeginTransformFeedbackEXT(m_commandBuffer->handle(), 0, 1, nullptr, offsets); |
| 6189 | m_errorMonitor->VerifyFound(); |
| 6190 | } |
| 6191 | |
| 6192 | // Don't set VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT. |
| 6193 | { |
| 6194 | auto info = lvl_init_struct<VkBufferCreateInfo>(); |
| 6195 | // info.usage = VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT; |
| 6196 | info.size = 4; |
| 6197 | VkBufferObj const buffer_obj(*m_device, info); |
| 6198 | |
| 6199 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdBeginTransformFeedbackEXT-pCounterBuffers-02372"); |
| 6200 | vkCmdBeginTransformFeedbackEXT(m_commandBuffer->handle(), 0, 1, &buffer_obj.handle(), nullptr); |
| 6201 | m_errorMonitor->VerifyFound(); |
| 6202 | } |
| 6203 | |
| 6204 | // Begin while transform feedback is active. |
| 6205 | { |
| 6206 | vkCmdBeginTransformFeedbackEXT(m_commandBuffer->handle(), 0, 1, nullptr, nullptr); |
| 6207 | |
| 6208 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdBeginTransformFeedbackEXT-None-02367"); |
| 6209 | vkCmdBeginTransformFeedbackEXT(m_commandBuffer->handle(), 0, 1, nullptr, nullptr); |
| 6210 | m_errorMonitor->VerifyFound(); |
| 6211 | |
| 6212 | auto vkCmdEndTransformFeedbackEXT = |
| 6213 | (PFN_vkCmdEndTransformFeedbackEXT)vk::GetDeviceProcAddr(m_device->device(), "vkCmdEndTransformFeedbackEXT"); |
| 6214 | ASSERT_TRUE(vkCmdEndTransformFeedbackEXT != nullptr); |
| 6215 | |
| 6216 | vkCmdEndTransformFeedbackEXT(m_commandBuffer->handle(), 0, 1, nullptr, nullptr); |
| 6217 | } |
| 6218 | } |
| 6219 | |
| 6220 | TEST_F(VkLayerTest, TransformFeedbackCmdEndTransformFeedbackEXT) { |
| 6221 | TEST_DESCRIPTION("Submit invalid arguments to vkCmdEndTransformFeedbackEXT"); |
| 6222 | |
| 6223 | if (!InstanceExtensionSupported(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME)) { |
| 6224 | printf("%s Did not find required instance extension %s; skipped.\n", kSkipPrefix, |
| 6225 | VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME); |
| 6226 | return; |
| 6227 | } |
| 6228 | m_instance_extension_names.push_back(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME); |
| 6229 | |
| 6230 | ASSERT_NO_FATAL_FAILURE(InitFramework(m_errorMonitor)); |
| 6231 | |
| 6232 | if (!DeviceExtensionSupported(gpu(), nullptr, VK_EXT_TRANSFORM_FEEDBACK_EXTENSION_NAME)) { |
| 6233 | printf("%s %s Extension not supported, skipping tests\n", kSkipPrefix, VK_EXT_TRANSFORM_FEEDBACK_EXTENSION_NAME); |
| 6234 | return; |
| 6235 | } |
| 6236 | m_device_extension_names.push_back(VK_EXT_TRANSFORM_FEEDBACK_EXTENSION_NAME); |
| 6237 | |
| 6238 | { |
| 6239 | PFN_vkGetPhysicalDeviceFeatures2KHR vkGetPhysicalDeviceFeatures2KHR = |
| 6240 | (PFN_vkGetPhysicalDeviceFeatures2KHR)vk::GetInstanceProcAddr(instance(), "vkGetPhysicalDeviceFeatures2KHR"); |
| 6241 | ASSERT_TRUE(vkGetPhysicalDeviceFeatures2KHR != nullptr); |
| 6242 | |
| 6243 | auto tf_features = lvl_init_struct<VkPhysicalDeviceTransformFeedbackFeaturesEXT>(); |
| 6244 | auto pd_features = lvl_init_struct<VkPhysicalDeviceFeatures2>(&tf_features); |
| 6245 | vkGetPhysicalDeviceFeatures2KHR(gpu(), &pd_features); |
| 6246 | |
| 6247 | if (!tf_features.transformFeedback) { |
| 6248 | printf("%s transformFeedback not supported; skipped.\n", kSkipPrefix); |
| 6249 | return; |
| 6250 | } |
| 6251 | |
| 6252 | ASSERT_NO_FATAL_FAILURE(InitState(nullptr, &pd_features)); |
| 6253 | } |
| 6254 | |
| 6255 | ASSERT_NO_FATAL_FAILURE(InitRenderTarget()); |
| 6256 | |
| 6257 | auto vkCmdEndTransformFeedbackEXT = |
| 6258 | (PFN_vkCmdEndTransformFeedbackEXT)vk::GetDeviceProcAddr(m_device->device(), "vkCmdEndTransformFeedbackEXT"); |
| 6259 | ASSERT_TRUE(vkCmdEndTransformFeedbackEXT != nullptr); |
| 6260 | |
| 6261 | { |
| 6262 | // Activate transform feedback. |
| 6263 | auto vkCmdBeginTransformFeedbackEXT = |
| 6264 | (PFN_vkCmdBeginTransformFeedbackEXT)vk::GetDeviceProcAddr(m_device->device(), "vkCmdBeginTransformFeedbackEXT"); |
| 6265 | ASSERT_TRUE(vkCmdBeginTransformFeedbackEXT != nullptr); |
| 6266 | vkCmdBeginTransformFeedbackEXT(m_commandBuffer->handle(), 0, 1, nullptr, nullptr); |
| 6267 | |
| 6268 | { |
| 6269 | auto tf_properties = lvl_init_struct<VkPhysicalDeviceTransformFeedbackPropertiesEXT>(); |
| 6270 | auto pd_properties = lvl_init_struct<VkPhysicalDeviceProperties2>(&tf_properties); |
| 6271 | vk::GetPhysicalDeviceProperties2(gpu(), &pd_properties); |
| 6272 | |
| 6273 | // Request a firstCounterBuffer that is too large. |
| 6274 | { |
| 6275 | auto const firstCounterBuffer = tf_properties.maxTransformFeedbackBuffers; |
| 6276 | |
| 6277 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdEndTransformFeedbackEXT-firstCounterBuffer-02376"); |
| 6278 | m_errorMonitor->SetUnexpectedError("VUID-vkCmdEndTransformFeedbackEXT-firstCounterBuffer-02377"); |
| 6279 | vkCmdEndTransformFeedbackEXT(m_commandBuffer->handle(), firstCounterBuffer, 1, nullptr, nullptr); |
| 6280 | m_errorMonitor->VerifyFound(); |
| 6281 | } |
| 6282 | |
| 6283 | // Request too many buffers. |
| 6284 | if (tf_properties.maxTransformFeedbackBuffers < std::numeric_limits<uint32_t>::max()) { |
| 6285 | auto const counterBufferCount = tf_properties.maxTransformFeedbackBuffers + 1; |
| 6286 | |
| 6287 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdEndTransformFeedbackEXT-firstCounterBuffer-02377"); |
| 6288 | vkCmdEndTransformFeedbackEXT(m_commandBuffer->handle(), 0, counterBufferCount, nullptr, nullptr); |
| 6289 | m_errorMonitor->VerifyFound(); |
| 6290 | } |
| 6291 | } |
| 6292 | |
| 6293 | // Request an out-of-bounds location. |
| 6294 | { |
| 6295 | auto info = lvl_init_struct<VkBufferCreateInfo>(); |
| 6296 | info.usage = VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT; |
| 6297 | info.size = 4; |
| 6298 | VkBufferObj const buffer_obj(*m_device, info); |
| 6299 | |
| 6300 | VkDeviceSize const offsets[1]{1}; |
| 6301 | |
| 6302 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdEndTransformFeedbackEXT-pCounterBufferOffsets-02378"); |
| 6303 | vkCmdEndTransformFeedbackEXT(m_commandBuffer->handle(), 0, 1, &buffer_obj.handle(), offsets); |
| 6304 | m_errorMonitor->VerifyFound(); |
| 6305 | } |
| 6306 | |
| 6307 | // Request specific offsets without specifying buffers. |
| 6308 | { |
| 6309 | VkDeviceSize const offsets[1]{}; |
| 6310 | |
| 6311 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdEndTransformFeedbackEXT-pCounterBuffer-02379"); |
| 6312 | vkCmdEndTransformFeedbackEXT(m_commandBuffer->handle(), 0, 1, nullptr, offsets); |
| 6313 | m_errorMonitor->VerifyFound(); |
| 6314 | } |
| 6315 | |
| 6316 | // Don't set VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT. |
| 6317 | { |
| 6318 | auto info = lvl_init_struct<VkBufferCreateInfo>(); |
| 6319 | // info.usage = VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT; |
| 6320 | info.size = 4; |
| 6321 | VkBufferObj const buffer_obj(*m_device, info); |
| 6322 | |
| 6323 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdEndTransformFeedbackEXT-pCounterBuffers-02380"); |
| 6324 | vkCmdEndTransformFeedbackEXT(m_commandBuffer->handle(), 0, 1, &buffer_obj.handle(), nullptr); |
| 6325 | m_errorMonitor->VerifyFound(); |
| 6326 | } |
| 6327 | } |
| 6328 | |
| 6329 | // End while transform feedback is inactive. |
| 6330 | { |
| 6331 | vkCmdEndTransformFeedbackEXT(m_commandBuffer->handle(), 0, 1, nullptr, nullptr); |
| 6332 | |
| 6333 | m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdEndTransformFeedbackEXT-None-02375"); |
| 6334 | vkCmdEndTransformFeedbackEXT(m_commandBuffer->handle(), 0, 1, nullptr, nullptr); |
| 6335 | m_errorMonitor->VerifyFound(); |
| 6336 | } |
| 6337 | } |