blob: f72fc8841f2af2e24f35b9c0c935a739bfb33de9 [file] [log] [blame]
unknown088160a2019-05-23 17:43:13 -06001/*
sfricke-samsung6d97e562020-01-07 22:01:00 -08002 * 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.
unknown088160a2019-05-23 17:43:13 -06006 *
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
30TEST_F(VkLayerTest, InvalidCommandPoolConsistency) {
31 TEST_DESCRIPTION("Allocate command buffers from one command pool and attempt to delete them from another.");
32
Mark Lobodzinski20310782020-02-28 14:25:17 -070033 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkFreeCommandBuffers-pCommandBuffers-parent");
unknown088160a2019-05-23 17:43:13 -060034
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 Lobodzinski902cb0f2019-09-27 14:45:36 -060044 vk::CreateCommandPool(m_device->device(), &pool_create_info, nullptr, &command_pool_one);
unknown088160a2019-05-23 17:43:13 -060045
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -060046 vk::CreateCommandPool(m_device->device(), &pool_create_info, nullptr, &command_pool_two);
unknown088160a2019-05-23 17:43:13 -060047
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 Lobodzinski902cb0f2019-09-27 14:45:36 -060054 vk::AllocateCommandBuffers(m_device->device(), &command_buffer_allocate_info, &cb);
unknown088160a2019-05-23 17:43:13 -060055
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -060056 vk::FreeCommandBuffers(m_device->device(), command_pool_two, 1, &cb);
unknown088160a2019-05-23 17:43:13 -060057
58 m_errorMonitor->VerifyFound();
59
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -060060 vk::DestroyCommandPool(m_device->device(), command_pool_one, NULL);
61 vk::DestroyCommandPool(m_device->device(), command_pool_two, NULL);
unknown088160a2019-05-23 17:43:13 -060062}
63
64TEST_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 Lobodzinski902cb0f2019-09-27 14:45:36 -060088 VkResult err = vk::CreateRenderPass(m_device->device(), &rpci, nullptr, &rp);
unknown088160a2019-05-23 17:43:13 -060089 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 Lobodzinski902cb0f2019-09-27 14:45:36 -0600100 err = vk::CreateFramebuffer(m_device->device(), &fbci, nullptr, &fb);
unknown088160a2019-05-23 17:43:13 -0600101 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 Lobodzinski902cb0f2019-09-27 14:45:36 -0600117 vk::CmdBeginRenderPass(m_commandBuffer->handle(), &rpbi, VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS);
unknown088160a2019-05-23 17:43:13 -0600118
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 Lobodzinski902cb0f2019-09-27 14:45:36 -0600133 vk::BeginCommandBuffer(secondary.handle(), &cbbi);
unknown088160a2019-05-23 17:43:13 -0600134 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 Lobodzinski902cb0f2019-09-27 14:45:36 -0600148 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);
unknown088160a2019-05-23 17:43:13 -0600150 secondary.end();
151
Mark Lobodzinski20310782020-02-28 14:25:17 -0700152 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdPipelineBarrier-image-02635");
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -0600153 vk::CmdExecuteCommands(m_commandBuffer->handle(), 1, &secondary.handle());
unknown088160a2019-05-23 17:43:13 -0600154 m_errorMonitor->VerifyFound();
155
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -0600156 vk::DestroyFramebuffer(m_device->device(), fb, nullptr);
157 vk::DestroyRenderPass(m_device->device(), rp, nullptr);
unknown088160a2019-05-23 17:43:13 -0600158}
159
160TEST_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 Lobodzinski20310782020-02-28 14:25:17 -0700166 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "Dynamic depth bias state not set for this command buffer");
unknown088160a2019-05-23 17:43:13 -0600167 VKTriangleTest(BsoFailDepthBias);
168 m_errorMonitor->VerifyFound();
169}
170
171TEST_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 Lobodzinski20310782020-02-28 14:25:17 -0700177 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "Dynamic line width state not set for this command buffer");
unknown088160a2019-05-23 17:43:13 -0600178 VKTriangleTest(BsoFailLineWidth);
179 m_errorMonitor->VerifyFound();
180}
181
Jeff Bolzf390c6c2019-08-16 16:29:53 -0500182TEST_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 Lobodzinski09ce9c42020-03-06 10:02:44 -0700193 ASSERT_NO_FATAL_FAILURE(InitFramework(m_errorMonitor));
Jeff Bolzf390c6c2019-08-16 16:29:53 -0500194 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 Lobodzinski902cb0f2019-09-27 14:45:36 -0600205 (PFN_vkGetPhysicalDeviceFeatures2KHR)vk::GetInstanceProcAddr(instance(), "vkGetPhysicalDeviceFeatures2KHR");
Jeff Bolzf390c6c2019-08-16 16:29:53 -0500206 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 Lobodzinski20310782020-02-28 14:25:17 -0700219 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "Dynamic line stipple state not set for this command buffer");
Jeff Bolzf390c6c2019-08-16 16:29:53 -0500220 VKTriangleTest(BsoFailLineStipple);
221 m_errorMonitor->VerifyFound();
222}
223
unknown088160a2019-05-23 17:43:13 -0600224TEST_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 Lobodzinski20310782020-02-28 14:25:17 -0700230 m_errorMonitor->SetDesiredFailureMsg(kErrorBit,
unknown088160a2019-05-23 17:43:13 -0600231 "Dynamic viewport(s) 0 are used by pipeline state object, but were not provided");
232 VKTriangleTest(BsoFailViewport);
233 m_errorMonitor->VerifyFound();
234}
235
236TEST_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 Lobodzinski20310782020-02-28 14:25:17 -0700241 m_errorMonitor->SetDesiredFailureMsg(kErrorBit,
unknown088160a2019-05-23 17:43:13 -0600242 "Dynamic scissor(s) 0 are used by pipeline state object, but were not provided");
243 VKTriangleTest(BsoFailScissor);
244 m_errorMonitor->VerifyFound();
245}
246
247TEST_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 Lobodzinski20310782020-02-28 14:25:17 -0700253 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "Dynamic blend constants state not set for this command buffer");
unknown088160a2019-05-23 17:43:13 -0600254 VKTriangleTest(BsoFailBlend);
255 m_errorMonitor->VerifyFound();
256}
257
258TEST_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 Lobodzinski20310782020-02-28 14:25:17 -0700268 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "Dynamic depth bounds state not set for this command buffer");
unknown088160a2019-05-23 17:43:13 -0600269 VKTriangleTest(BsoFailDepthBounds);
270 m_errorMonitor->VerifyFound();
271}
272
273TEST_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 Lobodzinski20310782020-02-28 14:25:17 -0700279 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "Dynamic stencil read mask state not set for this command buffer");
unknown088160a2019-05-23 17:43:13 -0600280 VKTriangleTest(BsoFailStencilReadMask);
281 m_errorMonitor->VerifyFound();
282}
283
284TEST_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 Lobodzinski20310782020-02-28 14:25:17 -0700290 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "Dynamic stencil write mask state not set for this command buffer");
unknown088160a2019-05-23 17:43:13 -0600291 VKTriangleTest(BsoFailStencilWriteMask);
292 m_errorMonitor->VerifyFound();
293}
294
295TEST_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 Lobodzinski20310782020-02-28 14:25:17 -0700301 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "Dynamic stencil reference state not set for this command buffer");
unknown088160a2019-05-23 17:43:13 -0600302 VKTriangleTest(BsoFailStencilReference);
303 m_errorMonitor->VerifyFound();
304}
305
306TEST_F(VkLayerTest, IndexBufferNotBound) {
307 TEST_DESCRIPTION("Run an indexed draw call without an index buffer bound.");
308
309 ASSERT_NO_FATAL_FAILURE(Init());
Mark Lobodzinski20310782020-02-28 14:25:17 -0700310 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "Index buffer object not bound to this command buffer when Indexed ");
unknown088160a2019-05-23 17:43:13 -0600311 VKTriangleTest(BsoFailIndexBuffer);
312 m_errorMonitor->VerifyFound();
313}
314
315TEST_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 Lobodzinski20310782020-02-28 14:25:17 -0700319 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "vkCmdDrawIndexed() index size ");
unknown088160a2019-05-23 17:43:13 -0600320 VKTriangleTest(BsoFailIndexBufferBadSize);
321 m_errorMonitor->VerifyFound();
322}
323
324TEST_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 Lobodzinski20310782020-02-28 14:25:17 -0700328 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "vkCmdDrawIndexed() index size ");
unknown088160a2019-05-23 17:43:13 -0600329 VKTriangleTest(BsoFailIndexBufferBadOffset);
330 m_errorMonitor->VerifyFound();
331}
332
333TEST_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 Lobodzinski20310782020-02-28 14:25:17 -0700337 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "vkCmdDrawIndexed() index size ");
unknown088160a2019-05-23 17:43:13 -0600338 VKTriangleTest(BsoFailIndexBufferBadMapSize);
339 m_errorMonitor->VerifyFound();
340}
341
342TEST_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 Lobodzinski20310782020-02-28 14:25:17 -0700346 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "vkCmdDrawIndexed() index size ");
unknown088160a2019-05-23 17:43:13 -0600347 VKTriangleTest(BsoFailIndexBufferBadMapOffset);
348 m_errorMonitor->VerifyFound();
349}
350
351TEST_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 Lobodzinski20310782020-02-28 14:25:17 -0700354 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdClearAttachments-aspectMask-02501");
unknown088160a2019-05-23 17:43:13 -0600355
356 VKTriangleTest(BsoFailCmdClearAttachments);
357 m_errorMonitor->VerifyFound();
358}
359
Mark Lobodzinskicd0204c2019-11-11 16:59:18 -0700360TEST_F(VkLayerTest, SecondaryCommandbufferAsPrimary) {
361 TEST_DESCRIPTION("Create a secondary command buffer and pass it to QueueSubmit.");
Mark Lobodzinski20310782020-02-28 14:25:17 -0700362 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkSubmitInfo-pCommandBuffers-00075");
Mark Lobodzinskicd0204c2019-11-11 16:59:18 -0700363
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
unknown088160a2019-05-23 17:43:13 -0600386TEST_F(VkLayerTest, CommandBufferTwoSubmits) {
Mark Lobodzinski20310782020-02-28 14:25:17 -0700387 m_errorMonitor->SetDesiredFailureMsg(kErrorBit,
unknown088160a2019-05-23 17:43:13 -0600388 "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 Lobodzinski902cb0f2019-09-27 14:45:36 -0600413 err = vk::QueueSubmit(m_device->m_queue, 1, &submit_info, VK_NULL_HANDLE);
unknown088160a2019-05-23 17:43:13 -0600414 ASSERT_VK_SUCCESS(err);
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -0600415 vk::QueueWaitIdle(m_device->m_queue);
unknown088160a2019-05-23 17:43:13 -0600416
417 // Cause validation error by re-submitting cmd buffer that should only be
418 // submitted once
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -0600419 err = vk::QueueSubmit(m_device->m_queue, 1, &submit_info, VK_NULL_HANDLE);
420 vk::QueueWaitIdle(m_device->m_queue);
unknown088160a2019-05-23 17:43:13 -0600421
422 m_errorMonitor->VerifyFound();
423}
424
425TEST_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 Lobodzinski20310782020-02-28 14:25:17 -0700464 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, iter.msg);
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -0600465 vk::CreatePipelineLayout(m_device->device(), &pipeline_layout_ci, NULL, &pipeline_layout);
unknown088160a2019-05-23 17:43:13 -0600466 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 Lobodzinski20310782020-02-28 14:25:17 -0700474 kErrorBit, "vkCreatePipelineLayout: value of pCreateInfo->pPushConstantRanges[0].stageFlags must not be 0");
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -0600475 vk::CreatePipelineLayout(m_device->device(), &pipeline_layout_ci, NULL, &pipeline_layout);
unknown088160a2019-05-23 17:43:13 -0600476 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 Lobodzinski20310782020-02-28 14:25:17 -0700531 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, iter.msg.begin(), iter.msg.end());
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -0600532 vk::CreatePipelineLayout(m_device->device(), &pipeline_layout_ci, NULL, &pipeline_layout);
unknown088160a2019-05-23 17:43:13 -0600533 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 Lobodzinski20310782020-02-28 14:25:17 -0700552 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "vkCmdPushConstants: value of stageFlags must not be 0");
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -0600553 vk::CmdPushConstants(m_commandBuffer->handle(), pipeline_layout_obj.handle(), 0, 0, 16, dummy_values);
unknown088160a2019-05-23 17:43:13 -0600554 m_errorMonitor->VerifyFound();
555
556 // Positive tests for the overlapping ranges
557 m_errorMonitor->ExpectSuccess();
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -0600558 vk::CmdPushConstants(m_commandBuffer->handle(), pipeline_layout_obj.handle(), VK_SHADER_STAGE_FRAGMENT_BIT, 0, 16,
559 dummy_values);
unknown088160a2019-05-23 17:43:13 -0600560 m_errorMonitor->VerifyNotFound();
561 m_errorMonitor->ExpectSuccess();
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -0600562 vk::CmdPushConstants(m_commandBuffer->handle(), pipeline_layout_obj.handle(), VK_SHADER_STAGE_VERTEX_BIT, 32, 48, dummy_values);
unknown088160a2019-05-23 17:43:13 -0600563 m_errorMonitor->VerifyNotFound();
564 m_errorMonitor->ExpectSuccess();
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -0600565 vk::CmdPushConstants(m_commandBuffer->handle(), pipeline_layout_obj.handle(),
566 VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT, 16, 16, dummy_values);
unknown088160a2019-05-23 17:43:13 -0600567 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 Lobodzinski20310782020-02-28 14:25:17 -0700571 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdPushConstants-offset-01795");
unknown088160a2019-05-23 17:43:13 -0600572 // Missing cmd stages for found overlapping range -- "VUID-vkCmdPushConstants-offset-01796" VUID-vkCmdPushConstants-offset-01796
Mark Lobodzinski20310782020-02-28 14:25:17 -0700573 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdPushConstants-offset-01796");
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -0600574 vk::CmdPushConstants(m_commandBuffer->handle(), pipeline_layout_obj.handle(), VK_SHADER_STAGE_GEOMETRY_BIT, 0, 16,
575 dummy_values);
unknown088160a2019-05-23 17:43:13 -0600576 m_errorMonitor->VerifyFound();
577
578 // Wrong no extant range
Mark Lobodzinski20310782020-02-28 14:25:17 -0700579 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdPushConstants-offset-01795");
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -0600580 vk::CmdPushConstants(m_commandBuffer->handle(), pipeline_layout_obj.handle(), VK_SHADER_STAGE_FRAGMENT_BIT, 80, 4,
581 dummy_values);
unknown088160a2019-05-23 17:43:13 -0600582 m_errorMonitor->VerifyFound();
583
584 // Wrong overlapping extent
Mark Lobodzinski20310782020-02-28 14:25:17 -0700585 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdPushConstants-offset-01795");
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -0600586 vk::CmdPushConstants(m_commandBuffer->handle(), pipeline_layout_obj.handle(),
587 VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT, 0, 20, dummy_values);
unknown088160a2019-05-23 17:43:13 -0600588 m_errorMonitor->VerifyFound();
589
590 // Wrong stage flags for valid overlapping range
Mark Lobodzinski20310782020-02-28 14:25:17 -0700591 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdPushConstants-offset-01796");
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -0600592 vk::CmdPushConstants(m_commandBuffer->handle(), pipeline_layout_obj.handle(), VK_SHADER_STAGE_VERTEX_BIT, 16, 16, dummy_values);
unknown088160a2019-05-23 17:43:13 -0600593 m_errorMonitor->VerifyFound();
594
595 m_commandBuffer->EndRenderPass();
596 m_commandBuffer->end();
597}
598
599TEST_F(VkLayerTest, NoBeginCommandBuffer) {
Mark Lobodzinski20310782020-02-28 14:25:17 -0700600 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "You must call vkBeginCommandBuffer() before this call to ");
unknown088160a2019-05-23 17:43:13 -0600601
602 ASSERT_NO_FATAL_FAILURE(Init());
603 VkCommandBufferObj commandBuffer(m_device, m_commandPool);
604 // Call EndCommandBuffer() w/o calling BeginCommandBuffer()
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -0600605 vk::EndCommandBuffer(commandBuffer.handle());
unknown088160a2019-05-23 17:43:13 -0600606
607 m_errorMonitor->VerifyFound();
608}
609
610TEST_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 Lobodzinski20310782020-02-28 14:25:17 -0700625 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkCommandBufferBeginInfo-flags-00053");
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -0600626 vk::BeginCommandBuffer(cb.handle(), &cmd_buf_info);
unknown088160a2019-05-23 17:43:13 -0600627 m_errorMonitor->VerifyFound();
628}
629
630TEST_F(VkLayerTest, SecondaryCommandBufferRerecordedExplicitReset) {
631 ASSERT_NO_FATAL_FAILURE(Init());
632
Mark Lobodzinski20310782020-02-28 14:25:17 -0700633 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "was destroyed or rerecorded");
unknown088160a2019-05-23 17:43:13 -0600634
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 Lobodzinski902cb0f2019-09-27 14:45:36 -0600643 vk::CmdExecuteCommands(m_commandBuffer->handle(), 1, &secondary.handle());
unknown088160a2019-05-23 17:43:13 -0600644
645 // rerecording of secondary
646 secondary.reset(); // explicit reset here.
647 secondary.begin();
648 secondary.end();
649
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -0600650 vk::CmdExecuteCommands(m_commandBuffer->handle(), 1, &secondary.handle());
unknown088160a2019-05-23 17:43:13 -0600651 m_errorMonitor->VerifyFound();
652}
653
654TEST_F(VkLayerTest, SecondaryCommandBufferRerecordedNoReset) {
655 ASSERT_NO_FATAL_FAILURE(Init());
656
Mark Lobodzinski20310782020-02-28 14:25:17 -0700657 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "was destroyed or rerecorded");
unknown088160a2019-05-23 17:43:13 -0600658
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 Lobodzinski902cb0f2019-09-27 14:45:36 -0600667 vk::CmdExecuteCommands(m_commandBuffer->handle(), 1, &secondary.handle());
unknown088160a2019-05-23 17:43:13 -0600668
669 // rerecording of secondary
670 secondary.begin(); // implicit reset in begin
671 secondary.end();
672
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -0600673 vk::CmdExecuteCommands(m_commandBuffer->handle(), 1, &secondary.handle());
unknown088160a2019-05-23 17:43:13 -0600674 m_errorMonitor->VerifyFound();
675}
676
677TEST_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 Lobodzinski902cb0f2019-09-27 14:45:36 -0600682 vk::CreateEvent(m_device->device(), &eci, nullptr, &event);
unknown088160a2019-05-23 17:43:13 -0600683
684 VkCommandBufferObj secondary(m_device, m_commandPool, VK_COMMAND_BUFFER_LEVEL_SECONDARY);
685 secondary.begin();
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -0600686 vk::CmdSetEvent(secondary.handle(), event, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT);
unknown088160a2019-05-23 17:43:13 -0600687 secondary.end();
688
689 m_commandBuffer->begin();
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -0600690 vk::CmdExecuteCommands(m_commandBuffer->handle(), 1, &secondary.handle());
unknown088160a2019-05-23 17:43:13 -0600691 m_commandBuffer->end();
692
693 // destroying the event should invalidate both primary and secondary CB
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -0600694 vk::DestroyEvent(m_device->device(), event, nullptr);
unknown088160a2019-05-23 17:43:13 -0600695
Mark Lobodzinski20310782020-02-28 14:25:17 -0700696 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "UNASSIGNED-CoreValidation-DrawState-InvalidCommandBuffer-VkEvent");
unknown088160a2019-05-23 17:43:13 -0600697 m_commandBuffer->QueueCommandBuffer(false);
698 m_errorMonitor->VerifyFound();
699}
700
701TEST_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 Lobodzinski20310782020-02-28 14:25:17 -0700706 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkBeginCommandBuffer-commandBuffer-00049");
unknown088160a2019-05-23 17:43:13 -0600707
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 Lobodzinski902cb0f2019-09-27 14:45:36 -0600723 vk::BeginCommandBuffer(commandBuffer.handle(), &cmd_buf_info);
unknown088160a2019-05-23 17:43:13 -0600724 // Can't re-begin. This should trigger error
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -0600725 vk::BeginCommandBuffer(commandBuffer.handle(), &cmd_buf_info);
unknown088160a2019-05-23 17:43:13 -0600726 m_errorMonitor->VerifyFound();
727
Mark Lobodzinski20310782020-02-28 14:25:17 -0700728 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkResetCommandBuffer-commandBuffer-00046");
unknown088160a2019-05-23 17:43:13 -0600729 VkCommandBufferResetFlags flags = 0; // Don't care about flags for this test
730 // Reset attempt will trigger error due to incorrect CommandPool state
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -0600731 vk::ResetCommandBuffer(commandBuffer.handle(), flags);
unknown088160a2019-05-23 17:43:13 -0600732 m_errorMonitor->VerifyFound();
733
Mark Lobodzinski20310782020-02-28 14:25:17 -0700734 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkBeginCommandBuffer-commandBuffer-00050");
unknown088160a2019-05-23 17:43:13 -0600735 // Transition CB to RECORDED state
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -0600736 vk::EndCommandBuffer(commandBuffer.handle());
unknown088160a2019-05-23 17:43:13 -0600737 // Now attempting to Begin will implicitly reset, which triggers error
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -0600738 vk::BeginCommandBuffer(commandBuffer.handle(), &cmd_buf_info);
unknown088160a2019-05-23 17:43:13 -0600739 m_errorMonitor->VerifyFound();
740}
741
sfricke-samsungae9f00a2020-05-28 20:48:49 -0700742TEST_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
unknown088160a2019-05-23 17:43:13 -0600758TEST_F(VkLayerTest, ClearColorAttachmentsOutsideRenderPass) {
759 // Call CmdClearAttachmentss outside of an active RenderPass
760
Mark Lobodzinski20310782020-02-28 14:25:17 -0700761 m_errorMonitor->SetDesiredFailureMsg(kErrorBit,
unknown088160a2019-05-23 17:43:13 -0600762 "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 Lobodzinskid5447512019-06-28 09:56:36 -0600777 VkClearRect clear_rect = {{{0, 0}, {32, 32}}, 0, 1};
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -0600778 vk::CmdClearAttachments(m_commandBuffer->handle(), 1, &color_attachment, 1, &clear_rect);
unknown088160a2019-05-23 17:43:13 -0600779
780 m_errorMonitor->VerifyFound();
781}
782
Mark Lobodzinski7d7da062019-06-27 16:01:39 -0600783TEST_F(VkLayerTest, ClearColorAttachmentsZeroLayercount) {
784 TEST_DESCRIPTION("Call CmdClearAttachments with a pRect having a layerCount of zero.");
785
Mark Lobodzinski20310782020-02-28 14:25:17 -0700786 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdClearAttachments-layerCount-01934");
Mark Lobodzinski7d7da062019-06-27 16:01:39 -0600787
788 ASSERT_NO_FATAL_FAILURE(Init());
789 ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
790
791 m_commandBuffer->begin();
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -0600792 vk::CmdBeginRenderPass(m_commandBuffer->handle(), &renderPassBeginInfo(), VK_SUBPASS_CONTENTS_INLINE);
Mark Lobodzinski7d7da062019-06-27 16:01:39 -0600793
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 Lobodzinski902cb0f2019-09-27 14:45:36 -0600802 vk::CmdClearAttachments(m_commandBuffer->handle(), 1, &color_attachment, 1, &clear_rect);
Mark Lobodzinski7d7da062019-06-27 16:01:39 -0600803
804 m_errorMonitor->VerifyFound();
805}
806
sfricke-samsungf0f3d8b2020-04-25 02:20:47 -0700807TEST_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
unknown088160a2019-05-23 17:43:13 -0600839TEST_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 Lobodzinski902cb0f2019-09-27 14:45:36 -0600851 vk::CmdBeginRenderPass(m_commandBuffer->handle(), &renderPassBeginInfo(), VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS);
unknown088160a2019-05-23 17:43:13 -0600852 VkCommandBuffer handle = cb.handle();
853
Mark Lobodzinski20310782020-02-28 14:25:17 -0700854 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdExecuteCommands-pCommandBuffers-00088");
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -0600855 vk::CmdExecuteCommands(m_commandBuffer->handle(), 1, &handle);
unknown088160a2019-05-23 17:43:13 -0600856 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 Kraus8e53cf02020-01-03 05:30:04 +0100864TEST_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 Lobodzinski20310782020-02-28 14:25:17 -0700875 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdExecuteCommands-bufferlevel");
Petr Kraus8e53cf02020-01-03 05:30:04 +0100876 vk::CmdExecuteCommands(main_cb.handle(), 1, &secondary_cb.handle());
877 m_errorMonitor->VerifyFound();
878}
879
unknown088160a2019-05-23 17:43:13 -0600880TEST_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";
unknown088160a2019-05-23 17:43:13 -0600935
936 VkShaderObj vs(m_device, vsSource, VK_SHADER_STAGE_VERTEX_BIT, this);
locke-lunarg8e2c91b2019-06-11 17:53:26 -0600937 VkShaderObj fs(m_device, bindStateFragShaderText, VK_SHADER_STAGE_FRAGMENT_BIT, this);
unknown088160a2019-05-23 17:43:13 -0600938
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 Lobodzinski902cb0f2019-09-27 14:45:36 -0600966 vk::CmdBindPipeline(m_commandBuffer->handle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipe1.handle());
967 vk::CmdBindVertexBuffers(m_commandBuffer->handle(), 0, 1, &vbo.handle(), &offset);
Mark Lobodzinski20310782020-02-28 14:25:17 -0700968 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");
unknown088160a2019-05-23 17:43:13 -0600971 m_commandBuffer->Draw(1, 0, 0, 0);
972 m_errorMonitor->VerifyFound();
973
974 // Test with invalid buffer stride
975 offset = 0;
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -0600976 vk::CmdBindPipeline(m_commandBuffer->handle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipe2.handle());
977 vk::CmdBindVertexBuffers(m_commandBuffer->handle(), 0, 1, &vbo.handle(), &offset);
Mark Lobodzinski20310782020-02-28 14:25:17 -0700978 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "Invalid attribAddress alignment for vertex attribute 0");
unknown088160a2019-05-23 17:43:13 -0600979 // Attribute[1] is aligned properly even with a wrong stride
Mark Lobodzinski20310782020-02-28 14:25:17 -0700980 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "Invalid attribAddress alignment for vertex attribute 2");
unknown088160a2019-05-23 17:43:13 -0600981 m_commandBuffer->Draw(1, 0, 0, 0);
982 m_errorMonitor->VerifyFound();
983
984 m_commandBuffer->EndRenderPass();
985 m_commandBuffer->end();
986}
987
988TEST_F(VkLayerTest, NonSimultaneousSecondaryMarksPrimary) {
989 ASSERT_NO_FATAL_FAILURE(Init());
locke-lunarg77b9f7c2019-06-18 00:06:03 -0600990 const char *simultaneous_use_message = "UNASSIGNED-CoreValidation-DrawState-InvalidCommandBufferSimultaneousUse";
unknown088160a2019-05-23 17:43:13 -0600991
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 Lobodzinski20310782020-02-28 14:25:17 -07001005 m_errorMonitor->SetDesiredFailureMsg(kWarningBit, simultaneous_use_message);
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06001006 vk::CmdExecuteCommands(m_commandBuffer->handle(), 1, &secondary.handle());
unknown088160a2019-05-23 17:43:13 -06001007 m_errorMonitor->VerifyFound();
1008 m_commandBuffer->end();
1009}
1010
1011TEST_F(VkLayerTest, SimultaneousUseSecondaryTwoExecutes) {
1012 ASSERT_NO_FATAL_FAILURE(Init());
1013
John Zulauff1640d12019-08-13 15:39:58 -06001014 const char *simultaneous_use_message = "VUID-vkCmdExecuteCommands-pCommandBuffers-00092";
unknown088160a2019-05-23 17:43:13 -06001015
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 Lobodzinski902cb0f2019-09-27 14:45:36 -06001028 vk::CmdExecuteCommands(m_commandBuffer->handle(), 1, &secondary.handle());
Mark Lobodzinski20310782020-02-28 14:25:17 -07001029 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, simultaneous_use_message);
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06001030 vk::CmdExecuteCommands(m_commandBuffer->handle(), 1, &secondary.handle());
unknown088160a2019-05-23 17:43:13 -06001031 m_errorMonitor->VerifyFound();
1032 m_commandBuffer->end();
1033}
1034
1035TEST_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 Zulauff1640d12019-08-13 15:39:58 -06001041 const char *simultaneous_use_message = "VUID-vkCmdExecuteCommands-pCommandBuffers-00093";
unknown088160a2019-05-23 17:43:13 -06001042
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 Lobodzinski20310782020-02-28 14:25:17 -07001056 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, simultaneous_use_message);
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06001057 vk::CmdExecuteCommands(m_commandBuffer->handle(), 2, cbs);
unknown088160a2019-05-23 17:43:13 -06001058 m_errorMonitor->VerifyFound();
1059 m_commandBuffer->end();
1060}
1061
1062TEST_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 Lobodzinski902cb0f2019-09-27 14:45:36 -06001075 vk::AllocateCommandBuffers(m_device->device(), &alloc_info, cmd_bufs);
unknown088160a2019-05-23 17:43:13 -06001076
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 Lobodzinski902cb0f2019-09-27 14:45:36 -06001082 vk::BeginCommandBuffer(cmd_bufs[0], &cb_binfo);
unknown088160a2019-05-23 17:43:13 -06001083 VkViewport viewport = {0, 0, 16, 16, 0, 1};
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06001084 vk::CmdSetViewport(cmd_bufs[0], 0, 1, &viewport);
1085 vk::EndCommandBuffer(cmd_bufs[0]);
unknown088160a2019-05-23 17:43:13 -06001086 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 Lobodzinski20310782020-02-28 14:25:17 -07001092 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, simultaneous_use_message);
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06001093 vk::QueueSubmit(m_device->m_queue, 1, &submit_info, VK_NULL_HANDLE);
unknown088160a2019-05-23 17:43:13 -06001094 m_errorMonitor->VerifyFound();
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06001095 vk::QueueWaitIdle(m_device->m_queue);
unknown088160a2019-05-23 17:43:13 -06001096
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 Lobodzinski902cb0f2019-09-27 14:45:36 -06001100 vk::BeginCommandBuffer(cmd_bufs[1], &cb_binfo);
1101 vk::CmdSetViewport(cmd_bufs[1], 0, 1, &viewport);
1102 vk::EndCommandBuffer(cmd_bufs[1]);
Mark Lobodzinski20310782020-02-28 14:25:17 -07001103 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, one_shot_message);
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06001104 vk::QueueSubmit(m_device->m_queue, 1, &submit_info, VK_NULL_HANDLE);
unknown088160a2019-05-23 17:43:13 -06001105 m_errorMonitor->VerifyFound();
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06001106 vk::QueueWaitIdle(m_device->m_queue);
unknown088160a2019-05-23 17:43:13 -06001107}
1108
1109TEST_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 Lobodzinski20310782020-02-28 14:25:17 -07001113 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "requires an image view of type VK_IMAGE_VIEW_TYPE_3D");
unknown088160a2019-05-23 17:43:13 -06001114
1115 ASSERT_NO_FATAL_FAILURE(Init());
1116 ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
1117
unknown088160a2019-05-23 17:43:13 -06001118 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-lunarg8e2c91b2019-06-11 17:53:26 -06001126 VkShaderObj vs(m_device, bindStateVertShaderText, VK_SHADER_STAGE_VERTEX_BIT, this);
unknown088160a2019-05-23 17:43:13 -06001127 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 Lobodzinski902cb0f2019-09-27 14:45:36 -06001147 vk::CmdBindPipeline(m_commandBuffer->handle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipe.handle());
unknown088160a2019-05-23 17:43:13 -06001148 m_commandBuffer->BindDescriptorSet(descriptorSet);
1149
1150 VkViewport viewport = {0, 0, 16, 16, 0, 1};
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06001151 vk::CmdSetViewport(m_commandBuffer->handle(), 0, 1, &viewport);
unknown088160a2019-05-23 17:43:13 -06001152 VkRect2D scissor = {{0, 0}, {16, 16}};
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06001153 vk::CmdSetScissor(m_commandBuffer->handle(), 0, 1, &scissor);
unknown088160a2019-05-23 17:43:13 -06001154
1155 // error produced here.
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06001156 vk::CmdDraw(m_commandBuffer->handle(), 3, 1, 0, 0);
unknown088160a2019-05-23 17:43:13 -06001157
1158 m_errorMonitor->VerifyFound();
1159
1160 m_commandBuffer->EndRenderPass();
1161 m_commandBuffer->end();
1162}
1163
1164TEST_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 Lobodzinski20310782020-02-28 14:25:17 -07001169 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "requires bound image to have multiple samples");
unknown088160a2019-05-23 17:43:13 -06001170
1171 ASSERT_NO_FATAL_FAILURE(Init());
1172 ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
1173
unknown088160a2019-05-23 17:43:13 -06001174 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-lunarg8e2c91b2019-06-11 17:53:26 -06001182 VkShaderObj vs(m_device, bindStateVertShaderText, VK_SHADER_STAGE_VERTEX_BIT, this);
unknown088160a2019-05-23 17:43:13 -06001183 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 Lobodzinski902cb0f2019-09-27 14:45:36 -06001203 vk::CmdBindPipeline(m_commandBuffer->handle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipe.handle());
unknown088160a2019-05-23 17:43:13 -06001204 m_commandBuffer->BindDescriptorSet(descriptorSet);
1205
1206 VkViewport viewport = {0, 0, 16, 16, 0, 1};
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06001207 vk::CmdSetViewport(m_commandBuffer->handle(), 0, 1, &viewport);
unknown088160a2019-05-23 17:43:13 -06001208 VkRect2D scissor = {{0, 0}, {16, 16}};
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06001209 vk::CmdSetScissor(m_commandBuffer->handle(), 0, 1, &scissor);
unknown088160a2019-05-23 17:43:13 -06001210
1211 // error produced here.
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06001212 vk::CmdDraw(m_commandBuffer->handle(), 3, 1, 0, 0);
unknown088160a2019-05-23 17:43:13 -06001213
1214 m_errorMonitor->VerifyFound();
1215
1216 m_commandBuffer->EndRenderPass();
1217 m_commandBuffer->end();
1218}
1219
1220TEST_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 Lobodzinski20310782020-02-28 14:25:17 -07001224 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "SINT component type, but bound descriptor");
unknown088160a2019-05-23 17:43:13 -06001225
1226 ASSERT_NO_FATAL_FAILURE(Init());
1227 ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
1228
unknown088160a2019-05-23 17:43:13 -06001229 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-lunarg8e2c91b2019-06-11 17:53:26 -06001237 VkShaderObj vs(m_device, bindStateVertShaderText, VK_SHADER_STAGE_VERTEX_BIT, this);
unknown088160a2019-05-23 17:43:13 -06001238 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 Lobodzinski902cb0f2019-09-27 14:45:36 -06001258 vk::CmdBindPipeline(m_commandBuffer->handle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipe.handle());
unknown088160a2019-05-23 17:43:13 -06001259 m_commandBuffer->BindDescriptorSet(descriptorSet);
1260
1261 VkViewport viewport = {0, 0, 16, 16, 0, 1};
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06001262 vk::CmdSetViewport(m_commandBuffer->handle(), 0, 1, &viewport);
unknown088160a2019-05-23 17:43:13 -06001263 VkRect2D scissor = {{0, 0}, {16, 16}};
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06001264 vk::CmdSetScissor(m_commandBuffer->handle(), 0, 1, &scissor);
unknown088160a2019-05-23 17:43:13 -06001265
1266 // error produced here.
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06001267 vk::CmdDraw(m_commandBuffer->handle(), 3, 1, 0, 0);
unknown088160a2019-05-23 17:43:13 -06001268
1269 m_errorMonitor->VerifyFound();
1270
1271 m_commandBuffer->EndRenderPass();
1272 m_commandBuffer->end();
1273}
1274
unknown088160a2019-05-23 17:43:13 -06001275TEST_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-samsung30b094c2020-05-30 11:42:11 -07001278 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 }
unknown088160a2019-05-23 17:43:13 -06001293
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-samsung30b094c2020-05-30 11:42:11 -07001302 image_create_info.format = image_format;
unknown088160a2019-05-23 17:43:13 -06001303 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-samsung30b094c2020-05-30 11:42:11 -07001341 const char *vuid = (maintenance1 == true) ? "VUID-VkImageCopy-extent-00140" : "VUID-VkImageCopy-layerCount-00138";
1342 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, vuid);
unknown088160a2019-05-23 17:43:13 -06001343 m_commandBuffer->CopyImage(src_image_obj.image(), VK_IMAGE_LAYOUT_GENERAL, dst_image_obj.image(), VK_IMAGE_LAYOUT_GENERAL, 1,
1344 &copyRegion);
1345 m_errorMonitor->VerifyFound();
1346}
1347
1348TEST_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 Lobodzinski902cb0f2019-09-27 14:45:36 -06001418 vk::CmdCopyImageToBuffer(m_commandBuffer->handle(), image.handle(), VK_IMAGE_LAYOUT_GENERAL, buffer_1024.handle(), 1, &region);
1419 vk::CmdCopyBufferToImage(m_commandBuffer->handle(), buffer_1024.handle(), image.handle(), VK_IMAGE_LAYOUT_GENERAL, 1, &region);
unknown088160a2019-05-23 17:43:13 -06001420
1421 // Mip 2 should fit in 64b buffer - 64 texels @ 1b each
1422 region.imageExtent = {8, 8, 1};
1423 region.imageSubresource.mipLevel = 2;
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06001424 vk::CmdCopyImageToBuffer(m_commandBuffer->handle(), image.handle(), VK_IMAGE_LAYOUT_GENERAL, buffer_64.handle(), 1, &region);
1425 vk::CmdCopyBufferToImage(m_commandBuffer->handle(), buffer_64.handle(), image.handle(), VK_IMAGE_LAYOUT_GENERAL, 1, &region);
unknown088160a2019-05-23 17:43:13 -06001426
1427 // Mip 3 should fit in 16b buffer - 16 texels @ 1b each
1428 region.imageExtent = {4, 4, 1};
1429 region.imageSubresource.mipLevel = 3;
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06001430 vk::CmdCopyImageToBuffer(m_commandBuffer->handle(), image.handle(), VK_IMAGE_LAYOUT_GENERAL, buffer_16.handle(), 1, &region);
1431 vk::CmdCopyBufferToImage(m_commandBuffer->handle(), buffer_16.handle(), image.handle(), VK_IMAGE_LAYOUT_GENERAL, 1, &region);
unknown088160a2019-05-23 17:43:13 -06001432
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 Lobodzinski902cb0f2019-09-27 14:45:36 -06001436 vk::CmdCopyImageToBuffer(m_commandBuffer->handle(), image.handle(), VK_IMAGE_LAYOUT_GENERAL, buffer_16.handle(), 1, &region);
1437 vk::CmdCopyBufferToImage(m_commandBuffer->handle(), buffer_16.handle(), image.handle(), VK_IMAGE_LAYOUT_GENERAL, 1, &region);
unknown088160a2019-05-23 17:43:13 -06001438
1439 region.imageExtent = {1, 1, 1};
1440 region.imageSubresource.mipLevel = 5;
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06001441 vk::CmdCopyImageToBuffer(m_commandBuffer->handle(), image.handle(), VK_IMAGE_LAYOUT_GENERAL, buffer_16.handle(), 1, &region);
1442 vk::CmdCopyBufferToImage(m_commandBuffer->handle(), buffer_16.handle(), image.handle(), VK_IMAGE_LAYOUT_GENERAL, 1, &region);
unknown088160a2019-05-23 17:43:13 -06001443 m_errorMonitor->VerifyNotFound();
1444
1445 // Buffer must accommodate a full compressed block, regardless of texel count
Mark Lobodzinski20310782020-02-28 14:25:17 -07001446 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyImageToBuffer-pRegions-00183");
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06001447 vk::CmdCopyImageToBuffer(m_commandBuffer->handle(), image.handle(), VK_IMAGE_LAYOUT_GENERAL, buffer_8.handle(), 1, &region);
unknown088160a2019-05-23 17:43:13 -06001448 m_errorMonitor->VerifyFound();
Mark Lobodzinski20310782020-02-28 14:25:17 -07001449 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyBufferToImage-pRegions-00171");
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06001450 vk::CmdCopyBufferToImage(m_commandBuffer->handle(), buffer_8.handle(), image.handle(), VK_IMAGE_LAYOUT_GENERAL, 1, &region);
unknown088160a2019-05-23 17:43:13 -06001451 m_errorMonitor->VerifyFound();
1452
sfricke-samsung3a10b922020-05-13 23:23:16 -07001453 std::string vuid;
1454 bool ycbcr = (DeviceExtensionEnabled(VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME) ||
1455 (DeviceValidationVersion() >= VK_API_VERSION_1_1));
1456
unknown088160a2019-05-23 17:43:13 -06001457 // Copy width < compressed block size, but not the full mip width
1458 region.imageExtent = {1, 2, 1};
1459 region.imageSubresource.mipLevel = 4;
sfricke-samsung3a10b922020-05-13 23:23:16 -07001460 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 Lobodzinski20310782020-02-28 14:25:17 -07001462 m_errorMonitor->SetDesiredFailureMsg(kErrorBit,
unknown088160a2019-05-23 17:43:13 -06001463 "VUID-vkCmdCopyImageToBuffer-imageOffset-01794"); // image transfer granularity
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06001464 vk::CmdCopyImageToBuffer(m_commandBuffer->handle(), image.handle(), VK_IMAGE_LAYOUT_GENERAL, buffer_16.handle(), 1, &region);
unknown088160a2019-05-23 17:43:13 -06001465 m_errorMonitor->VerifyFound();
sfricke-samsung3a10b922020-05-13 23:23:16 -07001466 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, vuid); // width not a multiple of compressed block width
Mark Lobodzinski20310782020-02-28 14:25:17 -07001467 m_errorMonitor->SetDesiredFailureMsg(kErrorBit,
unknown088160a2019-05-23 17:43:13 -06001468 "VUID-vkCmdCopyBufferToImage-imageOffset-01793"); // image transfer granularity
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06001469 vk::CmdCopyBufferToImage(m_commandBuffer->handle(), buffer_16.handle(), image.handle(), VK_IMAGE_LAYOUT_GENERAL, 1, &region);
unknown088160a2019-05-23 17:43:13 -06001470 m_errorMonitor->VerifyFound();
1471
1472 // Copy height < compressed block size but not the full mip height
1473 region.imageExtent = {2, 1, 1};
sfricke-samsung3a10b922020-05-13 23:23:16 -07001474 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 Lobodzinski20310782020-02-28 14:25:17 -07001476 m_errorMonitor->SetDesiredFailureMsg(kErrorBit,
unknown088160a2019-05-23 17:43:13 -06001477 "VUID-vkCmdCopyImageToBuffer-imageOffset-01794"); // image transfer granularity
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06001478 vk::CmdCopyImageToBuffer(m_commandBuffer->handle(), image.handle(), VK_IMAGE_LAYOUT_GENERAL, buffer_16.handle(), 1, &region);
unknown088160a2019-05-23 17:43:13 -06001479 m_errorMonitor->VerifyFound();
sfricke-samsung3a10b922020-05-13 23:23:16 -07001480 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, vuid); // height not a multiple of compressed block width
Mark Lobodzinski20310782020-02-28 14:25:17 -07001481 m_errorMonitor->SetDesiredFailureMsg(kErrorBit,
unknown088160a2019-05-23 17:43:13 -06001482 "VUID-vkCmdCopyBufferToImage-imageOffset-01793"); // image transfer granularity
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06001483 vk::CmdCopyBufferToImage(m_commandBuffer->handle(), buffer_16.handle(), image.handle(), VK_IMAGE_LAYOUT_GENERAL, 1, &region);
unknown088160a2019-05-23 17:43:13 -06001484 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-samsung3a10b922020-05-13 23:23:16 -07001489 vuid = ycbcr ? "VUID-VkBufferImageCopy-None-01737" : "VUID-VkBufferImageCopy-imageOffset-00205";
1490 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, vuid); // imageOffset not a multiple of block size
Mark Lobodzinski20310782020-02-28 14:25:17 -07001491 m_errorMonitor->SetDesiredFailureMsg(kErrorBit,
unknown088160a2019-05-23 17:43:13 -06001492 "VUID-vkCmdCopyImageToBuffer-imageOffset-01794"); // image transfer granularity
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06001493 vk::CmdCopyImageToBuffer(m_commandBuffer->handle(), image.handle(), VK_IMAGE_LAYOUT_GENERAL, buffer_16.handle(), 1, &region);
unknown088160a2019-05-23 17:43:13 -06001494 m_errorMonitor->VerifyFound();
sfricke-samsung3a10b922020-05-13 23:23:16 -07001495 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, vuid); // imageOffset not a multiple of block size
Mark Lobodzinski20310782020-02-28 14:25:17 -07001496 m_errorMonitor->SetDesiredFailureMsg(kErrorBit,
unknown088160a2019-05-23 17:43:13 -06001497 "VUID-vkCmdCopyBufferToImage-imageOffset-01793"); // image transfer granularity
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06001498 vk::CmdCopyBufferToImage(m_commandBuffer->handle(), buffer_16.handle(), image.handle(), VK_IMAGE_LAYOUT_GENERAL, 1, &region);
unknown088160a2019-05-23 17:43:13 -06001499 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 Lobodzinski902cb0f2019-09-27 14:45:36 -06001506 vk::CmdCopyImageToBuffer(m_commandBuffer->handle(), odd_image.handle(), VK_IMAGE_LAYOUT_GENERAL, buffer_16.handle(), 1,
1507 &region);
1508 vk::CmdCopyBufferToImage(m_commandBuffer->handle(), buffer_16.handle(), odd_image.handle(), VK_IMAGE_LAYOUT_GENERAL, 1,
1509 &region);
unknown088160a2019-05-23 17:43:13 -06001510 m_errorMonitor->VerifyNotFound();
1511
unknown088160a2019-05-23 17:43:13 -06001512 // Offset + extent width < mip width and not a multiple of block width - should fail
1513 region.imageExtent = {3, 3, 1};
sfricke-samsung3a10b922020-05-13 23:23:16 -07001514 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 Lobodzinski20310782020-02-28 14:25:17 -07001516 m_errorMonitor->SetDesiredFailureMsg(kErrorBit,
unknown088160a2019-05-23 17:43:13 -06001517 "VUID-vkCmdCopyImageToBuffer-imageOffset-01794"); // image transfer granularity
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06001518 vk::CmdCopyImageToBuffer(m_commandBuffer->handle(), odd_image.handle(), VK_IMAGE_LAYOUT_GENERAL, buffer_16.handle(), 1,
1519 &region);
unknown088160a2019-05-23 17:43:13 -06001520 m_errorMonitor->VerifyFound();
sfricke-samsung3a10b922020-05-13 23:23:16 -07001521 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, vuid); // offset+extent not a multiple of block width
Mark Lobodzinski20310782020-02-28 14:25:17 -07001522 m_errorMonitor->SetDesiredFailureMsg(kErrorBit,
unknown088160a2019-05-23 17:43:13 -06001523 "VUID-vkCmdCopyBufferToImage-imageOffset-01793"); // image transfer granularity
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06001524 vk::CmdCopyBufferToImage(m_commandBuffer->handle(), buffer_16.handle(), odd_image.handle(), VK_IMAGE_LAYOUT_GENERAL, 1,
1525 &region);
unknown088160a2019-05-23 17:43:13 -06001526 m_errorMonitor->VerifyFound();
1527}
1528
1529TEST_F(VkLayerTest, ImageBufferCopyTests) {
1530 TEST_DESCRIPTION("Image to buffer and buffer to image tests");
sfricke-samsung6d97e562020-01-07 22:01:00 -08001531
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 Lobodzinski09ce9c42020-03-06 10:02:44 -07001538 ASSERT_NO_FATAL_FAILURE(InitFramework(m_errorMonitor, nullptr));
sfricke-samsung6d97e562020-01-07 22:01:00 -08001539 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());
unknown088160a2019-05-23 17:43:13 -06001550
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-samsung6d97e562020-01-07 22:01:00 -08001561 // 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 Lobodzinski20310782020-02-28 14:25:17 -07001563 VkImageObj image_64k(m_device); // 128^2 texels, 64k
1564 VkImageObj image_16k(m_device); // 64^2 texels, 16k
sfricke-samsung6d97e562020-01-07 22:01:00 -08001565 // depth stencil
unknown088160a2019-05-23 17:43:13 -06001566 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-samsung6d97e562020-01-07 22:01:00 -08001571 // 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
unknown088160a2019-05-23 17:43:13 -06001576
sfricke-samsung6d97e562020-01-07 22:01:00 -08001577 // 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 }
unknown088160a2019-05-23 17:43:13 -06001596
1597 // Verify all needed Depth/Stencil formats are supported
1598 bool missing_ds_support = false;
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06001599 vk::GetPhysicalDeviceFormatProperties(m_device->phy().handle(), VK_FORMAT_D32_SFLOAT_S8_UINT, &props);
unknown088160a2019-05-23 17:43:13 -06001600 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 Lobodzinski902cb0f2019-09-27 14:45:36 -06001603 vk::GetPhysicalDeviceFormatProperties(m_device->phy().handle(), VK_FORMAT_D24_UNORM_S8_UINT, &props);
unknown088160a2019-05-23 17:43:13 -06001604 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 Lobodzinski902cb0f2019-09-27 14:45:36 -06001607 vk::GetPhysicalDeviceFormatProperties(m_device->phy().handle(), VK_FORMAT_D16_UNORM, &props);
unknown088160a2019-05-23 17:43:13 -06001608 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 Lobodzinski902cb0f2019-09-27 14:45:36 -06001611 vk::GetPhysicalDeviceFormatProperties(m_device->phy().handle(), VK_FORMAT_S8_UINT, &props);
unknown088160a2019-05-23 17:43:13 -06001612 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-samsung6d97e562020-01-07 22:01:00 -08001663 if (missing_rgba_support) {
1664 printf("%s R8G8B8A8_UINT transfer unsupported - skipping RGBA tests.\n", kSkipPrefix);
unknown088160a2019-05-23 17:43:13 -06001665
sfricke-samsung6d97e562020-01-07 22:01:00 -08001666 // start recording for future tests
1667 m_commandBuffer->begin();
1668 } else {
1669 // attempt copies before putting command buffer in recording state
Mark Lobodzinski20310782020-02-28 14:25:17 -07001670 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyBufferToImage-commandBuffer-recording");
sfricke-samsung6d97e562020-01-07 22:01:00 -08001671 vk::CmdCopyBufferToImage(m_commandBuffer->handle(), buffer_64k.handle(), image_64k.handle(), VK_IMAGE_LAYOUT_GENERAL, 1,
1672 &region);
unknown088160a2019-05-23 17:43:13 -06001673 m_errorMonitor->VerifyFound();
1674
Mark Lobodzinski20310782020-02-28 14:25:17 -07001675 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyImageToBuffer-commandBuffer-recording");
sfricke-samsung6d97e562020-01-07 22:01:00 -08001676 vk::CmdCopyImageToBuffer(m_commandBuffer->handle(), image_64k.handle(), VK_IMAGE_LAYOUT_GENERAL, buffer_64k.handle(), 1,
1677 &region);
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 &region);
1687 vk::CmdCopyBufferToImage(m_commandBuffer->handle(), buffer_16k.handle(), image_16k.handle(), VK_IMAGE_LAYOUT_GENERAL, 1,
1688 &region);
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 &region);
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 &region);
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 &region);
1700 m_errorMonitor->VerifyNotFound();
1701
1702 // image/buffer too small (extent too large) on copy to image
1703 region.imageExtent = {65, 64, 1};
Mark Lobodzinski20310782020-02-28 14:25:17 -07001704 m_errorMonitor->SetDesiredFailureMsg(kErrorBit,
sfricke-samsung6d97e562020-01-07 22:01:00 -08001705 "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 &region);
1708 m_errorMonitor->VerifyFound();
1709
1710 m_errorMonitor->SetUnexpectedError("VUID-VkBufferImageCopy-imageOffset-00197");
Mark Lobodzinski20310782020-02-28 14:25:17 -07001711 m_errorMonitor->SetDesiredFailureMsg(kErrorBit,
sfricke-samsung6d97e562020-01-07 22:01:00 -08001712 "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 &region);
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 Lobodzinski20310782020-02-28 14:25:17 -07001720 m_errorMonitor->SetDesiredFailureMsg(kErrorBit,
sfricke-samsung6d97e562020-01-07 22:01:00 -08001721 "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 &region);
1724 m_errorMonitor->VerifyFound();
1725
1726 m_errorMonitor->SetUnexpectedError("VUID-VkBufferImageCopy-imageOffset-00197");
1727 m_errorMonitor->SetUnexpectedError("VUID-VkBufferImageCopy-imageOffset-00198");
Mark Lobodzinski20310782020-02-28 14:25:17 -07001728 m_errorMonitor->SetDesiredFailureMsg(kErrorBit,
sfricke-samsung6d97e562020-01-07 22:01:00 -08001729 "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 &region);
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 Lobodzinski20310782020-02-28 14:25:17 -07001738 m_errorMonitor->SetDesiredFailureMsg(kErrorBit,
sfricke-samsung6d97e562020-01-07 22:01:00 -08001739 "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 &region);
1742 m_errorMonitor->VerifyFound();
1743
1744 region.imageExtent = {64, 65, 1};
1745 region.bufferOffset = 0;
1746 m_errorMonitor->SetUnexpectedError("VUID-VkBufferImageCopy-imageOffset-00198");
Mark Lobodzinski20310782020-02-28 14:25:17 -07001747 m_errorMonitor->SetDesiredFailureMsg(kErrorBit,
sfricke-samsung6d97e562020-01-07 22:01:00 -08001748 "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 &region);
1751 m_errorMonitor->VerifyFound();
1752
1753 // buffer size OK but rowlength causes loose packing
Mark Lobodzinski20310782020-02-28 14:25:17 -07001754 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyImageToBuffer-pRegions-00183");
sfricke-samsung6d97e562020-01-07 22:01:00 -08001755 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 &region);
1759 m_errorMonitor->VerifyFound();
1760
1761 // An extent with zero area should produce a warning, but no error
Mark Lobodzinski20310782020-02-28 14:25:17 -07001762 m_errorMonitor->SetDesiredFailureMsg(kWarningBit | kErrorBit, "} has zero area");
sfricke-samsung6d97e562020-01-07 22:01:00 -08001763 region.imageExtent.width = 0;
1764 vk::CmdCopyImageToBuffer(m_commandBuffer->handle(), image_16k.handle(), VK_IMAGE_LAYOUT_GENERAL, buffer_16k.handle(), 1,
1765 &region);
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 Lobodzinski20310782020-02-28 14:25:17 -07001773 m_errorMonitor->SetDesiredFailureMsg(kErrorBit,
sfricke-samsung6d97e562020-01-07 22:01:00 -08001774 "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, &region);
1778 m_errorMonitor->VerifyFound();
1779
Mark Lobodzinski20310782020-02-28 14:25:17 -07001780 m_errorMonitor->SetDesiredFailureMsg(kErrorBit,
sfricke-samsung6d97e562020-01-07 22:01:00 -08001781 "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, &region);
1785 m_errorMonitor->VerifyFound();
1786 }
1787
Mark Lobodzinski20310782020-02-28 14:25:17 -07001788 m_errorMonitor->SetDesiredFailureMsg(kErrorBit,
sfricke-samsung6d97e562020-01-07 22:01:00 -08001789 "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 &region);
1793 m_errorMonitor->VerifyFound();
unknown088160a2019-05-23 17:43:13 -06001794 region.imageSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
sfricke-samsung6d97e562020-01-07 22:01:00 -08001795
1796 // Out-of-range mip levels should fail
1797 region.imageSubresource.mipLevel = image_16k.create_info().mipLevels + 1;
Mark Lobodzinski20310782020-02-28 14:25:17 -07001798 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyImageToBuffer-imageSubresource-01703");
sfricke-samsung6d97e562020-01-07 22:01:00 -08001799 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 Lobodzinski20310782020-02-28 14:25:17 -07001803 kErrorBit,
sfricke-samsung6d97e562020-01-07 22:01:00 -08001804 "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 &region);
1807 m_errorMonitor->VerifyFound();
Mark Lobodzinski20310782020-02-28 14:25:17 -07001808 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyBufferToImage-imageSubresource-01701");
sfricke-samsung6d97e562020-01-07 22:01:00 -08001809 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 Lobodzinski20310782020-02-28 14:25:17 -07001813 kErrorBit,
sfricke-samsung6d97e562020-01-07 22:01:00 -08001814 "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 &region);
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 Lobodzinski20310782020-02-28 14:25:17 -07001823 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyImageToBuffer-imageSubresource-01704");
sfricke-samsung6d97e562020-01-07 22:01:00 -08001824 vk::CmdCopyImageToBuffer(m_commandBuffer->handle(), image_16k.handle(), VK_IMAGE_LAYOUT_GENERAL, buffer_16k.handle(), 1,
1825 &region);
1826 m_errorMonitor->VerifyFound();
Mark Lobodzinski20310782020-02-28 14:25:17 -07001827 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyBufferToImage-imageSubresource-01702");
sfricke-samsung6d97e562020-01-07 22:01:00 -08001828 vk::CmdCopyBufferToImage(m_commandBuffer->handle(), buffer_16k.handle(), image_16k.handle(), VK_IMAGE_LAYOUT_GENERAL, 1,
1829 &region);
1830 m_errorMonitor->VerifyFound();
1831 region.imageSubresource.baseArrayLayer = 0;
1832
1833 // Layout mismatch should fail
Mark Lobodzinski20310782020-02-28 14:25:17 -07001834 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyImageToBuffer-srcImageLayout-00189");
sfricke-samsung6d97e562020-01-07 22:01:00 -08001835 vk::CmdCopyImageToBuffer(m_commandBuffer->handle(), image_16k.handle(), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
1836 buffer_16k.handle(), 1, &region);
1837 m_errorMonitor->VerifyFound();
Mark Lobodzinski20310782020-02-28 14:25:17 -07001838 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyBufferToImage-dstImageLayout-00180");
sfricke-samsung6d97e562020-01-07 22:01:00 -08001839 vk::CmdCopyBufferToImage(m_commandBuffer->handle(), buffer_16k.handle(), image_16k.handle(),
1840 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &region);
unknown088160a2019-05-23 17:43:13 -06001841 m_errorMonitor->VerifyFound();
1842 }
1843
unknown088160a2019-05-23 17:43:13 -06001844 // 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 Lobodzinski902cb0f2019-09-27 14:45:36 -06001861 vk::CmdCopyImageToBuffer(m_commandBuffer->handle(), ds_image_4D_1S.handle(), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
1862 buffer_256k.handle(), 1, &ds_region);
unknown088160a2019-05-23 17:43:13 -06001863 m_errorMonitor->VerifyNotFound();
1864
1865 m_errorMonitor->ExpectSuccess(); // Extract 3b depth per texel, pack (loose) into 256k buffer
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06001866 vk::CmdCopyImageToBuffer(m_commandBuffer->handle(), ds_image_3D_1S.handle(), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
1867 buffer_256k.handle(), 1, &ds_region);
unknown088160a2019-05-23 17:43:13 -06001868 m_errorMonitor->VerifyNotFound();
1869
1870 m_errorMonitor->ExpectSuccess(); // Copy 2b depth per texel, into 128k buffer
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06001871 vk::CmdCopyImageToBuffer(m_commandBuffer->handle(), ds_image_2D.handle(), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
1872 buffer_128k.handle(), 1, &ds_region);
unknown088160a2019-05-23 17:43:13 -06001873 m_errorMonitor->VerifyNotFound();
1874
1875 // Depth copies that should fail
1876 ds_region.bufferOffset = 4;
1877 m_errorMonitor->SetDesiredFailureMsg(
Mark Lobodzinski20310782020-02-28 14:25:17 -07001878 kErrorBit,
unknown088160a2019-05-23 17:43:13 -06001879 "VUID-vkCmdCopyImageToBuffer-pRegions-00183"); // Extract 4b depth per texel, pack into 256k buffer
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06001880 vk::CmdCopyImageToBuffer(m_commandBuffer->handle(), ds_image_4D_1S.handle(), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
1881 buffer_256k.handle(), 1, &ds_region);
unknown088160a2019-05-23 17:43:13 -06001882 m_errorMonitor->VerifyFound();
1883
1884 m_errorMonitor->SetDesiredFailureMsg(
Mark Lobodzinski20310782020-02-28 14:25:17 -07001885 kErrorBit,
unknown088160a2019-05-23 17:43:13 -06001886 "VUID-vkCmdCopyImageToBuffer-pRegions-00183"); // Extract 3b depth per texel, pack (loose) into 256k buffer
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06001887 vk::CmdCopyImageToBuffer(m_commandBuffer->handle(), ds_image_3D_1S.handle(), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
1888 buffer_256k.handle(), 1, &ds_region);
unknown088160a2019-05-23 17:43:13 -06001889 m_errorMonitor->VerifyFound();
1890
1891 m_errorMonitor->SetDesiredFailureMsg(
Mark Lobodzinski20310782020-02-28 14:25:17 -07001892 kErrorBit,
unknown088160a2019-05-23 17:43:13 -06001893 "VUID-vkCmdCopyImageToBuffer-pRegions-00183"); // Copy 2b depth per texel, into 128k buffer
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06001894 vk::CmdCopyImageToBuffer(m_commandBuffer->handle(), ds_image_2D.handle(), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
1895 buffer_128k.handle(), 1, &ds_region);
unknown088160a2019-05-23 17:43:13 -06001896 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 Lobodzinski902cb0f2019-09-27 14:45:36 -06001902 vk::CmdCopyImageToBuffer(m_commandBuffer->handle(), ds_image_4D_1S.handle(), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
1903 buffer_64k.handle(), 1, &ds_region);
unknown088160a2019-05-23 17:43:13 -06001904 m_errorMonitor->VerifyNotFound();
1905
1906 m_errorMonitor->ExpectSuccess(); // Extract 1b stencil per texel, pack into 64k buffer
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06001907 vk::CmdCopyImageToBuffer(m_commandBuffer->handle(), ds_image_3D_1S.handle(), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
1908 buffer_64k.handle(), 1, &ds_region);
unknown088160a2019-05-23 17:43:13 -06001909 m_errorMonitor->VerifyNotFound();
1910
1911 m_errorMonitor->ExpectSuccess(); // Copy 1b depth per texel, into 64k buffer
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06001912 vk::CmdCopyImageToBuffer(m_commandBuffer->handle(), ds_image_1S.handle(), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
1913 buffer_64k.handle(), 1, &ds_region);
unknown088160a2019-05-23 17:43:13 -06001914 m_errorMonitor->VerifyNotFound();
1915
1916 // Stencil copies that should fail
1917 m_errorMonitor->SetDesiredFailureMsg(
Mark Lobodzinski20310782020-02-28 14:25:17 -07001918 kErrorBit,
unknown088160a2019-05-23 17:43:13 -06001919 "VUID-vkCmdCopyImageToBuffer-pRegions-00183"); // Extract 1b stencil per texel, pack into 64k buffer
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06001920 vk::CmdCopyImageToBuffer(m_commandBuffer->handle(), ds_image_4D_1S.handle(), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
1921 buffer_16k.handle(), 1, &ds_region);
unknown088160a2019-05-23 17:43:13 -06001922 m_errorMonitor->VerifyFound();
1923
1924 m_errorMonitor->SetDesiredFailureMsg(
Mark Lobodzinski20310782020-02-28 14:25:17 -07001925 kErrorBit,
unknown088160a2019-05-23 17:43:13 -06001926 "VUID-vkCmdCopyImageToBuffer-pRegions-00183"); // Extract 1b stencil per texel, pack into 64k buffer
1927 ds_region.bufferRowLength = 260;
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06001928 vk::CmdCopyImageToBuffer(m_commandBuffer->handle(), ds_image_3D_1S.handle(), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
1929 buffer_64k.handle(), 1, &ds_region);
unknown088160a2019-05-23 17:43:13 -06001930 m_errorMonitor->VerifyFound();
1931
1932 ds_region.bufferRowLength = 0;
1933 ds_region.bufferOffset = 4;
1934 m_errorMonitor->SetDesiredFailureMsg(
Mark Lobodzinski20310782020-02-28 14:25:17 -07001935 kErrorBit,
unknown088160a2019-05-23 17:43:13 -06001936 "VUID-vkCmdCopyImageToBuffer-pRegions-00183"); // Copy 1b depth per texel, into 64k buffer
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06001937 vk::CmdCopyImageToBuffer(m_commandBuffer->handle(), ds_image_1S.handle(), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
1938 buffer_64k.handle(), 1, &ds_region);
unknown088160a2019-05-23 17:43:13 -06001939 m_errorMonitor->VerifyFound();
1940 }
1941
1942 // Test compressed formats, if supported
sfricke-samsung6d97e562020-01-07 22:01:00 -08001943 // Support here requires both feature bit for compression and picked format supports transfer feature bits
unknown088160a2019-05-23 17:43:13 -06001944 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-samsung6d97e562020-01-07 22:01:00 -08001950 // 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)) {
unknown088160a2019-05-23 17:43:13 -06001972 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-samsung6d97e562020-01-07 22:01:00 -08001976 } else if (device_features.textureCompressionETC2 && (!missing_etc_support)) {
unknown088160a2019-05-23 17:43:13 -06001977 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-samsung6d97e562020-01-07 22:01:00 -08001981 } else if (device_features.textureCompressionASTC_LDR && (!missing_astc_support)) {
unknown088160a2019-05-23 17:43:13 -06001982 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-samsung6d97e562020-01-07 22:01:00 -08001986 } else {
1987 missing_compression_support = true;
unknown088160a2019-05-23 17:43:13 -06001988 }
unknown088160a2019-05-23 17:43:13 -06001989
sfricke-samsung6d97e562020-01-07 22:01:00 -08001990 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-samsung3a10b922020-05-13 23:23:16 -07001994 std::string vuid;
sfricke-samsung6d97e562020-01-07 22:01:00 -08001995 // 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, &region);
2000 m_errorMonitor->VerifyNotFound();
unknown088160a2019-05-23 17:43:13 -06002001
sfricke-samsung6d97e562020-01-07 22:01:00 -08002002 // with offset, too big for buffer
Mark Lobodzinski20310782020-02-28 14:25:17 -07002003 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyImageToBuffer-pRegions-00183");
sfricke-samsung6d97e562020-01-07 22:01:00 -08002004 region.bufferOffset = 16;
2005 vk::CmdCopyImageToBuffer(m_commandBuffer->handle(), image_16k_4x4comp.handle(), VK_IMAGE_LAYOUT_GENERAL,
2006 buffer_16k.handle(), 1, &region);
2007 m_errorMonitor->VerifyFound();
2008 region.bufferOffset = 0;
unknown088160a2019-05-23 17:43:13 -06002009
sfricke-samsung6d97e562020-01-07 22:01:00 -08002010 // extents that are not a multiple of compressed block size
sfricke-samsung3a10b922020-05-13 23:23:16 -07002011 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 Lobodzinski20310782020-02-28 14:25:17 -07002013 m_errorMonitor->SetDesiredFailureMsg(kErrorBit,
sfricke-samsung6d97e562020-01-07 22:01:00 -08002014 "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, &region);
2018 m_errorMonitor->VerifyFound();
2019 region.imageExtent.width = 128;
unknown088160a2019-05-23 17:43:13 -06002020
sfricke-samsung3a10b922020-05-13 23:23:16 -07002021 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 Lobodzinski20310782020-02-28 14:25:17 -07002023 m_errorMonitor->SetDesiredFailureMsg(kErrorBit,
sfricke-samsung6d97e562020-01-07 22:01:00 -08002024 "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, &region);
2028 m_errorMonitor->VerifyFound();
2029 region.imageExtent.height = 128;
unknown088160a2019-05-23 17:43:13 -06002030
sfricke-samsung6d97e562020-01-07 22:01:00 -08002031 // TODO: All available compressed formats are 2D, with block depth of 1. Unable to provoke VU_01277.
unknown088160a2019-05-23 17:43:13 -06002032
sfricke-samsung6d97e562020-01-07 22:01:00 -08002033 // 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, &region);
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, &region);
2045 m_errorMonitor->VerifyNotFound();
2046 region.imageOffset = {0, 0, 0};
unknown088160a2019-05-23 17:43:13 -06002047
sfricke-samsung6d97e562020-01-07 22:01:00 -08002048 // buffer offset must be a multiple of texel block size (16)
sfricke-samsung3a10b922020-05-13 23:23:16 -07002049 vuid = mp_extensions ? "VUID-VkBufferImageCopy-None-01738" : "VUID-VkBufferImageCopy-bufferOffset-00206";
2050 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, vuid);
sfricke-samsung125d2b42020-05-28 06:32:43 -07002051 vuid = mp_extensions ? "VUID-VkBufferImageCopy-bufferOffset-01558" : "VUID-VkBufferImageCopy-bufferOffset-00193";
2052 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, vuid);
sfricke-samsung6d97e562020-01-07 22:01:00 -08002053 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, &region);
2057 m_errorMonitor->VerifyFound();
unknown088160a2019-05-23 17:43:13 -06002058
sfricke-samsung6d97e562020-01-07 22:01:00 -08002059 // rowlength not a multiple of block width (4)
sfricke-samsung3a10b922020-05-13 23:23:16 -07002060 vuid = mp_extensions ? "VUID-VkBufferImageCopy-None-01735" : "VUID-VkBufferImageCopy-bufferRowLength-00203";
2061 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, vuid);
sfricke-samsung6d97e562020-01-07 22:01:00 -08002062 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, &region);
2067 m_errorMonitor->VerifyFound();
2068
2069 // imageheight not a multiple of block height (4)
sfricke-samsung3a10b922020-05-13 23:23:16 -07002070 vuid = mp_extensions ? "VUID-VkBufferImageCopy-None-01736" : "VUID-VkBufferImageCopy-bufferImageHeight-00204";
2071 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, vuid);
sfricke-samsung6d97e562020-01-07 22:01:00 -08002072 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, &region);
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 Lobodzinski20310782020-02-28 14:25:17 -07002118 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkBufferImageCopy-aspectMask-01560");
sfricke-samsung6d97e562020-01-07 22:01:00 -08002119 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 Lobodzinski20310782020-02-28 14:25:17 -07002125 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkBufferImageCopy-aspectMask-01560");
sfricke-samsung6d97e562020-01-07 22:01:00 -08002126 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-samsungb616d3f2020-06-03 22:00:34 -07002130
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-samsung6d97e562020-01-07 22:01:00 -08002140 }
unknown088160a2019-05-23 17:43:13 -06002141 }
2142}
2143
2144TEST_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 Lobodzinski20310782020-02-28 14:25:17 -07002186 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkBufferImageCopy-srcImage-00201");
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06002187 vk::CmdCopyBufferToImage(m_commandBuffer->handle(), buffer.handle(), image.handle(), VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1,
2188 &region);
unknown088160a2019-05-23 17:43:13 -06002189 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 Lobodzinski20310782020-02-28 14:25:17 -07002197 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 Lobodzinski902cb0f2019-09-27 14:45:36 -06002200 vk::CmdCopyBufferToImage(m_commandBuffer->handle(), buffer.handle(), image.handle(), VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1,
2201 &region);
unknown088160a2019-05-23 17:43:13 -06002202 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 Lobodzinski20310782020-02-28 14:25:17 -07002208 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkBufferImageCopy-bufferOffset-00193");
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06002209 vk::CmdCopyBufferToImage(m_commandBuffer->handle(), buffer.handle(), image.handle(), VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1,
2210 &region);
unknown088160a2019-05-23 17:43:13 -06002211 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 Lobodzinski20310782020-02-28 14:25:17 -07002216 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkBufferImageCopy-bufferOffset-00194");
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06002217 vk::CmdCopyBufferToImage(m_commandBuffer->handle(), buffer2.handle(), image2.handle(), VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1,
2218 &region2);
unknown088160a2019-05-23 17:43:13 -06002219 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 Lobodzinski20310782020-02-28 14:25:17 -07002227 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkBufferImageCopy-bufferRowLength-00195");
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06002228 vk::CmdCopyBufferToImage(m_commandBuffer->handle(), buffer.handle(), image.handle(), VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1,
2229 &region);
unknown088160a2019-05-23 17:43:13 -06002230 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 Lobodzinski20310782020-02-28 14:25:17 -07002236 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkBufferImageCopy-bufferImageHeight-00196");
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06002237 vk::CmdCopyBufferToImage(m_commandBuffer->handle(), buffer.handle(), image.handle(), VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1,
2238 &region);
unknown088160a2019-05-23 17:43:13 -06002239 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 Lobodzinski20310782020-02-28 14:25:17 -07002263 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 Lobodzinski902cb0f2019-09-27 14:45:36 -06002265 vk::CmdBlitImage(m_commandBuffer->handle(), intImage1.handle(), intImage1.Layout(), intImage2.handle(), intImage2.Layout(), 1,
2266 &blitRegion, VK_FILTER_LINEAR);
unknown088160a2019-05-23 17:43:13 -06002267 m_errorMonitor->VerifyFound();
2268}
2269
2270TEST_F(VkLayerTest, CopyImageTypeExtentMismatch) {
2271 // Image copy tests where format type and extents don't match
2272 ASSERT_NO_FATAL_FAILURE(Init());
2273
sfricke-samsung30b094c2020-05-30 11:42:11 -07002274 // 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
unknown088160a2019-05-23 17:43:13 -06002280 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 &copy_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 Lobodzinski20310782020-02-28 14:25:17 -07002347 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageCopy-srcImage-00146");
2348 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageCopy-srcOffset-00145"); // also y-dim overrun
unknown088160a2019-05-23 17:43:13 -06002349 m_commandBuffer->CopyImage(image_1D.image(), VK_IMAGE_LAYOUT_GENERAL, image_2D.image(), VK_IMAGE_LAYOUT_GENERAL, 1,
2350 &copy_region);
2351 m_errorMonitor->VerifyFound();
2352 copy_region.srcOffset.y = 0;
2353 copy_region.dstOffset.y = 1;
Mark Lobodzinski20310782020-02-28 14:25:17 -07002354 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageCopy-dstImage-00152");
2355 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageCopy-dstOffset-00151"); // also y-dim overrun
unknown088160a2019-05-23 17:43:13 -06002356 m_commandBuffer->CopyImage(image_2D.image(), VK_IMAGE_LAYOUT_GENERAL, image_1D.image(), VK_IMAGE_LAYOUT_GENERAL, 1,
2357 &copy_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 Lobodzinski20310782020-02-28 14:25:17 -07002363 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageCopy-srcImage-00146");
2364 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageCopy-srcOffset-00145"); // also y-dim overrun
unknown088160a2019-05-23 17:43:13 -06002365 m_commandBuffer->CopyImage(image_1D.image(), VK_IMAGE_LAYOUT_GENERAL, image_2D.image(), VK_IMAGE_LAYOUT_GENERAL, 1,
2366 &copy_region);
2367 m_errorMonitor->VerifyFound();
Mark Lobodzinski20310782020-02-28 14:25:17 -07002368 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageCopy-dstImage-00152");
2369 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageCopy-dstOffset-00151"); // also y-dim overrun
unknown088160a2019-05-23 17:43:13 -06002370 m_commandBuffer->CopyImage(image_2D.image(), VK_IMAGE_LAYOUT_GENERAL, image_1D.image(), VK_IMAGE_LAYOUT_GENERAL, 1,
2371 &copy_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 Lobodzinski20310782020-02-28 14:25:17 -07002377 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageCopy-srcImage-01785");
2378 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageCopy-srcOffset-00147"); // also z-dim overrun
unknown088160a2019-05-23 17:43:13 -06002379 m_commandBuffer->CopyImage(image_1D.image(), VK_IMAGE_LAYOUT_GENERAL, image_2D.image(), VK_IMAGE_LAYOUT_GENERAL, 1,
2380 &copy_region);
2381 m_errorMonitor->VerifyFound();
2382 copy_region.srcOffset.z = 0;
2383 copy_region.dstOffset.z = 1;
Mark Lobodzinski20310782020-02-28 14:25:17 -07002384 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageCopy-dstImage-01786");
2385 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageCopy-dstOffset-00153"); // also z-dim overrun
unknown088160a2019-05-23 17:43:13 -06002386 m_commandBuffer->CopyImage(image_2D.image(), VK_IMAGE_LAYOUT_GENERAL, image_1D.image(), VK_IMAGE_LAYOUT_GENERAL, 1,
2387 &copy_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 Lobodzinski20310782020-02-28 14:25:17 -07002393 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageCopy-srcImage-01785");
2394 m_errorMonitor->SetDesiredFailureMsg(kErrorBit,
unknown088160a2019-05-23 17:43:13 -06002395 "VUID-VkImageCopy-srcOffset-00147"); // also z-dim overrun (src)
Mark Lobodzinski20310782020-02-28 14:25:17 -07002396 m_errorMonitor->SetDesiredFailureMsg(kErrorBit,
unknown088160a2019-05-23 17:43:13 -06002397 "VUID-VkImageCopy-dstOffset-00153"); // also z-dim overrun (dst)
Mark Lobodzinski20310782020-02-28 14:25:17 -07002398 m_errorMonitor->SetDesiredFailureMsg(kErrorBit,
sfricke-samsung211ee9c2020-02-13 23:38:39 -08002399 "VUID-VkImageCopy-srcImage-01789"); // 2D needs to be 1 pre-Vulkan 1.1
unknown088160a2019-05-23 17:43:13 -06002400 m_commandBuffer->CopyImage(image_1D.image(), VK_IMAGE_LAYOUT_GENERAL, image_2D.image(), VK_IMAGE_LAYOUT_GENERAL, 1,
2401 &copy_region);
2402 m_errorMonitor->VerifyFound();
Mark Lobodzinski20310782020-02-28 14:25:17 -07002403 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageCopy-dstImage-01786");
2404 m_errorMonitor->SetDesiredFailureMsg(kErrorBit,
unknown088160a2019-05-23 17:43:13 -06002405 "VUID-VkImageCopy-srcOffset-00147"); // also z-dim overrun (src)
Mark Lobodzinski20310782020-02-28 14:25:17 -07002406 m_errorMonitor->SetDesiredFailureMsg(kErrorBit,
unknown088160a2019-05-23 17:43:13 -06002407 "VUID-VkImageCopy-dstOffset-00153"); // also z-dim overrun (dst)
Mark Lobodzinski20310782020-02-28 14:25:17 -07002408 m_errorMonitor->SetDesiredFailureMsg(kErrorBit,
sfricke-samsung211ee9c2020-02-13 23:38:39 -08002409 "VUID-VkImageCopy-srcImage-01789"); // 2D needs to be 1 pre-Vulkan 1.1
unknown088160a2019-05-23 17:43:13 -06002410 m_commandBuffer->CopyImage(image_2D.image(), VK_IMAGE_LAYOUT_GENERAL, image_1D.image(), VK_IMAGE_LAYOUT_GENERAL, 1,
2411 &copy_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 Lobodzinski20310782020-02-28 14:25:17 -07002418 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageCopy-srcImage-01787");
2419 m_errorMonitor->SetDesiredFailureMsg(kErrorBit,
unknown088160a2019-05-23 17:43:13 -06002420 "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 &copy_region);
2423 m_errorMonitor->VerifyFound();
2424 copy_region.srcOffset.z = 0;
2425 copy_region.dstOffset.z = 1;
Mark Lobodzinski20310782020-02-28 14:25:17 -07002426 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageCopy-dstImage-01788");
2427 m_errorMonitor->SetDesiredFailureMsg(kErrorBit,
unknown088160a2019-05-23 17:43:13 -06002428 "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 &copy_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-samsung30b094c2020-05-30 11:42:11 -07002437 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageCopy-srcImage-00139");
Mark Lobodzinski20310782020-02-28 14:25:17 -07002438 m_errorMonitor->SetDesiredFailureMsg(kErrorBit,
unknown088160a2019-05-23 17:43:13 -06002439 "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 &copy_region);
2442 m_errorMonitor->VerifyFound();
sfricke-samsung211ee9c2020-02-13 23:38:39 -08002443 copy_region.srcSubresource.baseArrayLayer = 0;
2444
unknown088160a2019-05-23 17:43:13 -06002445 m_commandBuffer->end();
2446}
2447
2448TEST_F(VkLayerTest, CopyImageTypeExtentMismatchMaintenance1) {
2449 // Image copy tests where format type and extents don't match and the Maintenance1 extension is enabled
Mark Lobodzinski09ce9c42020-03-06 10:02:44 -07002450 ASSERT_NO_FATAL_FAILURE(InitFramework(m_errorMonitor));
unknown088160a2019-05-23 17:43:13 -06002451 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 Lobodzinski902cb0f2019-09-27 14:45:36 -06002464 vk::GetPhysicalDeviceFormatProperties(m_device->phy().handle(), image_format, &format_props);
unknown088160a2019-05-23 17:43:13 -06002465 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-samsung211ee9c2020-02-13 23:38:39 -08002514 // 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
unknown088160a2019-05-23 17:43:13 -06002522 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 Lobodzinski20310782020-02-28 14:25:17 -07002540 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyImage-srcSubresource-01698");
unknown088160a2019-05-23 17:43:13 -06002541 m_commandBuffer->CopyImage(image_2D_array.image(), VK_IMAGE_LAYOUT_GENERAL, image_3D.image(), VK_IMAGE_LAYOUT_GENERAL, 1,
2542 &copy_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 Lobodzinski20310782020-02-28 14:25:17 -07002550 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyImage-dstSubresource-01699");
unknown088160a2019-05-23 17:43:13 -06002551 m_commandBuffer->CopyImage(image_3D.image(), VK_IMAGE_LAYOUT_GENERAL, image_2D_array.image(), VK_IMAGE_LAYOUT_GENERAL, 1,
2552 &copy_region);
2553 m_errorMonitor->VerifyFound();
sfricke-samsung211ee9c2020-02-13 23:38:39 -08002554 copy_region.dstSubresource.baseArrayLayer = 0;
unknown088160a2019-05-23 17:43:13 -06002555 copy_region.dstSubresource.layerCount = 1;
2556
sfricke-samsung211ee9c2020-02-13 23:38:39 -08002557 // 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 Lobodzinski20310782020-02-28 14:25:17 -07002560 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageCopy-srcImage-01790");
sfricke-samsung211ee9c2020-02-13 23:38:39 -08002561 m_commandBuffer->CopyImage(image_2D_array.image(), VK_IMAGE_LAYOUT_GENERAL, image_2D_array_2.image(), VK_IMAGE_LAYOUT_GENERAL,
2562 1, &copy_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 Lobodzinski20310782020-02-28 14:25:17 -07002568 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageCopy-srcImage-01791");
2569 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageCopy-extent-00140");
sfricke-samsung211ee9c2020-02-13 23:38:39 -08002570 m_commandBuffer->CopyImage(image_2D_array.image(), VK_IMAGE_LAYOUT_GENERAL, image_3D.image(), VK_IMAGE_LAYOUT_GENERAL, 1,
2571 &copy_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 Lobodzinski20310782020-02-28 14:25:17 -07002577 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageCopy-dstImage-01792");
2578 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageCopy-extent-00140");
sfricke-samsung211ee9c2020-02-13 23:38:39 -08002579 m_commandBuffer->CopyImage(image_3D.image(), VK_IMAGE_LAYOUT_GENERAL, image_2D_array.image(), VK_IMAGE_LAYOUT_GENERAL, 1,
2580 &copy_region);
2581 m_errorMonitor->VerifyFound();
2582 copy_region.extent = {32, 1, 1};
2583
unknown088160a2019-05-23 17:43:13 -06002584 m_commandBuffer->end();
2585}
2586
2587TEST_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 Lobodzinski902cb0f2019-09-27 14:45:36 -06002622 if (VK_SUCCESS != vk::GetPhysicalDeviceImageFormatProperties(m_device->phy().handle(), ci.format, ci.imageType, ci.tiling,
2623 ci.usage, ci.flags, &img_prop)) {
unknown088160a2019-05-23 17:43:13 -06002624 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, &copy_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 Lobodzinski20310782020-02-28 14:25:17 -07002666 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, vuid);
2667 m_errorMonitor->SetDesiredFailureMsg(kErrorBit,
unknown088160a2019-05-23 17:43:13 -06002668 "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, &copy_region);
2670 m_errorMonitor->VerifyFound();
2671 copy_region.srcOffset = {12, 1, 0}; // source height
Mark Lobodzinski20310782020-02-28 14:25:17 -07002672 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, vuid);
2673 m_errorMonitor->SetDesiredFailureMsg(kErrorBit,
unknown088160a2019-05-23 17:43:13 -06002674 "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, &copy_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 Lobodzinski20310782020-02-28 14:25:17 -07002681 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, vuid);
2682 m_errorMonitor->SetDesiredFailureMsg(kErrorBit,
unknown088160a2019-05-23 17:43:13 -06002683 "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, &copy_region);
2685 m_errorMonitor->VerifyFound();
2686 copy_region.dstOffset = {4, 1, 0}; // dest height
Mark Lobodzinski20310782020-02-28 14:25:17 -07002687 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, vuid);
2688 m_errorMonitor->SetDesiredFailureMsg(kErrorBit,
unknown088160a2019-05-23 17:43:13 -06002689 "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, &copy_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 Lobodzinski20310782020-02-28 14:25:17 -07002697 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, vuid);
2698 m_errorMonitor->SetDesiredFailureMsg(kErrorBit,
unknown088160a2019-05-23 17:43:13 -06002699 "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, &copy_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 Lobodzinski20310782020-02-28 14:25:17 -07002704 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, vuid);
2705 m_errorMonitor->SetDesiredFailureMsg(kErrorBit,
unknown088160a2019-05-23 17:43:13 -06002706 "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, &copy_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 Lobodzinski20310782020-02-28 14:25:17 -07002712 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, vuid);
2713 m_errorMonitor->SetDesiredFailureMsg(kErrorBit,
unknown088160a2019-05-23 17:43:13 -06002714 "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, &copy_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 Lobodzinski20310782020-02-28 14:25:17 -07002719 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, vuid);
2720 m_errorMonitor->SetDesiredFailureMsg(kErrorBit,
unknown088160a2019-05-23 17:43:13 -06002721 "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, &copy_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
2732TEST_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 Lobodzinski09ce9c42020-03-06 10:02:44 -07002741 ASSERT_NO_FATAL_FAILURE(InitFramework(m_errorMonitor));
unknown088160a2019-05-23 17:43:13 -06002742 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 Lobodzinski20310782020-02-28 14:25:17 -07002811 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageCopy-srcImage-01727");
2812 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyImage-srcOffset-01783");
unknown088160a2019-05-23 17:43:13 -06002813 m_commandBuffer->CopyImage(image_422.image(), VK_IMAGE_LAYOUT_GENERAL, image_ucmp.image(), VK_IMAGE_LAYOUT_GENERAL, 1,
2814 &copy_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 Lobodzinski20310782020-02-28 14:25:17 -07002820 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageCopy-dstImage-01731");
2821 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyImage-dstOffset-01784");
Mark Lobodzinski20310782020-02-28 14:25:17 -07002822 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageCopy-dstOffset-00150");
unknown088160a2019-05-23 17:43:13 -06002823 m_commandBuffer->CopyImage(image_ucmp.image(), VK_IMAGE_LAYOUT_GENERAL, image_422.image(), VK_IMAGE_LAYOUT_GENERAL, 1,
2824 &copy_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 Lobodzinski20310782020-02-28 14:25:17 -07002830 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageCopy-srcImage-01728");
2831 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyImage-srcOffset-01783");
unknown088160a2019-05-23 17:43:13 -06002832 m_commandBuffer->CopyImage(image_422.image(), VK_IMAGE_LAYOUT_GENERAL, image_ucmp.image(), VK_IMAGE_LAYOUT_GENERAL, 1,
2833 &copy_region);
2834 m_errorMonitor->VerifyFound();
2835
unknown357e1782019-09-25 17:57:40 -06002836 // 422 dest
unknown088160a2019-05-23 17:43:13 -06002837 m_commandBuffer->CopyImage(image_ucmp.image(), VK_IMAGE_LAYOUT_GENERAL, image_422.image(), VK_IMAGE_LAYOUT_GENERAL, 1,
2838 &copy_region);
unknown357e1782019-09-25 17:57:40 -06002839 m_errorMonitor->VerifyNotFound();
unknown088160a2019-05-23 17:43:13 -06002840 copy_region.dstOffset = {0, 0, 0};
2841
2842 m_commandBuffer->end();
2843}
2844
2845TEST_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 Lobodzinski09ce9c42020-03-06 10:02:44 -07002854 ASSERT_NO_FATAL_FAILURE(InitFramework(m_errorMonitor));
unknown088160a2019-05-23 17:43:13 -06002855 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 Lobodzinski20310782020-02-28 14:25:17 -07002934 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageCopy-srcImage-01552");
unknown088160a2019-05-23 17:43:13 -06002935 m_commandBuffer->CopyImage(mp2_image.image(), VK_IMAGE_LAYOUT_GENERAL, mp3_image.image(), VK_IMAGE_LAYOUT_GENERAL, 1,
2936 &copy_region);
2937 m_errorMonitor->VerifyFound();
2938
unknown088160a2019-05-23 17:43:13 -06002939 copy_region.srcSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
2940 copy_region.dstSubresource.aspectMask = VK_IMAGE_ASPECT_PLANE_0_BIT_KHR;
Mark Lobodzinski20310782020-02-28 14:25:17 -07002941 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageCopy-srcImage-01553");
unknown088160a2019-05-23 17:43:13 -06002942 m_commandBuffer->CopyImage(mp3_image.image(), VK_IMAGE_LAYOUT_GENERAL, mp2_image.image(), VK_IMAGE_LAYOUT_GENERAL, 1,
2943 &copy_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 Lobodzinski20310782020-02-28 14:25:17 -07002948 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageCopy-dstImage-01554");
unknown088160a2019-05-23 17:43:13 -06002949 m_commandBuffer->CopyImage(mp3_image.image(), VK_IMAGE_LAYOUT_GENERAL, mp2_image.image(), VK_IMAGE_LAYOUT_GENERAL, 1,
2950 &copy_region);
2951 m_errorMonitor->VerifyFound();
2952
2953 copy_region.dstSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
Mark Lobodzinski20310782020-02-28 14:25:17 -07002954 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageCopy-dstImage-01555");
unknown088160a2019-05-23 17:43:13 -06002955 m_commandBuffer->CopyImage(mp2_image.image(), VK_IMAGE_LAYOUT_GENERAL, mp3_image.image(), VK_IMAGE_LAYOUT_GENERAL, 1,
2956 &copy_region);
2957 m_errorMonitor->VerifyFound();
2958
2959 copy_region.dstSubresource.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT;
Mark Lobodzinski20310782020-02-28 14:25:17 -07002960 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageCopy-srcImage-01556");
sfricke-samsung99dc12c2020-04-23 01:52:01 -07002961 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyImage-None-01549"); // since also non-compatiable
unknown088160a2019-05-23 17:43:13 -06002962 m_commandBuffer->CopyImage(mp2_image.image(), VK_IMAGE_LAYOUT_GENERAL, sp_image.image(), VK_IMAGE_LAYOUT_GENERAL, 1,
2963 &copy_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 Lobodzinski20310782020-02-28 14:25:17 -07002968 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageCopy-dstImage-01557");
sfricke-samsung99dc12c2020-04-23 01:52:01 -07002969 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyImage-None-01549"); // since also non-compatiable
unknown088160a2019-05-23 17:43:13 -06002970 m_commandBuffer->CopyImage(sp_image.image(), VK_IMAGE_LAYOUT_GENERAL, mp3_image.image(), VK_IMAGE_LAYOUT_GENERAL, 1,
2971 &copy_region);
2972 m_errorMonitor->VerifyFound();
2973
2974 m_commandBuffer->end();
2975}
2976
2977TEST_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 &copy_region);
3029 m_errorMonitor->VerifyNotFound();
3030
3031 // Source exceeded in x-dim, VU 01202
3032 copy_region.srcOffset.x = 4;
Mark Lobodzinski20310782020-02-28 14:25:17 -07003033 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageCopy-srcOffset-00144");
unknown088160a2019-05-23 17:43:13 -06003034 m_commandBuffer->CopyImage(src_image.image(), VK_IMAGE_LAYOUT_GENERAL, dst_image.image(), VK_IMAGE_LAYOUT_GENERAL, 1,
3035 &copy_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 Lobodzinski20310782020-02-28 14:25:17 -07003041 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageCopy-srcOffset-00145");
unknown088160a2019-05-23 17:43:13 -06003042 m_commandBuffer->CopyImage(src_image.image(), VK_IMAGE_LAYOUT_GENERAL, dst_image.image(), VK_IMAGE_LAYOUT_GENERAL, 1,
3043 &copy_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 Lobodzinski20310782020-02-28 14:25:17 -07003049 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageCopy-srcOffset-00147");
unknown088160a2019-05-23 17:43:13 -06003050 m_commandBuffer->CopyImage(src_image.image(), VK_IMAGE_LAYOUT_GENERAL, dst_image.image(), VK_IMAGE_LAYOUT_GENERAL, 1,
3051 &copy_region);
3052 m_errorMonitor->VerifyFound();
3053
3054 m_commandBuffer->end();
3055}
3056
3057TEST_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 &copy_region);
3109 m_errorMonitor->VerifyNotFound();
3110
3111 // Dest exceeded in x-dim, VU 01205
3112 copy_region.dstOffset.x = 4;
Mark Lobodzinski20310782020-02-28 14:25:17 -07003113 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageCopy-dstOffset-00150");
unknown088160a2019-05-23 17:43:13 -06003114 m_commandBuffer->CopyImage(src_image.image(), VK_IMAGE_LAYOUT_GENERAL, dst_image.image(), VK_IMAGE_LAYOUT_GENERAL, 1,
3115 &copy_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 Lobodzinski20310782020-02-28 14:25:17 -07003121 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageCopy-dstOffset-00151");
unknown088160a2019-05-23 17:43:13 -06003122 m_commandBuffer->CopyImage(src_image.image(), VK_IMAGE_LAYOUT_GENERAL, dst_image.image(), VK_IMAGE_LAYOUT_GENERAL, 1,
3123 &copy_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 Lobodzinski20310782020-02-28 14:25:17 -07003129 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageCopy-dstOffset-00153");
unknown088160a2019-05-23 17:43:13 -06003130 m_commandBuffer->CopyImage(src_image.image(), VK_IMAGE_LAYOUT_GENERAL, dst_image.image(), VK_IMAGE_LAYOUT_GENERAL, 1,
3131 &copy_region);
3132 m_errorMonitor->VerifyFound();
3133
3134 m_commandBuffer->end();
3135}
3136
sfricke-samsung8ceaaea2020-03-07 14:08:08 -08003137TEST_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-samsung99dc12c2020-04-23 01:52:01 -07003162 // 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-samsung8ceaaea2020-03-07 14:08:08 -08003164 VkFormatProperties props = {0, 0, 0};
3165 bool missing_format_support = false;
sfricke-samsung99dc12c2020-04-23 01:52:01 -07003166 vk::GetPhysicalDeviceFormatProperties(m_device->phy().handle(), VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM, &props);
sfricke-samsung8ceaaea2020-03-07 14:08:08 -08003167 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-samsung99dc12c2020-04-23 01:52:01 -07003172 printf("%s VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM transfer not supported; skipped.\n", kSkipPrefix);
sfricke-samsung8ceaaea2020-03-07 14:08:08 -08003173 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-samsung99dc12c2020-04-23 01:52:01 -07003179 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-samsung8ceaaea2020-03-07 14:08:08 -08003180 ASSERT_TRUE(src_image.initialized());
sfricke-samsung99dc12c2020-04-23 01:52:01 -07003181 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-samsung8ceaaea2020-03-07 14:08:08 -08003182 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 &copy_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 &copy_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 &copy_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 &copy_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 &copy_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-samsung8ceaaea2020-03-07 14:08:08 -08003243 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 &copy_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-samsung8ceaaea2020-03-07 14:08:08 -08003252 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 &copy_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-samsung8ceaaea2020-03-07 14:08:08 -08003260 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 &copy_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-samsung8ceaaea2020-03-07 14:08:08 -08003268 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 &copy_region);
3271 m_errorMonitor->VerifyFound();
3272
3273 m_commandBuffer->end();
3274}
3275
unknown088160a2019-05-23 17:43:13 -06003276TEST_F(VkLayerTest, CopyImageFormatSizeMismatch) {
sfricke-samsung51067b22020-04-30 21:41:17 -07003277 if (!EnableDeviceProfileLayer()) {
3278 printf("%s Failed to enable device profile layer.\n", kSkipPrefix);
3279 return;
3280 }
unknown088160a2019-05-23 17:43:13 -06003281
sfricke-samsung8ceaaea2020-03-07 14:08:08 -08003282 // 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());
unknown088160a2019-05-23 17:43:13 -06003300
sfricke-samsung51067b22020-04-30 21:41:17 -07003301 PFN_vkSetPhysicalDeviceFormatPropertiesEXT fpvkSetPhysicalDeviceFormatPropertiesEXT = nullptr;
3302 PFN_vkGetOriginalPhysicalDeviceFormatPropertiesEXT fpvkGetOriginalPhysicalDeviceFormatPropertiesEXT = nullptr;
sfricke-samsungdce5f692020-03-07 13:59:31 -08003303
sfricke-samsung51067b22020-04-30 21:41:17 -07003304 // 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);
unknown088160a2019-05-23 17:43:13 -06003319
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;
unknown088160a2019-05-23 17:43:13 -06003324 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-samsung51067b22020-04-30 21:41:17 -07003330 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;
unknown088160a2019-05-23 17:43:13 -06003332 image_create_info.flags = 0;
3333
sfricke-samsung51067b22020-04-30 21:41:17 -07003334 image_create_info.format = VK_FORMAT_R8_UNORM;
3335 VkImageObj image_8b_unorm(m_device);
3336 image_8b_unorm.init(&image_create_info);
unknown088160a2019-05-23 17:43:13 -06003337
sfricke-samsung51067b22020-04-30 21:41:17 -07003338 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, &copyRegion);
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, &copyRegion);
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, &copyRegion);
3388 m_errorMonitor->VerifyFound();
3389
3390 m_commandBuffer->end();
unknown088160a2019-05-23 17:43:13 -06003391 }
3392
sfricke-samsung51067b22020-04-30 21:41:17 -07003393 // 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);
unknown088160a2019-05-23 17:43:13 -06003400
sfricke-samsung51067b22020-04-30 21:41:17 -07003401 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);
unknown088160a2019-05-23 17:43:13 -06003404
sfricke-samsung51067b22020-04-30 21:41:17 -07003405 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;
unknown088160a2019-05-23 17:43:13 -06003422
sfricke-samsung51067b22020-04-30 21:41:17 -07003423 // 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;
unknown088160a2019-05-23 17:43:13 -06003426
sfricke-samsung51067b22020-04-30 21:41:17 -07003427 // 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, &copyRegion);
3431 m_errorMonitor->VerifyNotFound();
unknown088160a2019-05-23 17:43:13 -06003432
sfricke-samsung51067b22020-04-30 21:41:17 -07003433 // 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, &copyRegion);
3437 m_errorMonitor->VerifyNotFound();
unknown088160a2019-05-23 17:43:13 -06003438
sfricke-samsung51067b22020-04-30 21:41:17 -07003439 // 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, &copyRegion);
3444 m_errorMonitor->VerifyFound();
unknown088160a2019-05-23 17:43:13 -06003445
sfricke-samsung51067b22020-04-30 21:41:17 -07003446 // 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-samsungdce5f692020-03-07 13:59:31 -08003449
sfricke-samsung51067b22020-04-30 21:41:17 -07003450 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, &copyRegion);
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, &copyRegion);
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, &copyRegion);
3464 m_errorMonitor->VerifyFound();
3465
3466 m_commandBuffer->end();
3467 }
unknown088160a2019-05-23 17:43:13 -06003468}
3469
3470TEST_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 Lobodzinski902cb0f2019-09-27 14:45:36 -06003479 vk::GetPhysicalDeviceFormatProperties(m_device->phy().handle(), VK_FORMAT_D32_SFLOAT, &properties);
unknown088160a2019-05-23 17:43:13 -06003480 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-samsung99dc12c2020-04-23 01:52:01 -07003514 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyImage-srcImage-00135");
unknown088160a2019-05-23 17:43:13 -06003515 m_commandBuffer->CopyImage(srcImage.handle(), VK_IMAGE_LAYOUT_GENERAL, dstImage.handle(), VK_IMAGE_LAYOUT_GENERAL, 1,
3516 &copyRegion);
3517 m_commandBuffer->end();
3518
3519 m_errorMonitor->VerifyFound();
3520}
3521
3522TEST_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 Lobodzinski902cb0f2019-09-27 14:45:36 -06003528 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);
unknown088160a2019-05-23 17:43:13 -06003531
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 Lobodzinski20310782020-02-28 14:25:17 -07003585 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyImage-srcImage-00136");
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06003586 vk::CmdCopyImage(m_commandBuffer->handle(), image1.handle(), VK_IMAGE_LAYOUT_GENERAL, image4.handle(), VK_IMAGE_LAYOUT_GENERAL,
3587 1, &copyRegion);
unknown088160a2019-05-23 17:43:13 -06003588 m_errorMonitor->VerifyFound();
3589
Mark Lobodzinski20310782020-02-28 14:25:17 -07003590 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyImage-srcImage-00136");
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06003591 vk::CmdCopyImage(m_commandBuffer->handle(), image2.handle(), VK_IMAGE_LAYOUT_GENERAL, image1.handle(), VK_IMAGE_LAYOUT_GENERAL,
3592 1, &copyRegion);
unknown088160a2019-05-23 17:43:13 -06003593 m_errorMonitor->VerifyFound();
3594
3595 // Copy between multi-sample images with different sample counts
Mark Lobodzinski20310782020-02-28 14:25:17 -07003596 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyImage-srcImage-00136");
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06003597 vk::CmdCopyImage(m_commandBuffer->handle(), image2.handle(), VK_IMAGE_LAYOUT_GENERAL, image4.handle(), VK_IMAGE_LAYOUT_GENERAL,
3598 1, &copyRegion);
unknown088160a2019-05-23 17:43:13 -06003599 m_errorMonitor->VerifyFound();
3600
Mark Lobodzinski20310782020-02-28 14:25:17 -07003601 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdCopyImage-srcImage-00136");
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06003602 vk::CmdCopyImage(m_commandBuffer->handle(), image4.handle(), VK_IMAGE_LAYOUT_GENERAL, image2.handle(), VK_IMAGE_LAYOUT_GENERAL,
3603 1, &copyRegion);
unknown088160a2019-05-23 17:43:13 -06003604 m_errorMonitor->VerifyFound();
3605
3606 m_commandBuffer->end();
3607}
3608
3609TEST_F(VkLayerTest, CopyImageAspectMismatch) {
3610 TEST_DESCRIPTION("Image copies with aspect mask errors");
sfricke-samsung99dc12c2020-04-23 01:52:01 -07003611
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
unknown088160a2019-05-23 17:43:13 -06003643 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-samsung99dc12c2020-04-23 01:52:01 -07003649 // 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
unknown088160a2019-05-23 17:43:13 -06003661 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 Lobodzinski20310782020-02-28 14:25:17 -07003685 m_errorMonitor->SetDesiredFailureMsg(kErrorBit,
unknown088160a2019-05-23 17:43:13 -06003686 "You must call vkBeginCommandBuffer"); // "VUID-vkCmdCopyImage-commandBuffer-recording");
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06003687 vk::CmdCopyImage(m_commandBuffer->handle(), depth_image.handle(), VK_IMAGE_LAYOUT_GENERAL, depth_image.handle(),
3688 VK_IMAGE_LAYOUT_GENERAL, 1, &copyRegion);
unknown088160a2019-05-23 17:43:13 -06003689 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-samsung99dc12c2020-04-23 01:52:01 -07003695 const char *vuid = mp_extensions ? "VUID-VkImageCopy-srcImage-01551" : "VUID-VkImageCopy-aspectMask-00137";
Mark Lobodzinski20310782020-02-28 14:25:17 -07003696 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, vuid);
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06003697 vk::CmdCopyImage(m_commandBuffer->handle(), ds_image.handle(), VK_IMAGE_LAYOUT_GENERAL, ds_image.handle(),
3698 VK_IMAGE_LAYOUT_GENERAL, 1, &copyRegion);
unknown088160a2019-05-23 17:43:13 -06003699 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 Lobodzinski20310782020-02-28 14:25:17 -07003705 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageSubresourceLayers-aspectMask-00167");
unknown088160a2019-05-23 17:43:13 -06003706 // These aspect/format mismatches are redundant but unavoidable here
Mark Lobodzinski20310782020-02-28 14:25:17 -07003707 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageCopy-aspectMask-00142");
3708 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, vuid);
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06003709 vk::CmdCopyImage(m_commandBuffer->handle(), color_image.handle(), VK_IMAGE_LAYOUT_GENERAL, color_image.handle(),
3710 VK_IMAGE_LAYOUT_GENERAL, 1, &copyRegion);
unknown088160a2019-05-23 17:43:13 -06003711 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 Lobodzinski20310782020-02-28 14:25:17 -07003715 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageSubresourceLayers-aspectMask-00167");
unknown088160a2019-05-23 17:43:13 -06003716 // These aspect/format mismatches are redundant but unavoidable here
Mark Lobodzinski20310782020-02-28 14:25:17 -07003717 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageCopy-aspectMask-00143");
3718 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, vuid);
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06003719 vk::CmdCopyImage(m_commandBuffer->handle(), color_image.handle(), VK_IMAGE_LAYOUT_GENERAL, color_image.handle(),
3720 VK_IMAGE_LAYOUT_GENERAL, 1, &copyRegion);
unknown088160a2019-05-23 17:43:13 -06003721 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 Lobodzinski20310782020-02-28 14:25:17 -07003726 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageSubresourceLayers-aspectMask-00168");
unknown088160a2019-05-23 17:43:13 -06003727 // These aspect/format mismatches are redundant but unavoidable here
Mark Lobodzinski20310782020-02-28 14:25:17 -07003728 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, vuid);
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06003729 vk::CmdCopyImage(m_commandBuffer->handle(), color_image.handle(), VK_IMAGE_LAYOUT_GENERAL, color_image.handle(),
3730 VK_IMAGE_LAYOUT_GENERAL, 1, &copyRegion);
unknown088160a2019-05-23 17:43:13 -06003731 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 Lobodzinski20310782020-02-28 14:25:17 -07003735 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageSubresourceLayers-aspectMask-00168");
unknown088160a2019-05-23 17:43:13 -06003736 // These aspect/format mismatches are redundant but unavoidable here
Mark Lobodzinski20310782020-02-28 14:25:17 -07003737 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, vuid);
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06003738 vk::CmdCopyImage(m_commandBuffer->handle(), color_image.handle(), VK_IMAGE_LAYOUT_GENERAL, color_image.handle(),
3739 VK_IMAGE_LAYOUT_GENERAL, 1, &copyRegion);
unknown088160a2019-05-23 17:43:13 -06003740 m_errorMonitor->VerifyFound();
3741
3742 copyRegion.srcSubresource.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT;
3743 copyRegion.dstSubresource.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT;
sfricke-samsung99dc12c2020-04-23 01:52:01 -07003744 const char *compatible_vuid = mp_extensions ? "VUID-vkCmdCopyImage-srcImage-01548" : "VUID-vkCmdCopyImage-srcImage-00135";
unknown088160a2019-05-23 17:43:13 -06003745
3746 // Aspect mask doesn't match source image format
Mark Lobodzinski20310782020-02-28 14:25:17 -07003747 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageCopy-aspectMask-00142");
unknown088160a2019-05-23 17:43:13 -06003748 // Again redundant but unavoidable
sfricke-samsung99dc12c2020-04-23 01:52:01 -07003749 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, compatible_vuid);
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06003750 vk::CmdCopyImage(m_commandBuffer->handle(), color_image.handle(), VK_IMAGE_LAYOUT_GENERAL, depth_image.handle(),
3751 VK_IMAGE_LAYOUT_GENERAL, 1, &copyRegion);
unknown088160a2019-05-23 17:43:13 -06003752 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 Lobodzinski20310782020-02-28 14:25:17 -07003757 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkImageCopy-aspectMask-00143");
unknown088160a2019-05-23 17:43:13 -06003758 // Again redundant but unavoidable
sfricke-samsung99dc12c2020-04-23 01:52:01 -07003759 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, compatible_vuid);
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06003760 vk::CmdCopyImage(m_commandBuffer->handle(), color_image.handle(), VK_IMAGE_LAYOUT_GENERAL, depth_image.handle(),
3761 VK_IMAGE_LAYOUT_GENERAL, 1, &copyRegion);
unknown088160a2019-05-23 17:43:13 -06003762 m_errorMonitor->VerifyFound();
3763
3764 m_commandBuffer->end();
3765}
3766
3767TEST_F(VkLayerTest, ResolveImageLowSampleCount) {
Mark Lobodzinski20310782020-02-28 14:25:17 -07003768 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "vkCmdResolveImage called with source sample count less than 2.");
unknown088160a2019-05-23 17:43:13 -06003769
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
3823TEST_F(VkLayerTest, ResolveImageHighSampleCount) {
Mark Lobodzinski20310782020-02-28 14:25:17 -07003824 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "vkCmdResolveImage called with dest sample count greater than 1.");
unknown088160a2019-05-23 17:43:13 -06003825
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
3885TEST_F(VkLayerTest, ResolveImageFormatMismatch) {
Mark Lobodzinski20310782020-02-28 14:25:17 -07003886 m_errorMonitor->SetDesiredFailureMsg(kWarningBit, "vkCmdResolveImage called with unmatched source and dest formats.");
unknown088160a2019-05-23 17:43:13 -06003887
3888 ASSERT_NO_FATAL_FAILURE(Init());
3889
3890 // Create two images of different types and try to copy between them
locke-lunarg8e2c91b2019-06-11 17:53:26 -06003891 VkImageObj srcImage(m_device);
3892 VkImageObj dstImage(m_device);
unknown088160a2019-05-23 17:43:13 -06003893
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-lunarg8e2c91b2019-06-11 17:53:26 -06003910 srcImage.init(&image_create_info);
unknown088160a2019-05-23 17:43:13 -06003911
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-lunarg8e2c91b2019-06-11 17:53:26 -06003918 dstImage.init(&image_create_info);
unknown088160a2019-05-23 17:43:13 -06003919
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-lunarg8e2c91b2019-06-11 17:53:26 -06003942 m_commandBuffer->ResolveImage(srcImage.handle(), VK_IMAGE_LAYOUT_GENERAL, dstImage.handle(), VK_IMAGE_LAYOUT_GENERAL, 1,
3943 &resolveRegion);
unknown088160a2019-05-23 17:43:13 -06003944 m_commandBuffer->end();
3945
3946 m_errorMonitor->VerifyFound();
unknown088160a2019-05-23 17:43:13 -06003947}
3948
3949TEST_F(VkLayerTest, ResolveImageTypeMismatch) {
Mark Lobodzinski20310782020-02-28 14:25:17 -07003950 m_errorMonitor->SetDesiredFailureMsg(kWarningBit, "vkCmdResolveImage called with unmatched source and dest image types.");
unknown088160a2019-05-23 17:43:13 -06003951
3952 ASSERT_NO_FATAL_FAILURE(Init());
3953
3954 // Create two images of different types and try to copy between them
locke-lunarg8e2c91b2019-06-11 17:53:26 -06003955 VkImageObj srcImage(m_device);
3956 VkImageObj dstImage(m_device);
unknown088160a2019-05-23 17:43:13 -06003957
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-lunarg8e2c91b2019-06-11 17:53:26 -06003974 srcImage.init(&image_create_info);
unknown088160a2019-05-23 17:43:13 -06003975
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-lunarg8e2c91b2019-06-11 17:53:26 -06003981 dstImage.init(&image_create_info);
unknown088160a2019-05-23 17:43:13 -06003982
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-lunarg8e2c91b2019-06-11 17:53:26 -06004005 m_commandBuffer->ResolveImage(srcImage.handle(), VK_IMAGE_LAYOUT_GENERAL, dstImage.handle(), VK_IMAGE_LAYOUT_GENERAL, 1,
4006 &resolveRegion);
unknown088160a2019-05-23 17:43:13 -06004007 m_commandBuffer->end();
4008
4009 m_errorMonitor->VerifyFound();
unknown088160a2019-05-23 17:43:13 -06004010}
4011
4012TEST_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 Lobodzinski20310782020-02-28 14:25:17 -07004076 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdResolveImage-srcImageLayout-00260");
unknown088160a2019-05-23 17:43:13 -06004077 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 Lobodzinski20310782020-02-28 14:25:17 -07004081 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdResolveImage-dstImageLayout-00262");
unknown088160a2019-05-23 17:43:13 -06004082 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
4088TEST_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 Lobodzinski20310782020-02-28 14:25:17 -07004153 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdResolveImage-srcSubresource-01709");
unknown088160a2019-05-23 17:43:13 -06004154 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 Lobodzinski20310782020-02-28 14:25:17 -07004160 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdResolveImage-dstSubresource-01710");
unknown088160a2019-05-23 17:43:13 -06004161 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 Lobodzinski20310782020-02-28 14:25:17 -07004167 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdResolveImage-srcSubresource-01711");
unknown088160a2019-05-23 17:43:13 -06004168 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 Lobodzinski20310782020-02-28 14:25:17 -07004174 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdResolveImage-dstSubresource-01712");
unknown088160a2019-05-23 17:43:13 -06004175 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
4183TEST_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-samsungcd924d92020-05-20 23:51:17 -07004235 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdClearColorImage-image-00007");
unknown088160a2019-05-23 17:43:13 -06004236
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06004237 vk::CmdClearColorImage(m_commandBuffer->handle(), ds_image.handle(), VK_IMAGE_LAYOUT_GENERAL, &clear_color, 1, &color_range);
unknown088160a2019-05-23 17:43:13 -06004238
4239 m_errorMonitor->VerifyFound();
4240
sfricke-samsungcd924d92020-05-20 23:51:17 -07004241 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdClearColorImage-image-00002");
unknown088160a2019-05-23 17:43:13 -06004242
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06004243 vk::CmdClearColorImage(m_commandBuffer->handle(), color_image_no_transfer.handle(), VK_IMAGE_LAYOUT_GENERAL, &clear_color, 1,
4244 &color_range);
unknown088160a2019-05-23 17:43:13 -06004245
4246 m_errorMonitor->VerifyFound();
4247
4248 // Call CmdClearDepthStencilImage with color image
sfricke-samsungcd924d92020-05-20 23:51:17 -07004249 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdClearDepthStencilImage-image-00014");
unknown088160a2019-05-23 17:43:13 -06004250
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06004251 vk::CmdClearDepthStencilImage(m_commandBuffer->handle(), color_image.handle(), VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
4252 &clear_value, 1, &ds_range);
unknown088160a2019-05-23 17:43:13 -06004253
4254 m_errorMonitor->VerifyFound();
4255}
4256
4257TEST_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 Lobodzinski20310782020-02-28 14:25:17 -07004276 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdSetViewport-commandBuffer-cmdpool");
unknown088160a2019-05-23 17:43:13 -06004277 VkViewport viewport = {0, 0, 16, 16, 0, 1};
4278 command_buffer.SetViewport(0, 1, &viewport);
4279 m_errorMonitor->VerifyFound();
4280 }
4281}
4282
4283TEST_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 Lobodzinski20310782020-02-28 14:25:17 -07004289 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdExecuteCommands-pCommandBuffers-00089");
unknown088160a2019-05-23 17:43:13 -06004290 m_commandBuffer->begin();
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06004291 vk::CmdExecuteCommands(m_commandBuffer->handle(), 1, &secondary.handle());
unknown088160a2019-05-23 17:43:13 -06004292 m_errorMonitor->VerifyFound();
4293 m_commandBuffer->end();
4294}
4295
4296TEST_F(VkLayerTest, ExecuteSecondaryCBWithLayoutMismatch) {
4297 TEST_DESCRIPTION("Attempt vkCmdExecuteCommands with a CB with incorrect initial layout.");
4298
Mark Lobodzinski09ce9c42020-03-06 10:02:44 -07004299 ASSERT_NO_FATAL_FAILURE(InitFramework(m_errorMonitor));
unknown088160a2019-05-23 17:43:13 -06004300 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 Lobodzinski902cb0f2019-09-27 14:45:36 -06004329 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);
unknown088160a2019-05-23 17:43:13 -06004331 };
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 Lobodzinski20310782020-02-28 14:25:17 -07004339 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "UNASSIGNED-vkCmdExecuteCommands-commandBuffer-00001");
unknown088160a2019-05-23 17:43:13 -06004340 m_commandBuffer->begin();
4341 pipeline(*m_commandBuffer, VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL);
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06004342 vk::CmdExecuteCommands(m_commandBuffer->handle(), 1, &secondary.handle());
unknown088160a2019-05-23 17:43:13 -06004343 m_errorMonitor->VerifyFound();
4344
unknown088160a2019-05-23 17:43:13 -06004345 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 Lobodzinski902cb0f2019-09-27 14:45:36 -06004355 vk::CmdExecuteCommands(m_commandBuffer->handle(), 1, &secondary.handle());
unknown088160a2019-05-23 17:43:13 -06004356 m_errorMonitor->VerifyNotFound();
4357 m_commandBuffer->end();
4358}
4359
4360TEST_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 Lobodzinski20310782020-02-28 14:25:17 -07004373 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdSetViewport-firstViewport-01224");
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06004374 vk::CmdSetViewport(m_commandBuffer->handle(), 1, 1, viewports);
unknown088160a2019-05-23 17:43:13 -06004375 m_errorMonitor->VerifyFound();
4376
Mark Lobodzinski20310782020-02-28 14:25:17 -07004377 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdSetViewport-viewportCount-arraylength");
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06004378 vk::CmdSetViewport(m_commandBuffer->handle(), 0, 0, nullptr);
unknown088160a2019-05-23 17:43:13 -06004379 m_errorMonitor->VerifyFound();
4380
Mark Lobodzinski20310782020-02-28 14:25:17 -07004381 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdSetViewport-viewportCount-01225");
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06004382 vk::CmdSetViewport(m_commandBuffer->handle(), 0, 2, viewports);
unknown088160a2019-05-23 17:43:13 -06004383 m_errorMonitor->VerifyFound();
4384
Mark Lobodzinski20310782020-02-28 14:25:17 -07004385 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdSetViewport-firstViewport-01224");
4386 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdSetViewport-viewportCount-01225");
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06004387 vk::CmdSetViewport(m_commandBuffer->handle(), 1, 2, viewports);
unknown088160a2019-05-23 17:43:13 -06004388 m_errorMonitor->VerifyFound();
4389
Mark Lobodzinski20310782020-02-28 14:25:17 -07004390 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdSetViewport-pViewports-parameter");
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06004391 vk::CmdSetViewport(m_commandBuffer->handle(), 0, 1, nullptr);
unknown088160a2019-05-23 17:43:13 -06004392 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 Lobodzinski20310782020-02-28 14:25:17 -07004441 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, test_case.veid);
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06004442 vk::CmdSetViewport(m_commandBuffer->handle(), 0, 1, &test_case.vp);
unknown088160a2019-05-23 17:43:13 -06004443 m_errorMonitor->VerifyFound();
4444 }
4445}
4446
4447TEST_F(VkLayerTest, SetDynViewportParamMaintenance1Tests) {
4448 TEST_DESCRIPTION("Verify errors are detected on misuse of SetViewport with a negative viewport extension enabled.");
4449
Mark Lobodzinski09ce9c42020-03-06 10:02:44 -07004450 ASSERT_NO_FATAL_FAILURE(InitFramework(m_errorMonitor));
unknown088160a2019-05-23 17:43:13 -06004451
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
4463TEST_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
unknown088160a2019-05-23 17:43:13 -06004473 m_commandBuffer->begin();
4474
Mark Lobodzinski20310782020-02-28 14:25:17 -07004475 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdSetViewport-viewportCount-arraylength");
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06004476 vk::CmdSetViewport(m_commandBuffer->handle(), 0, 0, nullptr);
unknown088160a2019-05-23 17:43:13 -06004477 m_errorMonitor->VerifyFound();
4478
Petr Kraus14e49492019-09-09 20:13:29 +02004479 const auto max_viewports = m_device->props.limits.maxViewports;
4480
Mark Lobodzinski20310782020-02-28 14:25:17 -07004481 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdSetViewport-pViewports-parameter");
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06004482 vk::CmdSetViewport(m_commandBuffer->handle(), 0, max_viewports, nullptr);
unknown088160a2019-05-23 17:43:13 -06004483 m_errorMonitor->VerifyFound();
4484
Petr Kraus14e49492019-09-09 20:13:29 +02004485 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 Lobodzinski20310782020-02-28 14:25:17 -07004493 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdSetViewport-firstViewport-01223");
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06004494 vk::CmdSetViewport(m_commandBuffer->handle(), 0, max_viewports + 1, viewports.data());
Petr Kraus14e49492019-09-09 20:13:29 +02004495 m_errorMonitor->VerifyFound();
4496
Mark Lobodzinski20310782020-02-28 14:25:17 -07004497 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdSetViewport-firstViewport-01223");
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06004498 vk::CmdSetViewport(m_commandBuffer->handle(), max_viewports, 1, viewports.data());
Petr Kraus14e49492019-09-09 20:13:29 +02004499 m_errorMonitor->VerifyFound();
4500
Mark Lobodzinski20310782020-02-28 14:25:17 -07004501 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdSetViewport-firstViewport-01223");
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06004502 vk::CmdSetViewport(m_commandBuffer->handle(), 1, max_viewports, viewports.data());
Petr Kraus14e49492019-09-09 20:13:29 +02004503 m_errorMonitor->VerifyFound();
4504
Mark Lobodzinski20310782020-02-28 14:25:17 -07004505 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdSetViewport-viewportCount-arraylength");
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06004506 vk::CmdSetViewport(m_commandBuffer->handle(), 1, 0, viewports.data());
Petr Kraus14e49492019-09-09 20:13:29 +02004507 m_errorMonitor->VerifyFound();
unknown088160a2019-05-23 17:43:13 -06004508 }
unknown088160a2019-05-23 17:43:13 -06004509}
4510
4511TEST_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 Lobodzinski20310782020-02-28 14:25:17 -07004544 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdExecuteCommands-pCommandBuffers-00100");
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06004545 vk::CmdExecuteCommands(m_commandBuffer->handle(), 1, &sec_cmdbuff_inside_rp.handle());
unknown088160a2019-05-23 17:43:13 -06004546 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 Lobodzinski902cb0f2019-09-27 14:45:36 -06004555 vk::CmdBeginRenderPass(m_commandBuffer->handle(), &rp_bi, VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS);
unknown088160a2019-05-23 17:43:13 -06004556
Mark Lobodzinski20310782020-02-28 14:25:17 -07004557 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdExecuteCommands-pCommandBuffers-00096");
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06004558 vk::CmdExecuteCommands(m_commandBuffer->handle(), 1, &sec_cmdbuff_outside_rp.handle());
unknown088160a2019-05-23 17:43:13 -06004559 m_errorMonitor->VerifyFound();
4560}
4561
4562TEST_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 Lobodzinski902cb0f2019-09-27 14:45:36 -06004575 ASSERT_VK_SUCCESS(vk::AllocateCommandBuffers(m_device->device(), &command_buffer_allocate_info, &secondary_command_buffer));
unknown088160a2019-05-23 17:43:13 -06004576 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 Lobodzinski902cb0f2019-09-27 14:45:36 -06004587 vk::BeginCommandBuffer(secondary_command_buffer, &command_buffer_begin_info);
unknown088160a2019-05-23 17:43:13 -06004588 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 Lobodzinski62490892019-06-28 09:58:27 -06004596 VkClearRect clear_rect = {{{0, 0}, {257, 32}}, 0, 1};
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06004597 vk::CmdClearAttachments(secondary_command_buffer, 1, &color_attachment, 1, &clear_rect);
4598 vk::EndCommandBuffer(secondary_command_buffer);
unknown088160a2019-05-23 17:43:13 -06004599 m_commandBuffer->begin();
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06004600 vk::CmdBeginRenderPass(m_commandBuffer->handle(), &m_renderPassBeginInfo, VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS);
unknown088160a2019-05-23 17:43:13 -06004601
Mark Lobodzinski20310782020-02-28 14:25:17 -07004602 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdClearAttachments-pRects-00016");
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06004603 vk::CmdExecuteCommands(m_commandBuffer->handle(), 1, &secondary_command_buffer);
unknown088160a2019-05-23 17:43:13 -06004604 m_errorMonitor->VerifyFound();
4605
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06004606 vk::CmdEndRenderPass(m_commandBuffer->handle());
unknown088160a2019-05-23 17:43:13 -06004607 m_commandBuffer->end();
4608}
4609
4610TEST_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 Lobodzinski09ce9c42020-03-06 10:02:44 -07004620 ASSERT_NO_FATAL_FAILURE(InitFramework(m_errorMonitor));
unknown088160a2019-05-23 17:43:13 -06004621 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 Lobodzinski902cb0f2019-09-27 14:45:36 -06004661 (PFN_vkCmdPushDescriptorSetKHR)vk::GetDeviceProcAddr(m_device->device(), "vkCmdPushDescriptorSetKHR");
unknown088160a2019-05-23 17:43:13 -06004662 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)) {
unknownc3033e52019-06-21 16:56:20 -06004670 printf("%s No compute or transfer only queue family, skipping bindpoint and queue tests.\n", kSkipPrefix);
unknown088160a2019-05-23 17:43:13 -06004671 } 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 Lobodzinski20310782020-02-28 14:25:17 -07004680 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdPushDescriptorSetKHR-pipelineBindPoint-00363");
4681 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkWriteDescriptorSet-descriptorType-00330");
unknown088160a2019-05-23 17:43:13 -06004682 if (err_qfi == transfer_only_qfi) {
4683 // This as this queue neither supports the gfx or compute bindpoints, we'll get two errors
Mark Lobodzinski20310782020-02-28 14:25:17 -07004684 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdPushDescriptorSetKHR-commandBuffer-cmdpool");
unknown088160a2019-05-23 17:43:13 -06004685 }
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 Lobodzinski20310782020-02-28 14:25:17 -07004701 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");
unknown088160a2019-05-23 17:43:13 -06004704 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 Lobodzinski20310782020-02-28 14:25:17 -07004713 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdPushDescriptorSetKHR-set-00365");
unknown088160a2019-05-23 17:43:13 -06004714 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 Lobodzinski20310782020-02-28 14:25:17 -07004719 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdPushDescriptorSetKHR-set-00364");
unknown088160a2019-05-23 17:43:13 -06004720 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 Lobodzinski20310782020-02-28 14:25:17 -07004727 m_errorMonitor->SetDesiredFailureMsg(kErrorBit,
unknown088160a2019-05-23 17:43:13 -06004728 "You must call vkBeginCommandBuffer() before this call to vkCmdPushDescriptorSetKHR()");
Mark Lobodzinski20310782020-02-28 14:25:17 -07004729 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkWriteDescriptorSet-descriptorType-00330");
unknown088160a2019-05-23 17:43:13 -06004730 vkCmdPushDescriptorSetKHR(m_commandBuffer->handle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline_layout.handle(), 0, 1,
4731 &descriptor_write);
4732 m_errorMonitor->VerifyFound();
4733}
4734
Jeremy Hayesf96a5162020-02-10 13:49:31 -07004735TEST_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 Lobodzinski09ce9c42020-03-06 10:02:44 -07004745 ASSERT_NO_FATAL_FAILURE(InitFramework(m_errorMonitor));
Jeremy Hayesf96a5162020-02-10 13:49:31 -07004746 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 Lobodzinski20310782020-02-28 14:25:17 -07004788 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkWriteDescriptorSet-descriptorType-00327");
Jeremy Hayesf96a5162020-02-10 13:49:31 -07004789 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
unknown088160a2019-05-23 17:43:13 -06004796TEST_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 Lobodzinski20310782020-02-28 14:25:17 -07004808 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdSetScissor-firstScissor-00593");
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06004809 vk::CmdSetScissor(m_commandBuffer->handle(), 1, 1, scissors);
unknown088160a2019-05-23 17:43:13 -06004810 m_errorMonitor->VerifyFound();
4811
Mark Lobodzinski20310782020-02-28 14:25:17 -07004812 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdSetScissor-scissorCount-arraylength");
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06004813 vk::CmdSetScissor(m_commandBuffer->handle(), 0, 0, nullptr);
unknown088160a2019-05-23 17:43:13 -06004814 m_errorMonitor->VerifyFound();
4815
Mark Lobodzinski20310782020-02-28 14:25:17 -07004816 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdSetScissor-scissorCount-00594");
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06004817 vk::CmdSetScissor(m_commandBuffer->handle(), 0, 2, scissors);
unknown088160a2019-05-23 17:43:13 -06004818 m_errorMonitor->VerifyFound();
4819
Mark Lobodzinski20310782020-02-28 14:25:17 -07004820 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdSetScissor-firstScissor-00593");
4821 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdSetScissor-scissorCount-00594");
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06004822 vk::CmdSetScissor(m_commandBuffer->handle(), 1, 2, scissors);
unknown088160a2019-05-23 17:43:13 -06004823 m_errorMonitor->VerifyFound();
4824
Mark Lobodzinski20310782020-02-28 14:25:17 -07004825 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdSetScissor-pScissors-parameter");
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06004826 vk::CmdSetScissor(m_commandBuffer->handle(), 0, 1, nullptr);
unknown088160a2019-05-23 17:43:13 -06004827 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 Lobodzinski20310782020-02-28 14:25:17 -07004844 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, test_case.vuid);
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06004845 vk::CmdSetScissor(m_commandBuffer->handle(), 0, 1, &test_case.scissor);
unknown088160a2019-05-23 17:43:13 -06004846 m_errorMonitor->VerifyFound();
4847 }
4848
4849 m_commandBuffer->end();
4850}
4851
4852TEST_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
unknown088160a2019-05-23 17:43:13 -06004862 m_commandBuffer->begin();
4863
Mark Lobodzinski20310782020-02-28 14:25:17 -07004864 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdSetScissor-scissorCount-arraylength");
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06004865 vk::CmdSetScissor(m_commandBuffer->handle(), 0, 0, nullptr);
unknown088160a2019-05-23 17:43:13 -06004866 m_errorMonitor->VerifyFound();
4867
Petr Kraus14e49492019-09-09 20:13:29 +02004868 const auto max_scissors = m_device->props.limits.maxViewports;
4869
Mark Lobodzinski20310782020-02-28 14:25:17 -07004870 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdSetScissor-pScissors-parameter");
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06004871 vk::CmdSetScissor(m_commandBuffer->handle(), 0, max_scissors, nullptr);
unknown088160a2019-05-23 17:43:13 -06004872 m_errorMonitor->VerifyFound();
4873
Petr Kraus14e49492019-09-09 20:13:29 +02004874 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 Lobodzinski20310782020-02-28 14:25:17 -07004882 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdSetScissor-firstScissor-00592");
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06004883 vk::CmdSetScissor(m_commandBuffer->handle(), 0, max_scissors + 1, scissors.data());
Petr Kraus14e49492019-09-09 20:13:29 +02004884 m_errorMonitor->VerifyFound();
4885
Mark Lobodzinski20310782020-02-28 14:25:17 -07004886 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdSetScissor-firstScissor-00592");
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06004887 vk::CmdSetScissor(m_commandBuffer->handle(), max_scissors, 1, scissors.data());
Petr Kraus14e49492019-09-09 20:13:29 +02004888 m_errorMonitor->VerifyFound();
4889
Mark Lobodzinski20310782020-02-28 14:25:17 -07004890 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdSetScissor-firstScissor-00592");
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06004891 vk::CmdSetScissor(m_commandBuffer->handle(), 1, max_scissors, scissors.data());
Petr Kraus14e49492019-09-09 20:13:29 +02004892 m_errorMonitor->VerifyFound();
4893
Mark Lobodzinski20310782020-02-28 14:25:17 -07004894 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdSetScissor-scissorCount-arraylength");
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06004895 vk::CmdSetScissor(m_commandBuffer->handle(), 1, 0, scissors.data());
Petr Kraus14e49492019-09-09 20:13:29 +02004896 m_errorMonitor->VerifyFound();
unknown088160a2019-05-23 17:43:13 -06004897 }
unknown088160a2019-05-23 17:43:13 -06004898}
4899
4900TEST_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-lunarg8e2c91b2019-06-11 17:53:26 -06004906 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();
unknown088160a2019-05-23 17:43:13 -06004916
4917 m_commandBuffer->begin();
4918 m_commandBuffer->BeginRenderPass(m_renderPassBeginInfo);
4919
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06004920 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);
unknown088160a2019-05-23 17:43:13 -06004923
4924 VkViewport viewport = {0, 0, 16, 16, 0, 1};
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06004925 vk::CmdSetViewport(m_commandBuffer->handle(), 0, 1, &viewport);
unknown088160a2019-05-23 17:43:13 -06004926 VkRect2D scissor = {{0, 0}, {16, 16}};
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06004927 vk::CmdSetScissor(m_commandBuffer->handle(), 0, 1, &scissor);
unknown088160a2019-05-23 17:43:13 -06004928
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-lunarg8e2c91b2019-06-11 17:53:26 -06004932 VkBufferObj draw_buffer;
4933 draw_buffer.init(*m_device, buffer_create_info);
unknown088160a2019-05-23 17:43:13 -06004934
4935 // VUID-vkCmdDrawIndirect-buffer-02709
Mark Lobodzinski20310782020-02-28 14:25:17 -07004936 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdDrawIndirect-buffer-02709");
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06004937 vk::CmdDrawIndirect(m_commandBuffer->handle(), draw_buffer.handle(), 0, 1, sizeof(VkDrawIndirectCommand));
unknown088160a2019-05-23 17:43:13 -06004938 m_errorMonitor->VerifyFound();
4939
4940 m_commandBuffer->EndRenderPass();
4941 m_commandBuffer->end();
unknown088160a2019-05-23 17:43:13 -06004942}
4943
Mark Lobodzinski977f0342019-12-19 14:24:09 -07004944TEST_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 Lobodzinski09ce9c42020-03-06 10:02:44 -07004954 ASSERT_NO_FATAL_FAILURE(InitFramework(m_errorMonitor));
Mark Lobodzinski977f0342019-12-19 14:24:09 -07004955
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 Lobodzinskid01b2bc2019-12-20 10:19:36 -07004960 return;
Mark Lobodzinski977f0342019-12-19 14:24:09 -07004961 }
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 Lobodzinski20310782020-02-28 14:25:17 -07004978 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdDrawIndirectByteCountEXT-vertexStride-02289");
Mark Lobodzinski977f0342019-12-19 14:24:09 -07004979 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
unknown088160a2019-05-23 17:43:13 -06004986TEST_F(VkLayerTest, DrawIndirectCountKHR) {
4987 TEST_DESCRIPTION("Test covered valid usage for vkCmdDrawIndirectCountKHR");
4988
Mark Lobodzinski09ce9c42020-03-06 10:02:44 -07004989 ASSERT_NO_FATAL_FAILURE(InitFramework(m_errorMonitor));
unknown088160a2019-05-23 17:43:13 -06004990 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 Lobodzinski902cb0f2019-09-27 14:45:36 -06005003 (PFN_vkCmdDrawIndirectCountKHR)vk::GetDeviceProcAddr(m_device->device(), "vkCmdDrawIndirectCountKHR");
unknown088160a2019-05-23 17:43:13 -06005004
locke-lunarg8e2c91b2019-06-11 17:53:26 -06005005 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();
unknown088160a2019-05-23 17:43:13 -06005015
5016 m_commandBuffer->begin();
5017 m_commandBuffer->BeginRenderPass(m_renderPassBeginInfo);
5018
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06005019 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);
unknown088160a2019-05-23 17:43:13 -06005022
5023 VkViewport viewport = {0, 0, 16, 16, 0, 1};
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06005024 vk::CmdSetViewport(m_commandBuffer->handle(), 0, 1, &viewport);
unknown088160a2019-05-23 17:43:13 -06005025 VkRect2D scissor = {{0, 0}, {16, 16}};
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06005026 vk::CmdSetScissor(m_commandBuffer->handle(), 0, 1, &scissor);
unknown088160a2019-05-23 17:43:13 -06005027
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 Lobodzinski902cb0f2019-09-27 14:45:36 -06005032 vk::CreateBuffer(m_device->device(), &buffer_create_info, nullptr, &draw_buffer);
unknown088160a2019-05-23 17:43:13 -06005033
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-lunarg8e2c91b2019-06-11 17:53:26 -06005037 VkBufferObj count_buffer;
5038 count_buffer.init(*m_device, count_buffer_create_info);
unknown088160a2019-05-23 17:43:13 -06005039
Mike Schuchardt65847d92019-12-20 13:50:47 -08005040 // VUID-vkCmdDrawIndirectCount-buffer-02708
Mark Lobodzinski20310782020-02-28 14:25:17 -07005041 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdDrawIndirectCount-buffer-02708");
locke-lunarg8e2c91b2019-06-11 17:53:26 -06005042 vkCmdDrawIndirectCountKHR(m_commandBuffer->handle(), draw_buffer, 0, count_buffer.handle(), 0, 1,
5043 sizeof(VkDrawIndirectCommand));
unknown088160a2019-05-23 17:43:13 -06005044 m_errorMonitor->VerifyFound();
5045
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06005046 vk::GetBufferMemoryRequirements(m_device->device(), draw_buffer, &memory_requirements);
unknown088160a2019-05-23 17:43:13 -06005047 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 Lobodzinski902cb0f2019-09-27 14:45:36 -06005050 vk::AllocateMemory(m_device->device(), &memory_allocate_info, NULL, &draw_buffer_memory);
5051 vk::BindBufferMemory(m_device->device(), draw_buffer, draw_buffer_memory, 0);
unknown088160a2019-05-23 17:43:13 -06005052
5053 VkBuffer count_buffer_unbound;
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06005054 vk::CreateBuffer(m_device->device(), &count_buffer_create_info, nullptr, &count_buffer_unbound);
unknown088160a2019-05-23 17:43:13 -06005055
Mike Schuchardt65847d92019-12-20 13:50:47 -08005056 // VUID-vkCmdDrawIndirectCount-countBuffer-02714
Mark Lobodzinski20310782020-02-28 14:25:17 -07005057 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdDrawIndirectCount-countBuffer-02714");
unknown088160a2019-05-23 17:43:13 -06005058 vkCmdDrawIndirectCountKHR(m_commandBuffer->handle(), draw_buffer, 0, count_buffer_unbound, 0, 1, sizeof(VkDrawIndirectCommand));
5059 m_errorMonitor->VerifyFound();
5060
Mike Schuchardt65847d92019-12-20 13:50:47 -08005061 // VUID-vkCmdDrawIndirectCount-offset-02710
Mark Lobodzinski20310782020-02-28 14:25:17 -07005062 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdDrawIndirectCount-offset-02710");
locke-lunarg8e2c91b2019-06-11 17:53:26 -06005063 vkCmdDrawIndirectCountKHR(m_commandBuffer->handle(), draw_buffer, 1, count_buffer.handle(), 0, 1,
5064 sizeof(VkDrawIndirectCommand));
unknown088160a2019-05-23 17:43:13 -06005065 m_errorMonitor->VerifyFound();
5066
Mike Schuchardt65847d92019-12-20 13:50:47 -08005067 // VUID-vkCmdDrawIndirectCount-countBufferOffset-02716
Mark Lobodzinski20310782020-02-28 14:25:17 -07005068 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdDrawIndirectCount-countBufferOffset-02716");
locke-lunarg8e2c91b2019-06-11 17:53:26 -06005069 vkCmdDrawIndirectCountKHR(m_commandBuffer->handle(), draw_buffer, 0, count_buffer.handle(), 1, 1,
5070 sizeof(VkDrawIndirectCommand));
unknown088160a2019-05-23 17:43:13 -06005071 m_errorMonitor->VerifyFound();
5072
Mike Schuchardt65847d92019-12-20 13:50:47 -08005073 // VUID-vkCmdDrawIndirectCount-stride-03110
Mark Lobodzinski20310782020-02-28 14:25:17 -07005074 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdDrawIndirectCount-stride-03110");
locke-lunarg8e2c91b2019-06-11 17:53:26 -06005075 vkCmdDrawIndirectCountKHR(m_commandBuffer->handle(), draw_buffer, 0, count_buffer.handle(), 0, 1, 1);
unknown088160a2019-05-23 17:43:13 -06005076 m_errorMonitor->VerifyFound();
5077
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06005078 // TODO: These covered VUIDs aren't tested. There is also no test coverage for the core Vulkan 1.0 vk::CmdDraw* equivalent of
unknown088160a2019-05-23 17:43:13 -06005079 // these:
Mike Schuchardt65847d92019-12-20 13:50:47 -08005080 // VUID-vkCmdDrawIndirectCount-renderPass-02684
5081 // VUID-vkCmdDrawIndirectCount-subpass-02685
5082 // VUID-vkCmdDrawIndirectCount-commandBuffer-02701
unknown088160a2019-05-23 17:43:13 -06005083
5084 m_commandBuffer->EndRenderPass();
5085 m_commandBuffer->end();
5086
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06005087 vk::DestroyBuffer(m_device->device(), draw_buffer, 0);
5088 vk::DestroyBuffer(m_device->device(), count_buffer_unbound, 0);
unknown088160a2019-05-23 17:43:13 -06005089
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06005090 vk::FreeMemory(m_device->device(), draw_buffer_memory, 0);
unknown088160a2019-05-23 17:43:13 -06005091}
5092
5093TEST_F(VkLayerTest, DrawIndexedIndirectCountKHR) {
5094 TEST_DESCRIPTION("Test covered valid usage for vkCmdDrawIndexedIndirectCountKHR");
5095
Mark Lobodzinski09ce9c42020-03-06 10:02:44 -07005096 ASSERT_NO_FATAL_FAILURE(InitFramework(m_errorMonitor));
unknown088160a2019-05-23 17:43:13 -06005097 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
unknown088160a2019-05-23 17:43:13 -06005106 auto vkCmdDrawIndexedIndirectCountKHR =
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06005107 (PFN_vkCmdDrawIndexedIndirectCountKHR)vk::GetDeviceProcAddr(m_device->device(), "vkCmdDrawIndexedIndirectCountKHR");
unknown088160a2019-05-23 17:43:13 -06005108
locke-lunarg8e2c91b2019-06-11 17:53:26 -06005109 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();
unknown088160a2019-05-23 17:43:13 -06005119
5120 m_commandBuffer->begin();
5121 m_commandBuffer->BeginRenderPass(m_renderPassBeginInfo);
5122
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06005123 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);
unknown088160a2019-05-23 17:43:13 -06005126
5127 VkViewport viewport = {0, 0, 16, 16, 0, 1};
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06005128 vk::CmdSetViewport(m_commandBuffer->handle(), 0, 1, &viewport);
unknown088160a2019-05-23 17:43:13 -06005129 VkRect2D scissor = {{0, 0}, {16, 16}};
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06005130 vk::CmdSetScissor(m_commandBuffer->handle(), 0, 1, &scissor);
unknown088160a2019-05-23 17:43:13 -06005131
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-lunarg8e2c91b2019-06-11 17:53:26 -06005135 VkBufferObj draw_buffer;
5136 draw_buffer.init(*m_device, buffer_create_info);
unknown088160a2019-05-23 17:43:13 -06005137
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-lunarg8e2c91b2019-06-11 17:53:26 -06005141 VkBufferObj count_buffer;
5142 count_buffer.init(*m_device, count_buffer_create_info);
unknown088160a2019-05-23 17:43:13 -06005143
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-lunarg8e2c91b2019-06-11 17:53:26 -06005147 VkBufferObj index_buffer;
5148 index_buffer.init(*m_device, index_buffer_create_info);
unknown088160a2019-05-23 17:43:13 -06005149
Mike Schuchardt65847d92019-12-20 13:50:47 -08005150 // VUID-vkCmdDrawIndexedIndirectCount-commandBuffer-02701 (partial - only tests whether the index buffer is bound)
Mark Lobodzinski20310782020-02-28 14:25:17 -07005151 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdDrawIndexedIndirectCount-commandBuffer-02701");
locke-lunarg8e2c91b2019-06-11 17:53:26 -06005152 vkCmdDrawIndexedIndirectCountKHR(m_commandBuffer->handle(), draw_buffer.handle(), 0, count_buffer.handle(), 0, 1,
unknown088160a2019-05-23 17:43:13 -06005153 sizeof(VkDrawIndexedIndirectCommand));
5154 m_errorMonitor->VerifyFound();
5155
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06005156 vk::CmdBindIndexBuffer(m_commandBuffer->handle(), index_buffer.handle(), 0, VK_INDEX_TYPE_UINT32);
unknown088160a2019-05-23 17:43:13 -06005157
5158 VkBuffer draw_buffer_unbound;
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06005159 vk::CreateBuffer(m_device->device(), &count_buffer_create_info, nullptr, &draw_buffer_unbound);
unknown088160a2019-05-23 17:43:13 -06005160
Mike Schuchardt65847d92019-12-20 13:50:47 -08005161 // VUID-vkCmdDrawIndexedIndirectCount-buffer-02708
Mark Lobodzinski20310782020-02-28 14:25:17 -07005162 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdDrawIndexedIndirectCount-buffer-02708");
locke-lunarg8e2c91b2019-06-11 17:53:26 -06005163 vkCmdDrawIndexedIndirectCountKHR(m_commandBuffer->handle(), draw_buffer_unbound, 0, count_buffer.handle(), 0, 1,
unknown088160a2019-05-23 17:43:13 -06005164 sizeof(VkDrawIndexedIndirectCommand));
5165 m_errorMonitor->VerifyFound();
5166
5167 VkBuffer count_buffer_unbound;
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06005168 vk::CreateBuffer(m_device->device(), &count_buffer_create_info, nullptr, &count_buffer_unbound);
unknown088160a2019-05-23 17:43:13 -06005169
Mike Schuchardt65847d92019-12-20 13:50:47 -08005170 // VUID-vkCmdDrawIndexedIndirectCount-countBuffer-02714
Mark Lobodzinski20310782020-02-28 14:25:17 -07005171 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdDrawIndexedIndirectCount-countBuffer-02714");
locke-lunarg8e2c91b2019-06-11 17:53:26 -06005172 vkCmdDrawIndexedIndirectCountKHR(m_commandBuffer->handle(), draw_buffer.handle(), 0, count_buffer_unbound, 0, 1,
unknown088160a2019-05-23 17:43:13 -06005173 sizeof(VkDrawIndexedIndirectCommand));
5174 m_errorMonitor->VerifyFound();
5175
Mike Schuchardt65847d92019-12-20 13:50:47 -08005176 // VUID-vkCmdDrawIndexedIndirectCount-offset-02710
Mark Lobodzinski20310782020-02-28 14:25:17 -07005177 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdDrawIndexedIndirectCount-offset-02710");
locke-lunarg8e2c91b2019-06-11 17:53:26 -06005178 vkCmdDrawIndexedIndirectCountKHR(m_commandBuffer->handle(), draw_buffer.handle(), 1, count_buffer.handle(), 0, 1,
unknown088160a2019-05-23 17:43:13 -06005179 sizeof(VkDrawIndexedIndirectCommand));
5180 m_errorMonitor->VerifyFound();
5181
Mike Schuchardt65847d92019-12-20 13:50:47 -08005182 // VUID-vkCmdDrawIndexedIndirectCount-countBufferOffset-02716
Mark Lobodzinski20310782020-02-28 14:25:17 -07005183 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdDrawIndexedIndirectCount-countBufferOffset-02716");
locke-lunarg8e2c91b2019-06-11 17:53:26 -06005184 vkCmdDrawIndexedIndirectCountKHR(m_commandBuffer->handle(), draw_buffer.handle(), 0, count_buffer.handle(), 1, 1,
unknown088160a2019-05-23 17:43:13 -06005185 sizeof(VkDrawIndexedIndirectCommand));
5186 m_errorMonitor->VerifyFound();
5187
Mike Schuchardt65847d92019-12-20 13:50:47 -08005188 // VUID-vkCmdDrawIndexedIndirectCount-stride-03142
Mark Lobodzinski20310782020-02-28 14:25:17 -07005189 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdDrawIndexedIndirectCount-stride-03142");
locke-lunarg8e2c91b2019-06-11 17:53:26 -06005190 vkCmdDrawIndexedIndirectCountKHR(m_commandBuffer->handle(), draw_buffer.handle(), 0, count_buffer.handle(), 0, 1, 1);
unknown088160a2019-05-23 17:43:13 -06005191 m_errorMonitor->VerifyFound();
5192
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06005193 // TODO: These covered VUIDs aren't tested. There is also no test coverage for the core Vulkan 1.0 vk::CmdDraw* equivalent of
unknown088160a2019-05-23 17:43:13 -06005194 // these:
Mike Schuchardt65847d92019-12-20 13:50:47 -08005195 // VUID-vkCmdDrawIndexedIndirectCount-renderPass-02684
5196 // VUID-vkCmdDrawIndexedIndirectCount-subpass-02685
5197 // VUID-vkCmdDrawIndexedIndirectCount-commandBuffer-02701 (partial)
unknown088160a2019-05-23 17:43:13 -06005198
5199 m_commandBuffer->EndRenderPass();
5200 m_commandBuffer->end();
5201
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06005202 vk::DestroyBuffer(m_device->device(), draw_buffer_unbound, 0);
5203 vk::DestroyBuffer(m_device->device(), count_buffer_unbound, 0);
unknown088160a2019-05-23 17:43:13 -06005204}
5205
sfricke-samsung860d3b22020-05-04 21:08:29 -07005206TEST_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
unknown088160a2019-05-23 17:43:13 -06005258TEST_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 Lobodzinski09ce9c42020-03-06 10:02:44 -07005268 ASSERT_NO_FATAL_FAILURE(InitFramework(m_errorMonitor));
unknown088160a2019-05-23 17:43:13 -06005269 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 Lobodzinski902cb0f2019-09-27 14:45:36 -06005280 (PFN_vkGetPhysicalDeviceFeatures2KHR)vk::GetInstanceProcAddr(instance(), "vkGetPhysicalDeviceFeatures2KHR");
unknown088160a2019-05-23 17:43:13 -06005281 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 Lobodzinski20310782020-02-28 14:25:17 -07005358 CreatePipelineHelper::OneshotTest(*this, break_vp, kErrorBit, test_case.vuids);
unknown088160a2019-05-23 17:43:13 -06005359 }
5360 }
5361
5362 // Based on SetDynScissorParamTests
5363 {
5364 auto vkCmdSetExclusiveScissorNV =
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06005365 (PFN_vkCmdSetExclusiveScissorNV)vk::GetDeviceProcAddr(m_device->device(), "vkCmdSetExclusiveScissorNV");
unknown088160a2019-05-23 17:43:13 -06005366
5367 const VkRect2D scissor = {{0, 0}, {16, 16}};
5368 const VkRect2D scissors[] = {scissor, scissor};
5369
5370 m_commandBuffer->begin();
5371
Mark Lobodzinski20310782020-02-28 14:25:17 -07005372 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdSetExclusiveScissorNV-firstExclusiveScissor-02035");
unknown088160a2019-05-23 17:43:13 -06005373 vkCmdSetExclusiveScissorNV(m_commandBuffer->handle(), 1, 1, scissors);
5374 m_errorMonitor->VerifyFound();
5375
Mark Lobodzinski20310782020-02-28 14:25:17 -07005376 m_errorMonitor->SetDesiredFailureMsg(kErrorBit,
unknown088160a2019-05-23 17:43:13 -06005377 "vkCmdSetExclusiveScissorNV: parameter exclusiveScissorCount must be greater than 0");
5378 vkCmdSetExclusiveScissorNV(m_commandBuffer->handle(), 0, 0, nullptr);
5379 m_errorMonitor->VerifyFound();
5380
Mark Lobodzinski20310782020-02-28 14:25:17 -07005381 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdSetExclusiveScissorNV-exclusiveScissorCount-02036");
unknown088160a2019-05-23 17:43:13 -06005382 vkCmdSetExclusiveScissorNV(m_commandBuffer->handle(), 0, 2, scissors);
5383 m_errorMonitor->VerifyFound();
5384
Mark Lobodzinski20310782020-02-28 14:25:17 -07005385 m_errorMonitor->SetDesiredFailureMsg(kErrorBit,
unknown088160a2019-05-23 17:43:13 -06005386 "vkCmdSetExclusiveScissorNV: parameter exclusiveScissorCount must be greater than 0");
Mark Lobodzinski20310782020-02-28 14:25:17 -07005387 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdSetExclusiveScissorNV-firstExclusiveScissor-02035");
unknown088160a2019-05-23 17:43:13 -06005388 vkCmdSetExclusiveScissorNV(m_commandBuffer->handle(), 1, 0, scissors);
5389 m_errorMonitor->VerifyFound();
5390
Mark Lobodzinski20310782020-02-28 14:25:17 -07005391 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdSetExclusiveScissorNV-firstExclusiveScissor-02035");
5392 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdSetExclusiveScissorNV-exclusiveScissorCount-02036");
unknown088160a2019-05-23 17:43:13 -06005393 vkCmdSetExclusiveScissorNV(m_commandBuffer->handle(), 1, 2, scissors);
5394 m_errorMonitor->VerifyFound();
5395
Mark Lobodzinski20310782020-02-28 14:25:17 -07005396 m_errorMonitor->SetDesiredFailureMsg(kErrorBit,
unknown088160a2019-05-23 17:43:13 -06005397 "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 Lobodzinski20310782020-02-28 14:25:17 -07005417 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, test_case.vuid);
unknown088160a2019-05-23 17:43:13 -06005418 vkCmdSetExclusiveScissorNV(m_commandBuffer->handle(), 0, 1, &test_case.scissor);
5419 m_errorMonitor->VerifyFound();
5420 }
5421
5422 m_commandBuffer->end();
5423 }
5424}
5425
5426TEST_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 Lobodzinski09ce9c42020-03-06 10:02:44 -07005436 ASSERT_NO_FATAL_FAILURE(InitFramework(m_errorMonitor));
unknown088160a2019-05-23 17:43:13 -06005437 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-LunarG048f5012020-04-29 16:55:11 -06005447 if (IsPlatform(kMockICD) || DeviceSimulation()) {
unknown088160a2019-05-23 17:43:13 -06005448 printf("%sNot suppored by MockICD, skipping tests\n", kSkipPrefix);
5449 return;
5450 }
5451
5452 PFN_vkGetPhysicalDeviceFeatures2KHR vkGetPhysicalDeviceFeatures2KHR =
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06005453 (PFN_vkGetPhysicalDeviceFeatures2KHR)vk::GetInstanceProcAddr(instance(), "vkGetPhysicalDeviceFeatures2KHR");
unknown088160a2019-05-23 17:43:13 -06005454 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 Lobodzinski20310782020-02-28 14:25:17 -07005503 CreatePipelineHelper::OneshotTest(*this, break_vp, kErrorBit,
unknown088160a2019-05-23 17:43:13 -06005504 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 Lobodzinski20310782020-02-28 14:25:17 -07005508 CreatePipelineHelper::OneshotTest(*this, break_vp2, kErrorBit,
unknown088160a2019-05-23 17:43:13 -06005509 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 Lobodzinski20310782020-02-28 14:25:17 -07005517 CreatePipelineHelper::OneshotTest(*this, break_vp3, kErrorBit,
unknown088160a2019-05-23 17:43:13 -06005518 vector<std::string>({"VUID-VkGraphicsPipelineCreateInfo-pStages-02097",
5519 "VUID-VkGraphicsPipelineCreateInfo-pStages-02098"}));
5520 }
5521
5522 PFN_vkCmdDrawMeshTasksIndirectNV vkCmdDrawMeshTasksIndirectNV =
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06005523 (PFN_vkCmdDrawMeshTasksIndirectNV)vk::GetInstanceProcAddr(instance(), "vkCmdDrawMeshTasksIndirectNV");
unknown088160a2019-05-23 17:43:13 -06005524
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 Lobodzinski902cb0f2019-09-27 14:45:36 -06005529 VkResult result = vk::CreateBuffer(m_device->device(), &buffer_create_info, nullptr, &buffer);
unknown088160a2019-05-23 17:43:13 -06005530 ASSERT_VK_SUCCESS(result);
5531
5532 m_commandBuffer->begin();
5533
Mark Lobodzinski20310782020-02-28 14:25:17 -07005534 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdDrawMeshTasksIndirectNV-drawCount-02146");
5535 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdDrawMeshTasksIndirectNV-drawCount-02718");
unknown088160a2019-05-23 17:43:13 -06005536 vkCmdDrawMeshTasksIndirectNV(m_commandBuffer->handle(), buffer, 0, 2, 0);
5537 m_errorMonitor->VerifyFound();
5538
5539 m_commandBuffer->end();
5540
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06005541 vk::DestroyBuffer(m_device->device(), buffer, 0);
unknown088160a2019-05-23 17:43:13 -06005542}
5543
5544TEST_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 Lobodzinski902cb0f2019-09-27 14:45:36 -06005552 vk::CreateEvent(m_device->device(), &event_create_info, nullptr, &event);
unknown088160a2019-05-23 17:43:13 -06005553
5554 m_commandBuffer->begin();
5555
Mark Lobodzinski20310782020-02-28 14:25:17 -07005556 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdSetEvent-stageMask-02107");
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06005557 vk::CmdSetEvent(m_commandBuffer->handle(), event, VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV);
unknown088160a2019-05-23 17:43:13 -06005558 m_errorMonitor->VerifyFound();
5559
Mark Lobodzinski20310782020-02-28 14:25:17 -07005560 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdSetEvent-stageMask-02108");
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06005561 vk::CmdSetEvent(m_commandBuffer->handle(), event, VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV);
unknown088160a2019-05-23 17:43:13 -06005562 m_errorMonitor->VerifyFound();
5563
Mark Lobodzinski20310782020-02-28 14:25:17 -07005564 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdResetEvent-stageMask-02109");
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06005565 vk::CmdResetEvent(m_commandBuffer->handle(), event, VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV);
unknown088160a2019-05-23 17:43:13 -06005566 m_errorMonitor->VerifyFound();
5567
Mark Lobodzinski20310782020-02-28 14:25:17 -07005568 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdResetEvent-stageMask-02110");
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06005569 vk::CmdResetEvent(m_commandBuffer->handle(), event, VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV);
unknown088160a2019-05-23 17:43:13 -06005570 m_errorMonitor->VerifyFound();
5571
Mark Lobodzinski20310782020-02-28 14:25:17 -07005572 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdWaitEvents-srcStageMask-02111");
5573 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdWaitEvents-dstStageMask-02113");
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06005574 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);
unknown088160a2019-05-23 17:43:13 -06005576 m_errorMonitor->VerifyFound();
5577
Mark Lobodzinski20310782020-02-28 14:25:17 -07005578 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdWaitEvents-srcStageMask-02112");
5579 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdWaitEvents-dstStageMask-02114");
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06005580 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);
unknown088160a2019-05-23 17:43:13 -06005582 m_errorMonitor->VerifyFound();
5583
Mark Lobodzinski20310782020-02-28 14:25:17 -07005584 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdPipelineBarrier-srcStageMask-02115");
5585 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdPipelineBarrier-dstStageMask-02117");
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06005586 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);
unknown088160a2019-05-23 17:43:13 -06005588 m_errorMonitor->VerifyFound();
5589
Mark Lobodzinski20310782020-02-28 14:25:17 -07005590 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdPipelineBarrier-srcStageMask-02116");
5591 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdPipelineBarrier-dstStageMask-02118");
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06005592 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);
unknown088160a2019-05-23 17:43:13 -06005594 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 Lobodzinski902cb0f2019-09-27 14:45:36 -06005601 ASSERT_VK_SUCCESS(vk::CreateSemaphore(m_device->device(), &semaphore_create_info, nullptr, &semaphore));
unknown088160a2019-05-23 17:43:13 -06005602
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 Lobodzinski902cb0f2019-09-27 14:45:36 -06005610 vk::QueueSubmit(m_device->m_queue, 1, &submit_info, VK_NULL_HANDLE);
unknown088160a2019-05-23 17:43:13 -06005611 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 Lobodzinski20310782020-02-28 14:25:17 -07005620 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkSubmitInfo-pWaitDstStageMask-02089");
5621 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-VkSubmitInfo-pWaitDstStageMask-02090");
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06005622 vk::QueueSubmit(m_device->m_queue, 1, &submit_info, VK_NULL_HANDLE);
unknown088160a2019-05-23 17:43:13 -06005623 m_errorMonitor->VerifyFound();
5624
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06005625 vk::QueueWaitIdle(m_device->m_queue);
unknown088160a2019-05-23 17:43:13 -06005626
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 Lobodzinski20310782020-02-28 14:25:17 -07005640 *this, break_vp, kErrorBit,
unknown088160a2019-05-23 17:43:13 -06005641 vector<std::string>({"VUID-VkPipelineShaderStageCreateInfo-pName-00707", "VUID-VkPipelineShaderStageCreateInfo-pName-00707",
5642 "VUID-VkPipelineShaderStageCreateInfo-stage-02091",
5643 "VUID-VkPipelineShaderStageCreateInfo-stage-02092"}));
5644
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06005645 vk::DestroyEvent(m_device->device(), event, nullptr);
5646 vk::DestroySemaphore(m_device->device(), semaphore, nullptr);
unknown088160a2019-05-23 17:43:13 -06005647}
Chris Mayerc93536f2019-09-19 16:34:49 +02005648
5649TEST_F(VkLayerTest, ViewportWScalingNV) {
5650 TEST_DESCRIPTION("Verify VK_NV_clip_space_w_scaling");
5651
Mark Lobodzinski09ce9c42020-03-06 10:02:44 -07005652 ASSERT_NO_FATAL_FAILURE(InitFramework(m_errorMonitor));
Chris Mayerc93536f2019-09-19 16:34:49 +02005653
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 Lobodzinski902cb0f2019-09-27 14:45:36 -06005673 reinterpret_cast<PFN_vkCmdSetViewportWScalingNV>(vk::GetDeviceProcAddr(m_device->device(), "vkCmdSetViewportWScalingNV"));
Chris Mayerc93536f2019-09-19 16:34:49 +02005674
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 Lobodzinski20310782020-02-28 14:25:17 -07005719 CreatePipelineHelper::OneshotTest(*this, set_vpci, kErrorBit, vector<std::string>(), true);
Chris Mayerc93536f2019-09-19 16:34:49 +02005720
5721 // Create pipeline with w-scaling enabled but without a valid scaling array
5722 vpsi.pViewportWScalings = nullptr;
Mark Lobodzinski20310782020-02-28 14:25:17 -07005723 CreatePipelineHelper::OneshotTest(*this, set_vpci, kErrorBit,
Chris Mayerc93536f2019-09-19 16:34:49 +02005724 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 Lobodzinski20310782020-02-28 14:25:17 -07005730 CreatePipelineHelper::OneshotTest(*this, set_vpci, kErrorBit,
Chris Mayerc93536f2019-09-19 16:34:49 +02005731 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 Lobodzinski902cb0f2019-09-27 14:45:36 -06005759 vk::CmdBindPipeline(m_commandBuffer->handle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipe.handle());
Chris Mayerc93536f2019-09-19 16:34:49 +02005760 m_errorMonitor->VerifyNotFound();
5761
Chris Mayerc93536f2019-09-19 16:34:49 +02005762 // Bind pipeline that has dynamic w-scaling enabled
5763 m_errorMonitor->ExpectSuccess();
Mark Lobodzinski902cb0f2019-09-27 14:45:36 -06005764 vk::CmdBindPipeline(m_commandBuffer->handle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipeDynWScale.handle());
Chris Mayerc93536f2019-09-19 16:34:49 +02005765 m_errorMonitor->VerifyNotFound();
5766
5767 const auto max_vps = m_device->props.limits.maxViewports;
5768
Mark Lobodzinski20310782020-02-28 14:25:17 -07005769 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdSetViewportWScalingNV-firstViewport-01323");
Chris Mayerc93536f2019-09-19 16:34:49 +02005770 vkCmdSetViewportWScalingNV(m_commandBuffer->handle(), max_vps, vp_count, scale.data());
5771 m_errorMonitor->VerifyFound();
5772
Mark Lobodzinski20310782020-02-28 14:25:17 -07005773 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCmdSetViewportWScalingNV-firstViewport-01324");
Chris Mayerc93536f2019-09-19 16:34:49 +02005774 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-samsung914e8002020-01-07 22:26:18 -08005783
5784TEST_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 Lobodzinski09ce9c42020-03-06 10:02:44 -07005794 ASSERT_NO_FATAL_FAILURE(InitFramework(m_errorMonitor));
sfricke-samsung914e8002020-01-07 22:26:18 -08005795 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 Lobodzinski20310782020-02-28 14:25:17 -07005836 m_errorMonitor->SetDesiredFailureMsg(kErrorBit, "VUID-vkCreateSamplerYcbcrConversion-None-01648");
sfricke-samsung914e8002020-01-07 22:26:18 -08005837 vkCreateSamplerYcbcrConversionFunction(m_device->handle(), &ycbcr_create_info, nullptr, &conversions);
5838 m_errorMonitor->VerifyFound();
Shannon McPherson50421602020-01-28 15:18:46 -07005839}
Jeremy Hayescd7df2c2020-05-21 16:36:47 -06005840
5841TEST_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
5916TEST_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
6103TEST_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
6220TEST_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}